Update Doors_Schedule.py

Doors_Schedule.py

@@ -1,6 +1,7 @@
 from collections import defaultdict
 import pandas as pd
 import random
+import math
 import re
 import io
 import pypdfium2 as pdfium
@@ -20,6 +21,14 @@ import PyPDF2
 import io
 from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
 from PyPDF2 import PdfReader, PdfWriter
+import zlib
+import base64
+import datetime
+import uuid
+from xml.etree.ElementTree import Element, SubElement, tostring, ElementTree
+from xml.dom.minidom import parseString
+from collections import defaultdict
+from xml.etree.ElementTree import Element, SubElement, tostring
 
 
 def convert2img(path):
@@ -378,7 +387,8 @@ def get_selected_columns_all(dfs, user_patterns):
         #if len(dfs[i]) <2:
           #selected_columns_new = details_in_another_table(clmn_name, clmn_idx, dfs[i], dfs)
         selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
-        selected_columns_new = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+        selected_columns_new2 = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+        selected_columns_new =  pd.concat([selected_columns_new, selected_columns_new2], axis=1)
 
         break
             #other_matches = details_in_another_table_mod(clmn_name, clmn_idx, dfs[i], dfs)
@@ -498,17 +508,26 @@ def get_width_info_tobeprinted(new_data):
     for _,_,_, w,h in new_data:
       w = re.sub(r",", "", w)
       h = re.sub(r",", "", h)
-      if float(w).is_integer():
-        w = int(float(w))
-      else:
+
+      #if w == "N/A":
+      if w.isalpha():
         w = w
-      if float(h).is_integer():
-        h = int(float(h))
       else:
+        if float(w).is_integer():
+          w = int(float(w))
+        else:
+          w = w
+      #if h == "N/A":
+      if h.isalpha():
         h = h
+      else:
+        if float(h).is_integer():
+          h = int(float(h))
+        else:
+          h = h
       width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
   return width_info_tobeprinted
-    
+
 def clean_dimensions(text):
     # Remove commas and "mm"
     text = re.sub(r'[,\s]*mm', '', text)  # Remove "mm" with optional spaces or commas before it
@@ -540,7 +559,7 @@ def get_widths_bb_format(cleaned_width, kelma):
   return widths
 
 
-def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
+'''def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
   width_info_tobeprinted = []
   secondary_info_tobeprinted = []
 
@@ -582,20 +601,101 @@ def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
 
   if len(main_info) == 4 and len(secondary_info) == 2:
     for coords, label, width, height, acous, fire, color in new_data:
+      print(type(width))
+      print(type(height))
       w = re.sub(r",", "", width)
       h = re.sub(r",", "", height)
-      if float(w).is_integer():
-        w = int(float(w))
-      else:
+      if w == "N/A":
         w = w
-      if float(h).is_integer():
-        h = int(float(h))
       else:
+        if float(w).is_integer():
+          w = int(float(w))
+        else:
+          w = w
+      if h == "N/A":
         h = h
+      else:
+        if float(h).is_integer():
+          h = int(float(h))
+        else:
+          h = h
       width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
       secondary_info_tobeprinted.append((acous, fire))
   return width_info_tobeprinted, secondary_info_tobeprinted
+'''    
+
+def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
+  width_info_tobeprinted = []
+  secondary_info_tobeprinted = []
+
+  if len(main_info) == 2 and len(secondary_info) == 1:
+   for coords, label, acous, color in new_data:
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 2 and len(secondary_info) == 2:
+    for coords, label, acous, fire, color in new_data:
+       secondary_info_tobeprinted.append((acous, fire))
+
+  if len(main_info) == 3 and len(secondary_info) == 1:
+    for coords, label, width, acous, color in new_data:
+      width_info_tobeprinted.append(width)
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 3 and len(secondary_info) == 2:
+    for coords, label, width, acous, fire, color in new_data:
+      width_info_tobeprinted.append(width)
+      secondary_info_tobeprinted.append((acous, fire))
 
+  if len(main_info) == 4 and len(secondary_info) == 1:
+    for coords, label, width, height, acous, color in new_data:
+      w = re.sub(r",", "", width)
+      h = re.sub(r",", "", height)
+      if w.isalpha():
+        w = w
+      else:
+        if float(w).is_integer():
+          w = int(float(w))
+        else:
+          w = w
+      #if h == "N/A":
+      if h.isalpha():
+        h = h
+      else:
+        if float(h).is_integer():
+          h = int(float(h))
+        else:
+          h = h
+      width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
+      secondary_info_tobeprinted.append((acous, fire))
+
+  if len(main_info) == 4 and len(secondary_info) == 2:
+    for coords, label, width, height, acous, fire, color in new_data:
+      print(type(width))
+      print(type(height))
+      w = re.sub(r",", "", width)
+      h = re.sub(r",", "", height)
+      #if w == "N/A":
+      if w.isalpha():
+        w = w
+      else:
+        if float(w).is_integer():
+          w = int(float(w))
+        else:
+          w = w
+      #if h == "N/A":
+      if h.isalpha():
+        h = h
+      else:
+        if float(h).is_integer():
+          h = int(float(h))
+        else:
+          h = h
+      width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
+      secondary_info_tobeprinted.append((acous, fire))
+  return width_info_tobeprinted, secondary_info_tobeprinted
+    
 def get_word_locations_plan_secondary(flattened_list, plan_texts, main_info, secondary_info):
   #hena fe 7alet en keda keda fe secondary information
   locations = []
@@ -795,7 +895,22 @@ def mix_width_secondary(widths, secondary_printed_clean):
     all_print.append(newest_text) 
   return all_print
 
-def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, secondary_info):
+def merge_pdf_bytes_list(pdfs):
+    writer = PdfWriter()
+
+    for pdf_bytes in pdfs:
+        pdf_stream = io.BytesIO(pdf_bytes)
+        reader = PdfReader(pdf_stream)
+        for page in reader.pages:
+            writer.add_page(page)
+
+    output_stream = io.BytesIO()
+    writer.write(output_stream)
+    output_stream.seek(0)
+
+    return output_stream.read()
+
+'''def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, secondary_info):
     pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
     pdf_document = fitz.open("pdf", pdf_stream.read())  # Open PDF in memory
 
@@ -937,7 +1052,6 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     return output_stream.getvalue()  # Return the modified PDF as bytes
 
-
 def modify_author_in_pypdf2(pdf_bytes, new_authors):
     pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
     reader = PyPDF2.PdfReader(pdf_stream)
@@ -969,10 +1083,6 @@ def modify_author_in_pypdf2(pdf_bytes, new_authors):
 
     return output_stream.read()
 
-
-
-
-
 def add_bluebeam_count_annotations(pdf_bytes, locations):
     pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
     pdf_document = fitz.open("pdf", pdf_stream.read())  # Open PDF in memory
@@ -1047,8 +1157,6 @@ def add_bluebeam_count_annotations(pdf_bytes, locations):
     pdf_document.close()
 
     return output_stream.getvalue()  # Return the modified PDF as bytes
-
-
     
 def modify_author_in_pypdf2(pdf_bytes, new_authors):
     pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
@@ -1081,8 +1189,6 @@ def modify_author_in_pypdf2(pdf_bytes, new_authors):
 
     return output_stream.read()
 
-
-
 def merge_pdf_bytes_list(pdfs):
     writer = PdfWriter()
 
@@ -1098,7 +1204,6 @@ def merge_pdf_bytes_list(pdfs):
 
     return output_stream.read()
 
-
 def process_pdf_secondary(input_pdf_path, output_pdf_path, locations, new_authors, main_info, secondary_info):
     
     if isinstance(input_pdf_path, bytes):
@@ -1115,7 +1220,6 @@ def process_pdf_secondary(input_pdf_path, output_pdf_path, locations, new_author
 
     return final_pdf_bytes
 
-
 def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     #Load original PDF
     if isinstance(input_pdf_path, bytes):
@@ -1130,6 +1234,312 @@ def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     #Modify author field using PyPDF2
     final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
     return final_pdf_bytes
+'''
+
+def calculate_bounding_rect_count(vertices,padding):
+    x, y = vertices[0]
+    xmin = x - padding
+    ymin = y - padding
+    xmax = x + padding
+    ymax = y + padding
+    return [xmin, ymin, xmax, ymax]
+
+def rgb_string_to_hex(rgb_string):
+    r, g, b = map(float, rgb_string.strip().split())
+    return '#{:02X}{:02X}{:02X}'.format(int(r * 255), int(g * 255), int(b * 255))
+
+
+
+
+
+
+
+
+
+def generate_annotation_xml_block_count(vertices, area_text, author, custom_data: dict, column_order: list, index: int,
+                                   label: str = '',height:str='',width:str='',
+                                   color:str='',countstyle:str='',countsize:str=''):
+    now = datetime.datetime.utcnow()
+    mod_date = now.strftime("D:%Y%m%d%H%M%S+00'00'")
+    creation_date = now.isoformat() + 'Z'
+    id_str = "fitz-" + uuid.uuid4().hex[:4].upper()
+
+    vert_str = ' '.join([f'{x:.4f}' for point in vertices for x in point])
+    ordered_column_values = [f'({custom_data.get(col, "")})' for col in column_order]
+    bsi_column_data = ''.join(ordered_column_values)
+
+    type_internal= 'Bluebeam.PDF.Annotations.AnnotationMeasureCount'
+    subject ='Count Measurement'
+    padding=10
+    rectvertices=calculate_bounding_rect_count(vertices,padding)
+    bbmeasure = '''<</Type/Measure
+                /Subtype/RL
+                /R(1 mm = 1 mm)
+                /X[<</Type/NumberFormat/U(mm)/C 0.3527778/D 100/SS()>>]
+                /D[<</Type/NumberFormat/U(mm)/C 1/D 100/SS()>>]
+                /A[<</Type/NumberFormat/U(sq mm)/C 1/D 100/FD true/SS()>>]
+                /T[<</Type/NumberFormat/U(\\260)/C 1/D 100/FD true/PS()/SS()>>]
+                /V[<</Type/NumberFormat/U(cu mm)/C 1/D 100/FD true/SS()>>]
+                /TargetUnitConversion 0.3527778>>'''
+
+    raw_text = f'''<<
+              /Version 1
+              /DS(font: Helvetica 12pt; text-align:center; line-height:13.8pt; color:#FF0000)
+              /CountStyle{countstyle}
+              /CountScale {countsize}
+              /MeasurementTypes 128
+              /BBMeasure{bbmeasure}
+              /NumCounts {area_text}
+              /AP<</N/BBObjPtr_{uuid.uuid4().hex.upper()}>>
+              /IT/PolygonCount
+              /Vertices[{vert_str}]
+              /IC[{color}]
+              /T({author})
+              /CreationDate({mod_date})
+              /BSIColumnData[{bsi_column_data}]
+              /RC(<?xml version="1.0"?><body xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:contentType="text/html" xfa:APIVersion="BluebeamPDFRevu:2018" xfa:spec="2.2.0" style="font:Helvetica 12pt; text-align:center; line-height:13.8pt; color:#FF0000" xmlns="http://www.w3.org/1999/xhtml"><p>{area_text}</p></body>)
+              /Label({label})
+              /Height {height}
+              /Width {width}
+              /Subj({subject})
+              /NM({id_str})
+              /Subtype/Polygon
+              /Rect[{rectvertices[0]} {rectvertices[1]} {rectvertices[2]} {rectvertices[3]}]
+              /Contents({area_text})
+              /F 4
+              /C[{color}]
+              /BS<</Type/Border/W 0/S/S>>
+              /M({mod_date})
+    >>'''.encode('utf-8')
+
+    compressed = zlib.compress(raw_text)
+    base64_raw = base64.b16encode(compressed).lower().decode()
+
+    annotation = Element('Annotation')
+    SubElement(annotation, 'Page')            ############## newline #####################
+    SubElement(annotation, 'Contents').text = area_text
+    SubElement(annotation, 'ModDate').text = creation_date
+    SubElement(annotation, 'Color').text = rgb_string_to_hex(color)  ############## newline #####################
+    SubElement(annotation, 'Type').text = 'Polygon'
+    SubElement(annotation, 'ID').text = id_str
+    SubElement(annotation, 'TypeInternal').text = type_internal
+    SubElement(annotation, 'Raw').text = base64_raw
+    SubElement(annotation, 'Index').text = str(index)
+
+    custom = SubElement(annotation, 'Custom')
+    for key, value in custom_data.items():
+        SubElement(custom, key).text = value
+
+    SubElement(annotation, 'Subject').text = subject
+    SubElement(annotation, 'CreationDate').text = creation_date
+    SubElement(annotation, 'Author').text = author
+    SubElement(annotation, 'Label').text = label
+    SubElement(annotation, 'Height').text = height
+    SubElement(annotation, 'Width').text = width
+
+
+    return annotation
+
+
+def save_multiple_annotations_count_bax(annotations, output_path, column_order,pdfWidth,pdfHeight, num_pages): ##new parameter for page number handling
+    """
+    annotations: list of dicts, each with:
+      - vertices:  [x, y]
+      - text: str (label)
+      - author: ADR
+      - custom_data: dict of custom field values
+      - type_internal: str (e.g., Bluebeam.PDF.Annotations.AnnotationMeasureCount)
+      - subject: str (e.g., Count Measurement)
+    """
+    doc = Element('Document', Version='1')
+    #group annotations by page number
+    annotations_by_page = defaultdict(list)
+    for ann in annotations:
+        page_num = ann.get('page', 1)
+        annotations_by_page[page_num].append(ann)
+     # Loop through ALL pages
+    # for page_index, (page_num, page_annotations) in enumerate(sorted(annotations_by_page.items())):
+    for page_index in range(num_pages): ##new line for page handling
+        page = SubElement(doc, 'Page', Index=str(page_index))
+        SubElement(page, 'Label').text = str(page_index + 1)   ##new line for page handling
+        SubElement(page, 'Width').text = str(pdfWidth)
+        SubElement(page, 'Height').text = str(pdfHeight)
+
+        #adding annotations only if they exist
+        for i, ann in enumerate(annotations_by_page.get(page_index + 1, [])):  ## adjusted for page handling
+
+            annotation_xml = generate_annotation_xml_block_count(
+                vertices=ann['vertices'],
+                area_text=ann['text'],
+                author=ann['author'],
+                custom_data=ann['custom_data'],
+                column_order=column_order,
+                index=i,
+                label=ann.get('label', 'label1'),
+                height=ann.get('height', '123'),
+                width=ann.get('width', '123'),
+                color=ann.get('color', ''),
+                countstyle=ann.get('countstyle', ''),
+                countsize=ann.get('countsize','')
+            )
+            annotation_xml.find('Page').text = str(page_index+1)    ## adjusted for page handling
+            page.append(annotation_xml)
+
+    pretty_xml = parseString(tostring(doc)).toprettyxml(indent="  ")
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(pretty_xml)
+
+    print(f"Saved {len(annotations)} annotations to {output_path}")
+    return pretty_xml
+
+
+#templates of countstyles so u can call e.g. CountStyles['Circle']
+CountStyles = {
+'Circle': '/Circle',
+'Diamond':'/Diamond',
+'Triangle':'/Triangle',
+'Square':'/Square',
+'Checkmark':'/Checkmark',
+}
+
+def convert_to_bytes(input_pdf_path):
+  with open(input_pdf_path, "rb") as file:
+    original_pdf_bytes = file.read()
+  return original_pdf_bytes
+
+def mirrored_points(x, y, height_plan):
+  #'vertices': [[new_data[i][0][0][0], new_data[i][0][0][1]]],
+  mirrored = []
+  mirrored.append([x, height_plan - y])
+  return mirrored
+
+# Modified to adjust mirrored points
+def create_bb_bax_secondary(new_data, widthat, heightat, secondary_tobeprinted, CountStyles, input_user_clmn_names, page_number, height_plan):
+  bax_annotations = []
+  for i in range(len(new_data)):
+    r,g,b = new_data[i][len(new_data[i])-1] # colorr
+    R = str(float(r/255))
+    G = str(float(g/255))
+    B = str(float(b/255))
+    vertix = mirrored_points(new_data[i][0][0][0], new_data[i][0][0][1], height_plan)
+    if input_user_clmn_names[4] and input_user_clmn_names[5]:
+        bax_annotations.append({
+          'vertices': vertix,
+          'text': '1', #number of counts in one time (in markup written as count 1) -> if u want to change it we can look for a way
+          'author': 'ADR',
+          'custom_data': {'FireRating': secondary_tobeprinted[i][0], 'AcousticRating': secondary_tobeprinted[i][1], 'Height_': heightat[i],'Width_': widthat[i]} , #identify custom colums here as( Column name: Text to add )
+          'label': new_data[i][1], #change label to whatever u want
+          'Height': heightat[i],  #for tameem to change - i added any values'
+          'Width':widthat[i],
+          'page' : page_number,
+          'color':R+ ' '+G + ' '+B,# normalized (RGB --> R/255 G/255 B/255)
+          'countstyle': CountStyles['Circle'],
+          'countsize':'0.8' #how big or small is the count icon
+      })
+    else:
+      # Fire mawgooda
+      if input_user_clmn_names[4]:
+          bax_annotations.append({
+              'vertices': vertix,
+              'text': '1', #number of counts in one time (in markup written as count 1) -> if u want to change it we can look for a way
+              'author': 'ADR',
+              'custom_data': {'FireRating': secondary_tobeprinted[i][0], 'AcousticRating': secondary_tobeprinted[i][1], 'Height_': heightat[i],'Width_': widthat[i]} , #identify custom colums here as( Column name: Text to add )
+              'label': new_data[i][1], #change label to whatever u want
+              'Height': heightat[i],  #for tameem to change - i added any values'
+              'Width':widthat[i],
+              'page' : page_number,
+              'color':R+ ' '+G + ' '+B,# normalized (RGB --> R/255 G/255 B/255)
+              'countstyle': CountStyles['Circle'],
+              'countsize':'0.8' #how big or small is the count icon
+          })
+      elif input_user_clmn_names[5]:
+          bax_annotations.append({
+              'vertices': vertix,
+              'text': '1', #number of counts in one time (in markup written as count 1) -> if u want to change it we can look for a way
+              'author': 'ADR',
+              'custom_data': {'FireRating': secondary_tobeprinted[i][0], 'AcousticRating': secondary_tobeprinted[i][1], 'Height_': heightat[i],'Width_': widthat[i]} , #identify custom colums here as( Column name: Text to add )
+              'label': new_data[i][1], #change label to whatever u want
+              'Height': heightat[i],  #for tameem to change - i added any values'
+              'Width':widthat[i],
+              'page' : page_number,
+              'color':R+ ' '+G + ' '+B,# normalized (RGB --> R/255 G/255 B/255)
+              'countstyle': CountStyles['Circle'],
+              'countsize':'0.8' #how big or small is the count icon
+          })
+
+
+  return bax_annotations
+
+# Modified to adjust mirrored points
+def create_bb_bax(new_data, widthat, heightat, CountStyles, page_number, height_plan):
+  bax_annotations = []
+  for i in range(len(new_data)):
+    #r,g,b = new_data[i][len(new_data[i])-2] # colorr
+    r,g,b = new_data[i][2] # colorr
+    R = str(float(r/255))
+    G = str(float(g/255))
+    B = str(float(b/255))
+
+    vertix = mirrored_points(new_data[i][0][0][0], new_data[i][0][0][1], height_plan)
+    bax_annotations.append({
+          'vertices': vertix,
+          'text': '1', #number of counts in one time (in markup written as count 1) -> if u want to change it we can look for a way
+          'author': 'ADR',
+          'custom_data': {'FireRating': 'N/A', 'AcousticRating': 'N/A', 'Height_': heightat[i],'Width_': widthat[i]} , #identify custom colums here as( Column name: Text to add )
+          'label': new_data[i][1], #change label to whatever u want
+          'height': heightat[i],  #for tameem to change - i added any values'
+          'width':widthat[i],
+          'page' : page_number,
+          'color':R+ ' '+G + ' '+B,# normalized (RGB --> R/255 G/255 B/255)
+          'countstyle': CountStyles['Circle'],
+          'countsize':'0.8' #how big or small is the count icon
+      })
+
+  return bax_annotations
+
+#Handle missing widths or heights in some rows
+def generate_separate_dimensions(widths):
+  widthat = []
+  heightat = []
+  #pattern = r'(\d+)\s*mm wide x\s*(\d+)\s*mm high'
+  pattern = r'(\d+(?:\.\d+)?)\s*mm wide x\s*(\d+(?:\.\d+)?)\s*mm high'
+  for s in widths:
+    match = re.match(pattern, s)
+    if match:
+        width = match.group(1)
+        height = match.group(2)
+        widthat.append(width)
+        heightat.append(height)
+    else:
+      widthat.append("N/A")
+      heightat.append("N/A")
+  return widthat, heightat
+
+def generate_bluebeam_columns_raw(column_names):
+    """
+    Generate BluebeamUserDefinedColumns XML as raw string, without headers or extra fields.
+    """
+    root = Element("BluebeamUserDefinedColumns")
+
+    for idx, name in enumerate(column_names):
+        item = SubElement(root, "BSIColumnItem", Index=str(idx), Subtype="Text")
+        SubElement(item, "Name").text = name
+        SubElement(item, "DisplayOrder").text = str(idx)
+        SubElement(item, "Deleted").text = "False"
+        SubElement(item, "Multiline").text = "False"
+
+    # Convert to string and decode raw bytes
+    return tostring(root, encoding="unicode", method="xml")
+
+
+# Example usage
+# column_names = ["mycustomcolumn"]
+#column_xml = generate_bluebeam_columns_raw(column_order)
+
+#with open("count_type_Windows.xml", "w", encoding="utf-8") as f:
+#    f.write(column_xml)
+
+#print(column_xml)
 
 def mainRun(schedule, plan, searcharray):
     print("mainRun is RUNNING")
@@ -1145,23 +1555,26 @@ def mainRun(schedule, plan, searcharray):
     print(f"search array: {searcharray}")
       
     dfs = extract_tables(schedule)
-
-    pdfs = []
+    pdf_widths = []
+    pdf_heights = []
+    pdfs_count_type = []
+    
+    annotation_counter = 0
+    page_number = 0
+    bax_annotations_all_inputs = [] #for the same plan
+    #pdfs = []
     for p in plan:
+        annotation_counter +=1
+        page_number +=1
         pdf_document = fitz.open("pdf", p)
         # Get the first page (0-indexed)
         page = pdf_document[0]
         rect = page.rect  # Rectangle: contains x0, y0, x1, y1
 
-        width_pdf = rect.width   # or: width = rect.x1 - rect.x0
-        height_pdf = rect.height # or: height = rect.y1 - rect.y0
-
-        print(f"plan width: {width_pdf}")
-        print(f"plan height: {height_pdf}")
-
-        all_new_data = []
-        all_widths = []
-        pdf_outputs = [] 
+        width_plan = page.cropbox.width   # or: width = rect.x1 - rect.x0
+        height_plan = page.cropbox.height # or: height = rect.y1 - rect.y0
+        width_plan = math.ceil(width_plan)
+        height_plan = math.ceil(height_plan)
         
         for j in range(len(searcharray)):
           user_input = searcharray[j]
@@ -1181,6 +1594,16 @@ def mainRun(schedule, plan, searcharray):
             print("mafeesh secondary information")
         
           selected_columns_combined = get_selected_columns_all(dfs, user_input)
+          if selected_columns_combined is None:
+              dfs_normal = extract_tables(schedule)
+              column_indices = get_column_indices_from_dfs_normal(dfs_normal, user_input)
+              if len(dfs) == 1:
+                selected_columns_combined = get_selected_columns_by_index(dfs[0], column_indices)
+              if len(dfs) > 1:
+                index_df = get_df_index(dfs, input_user_clmn_names)
+                selected_columns_combined = get_selected_columns_by_index(dfs[index_df], column_indices)
+          selected_columns_combined = selected_columns_combined.applymap(lambda x: 'N/A' if isinstance(x, str) and x.strip() == '' else x)
+          selected_columns_combined = selected_columns_combined.fillna('N/A')
           kelma = get_st_op_pattern(selected_columns_combined, user_input)
           col_dict = get_similar_colors_all(selected_columns_combined)
           flattened_list = get_flattened_tuples_list_all(col_dict)
@@ -1200,31 +1623,22 @@ def mainRun(schedule, plan, searcharray):
                       width_info_tobeprinted, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
                       cleaned_width = get_cleaned_width(width_info_tobeprinted)
                       widths = get_widths_bb_format(cleaned_width, kelma)
-                  #Handling schedules without dimensions (width and height)
-                  if selected_columns_combined.shape[1] == 2:
-                    widths = []
+                  
                   
                   secondary_printed_clean =  get_secondary_tobeprinted_clean(selected_columns_combined, secondary_tobeprinted, secondary_info)
                   all_print =  mix_width_secondary(widths, secondary_printed_clean)
-
-                  #Single page annotation
-                  all_widths.append(all_print)
-        
-                  #flat_list_new_data = [item for sublist in all_new_data for item in sublist]
-                  #flat_list_widths = [item for sublist in all_widths for item in sublist]
-        
-                  if pdf_outputs:
-                    final_pdf_bytes = process_pdf_secondary(pdf_outputs[j-1], "final_output_multiple_input_new2.pdf", all_new_data[j], all_widths[j], main_info, secondary_info)
-                    pdf_outputs.append(final_pdf_bytes)
-                  else:
-                    final_pdf_bytes = process_pdf_secondary(p, "final_output_multiple_input_new2.pdf", all_new_data[j], all_widths[j], main_info, secondary_info)
-                    pdf_outputs.append(final_pdf_bytes)
+                  
+                  #Count type annotation
+                  widht_count, height_count = generate_separate_dimensions(widths)
+                  bax = create_bb_bax_secondary(new_data3, widht_count, height_count, secondary_tobeprinted, CountStyles, user_input, page_number, height_plan)
+                  bax_annotations_all_inputs.append(bax)
+                  
                                     
           else:
               locations, not_found = get_word_locations_plan(flattened_list,plan_texts)
               new_data = get_cleaned_data(locations)
-              #Single page annotation
-              all_new_data.append(new_data)
+              if len(new_data) == 0:
+                  continue
               repeated_labels = get_repeated_labels(locations)
               if kelma == None:
                   widths = get_width_info_tobeprinted(new_data)
@@ -1232,30 +1646,36 @@ def mainRun(schedule, plan, searcharray):
                   width_info_tobeprinted = get_width_info_tobeprinted(new_data)
                   cleaned_width = get_cleaned_width(width_info_tobeprinted)
                   widths = get_widths_bb_format(cleaned_width, kelma)
-
-              #Handling schedules without dimensions (width and height)  
-              if selected_columns_combined.shape[1] == 2:
-                  widths = []
-              
-              #Single page annotation
-              all_widths.append(widths)
+              #count type annotation
+              widht_count, height_count = generate_separate_dimensions(widths)
+              bax = create_bb_bax(new_data, widht_count, height_count, CountStyles, page_number, height_plan)
+              bax_annotations_all_inputs.append(bax)
         
-              flat_list_new_data = [item for sublist in all_new_data for item in sublist]
-              flat_list_widths = [item for sublist in all_widths for item in sublist]
-        
-              if pdf_outputs:
-                  final_pdf_bytes = process_pdf(pdf_outputs[j-1], "final_output_width_trial.pdf", all_new_data[j], all_widths[j])
-                  pdf_outputs.append(final_pdf_bytes)
-              else:
-                  final_pdf_bytes = process_pdf(p, "final_output_width_trial.pdf", all_new_data[j], all_widths[j])
-                  pdf_outputs.append(final_pdf_bytes)  
-          
+        # if it is not byte type
+        #pdfs_count_type.append(convert_to_bytes(p))
+        pdfs_count_type.append(p)
+        pdf_widths.append(width_plan)
+        pdf_heights.append(height_plan)
+    merged_pdf = merge_pdf_bytes_list(pdfs_count_type)
+    print(f"number of pges of merged_pdf is {len(merged_pdf)} and its type is {type(merged_pdf)}")
+
+    bax_annotation = []
+    for bax_ann in bax_annotations_all_inputs:
+        bax_annotation.extend(bax_ann)
+
+    column_order = ['FireRating', 'AcousticRating', 'Height_', 'Width_']
+    
+    
+    
+    pretty_xml = save_multiple_annotations_count_bax(bax_annotation, 'count_type_Windows.bax', column_order,pdf_widths,pdf_heights,page_number)
+    column_xml = generate_bluebeam_columns_raw(column_order)
+
+
+    ##### SHOULD return pretty_xml, column_xml, merged_pdf
 
-        pdfs.append(final_pdf_bytes)
-        merged_pdf = merge_pdf_bytes_list(pdfs)
-        print(f"number of pges of merged_pdf is {len(merged_pdf)} and its type is {type(merged_pdf)}")
+    return pretty_xml, column_xml, merged_pdf
     
-    not_found = []
+'''    not_found = []
     doc2 =fitz.open('pdf',merged_pdf)
     len_doc2 = len(doc2)
     print(f"number of pges of doc2 is {len_doc2} and its type is {type(doc2)}")
@@ -1286,3 +1706,4 @@ def mainRun(schedule, plan, searcharray):
                 x,y,z=int(annot_color.get(v)[0]*255),int(annot_color.get(v)[1]*255),int(annot_color.get(v)[2]*255)
                 list1.loc[len(list1)] =[annot.info['content'],annot.info['id'],annot.info['subject'],[x,y,z]]
     return annotatedimg, doc2 , list1, repeated_labels , not_found 
+'''