Update Doors_Schedule

Doors_Schedule

@@ -227,3 +227,193 @@ def get_st_op_pattern(clm_idx, clmn_name, starting_row_index):
   kelma = df.iloc[starting_row_index[position], structural_opening_value]
   return kelma
 
+def get_similar_colors(selected_columns_new):
+  def generate_rgb():
+      return (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))  # RGB tuple
+
+  unique_keys = selected_columns_new['door_type'].unique()
+  key_colors = {key: generate_rgb() for key in unique_keys}  # Assign a unique RGB color to each key
+
+  # Create dictionary storing values, colors, and widths
+  col_dict = defaultdict(lambda: {'values': [], 'color': None, 'widths': []})
+
+  for _, row in selected_columns_new.iterrows():
+      key = row['door_type']
+      col_dict[key]['values'].append(row['door_id'])
+      col_dict[key]['widths'].append(row['structural opening'])  # Add structural opening
+      col_dict[key]['color'] = key_colors[key]  # Assign the unique RGB color
+
+  # Convert defaultdict to a normal dictionary
+  col_dict = dict(col_dict)
+  return col_dict
+
+def get_flattened_tuples_list(col_dict):
+  tuples_list = []
+  for key in col_dict.keys():
+      tuples_list.append([(value, width, col_dict[key]["color"]) for value, width in zip(col_dict[key]['values'], col_dict[key]['widths'])])
+  flattened_list = [item for sublist in tuples_list for item in sublist]
+  return flattened_list
+
+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):
+  locations = []
+  not_found = []
+  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)) 
+  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 = []
+  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)) 
+  return new_data
+
+def get_width_info_tobeprinted(new_data):
+  width_info_tobeprinted = []
+  for _,_,_, w in new_data:
+    width_info_tobeprinted.append(w)
+  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):
+  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:]
+    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
+
+import fitz  # PyMuPDF
+import PyPDF2
+import io
+from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
+
+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
+    for loc in locations:
+        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
+
+    #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 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)
+
+    return output_stream.getvalue()  # Return modified PDF as bytes
+
+def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
+    #Load original PDF
+    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)
+
+    #Save the final modified PDF to disk
+    with open(output_pdf_path, "wb") as file:
+        file.write(final_pdf_bytes)
+
+process_pdf(plan, "final_output_width.pdf", new_data, widths)