Update deploying_3_3.py

deploying_3_3.py

@@ -563,7 +563,17 @@ def get_hatch_color(entity):
 
 """### Hatched areas"""
 def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
-    
+
+      doc = ezdxf.readfile(filename)
+      doc.header['$MEASUREMENT'] = 1
+      msp = doc.modelspace()
+      trial=0
+      hatched_areas = []
+      threshold=0.001
+      TextFound = 0
+      j=0
+      unique_shapes = []
+
       text_with_positions = []
       text_color_mapping = {}
       color_palette = [
@@ -585,14 +595,181 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
           (74, 43, 98), (188, 13, 123), (129, 58, 91), (255, 128, 100),
           (171, 122, 145), (255, 98, 98), (222, 48, 77)
       ]
+
+      import re
+
+      text_with_positions = []
+
+      if(SearchArray):
+        for i in range(len(SearchArray)):
+
+          if (SearchArray[i][0] and SearchArray[i][1] and SearchArray[i][2]):
+                  for text_entity in doc.modelspace().query('TEXT MTEXT'):
+                      text = text_entity.text.strip() if hasattr(text_entity, 'text') else ""
+                      # if (text.startswith("P") and len(text) == 3) or (text.startswith("I") and len(text) == 3):  # Filter for "Wall"
+                      if(text.startswith(SearchArray[i][0]) and len(text)==int(SearchArray[i][2])):
+                          position = text_entity.dxf.insert  # Extract text position
+                          x, y = position.x, position.y
+
+                          for text_entity in doc.modelspace().query('TEXT MTEXT'):
+                              NBS = text_entity.text.strip() if hasattr(text_entity, 'text') else ""
+                              if (NBS.startswith(SearchArray[i][1])):
+                                  positionNBS = text_entity.dxf.insert  # Extract text position
+                                  xNBS, yNBS = positionNBS.x, positionNBS.y
+
+                                  if(x == xNBS or y == yNBS):
+                                    textNBS=NBS
+                                    break
+
+                              else:
+                                textNBS = None
+
+
+
+                          nearest_hatch = None
+                          min_distance = float('inf')  # Initialize with a very large value
+                          detected_color = (255, 255, 255)  # Default to white
+
+                          # Search for the nearest hatch
+                          for hatch in doc.modelspace().query('HATCH'):  # Query only hatches
+                              if hatch.paths:
+                                  for path in hatch.paths:
+                                      if path.type == 1:  # PolylinePath
+                                          vertices = [v[:2] for v in path.vertices]
+                                          # Calculate the centroid of the hatch
+                                          centroid_x = sum(v[0] for v in vertices) / len(vertices)
+                                          centroid_y = sum(v[1] for v in vertices) / len(vertices)
+                                          centroid = (centroid_x, centroid_y)
+
+                                          # Calculate the distance between the text and the hatch centroid
+                                          distance = calculate_distance((x, y), centroid)
+
+                                          # Update the nearest hatch if a closer one is found
+                                          if distance < min_distance:
+                                              min_distance = distance
+                                              nearest_hatch = hatch
+
+                                              # Get the color of this hatch
+                                              current_color = get_hatch_color(hatch)
+                                              if current_color != (255, 255, 255):  # Valid color found
+                                                  detected_color = current_color
+                                                  break  # Stop checking further paths for this hatch
+
+
+                          # Append the detected result only once
+                          Legendarray.append([text, textNBS, (x, y), detected_color])
+                  print("text_with_positions=",text_with_positions)
+
+          elif (SearchArray[i][0] and SearchArray[i][2]):
+                    for text_entity in doc.modelspace().query('TEXT MTEXT'):
+                      text = text_entity.text.strip() if hasattr(text_entity, 'text') else ""
+                      # if (text.startswith("P") and len(text) == 3) or (text.startswith("I") and len(text) == 3):  # Filter for "Wall"
+                      if(text.startswith(SearchArray[i][0]) and len(text)==int(SearchArray[i][2])):
+                          position = text_entity.dxf.insert  # Extract text position
+                          x, y = position.x, position.y
+                          textNBS = None
+                          nearest_hatch = None
+                          min_distance = float('inf')  # Initialize with a very large value
+                          detected_color = (255, 255, 255)  # Default to white
+
+                          # Search for the nearest hatch
+                          for hatch in doc.modelspace().query('HATCH'):  # Query only hatches
+                              if hatch.paths:
+                                  for path in hatch.paths:
+                                      if path.type == 1:  # PolylinePath
+                                          vertices = [v[:2] for v in path.vertices]
+                                          # Calculate the centroid of the hatch
+                                          centroid_x = sum(v[0] for v in vertices) / len(vertices)
+                                          centroid_y = sum(v[1] for v in vertices) / len(vertices)
+                                          centroid = (centroid_x, centroid_y)
+
+                                          # Calculate the distance between the text and the hatch centroid
+                                          distance = calculate_distance((x, y), centroid)
+
+                                          # Update the nearest hatch if a closer one is found
+                                          if distance < min_distance:
+                                              min_distance = distance
+                                              nearest_hatch = hatch
+
+                                              # Get the color of this hatch
+                                              current_color = get_hatch_color(hatch)
+                                              if current_color != (255, 255, 255):  # Valid color found
+                                                  detected_color = current_color
+                                                  break  # Stop checking further paths for this hatch
+
+
+                          # Append the detected result only once
+                          Legendarray.append([text, textNBS, (x, y), detected_color])
+                    print("text_with_positions=",text_with_positions)
+
+          elif(SearchArray[i][0]):
+            for text_entity in doc.modelspace().query('TEXT MTEXT'):
+                      text = text_entity.text.strip() if hasattr(text_entity, 'text') else ""
+                      # if (text.startswith("P") and len(text) == 3) or (text.startswith("I") and len(text) == 3):  # Filter for "Wall"
+                      if(text.startswith(SearchArray[i][0])):
+                          position = text_entity.dxf.insert  # Extract text position
+                          x, y = position.x, position.y
+                          textNBS = None
+                          nearest_hatch = None
+                          min_distance = float('inf')  # Initialize with a very large value
+                          detected_color = (255, 255, 255)  # Default to white
+
+                          # Search for the nearest hatch
+                          for hatch in doc.modelspace().query('HATCH'):  # Query only hatches
+                              if hatch.paths:
+                                  for path in hatch.paths:
+                                      if path.type == 1:  # PolylinePath
+                                          vertices = [v[:2] for v in path.vertices]
+                                          # Calculate the centroid of the hatch
+                                          centroid_x = sum(v[0] for v in vertices) / len(vertices)
+                                          centroid_y = sum(v[1] for v in vertices) / len(vertices)
+                                          centroid = (centroid_x, centroid_y)
+
+                                          # Calculate the distance between the text and the hatch centroid
+                                          distance = calculate_distance((x, y), centroid)
+
+                                          # Update the nearest hatch if a closer one is found
+                                          if distance < min_distance:
+                                              min_distance = distance
+                                              nearest_hatch = hatch
+
+                                              # Get the color of this hatch
+                                              current_color = get_hatch_color(hatch)
+                                              if current_color != (255, 255, 255):  # Valid color found
+                                                  detected_color = current_color
+                                                  break  # Stop checking further paths for this hatch
+
+
+                          # Append the detected result only once
+                          Legendarray.append([text, textNBS, (x, y), detected_color])
+            print("text_with_positions=",Legendarray)
+
+
+
+
+
+
+
+
+      grouped = {}
+      for entry in Legendarray:
+          key = entry[0]
+          grouped.setdefault(key, []).append(entry)
+
+      # Filter the groups: if any entry in a group has a non-None Text Nbs, keep only one of those
+      filtered_results = []
+      for key, entries in grouped.items():
+          # Find the first entry with a valid textNBS (non-None)
+          complete = next((entry for entry in entries if entry[1] is not None), None)
+          if complete:
+              filtered_results.append(complete)
+          else:
+              # If none are complete, you can choose to keep just one entry
+              filtered_results.append(entries[0])
+
+      text_with_positions=filtered_results
     
-      doc = ezdxf.readfile(filename)
-      doc.header['$MEASUREMENT'] = 1
-      msp = doc.modelspace()
-      trial=0
-      hatched_areas = []
-      threshold=0.01
-      unique_shapes = []
+
 
       for entity in doc.modelspace().query('TEXT MTEXT'):
         if hasattr(entity, 'text'):  # Ensure the entity has text content
@@ -847,7 +1024,7 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
                     hatched_areas.append([vertices, area1, perimeter, rgb_color])
 
       sorted_data = sorted(hatched_areas, key=lambda x: x[1])
-      return sorted_data
+      return sorted_data,Legendarray
 
 """### Rotate polygon"""
 
@@ -944,9 +1121,9 @@ def Create_DF(dxfpath,datadoc,hatched_areas,pdf_content=0):
   return SimilarAreaDictionary
 """### Draw on Image and PDF"""
 
-def adjustannotations(OutputPdfStage1):
+def adjustannotations(OutputPdfStage1,text_with_positions):
   input_pdf_path = OutputPdfStage1
-  output_pdf_path = "AnnotationAdjusted.pdf"
+  output_pdf_path = "Final-WallsAdjusted.pdf"
 
   # Load the input PDF
   pdf_bytes_io = BytesIO(OutputPdfStage1)
@@ -961,41 +1138,86 @@ def adjustannotations(OutputPdfStage1):
   metadata = reader.metadata
   writer.add_metadata(metadata)
 
-  # Iterate over pages
   for page_index, page in enumerate(writer.pages):
       if "/Annots" in page:
           annotations = page["/Annots"]
           for annot_index, annot in enumerate(annotations):
               obj = annot.get_object()
 
-              print("obj", obj)
+              # print("obj", obj)
               # print(obj.get("/IT"))
 
-              if obj.get("/Subtype") == "/Polygon":
-                print("AWL ANNOT IF")
+              if obj.get("/Subtype") == "/Line":
+                # print("AWL ANNOT IF")
                 # Check the /IT value to differentiate annotations
-                if "/Contents" in obj and "sq m" in obj["/Contents"]:
-                    print("Tany IF")
+                # if "/Contents" in obj and "m" in obj["/Contents"]:
+                if "/Subj" in obj and "Perimeter Measurement" in obj["/Subj"]:
+                    # print("Tany IF")
                     obj.update({
                         NameObject("/Measure"): DictionaryObject({
                             NameObject("/Type"): NameObject("/Measure"),
-                            NameObject("/Area"): DictionaryObject({
+                            NameObject("/L"): DictionaryObject({
                                 NameObject("/G"): FloatObject(1),
-                                NameObject("/U"): TextStringObject("sq m"),  # Unit of measurement for area
+                                NameObject("/U"): TextStringObject("m"),  # Unit of measurement for area
                             }),
-                            
-                            NameObject("/X"): FloatObject(1),  # Horizontal scale (e.g., 1 unit = 1 meter)
-                            NameObject("/Y"): FloatObject(1),  # Vertical scale
 
                         }),
-                        NameObject("/IT"): NameObject("/Area_Annotation"),  # Use more distinctive name
-                        NameObject("/Subj"): TextStringObject("Area Measurement"),   # Intent explicitly for Area
+                        NameObject("/IT"): NameObject("/LineDimension"),  # Use more distinctive name
+                        NameObject("/Subj"): TextStringObject("Length Measurement"),   # Intent explicitly for Area
+                    })
+              # print(obj)
+
+              if obj.get("/Subtype") in ["/Line", "/PolyLine"] and "/C" in obj:
+                  # Normalize and match the color
+                  annot_color = normalize_color(obj["/C"])
+                  matched_entry = next(
+                      ((text, NBS) for text,NBS, _, color in text_with_positions if color_close_enough(annot_color, color)),
+                      (None, None)
+                  )
+                  # print("matched_entry = ",matched_entry)
+                  matched_text, matched_nbs = matched_entry
+
+                  combined_text = ""
+                  if matched_text and matched_nbs:
+                      combined_text = f"{matched_text} - {matched_nbs}"
+                  elif matched_text:
+                      combined_text = matched_text
+                  elif matched_nbs:
+                      combined_text = matched_nbs
+
+                  obj.update({
+                        NameObject("/T"): TextStringObject(combined_text),  # Custom text for "Comment" column
                     })
                   
+              elif (obj.get("/Subtype") == "/Polygon" and "/C" in obj):
+                  # Normalize and match the color
+                  annot_color = normalize_color(obj["/C"])
+                  # print("annot_color = ",annot_color)
+                  # print("LASTarray = ",text_with_positions)
+                  # matched_entry = next(
+                  #     ((text, NBS) for text,NBS, _, color in text_with_positions if annot_color == color),
+                  #     (None, None)
+                  # )
+                  matched_entry = next(
+                      ((text, NBS) for text,NBS, _, color in text_with_positions if color_close_enough(annot_color, color)),
+                      (None, None)
+                  )
+                  # print("matched_entry = ",matched_entry)
+                  matched_text, matched_nbs = matched_entry
+
+                  combined_text = ""
+                  if matched_text and matched_nbs:
+                      combined_text = f"{matched_text} - {matched_nbs}"
+                  elif matched_text:
+                      combined_text = matched_text
+                  elif matched_nbs:
+                      combined_text = matched_nbs
+
+                  obj.update({
+                        NameObject("/T"): TextStringObject(combined_text),  # Custom text for "Comment" column
+                    })
+
 
-                print("After Update:", obj)
-  
-  # # Save the modified PDF
 
   output_pdf_io = BytesIO()
   writer.write(output_pdf_io)
@@ -1046,7 +1268,7 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0,pdf_con
     rotationangle = 270
 
 
-  hatched_areas = get_hatched_areas(datadoc,dxfpath,FinalRatio,rotationangle)
+  hatched_areas,Legendarray = get_hatched_areas(datadoc,dxfpath,FinalRatio,rotationangle)
   allshapes=[]
   # Iterate through each polygon in metric units
   NewColors = []
@@ -1254,7 +1476,9 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0,pdf_con
   SimilarAreaDictionary = grouped_df
   # doc.save(OutputPdfStage1)
   modified_pdf_data = doc.tobytes()
-  OutputPdfStage2=adjustannotations(modified_pdf_data)
+  # OutputPdfStage2=adjustannotations(modified_pdf_data)
+  OutputPdfStage2=adjustannotations(modified_pdf_data,text_with_positions)
+
 
   # with open("Adjusted_PDF.pdf", "wb") as f:
   #   f.write(OutputPdfStage2)