Create old_Doors_schedule.py

old_Doors_schedule.py

@@ -0,0 +1,1288 @@
+from collections import defaultdict
+import pandas as pd
+import random
+import re
+import io
+import pypdfium2 as pdfium
+import fitz 
+from PIL import Image, ImageDraw
+from PyPDF2 import PdfReader, PdfWriter
+from PyPDF2.generic import TextStringObject, NameObject, ArrayObject, FloatObject
+from PyPDF2.generic import NameObject, TextStringObject, DictionaryObject, FloatObject, ArrayObject
+from PyPDF2 import PdfReader
+from PyPDF2.generic import TextStringObject
+import numpy as np
+import cv2
+from collections import defaultdict
+import random
+import fitz  # PyMuPDF
+import PyPDF2
+import io
+from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
+from PyPDF2 import PdfReader, PdfWriter
+
+
+def convert2img(path):
+    pdf = pdfium.PdfDocument(path)
+    page = pdf.get_page(0)
+    pil_image = page.render().to_pil()
+    pl1=np.array(pil_image)
+    img = cv2.cvtColor(pl1, cv2.COLOR_RGB2BGR)
+    return img
+
+def convert2pillow(path):
+  pdf = pdfium.PdfDocument(path)
+  page = pdf.get_page(0)
+  pil_image = page.render().to_pil()
+  return pil_image
+
+def calculate_midpoint(x1,y1,x2,y2):
+  xm = int((x1 + x2) / 2)
+  ym = int((y1 + y2) / 2)
+  return (xm, ym)
+
+def read_text(input_pdf_path):
+    pdf_document = fitz.open('pdf',input_pdf_path)
+
+    for page_num in range(pdf_document.page_count):
+        page = pdf_document[page_num]
+        text_instances = page.get_text("words")
+
+        page.apply_redactions()
+    return text_instances
+
+def normalize_text(text):
+    """
+    Normalize text by removing all whitespace characters and converting to lowercase.
+    """
+    if not isinstance(text, str):
+        return ""
+    # Remove all whitespace characters (spaces, tabs, newlines)
+    text = re.sub(r'\s+', '', text)
+    return text.lower()
+
+
+def build_flexible_regex(term):
+    """
+    Match the full string, allowing whitespace or light punctuation between words,
+    but not allowing extra words or partial matches.
+    """
+    words = normalize_text(term).split()
+    pattern = r'[\s\.\:\-]*'.join(map(re.escape, words))
+    full_pattern = rf'^{pattern}$'
+    return re.compile(full_pattern, re.IGNORECASE)
+
+def flexible_search(df, search_terms):
+    """
+    Search for terms in column names and top N rows.
+    Returns matched column indices and cell positions.
+    """
+    normalized_columns = [normalize_text(col) for col in df.columns]
+    results = {term: {"col_matches": [], "cell_matches": []} for term in search_terms}
+
+    for term in search_terms:
+        regex = build_flexible_regex(term)
+
+        # Search in column names
+        for col_idx, col_text in enumerate(df.columns):
+            norm_col = normalize_text(col_text)
+            if regex.search(norm_col):
+                results[term]["col_matches"].append(col_idx)
+
+        # Search in top N rows
+        for row_idx in range(min(3, len(df))):
+            for col_idx in range(len(df.columns)):
+                cell_text = normalize_text(df.iat[row_idx, col_idx])
+                if regex.search(cell_text):
+                    results[term]["cell_matches"].append((row_idx, col_idx))
+
+    return results
+
+
+def generate_current_table_without_cropping(clm_idx, clmn_name, df):
+  selected_df = df.iloc[:, clm_idx]
+  print("hello I generated the selected columns table without cropping")
+  selected_df.columns = clmn_name
+  return selected_df
+
+
+
+def crop_rename_table(indices, clmn_name, clmn_idx,df):
+  #crop_at = (max(set(indices), key=indices.count)) + 1
+  crop_at =  max(indices) + 1
+
+  df = df.iloc[crop_at:]  # Starts from row index 5 (zero-based index)
+  df.reset_index(drop=True, inplace=True)  # Reset index after cropping
+
+
+  slctd_clms = df.iloc[:, clmn_idx]  # Select columns by index
+  slctd_clms.columns = clmn_name  # Rename selected columns
+
+  return slctd_clms
+
+def clean_column_row(row):
+    return [re.sub(r'^\d+-\s*', '', str(cell)) for cell in row]
+
+def details_in_another_table(clmn_name, clmn_idx, current_dfs, dfs):
+    matching_dfs = [
+        dff for dff in dfs
+        if dff is not current_dfs and current_dfs.shape[1] == dff.shape[1]
+    ]
+
+    if not matching_dfs:
+        return None
+
+    updated_dfs = []
+    for dff in matching_dfs:
+        selected_dff = dff.iloc[:, clmn_idx].copy()
+
+        # Clean the column names and make them a row
+        cleaned_header = clean_column_row(selected_dff.columns.tolist())
+        col_names_as_row = pd.DataFrame([cleaned_header])
+
+        # Rename columns
+        selected_dff.columns = clmn_name
+        col_names_as_row.columns = clmn_name
+
+        # Combine the cleaned row with data
+        temp_df = pd.concat([col_names_as_row, selected_dff], ignore_index=True)
+        updated_dfs.append(temp_df)
+
+    combined_df = pd.concat(updated_dfs, ignore_index=True)
+
+    return combined_df
+
+def map_user_input_to_standard_labels(user_inputs):
+    patterns = {
+        'door_id': r'\b(?:door\s*)?(?:id|no|number)\b|\bdoor\s*name\b',
+        'door_type': r'\b(?:\S+\s+)?door\s*type\b|\btype(?:\s+\w+)?\b',
+        'structural_opening': r'\bstructural\s+opening\b',
+        'width': r'\bwidth\b',
+        'height': r'\bheight\b',
+    }
+
+    def normalize(text):
+        return re.sub(r'\s+', ' ', text.strip(), flags=re.MULTILINE).lower()
+
+    mapped = {}
+
+    for item in user_inputs:
+        normalized_item = normalize(item)
+        matched = False
+        for label, pattern in patterns.items():
+            if label not in mapped and re.search(pattern, normalized_item, re.IGNORECASE):
+                mapped[label] = item
+                matched = True
+                break
+        #if not matched:
+         #   mapped[normalized_item] = None
+
+    return mapped
+
+def analyse_cell_columns(cell_columns_appearance):
+  cell_matches = []
+  col_matches = []
+  for key in cell_columns_appearance.keys():
+    if len(cell_columns_appearance[key]['cell_matches']) >0:
+      cell_matches.append(cell_columns_appearance[key]['cell_matches'][0])
+    if len(cell_columns_appearance[key]['col_matches']) >0:
+      col_matches.append(cell_columns_appearance[key]['col_matches'][0])
+  return cell_matches, col_matches
+
+# when column names are located in the cells
+def get_row_column_indices(cell_clmn_indx):
+  row_index = []
+  column_index = []
+  for t in cell_clmn_indx:
+    row_index.append(t[0])
+    column_index.append(t[1])
+  return row_index, column_index
+
+# when column names are located in the coulmns itself
+def get_column_index(col_matches):
+  idx = []
+  for t in col_matches:
+    idx.append(t)
+  return idx
+
+
+def extract_tables(schedule):
+  doc = fitz.open("pdf",schedule)
+  for page in doc:
+    tabs = page.find_tables()
+  dfs = []
+  for tab in tabs:
+    df = tab.to_pandas()
+    dfs.append(df)
+  return dfs
+
+def get_selected_columns(dfs, user_patterns):
+  selected_columns = []
+  selected_columns_new = None # Initialize selected_columns_new to None
+
+  for i in range(len(dfs)):
+    cell_columns_appearance = flexible_search(dfs[i], user_patterns)
+    cell_matches, col_matches = analyse_cell_columns(cell_columns_appearance)
+
+   
+
+    if len(user_patterns) == 2:
+      clmn_name = ["door_id", "door_type"] 
+    if len(user_patterns) == 4:
+      clmn_name = ["door_id", "door_type", "width", "height"]
+    if len(user_patterns) == 3:
+        clmn_name = ["door_id", "door_type", "structural opening"]
+    if len(cell_matches) == 0 and len(col_matches) == 0:
+      print(f"this is df {i}, SEARCH IN ANOTHER DF")
+    else:
+      #IN COLUMNS
+      if len(col_matches) == len(user_patterns):
+        column_index_list = get_column_index(col_matches)
+        print(f"this is df {i} mawgooda fel columns, check el df length 3ashan law el details fe table tany")
+
+        print(column_index_list)
+        if len(dfs[i]) <10:
+          selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
+
+        #details in the same table
+        if len(dfs[i]) >10:
+          selected_columns_new = generate_current_table_without_cropping(column_index_list,dfs[i])
+          #break
+
+      #IN CELLS
+      if len(cell_matches) == len(user_patterns):
+        row_index_list, column_index_list = get_row_column_indices(cell_matches)
+        print(f"this is df {i} mawgooda fel cells, check el df length 3ashan law el details fe table tany")
+
+        #details in another table
+        if len(dfs[i]) <10:
+          #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)
+          break
+        #details in the same table
+        if len(dfs[i]) >10:
+          print(f"this is df {i} call crop_rename_table(indices, clmn_name, clmn_idx,df)")
+          selected_columns_new = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+          break
+  return selected_columns_new
+
+
+
+def separate_main_secondary(input_user_clmn_names):
+  main_info = input_user_clmn_names[:4]
+  secondary_info = input_user_clmn_names[4:]
+  return main_info, secondary_info
+
+    
+# take main info
+def get_column_name(user_input_m):
+  #get empty indices
+  empty_indices = [i for i, v in enumerate(user_input_m) if v == '']
+
+  # fixed column names
+  fixed_list = ["door_id", "door_type", "width", "height"]
+  for i in range(len(empty_indices)):
+    if empty_indices[i] == 3:
+      fixed_list[2] = "structural_opening"
+    fixed_list[empty_indices[i]] = ""
+
+  #finalize the column name structure
+  clmn_name_m = [i for i in fixed_list if i]
+
+  return clmn_name_m
+
+# take secondary info
+def get_column_name_secondary(user_input_m):
+  #get empty indices
+  empty_indices = [i for i, v in enumerate(user_input_m) if v == '']
+
+  # fixed column names
+  fixed_list = ["fire_rate", "acoustic_rate"]
+  for i in range(len(empty_indices)):
+    fixed_list[empty_indices[i]] = ""
+
+  #finalize the column name structure
+  clmn_name_m = [i for i in fixed_list if i]
+
+  return clmn_name_m
+
+
+#handling both main and secondary info together in one table
+def get_selected_columns_all(dfs, user_patterns):
+  selected_columns = []
+  selected_columns_new = None # Initialize selected_columns_new to None
+
+  for i in range(len(dfs)):
+
+
+
+
+
+    main_info, secondary_info = separate_main_secondary(user_patterns)
+    clmn_name_main = get_column_name(main_info)
+    non_empty_main_info = [item for item in main_info if item]
+
+    clmn_name_secondary = get_column_name_secondary(secondary_info)
+
+
+    non_empty_secondary_info = [item for item in secondary_info if item]
+
+    clmn_name = clmn_name_main + clmn_name_secondary
+    non_empty_info = non_empty_main_info + non_empty_secondary_info
+
+    #print(f"main info: {main_info}")
+    print(f"clmn name: {clmn_name}")
+    print(f"non-empty info: {non_empty_info}")
+    #print(f"length of non-empty info: {len(non_empty_main_info)}")
+
+
+    cell_columns_appearance = flexible_search(dfs[i], non_empty_info)
+    cell_matches, col_matches = analyse_cell_columns(cell_columns_appearance)
+
+    print(f"length of cell_matches: {len(cell_matches)}")
+    print(f"cell_matches: {cell_matches}")
+    #clmn_name = map_user_input_to_standard_labels(user_patterns)
+    #if len(clmn_name) < len(user_patterns):
+
+
+
+
+    print(clmn_name)
+
+    if len(cell_matches) == 0 and len(col_matches) == 0:
+      print(f"this is df {i}, SEARCH IN ANOTHER DF")
+
+    else:
+      #IN COLUMNS
+      if len(col_matches) == len(non_empty_info):
+        column_index_list = get_column_index(col_matches)
+        print(f"this is df {i} mawgooda fel columns, check el df length 3ashan law el details fe table tany")
+        #print(len(clm_idx))
+        #details in another table
+        print(column_index_list)
+        if len(dfs[i]) <10:
+          selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
+          #break
+          #other_matches = details_in_another_table_mod(clmn_name, clmn_idx, dfs[i], dfs)
+        #details in the same table
+        if len(dfs[i]) >10:
+          selected_columns_new = generate_current_table_without_cropping(column_index_list,dfs[i])
+          #break
+
+      #IN CELLS
+      if len(cell_matches) == len(non_empty_info):
+        row_index_list, column_index_list = get_row_column_indices(cell_matches)
+        print(f"this is df {i} mawgooda fel cells, check el df length 3ashan law el details fe table tany")
+
+        #details in another table
+        #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])
+
+        break
+            #other_matches = details_in_another_table_mod(clmn_name, clmn_idx, dfs[i], dfs)
+        ##details in the same table
+        #if len(dfs[i]) >2:
+         # #print(f"this is df {i} call crop_rename_table(indices, clmn_name, clmn_idx,df)")
+          #break
+  return selected_columns_new
+
+
+# 3ayz akhaleehaa te search fel selected_columns column names nafsaha
+# 7ab2a 3ayz a3raf bardo maktooba ezay fel df el 7a2e2ya (akeed za ma el user medakhalha bezabt)
+def get_st_op_pattern(selected_columns, user_input):
+    target = 'structural_opening'
+    if target in selected_columns.columns:
+      name = user_input[2]
+      return name
+    return None
+
+
+def find_text_in_plan(label, x):
+  substring_coordinates = []
+  words = []
+  point_list  = []
+  #None, None, None
+  for tpl in x:
+    if tpl[4] == label:
+      substring_coordinates.append(calculate_midpoint(tpl[0],tpl[1],tpl[2],tpl[3]))# for pdf
+      point_list.append(calculate_midpoint(tpl[1],tpl[0],tpl[3],tpl[2]))# for rotated
+      words.append(tpl[4])
+  return substring_coordinates, words, point_list
+
+
+
+def get_word_locations_plan(flattened_list, plan_texts):
+  locations = []
+  not_found = []
+
+  if len(flattened_list[0]) == 2:
+    for lbl, clr in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr))
+
+  if len(flattened_list[0]) == 3:
+    for lbl, w, clr in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, w))
+  if len(flattened_list[0]) == 4:
+    for lbl, w, h, clr in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, w, h))
+  return locations, not_found
+    
+def get_repeated_labels(locations):
+  seen_labels = set()
+  repeated_labels = set()
+
+  for item in locations:
+      label = item[1]
+      if label in seen_labels:
+          repeated_labels.add(label)
+      else:
+          seen_labels.add(label)
+  return repeated_labels
+
+def get_cleaned_data(locations):
+  processed = defaultdict(int)
+
+  new_data = []
+  if len(locations[0]) == 3:
+    for coords, label, color in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color))
+
+  if len(locations[0]) == 4:
+    for coords, label, color, w in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, w))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, w))
+  if len(locations[0]) == 5:
+    for coords, label, color, w, h in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, w, h))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, w, h))
+
+  return new_data
+
+
+# law 0.5 maslan tetkatab we law mesh keda yesheel el decimal point
+def get_width_info_tobeprinted(new_data):
+  width_info_tobeprinted = []
+  if len(new_data[0]) == 4:
+    for _,_,_, w in new_data:
+      #w = re.sub(r",", "", w)
+      #w = int(float(w))
+      width_info_tobeprinted.append(w)
+  if len(new_data[0]) == 5:
+    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:
+        w = w
+      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
+    text = text.replace(",", "")  # Remove remaining commas if any
+    return text
+
+def get_cleaned_width(width_info_tobeprinted):
+  cleaned_width = []
+  for w in width_info_tobeprinted:
+    cleaned_width.append(clean_dimensions(w))  
+  return cleaned_width
+
+
+def get_widths_bb_format(cleaned_width, kelma):
+  pattern = r"\bW(?:idth)?\s*[×x]\s*H(?:eight)?\b"
+  match = re.search(pattern, kelma)
+  widths = []
+  for widthaa in cleaned_width:
+    index = max(widthaa.find("x"), widthaa.find("×"), widthaa.find("x"), widthaa.find("X"), widthaa.find("x"))
+    width_name = widthaa[:index]
+    height_name = widthaa[index+1:]
+    width_name = int(float(width_name))
+    height_name = int(float(height_name))
+    if match:
+      full_text = f"{width_name} mm wide x {height_name} mm high"
+    else:
+      full_text = f"{height_name} mm wide x {width_name} mm high"
+    widths.append(full_text)
+  return widths
+
+
+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 float(w).is_integer():
+        w = int(float(w))
+      else:
+        w = w
+      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)
+
+
+  if len(main_info) == 4 and len(secondary_info) == 2:
+    for coords, label, width, height, acous, fire, color in new_data:
+      w = re.sub(r",", "", width)
+      h = re.sub(r",", "", height)
+      if float(w).is_integer():
+        w = int(float(w))
+      else:
+        w = w
+      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 = []
+  not_found = []
+  len_main = len(main_info) #3 or #4 #sometimes maybe 2
+  len_secondary = len(secondary_info) #2 or #1
+
+  if len_main == 2 and len_secondary == 2:
+    for lbl, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, acoustic, fire))
+
+  if len_main == 2 and len_secondary == 1:
+    for lbl, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, acoustic))
+
+
+
+  if len_main == 3 and len_secondary == 2:
+    for lbl, w, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, clr, acoustic, fire))
+
+  if len_main == 3 and len_secondary == 1:
+    for lbl, w, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, clr, acoustic))
+
+
+
+  if len_main == 4 and len_secondary == 2:
+    for lbl, w, h, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, h, clr, acoustic, fire))
+
+  if len_main == 4 and len_secondary == 1:
+    for lbl, w, h, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, h, clr,acoustic))
+  return locations, not_found
+
+### newest, accept combined table
+def get_similar_colors_all(selected_columns_new):
+    def generate_rgb():
+        return (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+
+    unique_keys = selected_columns_new['door_type'].unique()
+    key_colors = {key: generate_rgb() for key in unique_keys}
+
+    #Column fields
+    clmns_fields = selected_columns_new.columns.to_list()
+
+    def col_template():
+        d = {
+            'values': [],
+            'color': None
+        }
+        for field in clmns_fields:
+            d[field] = []
+        return d
+
+    col_dict = defaultdict(col_template)
+
+    for _, row in selected_columns_new.iterrows():
+        key = row['door_type']
+        col_dict[key]['values'].append(row['door_id'])
+
+        for field in clmns_fields:
+            col_dict[key][field].append(row.get(field, None))
+
+        col_dict[key]['color'] = key_colors[key]
+
+    return dict(col_dict)
+
+### newest, accept combined table
+def get_flattened_tuples_list_all(col_dict):
+    exclude_fields = ['door_type', 'values']
+    flattened_list = []
+
+    for values_dict in col_dict.values():
+        # All fields that are lists and not in the excluded fields
+        list_fields = [k for k, v in values_dict.items()
+                       if isinstance(v, list) and k not in exclude_fields]
+        n_rows = len(values_dict[list_fields[0]]) if list_fields else 0
+
+        for i in range(n_rows):
+            tuple_row = tuple(values_dict[field][i] for field in list_fields) + (values_dict['color'],)
+            flattened_list.append(tuple_row)
+
+    return flattened_list
+
+
+#SECONDARY
+def get_cleaned_data_secondary(locations, main_info, secondary_info):
+  processed = defaultdict(int)
+
+  new_data = []
+  if len(main_info) == 2 and len(secondary_info) == 1:
+    for coords, label, color, acous in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, acous))
+
+  if len(main_info) == 2 and len(secondary_info) == 2:
+    for coords, label, color, acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, acous, fire))
+
+
+  if len(main_info) == 3 and len(secondary_info) == 1:
+    for coords, label, width, color, acous in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, color, acous))
+
+  if len(main_info) == 3 and len(secondary_info) == 2:
+    for coords, label, width, color, acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, color, acous, fire))
+
+  if len(main_info) == 4 and len(secondary_info) == 1:
+    for coords, label, width, height, color, acous in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, height, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, height, color, acous))
+
+  if len(main_info) == 4 and len(secondary_info) == 2:
+    for coords, label, width, height, color,  acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, height, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, height, color, acous, fire))
+
+  return new_data
+
+def get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info):
+  secondary_printed_clean = []
+  if len(secondary_info) == 1:
+    if any('acoustic' in col for col in selected_secondary_info.columns):
+      for acous in secondary_tobeprinted:
+        new_text = f"acoustic rating: {acous};"
+        secondary_printed_clean.append(new_text)
+    if any('fire' in col for col in selected_secondary_info.columns):
+      for fire in secondary_tobeprinted:
+        new_text = f"fire rating: {fire};"
+        secondary_printed_clean.append(new_text)
+  if len(secondary_info) == 2:
+    for fire, acous in secondary_tobeprinted:
+      new_text = f"fire rating: {fire}; acoustic rating: {acous};"
+      secondary_printed_clean.append(new_text)
+      print(new_text)
+  return secondary_printed_clean
+
+
+def mix_width_secondary(widths, secondary_printed_clean):
+  all_print = []
+  for i in range(len(widths)):
+    newest_text = f"{widths[i]}; {secondary_printed_clean[i]}"
+    all_print.append(newest_text) 
+  return all_print
+
+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
+
+    page = pdf_document[0]  # First page
+    if len(main_info) == 2 and len(secondary_info) == 1:
+        for loc in locations:
+            coor, lbl, acous, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    if len(main_info) == 2 and len(secondary_info) == 2:
+        for loc in locations:
+            coor, lbl, acous, fire, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    if len(main_info) == 3 and len(secondary_info) == 1:
+        for loc in locations:
+            if len(loc) != 5:
+                continue
+            coor, lbl, w, acous, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    if len(main_info) == 3 and len(secondary_info) == 2:
+        for loc in locations:
+            coor, lbl, w, acous, fire, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    if len(main_info) == 4 and len(secondary_info) == 1:
+        for loc in locations:
+            coor, lbl, w, h, acous, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    if len(main_info) == 4 and len(secondary_info) == 2:
+        for loc in locations:
+            coor, lbl, w, h, acous, fire, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+
+
+    #Save modified PDF to a variable instead of a file
+    output_stream = io.BytesIO()
+    pdf_document.save(output_stream)
+    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
+    reader = PyPDF2.PdfReader(pdf_stream)
+    writer = PyPDF2.PdfWriter()
+
+    author_index = 0  # Track author assignment
+
+    for page in reader.pages:
+        if "/Annots" in page:  #Check if annotations exist
+            for annot in page["/Annots"]:
+                annot_obj = annot.get_object()
+                # Assign each annotation a unique author
+                if len(new_authors) == 0:
+                    break
+                if author_index < len(new_authors):
+                    annot_obj.update({"/T": TextStringObject(new_authors[author_index])})#Convert to PdfString
+                    author_index += 1  # Move to next author
+
+                # If authors list is exhausted, keep the last one
+                else:
+                    annot_obj.update({"/T": TextStringObject(new_authors[-1])})
+
+        writer.add_page(page)
+
+    #Save the modified PDF to a variable
+    output_stream = io.BytesIO()
+    writer.write(output_stream)
+    output_stream.seek(0)
+
+    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
+
+    page = pdf_document[0]  # First page
+    print(f"length of locations 0 from not sec presence: {len(locations[0])}")
+
+    for loc in locations:
+
+      if len(loc) == 3:
+            coor, lbl, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+      if len(loc) == 4:
+            coor, lbl, clr,w = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+      if len(loc) == 5:
+            coor, lbl, clr,w,h = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    #Save modified PDF to a variable instead of a file
+    output_stream = io.BytesIO()
+    pdf_document.save(output_stream)
+    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
+    reader = PyPDF2.PdfReader(pdf_stream)
+    writer = PyPDF2.PdfWriter()
+
+    author_index = 0  # Track author assignment
+
+    for page in reader.pages:
+        if "/Annots" in page:  #Check if annotations exist
+            for annot in page["/Annots"]:
+                annot_obj = annot.get_object()
+                # Assign each annotation a unique author
+                if len(new_authors) == 0:
+                    break
+                if author_index < len(new_authors):
+                    annot_obj.update({"/T": TextStringObject(new_authors[author_index])})#Convert to PdfString
+                    author_index += 1  # Move to next author
+
+                # If authors list is exhausted, keep the last one
+                else:
+                    annot_obj.update({"/T": TextStringObject(new_authors[-1])})
+
+        writer.add_page(page)
+
+    #Save the modified PDF to a variable
+    output_stream = io.BytesIO()
+    writer.write(output_stream)
+    output_stream.seek(0)
+
+    return output_stream.read()
+
+
+
+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 process_pdf_secondary(input_pdf_path, output_pdf_path, locations, new_authors, main_info, secondary_info):
+    
+    if isinstance(input_pdf_path, bytes):
+      original_pdf_bytes = input_pdf_path
+    else:
+        with open(input_pdf_path, "rb") as file:
+            original_pdf_bytes = file.read()
+
+    #Add Bluebeam-compatible count annotations
+    annotated_pdf_bytes = add_bluebeam_count_annotations_secondary(original_pdf_bytes, locations, main_info, secondary_info)
+
+    #Modify author field using PyPDF2
+    final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
+
+    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):
+        original_pdf_bytes = input_pdf_path
+    else:
+        with open(input_pdf_path, "rb") as file:
+            original_pdf_bytes = file.read()
+
+    #Add Bluebeam-compatible count annotations
+    annotated_pdf_bytes = add_bluebeam_count_annotations(original_pdf_bytes, locations)
+
+    #Modify author field using PyPDF2
+    final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
+    return final_pdf_bytes
+
+def mainRun(schedule, plan, searcharray):
+    print("mainRun is RUNNING")
+    
+    #print(type(plan))
+    eltype = type(plan)
+    print(f"el type beta3 variable plan:: {eltype}")
+    len_plan = len(plan)
+    print(f"length of the plan's array is: {len_plan}")
+    p1_type = type(plan[0])
+    print(f"el mawgood fe p[0]: {p1_type}")
+    
+    print(f"search array: {searcharray}")
+      
+    dfs = extract_tables(schedule)
+
+    pdfs = []
+    for p in plan:
+        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 = [] 
+        
+        for j in range(len(searcharray)):
+          user_input = searcharray[j]
+            
+          secondary_presence = False
+          if user_input[4] or user_input[5]:
+            secondary_presence = True
+            main_info_, secondary_info_ = separate_main_secondary(user_input)
+            main_info = [item for item in main_info_ if item]
+            secondary_info = [item for item in secondary_info_ if item]        
+            print("feh secondary information")
+            if user_input[4]:
+              print("Fire rate mawgooda")
+            if user_input[5]:
+              print("Acoustic Rate mawgooda")
+          else:
+            print("mafeesh secondary information")
+        
+          selected_columns_combined = get_selected_columns_all(dfs, user_input)
+          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)
+          plan_texts = read_text(p)
+
+          if secondary_presence:
+                  plan_texts = read_text(p)
+                  locations, not_found = get_word_locations_plan_secondary(flattened_list,plan_texts, main_info, secondary_info)
+                  new_data3 = get_cleaned_data_secondary(locations,main_info,secondary_info)
+                  
+                  #Single page annotation
+                  all_new_data.append(new_data3)
+                  repeated_labels = get_repeated_labels(locations)
+                  if kelma == None:
+                      widths, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
+                  else:
+                      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)
+                                    
+          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)
+              repeated_labels = get_repeated_labels(locations)
+              if kelma == None:
+                  widths = get_width_info_tobeprinted(new_data)
+              else:
+                  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)
+        
+              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)  
+          
+
+        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)}")
+    
+    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)}")
+    page=doc2[0]
+    pix = page.get_pixmap()  # render page to an image
+    pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+    img=np.array(pl)
+    annotatedimg = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    
+    
+    list1=pd.DataFrame(columns=['content',  'id',  'subject','color'])
+    
+    # for page in doc:
+    for page in doc2:  
+        # Iterate through annotations on the page
+        for annot in page.annots():
+            # Get the color of the annotation
+            annot_color = annot.colors
+            if annot_color is not None:
+                # annot_color is a dictionary with 'stroke' and 'fill' keys
+                stroke_color = annot_color.get('stroke')  # Border color
+                fill_color = annot_color.get('fill')      # Fill color
+                if fill_color:
+                  v='fill'
+                  # print('fill')
+                if stroke_color:
+                  v='stroke'
+                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