Update dxf__omar3_2.py

dxf__omar3_2.py

@@ -1,3 +1,26 @@
+# -*- coding: utf-8 -*-
+"""Deploying 3.2
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1HEw0DdXhDcxtJN1pjs7bCnlhr-wXX3-m
+"""
+
+# pip install pymupdf
+
+# pip install ezdxf
+
+def normalize_vertices(vertices):
+    """Sort vertices to ensure consistent order."""
+    return tuple(sorted(tuple(v) for v in vertices))
+
+def areas_are_similar(area1, area2, tolerance=0.2):
+    """Check if two areas are within a given tolerance."""
+    return abs(area1 - area2) <= tolerance
+
+
+from ctypes import sizeof
 # -*- coding: utf-8 -*-wj
 """Version to be deployed of 3.2 Calculating area/perimeter
 
@@ -18,6 +41,13 @@ Original file is located at
 # pip install ezdxf scipy
 
 """## Imports"""
+import xml.etree.ElementTree as ET
+from PyPDF2 import PdfReader, PdfWriter
+from PyPDF2.generic import TextStringObject, NameObject, ArrayObject, FloatObject
+from PyPDF2.generic import NameObject, TextStringObject, DictionaryObject, FloatObject, ArrayObject
+
+from typing import NewType
+from ctypes import sizeof
 
 import numpy as np
 import cv2
@@ -28,17 +58,22 @@ import fitz
 import ezdxf as ez
 import sys
 from ezdxf import units
+# from google.colab.patches import cv2_imshow
 from ezdxf.math import OCS, Matrix44, Vec3
 import ezdxf
 import matplotlib.pyplot as plt
 from matplotlib.patches import Polygon
-from shapely.geometry import Polygon as ShapelyPolygon
+from shapely.geometry import Point, Polygon as ShapelyPolygon
 from ezdxf.math import Vec2
 import random
 import pandas as pd
-import google_sheet_Legend
+# import google_sheet_Legend
 import tsadropboxretrieval
 from ezdxf import bbox
+from math import sin, cos, radians
+import google_sheet_Legend
+from PyPDF2 import PdfReader
+from io import BytesIO
 
 """## Notes"""
 
@@ -58,8 +93,11 @@ This portion is used to convert vertices read from dxf to pixels in order to acc
 
 """PDF to image"""
 
-def pdftoimg(datadoc):
-  doc = fitz.open('pdf',datadoc)
+def pdftoimg(datadoc,pdf_content=0):
+  if pdf_content:
+     doc = fitz.open(stream=pdf_content, filetype="pdf")
+  else:
+     doc = fitz.open('pdf',datadoc)
   page=doc[0]
   pix = page.get_pixmap()  # render page to an image
   pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
@@ -90,9 +128,12 @@ def get_paper_size_in_inches(width, height):
             return size
     return "Unknown Size"
 
-def analyze_pdf(datadoc):
+def analyze_pdf(datadoc,pdf_content=0):
     # Open the PDF file
-    pdf_document = fitz.open('pdf',datadoc)
+    if pdf_content:
+       pdf_document = fitz.open(stream=pdf_content, filetype="pdf")
+    else:
+      pdf_document = fitz.open('pdf',datadoc)
 
     # Iterate through pages and print their sizes
     for page_number in range(len(pdf_document)):
@@ -147,9 +188,12 @@ def switch_case(argument):
 
 
 
-def RetriveRatio(datadoc,dxfpath):
-
-  width,height,paper_size = analyze_pdf (datadoc)
+def RetriveRatio(datadoc,dxfpath,pdf_content=0):
+  if pdf_content:
+     width,height,paper_size = analyze_pdf (datadoc,pdf_content)
+  else:
+     width,height,paper_size = analyze_pdf (datadoc)
+     
 
   if(width > height ):
     bigger=width
@@ -190,79 +234,667 @@ def flip(img):
   flipped_horizontal = cv2.flip(rotated_image, 1)
   return flipped_horizontal
 
+
+
+def aci_to_rgb(aci):
+    aci_rgb_map = {
+        0: (0, 0, 0),
+        1: (255, 0, 0),
+        2: (255, 255, 0),
+        3: (0, 255, 0),
+        4: (0, 255, 255),
+        5: (0, 0, 255),
+        6: (255, 0, 255),
+        7: (255, 255, 255),
+        8: (65, 65, 65),
+        9: (128, 128, 128),
+        10: (255, 0, 0),
+        11: (255, 170, 170),
+        12: (189, 0, 0),
+        13: (189, 126, 126),
+        14: (129, 0, 0),
+        15: (129, 86, 86),
+        16: (104, 0, 0),
+        17: (104, 69, 69),
+        18: (79, 0, 0),
+        19: (79, 53, 53),
+        20: (255, 63, 0),
+        21: (255, 191, 170),
+        22: (189, 46, 0),
+        23: (189, 141, 126),
+        24: (129, 31, 0),
+        25: (129, 96, 86),
+        26: (104, 25, 0),
+        27: (104, 78, 69),
+        28: (79, 19, 0),
+        29: (79, 59, 53),
+        30: (255, 127, 0),
+        31: (255, 212, 170),
+        32: (189, 94, 0),
+        33: (189, 157, 126),
+        34: (129, 64, 0),
+        35: (129, 107, 86),
+        36: (104, 52, 0),
+        37: (104, 86, 69),
+        38: (79, 39, 0),
+        39: (79, 66, 53),
+        40: (255, 191, 0),
+        41: (255, 234, 170),
+        42: (189, 141, 0),
+        43: (189, 173, 126),
+        44: (129, 96, 0),
+        45: (129, 118, 86),
+        46: (104, 78, 0),
+        47: (104, 95, 69),
+        48: (79, 59, 0),
+        49: (79, 73, 53),
+        50: (255, 255, 0),
+        51: (255, 255, 170),
+        52: (189, 189, 0),
+        53: (189, 189, 126),
+        54: (129, 129, 0),
+        55: (129, 129, 86),
+        56: (104, 104, 0),
+        57: (104, 104, 69),
+        58: (79, 79, 0),
+        59: (79, 79, 53),
+        60: (191, 255, 0),
+        61: (234, 255, 170),
+        62: (141, 189, 0),
+        63: (173, 189, 126),
+        64: (96, 129, 0),
+        65: (118, 129, 86),
+        66: (78, 104, 0),
+        67: (95, 104, 69),
+        68: (59, 79, 0),
+        69: (73, 79, 53),
+        70: (127, 255, 0),
+        71: (212, 255, 170),
+        72: (94, 189, 0),
+        73: (157, 189, 126),
+        74: (64, 129, 0),
+        75: (107, 129, 86),
+        76: (52, 104, 0),
+        77: (86, 104, 69),
+        78: (39, 79, 0),
+        79: (66, 79, 53),
+        80: (63, 255, 0),
+        81: (191, 255, 170),
+        82: (46, 189, 0),
+        83: (141, 189, 126),
+        84: (31, 129, 0),
+        85: (96, 129, 86),
+        86: (25, 104, 0),
+        87: (78, 104, 69),
+        88: (19, 79, 0),
+        89: (59, 79, 53),
+        90: (0, 255, 0),
+        91: (170, 255, 170),
+        92: (0, 189, 0),
+        93: (126, 189, 126),
+        94: (0, 129, 0),
+        95: (86, 129, 86),
+        96: (0, 104, 0),
+        97: (69, 104, 69),
+        98: (0, 79, 0),
+        99: (53, 79, 53),
+        100: (0, 255, 63),
+        101: (170, 255, 191),
+        102: (0, 189, 46),
+        103: (126, 189, 141),
+        104: (0, 129, 31),
+        105: (86, 129, 96),
+        106: (0, 104, 25),
+        107: (69, 104, 78),
+        108: (0, 79, 19),
+        109: (53, 79, 59),
+        110: (0, 255, 127),
+        111: (170, 255, 212),
+        112: (0, 189, 94),
+        113: (126, 189, 157),
+        114: (0, 129, 64),
+        115: (86, 129, 107),
+        116: (0, 104, 52),
+        117: (69, 104, 86),
+        118: (0, 79, 39),
+        119: (53, 79, 66),
+        120: (0, 255, 191),
+        121: (170, 255, 234),
+        122: (0, 189, 141),
+        123: (126, 189, 173),
+        124: (0, 129, 96),
+        125: (86, 129, 118),
+        126: (0, 104, 78),
+        127: (69, 104, 95),
+        128: (0, 79, 59),
+        129: (53, 79, 73),
+        130: (0, 255, 255),
+        131: (170, 255, 255),
+        132: (0, 189, 189),
+        133: (126, 189, 189),
+        134: (0, 129, 129),
+        135: (86, 129, 129),
+        136: (0, 104, 104),
+        137: (69, 104, 104),
+        138: (0, 79, 79),
+        139: (53, 79, 79),
+        140: (0, 191, 255),
+        141: (170, 234, 255),
+        142: (0, 141, 189),
+        143: (126, 173, 189),
+        144: (0, 96, 129),
+        145: (86, 118, 129),
+        146: (0, 78, 104),
+        147: (69, 95, 104),
+        148: (0, 59, 79),
+        149: (53, 73, 79),
+        150: (0, 127, 255),
+        151: (170, 212, 255),
+        152: (0, 94, 189),
+        153: (126, 157, 189),
+        154: (0, 64, 129),
+        155: (86, 107, 129),
+        156: (0, 52, 104),
+        157: (69, 86, 104),
+        158: (0, 39, 79),
+        159: (53, 66, 79),
+        160: (0, 63, 255),
+        161: (170, 191, 255),
+        162: (0, 46, 189),
+        163: (126, 141, 189),
+        164: (0, 31, 129),
+        165: (86, 96, 129),
+        166: (0, 25, 104),
+        167: (69, 78, 104),
+        168: (0, 19, 79),
+        169: (53, 59, 79),
+        170: (0, 0, 255),
+        171: (170, 170, 255),
+        172: (0, 0, 189),
+        173: (126, 126, 189),
+        174: (0, 0, 129),
+        175: (86, 86, 129),
+        176: (0, 0, 104),
+        177: (69, 69, 104),
+        178: (0, 0, 79),
+        179: (53, 53, 79),
+        180: (63, 0, 255),
+        181: (191, 170, 255),
+        182: (46, 0, 189),
+        183: (141, 126, 189),
+        184: (31, 0, 129),
+        185: (96, 86, 129),
+        186: (25, 0, 104),
+        187: (78, 69, 104),
+        188: (19, 0, 79),
+        189: (59, 53, 79),
+        190: (127, 0, 255),
+        191: (212, 170, 255),
+        192: (94, 0, 189),
+        193: (157, 126, 189),
+        194: (64, 0, 129),
+        195: (107, 86, 129),
+        196: (52, 0, 104),
+        197: (86, 69, 104),
+        198: (39, 0, 79),
+        199: (66, 53, 79),
+        200: (191, 0, 255),
+        201: (234, 170, 255),
+        202: (141, 0, 189),
+        203: (173, 126, 189),
+        204: (96, 0, 129),
+        205: (118, 86, 129),
+        206: (78, 0, 104),
+        207: (95, 69, 104),
+        208: (59, 0, 79),
+        209: (73, 53, 79),
+        210: (255, 0, 255),
+        211: (255, 170, 255),
+        212: (189, 0, 189),
+        213: (189, 126, 189),
+        214: (129, 0, 129),
+        215: (129, 86, 129),
+        216: (104, 0, 104),
+        217: (104, 69, 104),
+        218: (79, 0, 79),
+        219: (79, 53, 79),
+        220: (255, 0, 191),
+        221: (255, 170, 234),
+        222: (189, 0, 141),
+        223: (189, 126, 173),
+        224: (129, 0, 96),
+        225: (129, 86, 118),
+        226: (104, 0, 78),
+        227: (104, 69, 95),
+        228: (79, 0, 59),
+        229: (79, 53, 73),
+        230: (255, 0, 127),
+        231: (255, 170, 212),
+        232: (189, 0, 94),
+        233: (189, 126, 157),
+        234: (129, 0, 64),
+        235: (129, 86, 107),
+        236: (104, 0, 52),
+        237: (104, 69, 86),
+        238: (79, 0, 39),
+        239: (79, 53, 66),
+        240: (255, 0, 63),
+        241: (255, 170, 191),
+        242: (189, 0, 46),
+        243: (189, 126, 141),
+        244: (129, 0, 31),
+        245: (129, 86, 96),
+        246: (104, 0, 25),
+        247: (104, 69, 78),
+        248: (79, 0, 19),
+        249: (79, 53, 59),
+        250: (51, 51, 51),
+        251: (80, 80, 80),
+        252: (105, 105, 105),
+        253: (130, 130, 130),
+        254: (190, 190, 190),
+        255: (255, 255, 255)
+    }
+
+    # Default to white if index is invalid or not found
+    return aci_rgb_map.get(aci, (255, 255, 255))
+
+
+
+def int_to_rgb(color_int):
+    """Convert an integer to an (R, G, B) tuple."""
+    r = (color_int >> 16) & 255
+    g = (color_int >> 8) & 255
+    b = color_int & 255
+    return (r, g, b)
+
+
+
+def get_hatch_color(entity):
+    # Check if the entity has a "true color" set
+    if entity.dxf.hasattr('true_color'):
+      true_color = entity.dxf.true_color
+      rgb_color = int_to_rgb(true_color)  # Convert integer to (R, G, B)
+      print(f"True color detected (RGB): {rgb_color}")
+      return rgb_color
+
+    color_index = entity.dxf.color
+    print("color_index = ", color_index)
+
+    # Check if the color is set to ByLayer or ByBlock
+    if color_index == 0:  # ByLayer color
+        print("Color is ByLayer, checking layer color...")
+        layer_name = entity.dxf.layer
+        layer = entity.doc.layers.get(layer_name)
+
+        if layer:  # Ensure layer exists
+            layer_color_index = layer.dxf.color
+            print(f"Layer '{layer_name}' Color Index = {layer_color_index}")
+            return aci_to_rgb(layer_color_index)  # Use custom aci_to_rgb function
+        else:
+            print(f"Layer '{layer_name}' not found, defaulting to white.")
+            return (255, 255, 255)  # Default to white if layer not found
+
+    elif color_index == 256:  # ByBlock color
+        print("Color is ByBlock, checking block color or defaulting to white.")
+        block_color = (255, 255, 255)  # White as default
+
+        # Check if the entity is inside a block reference and inherit its color
+        if hasattr(entity, 'block'):  # Check if the entity belongs to a block
+            block_ref = entity.block
+            if block_ref.dxf.hasattr('color'):
+                block_color = aci_to_rgb(block_ref.dxf.color)
+                print(f"Block reference color found: {block_color}")
+            else:
+                print("Block has no color attribute, using default (white).")
+        return block_color
+
+    # Otherwise, convert the ACI color to RGB
+    print(f"Entity Color Index = {color_index}")
+    if 1 <= color_index <= 255:
+        rgb_color = aci_to_rgb(color_index)  # Use custom aci_to_rgb function
+        print(f"Converted RGB = {rgb_color}")
+        return rgb_color
+
+    # Default to white if color index is out of bounds or invalid
+    print("Invalid or unhandled color index, defaulting to white.")
+    return (255, 255, 255)
+
+def calculate_distance(p1, p2):
+    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+
+def normalize_color(color):
+    """Convert PDF color (range 0-1) to RGB (range 0-255)."""
+    return tuple(min(max(round(c * 255), 0), 255) for c in color)
+
+def color_close_enough(c1, c2, threshold=10):
+    return all(abs(a - b) <= threshold for a, b in zip(c1, c2))
+    
+    
 """### Hatched areas"""
+def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle,SearchArray):
 
-def get_hatched_areas(filename,FinalRatio):
       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 = [
+          (255, 0, 0), (0, 0, 255), (0, 255, 255), (0, 64, 0), (255, 204, 0),
+          (255, 128, 64), (255, 0, 128), (255, 128, 192), (128, 128, 255),
+          (128, 64, 0), (0, 255, 0), (0, 200, 0), (255, 128, 255), (128, 0, 255),
+          (0, 128, 192), (128, 0, 128), (128, 0, 0), (0, 128, 255), (149, 1, 70),
+          (255, 182, 128), (222, 48, 71), (240, 0, 112), (255, 0, 255),
+          (192, 46, 65), (0, 0, 128), (0, 128, 64), (255, 255, 0), (128, 0, 80),
+          (255, 255, 128), (90, 255, 140), (255, 200, 20), (91, 16, 51),
+          (90, 105, 138), (114, 10, 138), (36, 82, 78), (225, 105, 190),
+          (108, 150, 170), (11, 35, 75), (42, 176, 170), (255, 176, 170),
+          (209, 151, 15), (81, 27, 85), (226, 106, 122), (67, 119, 149),
+          (159, 179, 140), (159, 179, 30), (255, 85, 198), (255, 27, 85),
+          (188, 158, 8), (140, 188, 120), (59, 61, 52), (65, 81, 21),
+          (212, 255, 174), (15, 164, 90), (41, 217, 245), (213, 23, 182),
+          (11, 85, 169), (78, 153, 239), (0, 66, 141), (64, 98, 232),
+          (140, 112, 255), (57, 33, 154), (194, 117, 252), (116, 92, 135),
+          (74, 43, 98), (188, 13, 123), (129, 58, 91), (255, 128, 100),
+          (171, 122, 145), (255, 98, 98), (222, 48, 77)
+      ]
+
+      import re
+
+      Legendarray = []
+
+      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])
+
+      Legendarray=filtered_results
+    
 
-      for entity in msp:
 
-        if entity.dxftype() == 'HATCH':
-            flag=0
-            trial=0
+      for entity in doc.modelspace().query('TEXT MTEXT'):
+        if hasattr(entity, 'text'):  # Ensure the entity has text content
+            text = entity.text
+            if text.startswith('C') and (len(text) > 1 and (text[1].isdigit() or text[1].upper() == 'T' or text[1].upper() == 'L')):
+                parts = text.split(' ')  # Split into two parts: before and after the first newline
+                # print("Parts = ",parts[0])
+                main_text = parts[0]  # Text before the first newline
+
+                # Check if the main text starts with 'C' followed by a number or 'T'
+                # if pattern.match(main_text):
+                position = entity.dxf.insert
+
+
+                # Check if the text already has a color assigned
+                if main_text not in text_color_mapping:
+                    # Assign a new color from the palette
+                    color_index = len(text_color_mapping) % len(color_palette)
+                    text_color_mapping[main_text] = color_palette[color_index]
 
-            print(entity.dxftype())
+                # Get the assigned color
+                color = text_color_mapping[main_text]
 
+                # Set the entity's true color
+                # entity.dxf.true_color = rgb_to_true_color(color)
+
+                # Append text, position, and color to the array
+                text_with_positions.append([main_text, position, color])
+                
+      for entity in msp:
+        if entity.dxftype() == 'HATCH':
+            # print(f"Processing HATCH entity: {entity}")
             for path in entity.paths:
-              if str(path.type)=='BoundaryPathType.POLYLINE':
-                print('First type of Hatch')
-                vertices = [(vertex[0]* (FinalRatio), vertex[1]* (FinalRatio))for vertex in path.vertices]
-                if(len(vertices)>3):
-                 poly = ShapelyPolygon(vertices)
-
-                 minx, miny, maxx, maxy = poly.bounds
-
-                 # Calculate the width and height of the bounding box
-                 width = maxx - minx
-                 height = maxy - miny
-
-
-
-                 if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
-                   area1 = round(poly.area,3)
-                   perimeter = round (poly.length,3)
-                   if trial==0:
-                     hatched_areas.append([vertices,area1,perimeter])
-                     trial=1
-                   else:
-                        for i in range(len(hatched_areas)):
-                            if(area1 == hatched_areas[i][1]):
-                              flag=1
-              elif str(path.type) == 'BoundaryPathType.EDGE':
-                print('Second type of Hatch')
-              
-                vert=[]
-                flag=0
-                flag2=0
-                for edge in path.edges:
-                  x,y=edge.start
-                  x1,y1=edge.end
-                  if(flag==0):
-                    vert=[(x* (FinalRatio),y* (FinalRatio)),(x1* (FinalRatio),y1* (FinalRatio))]
-                  else:
-                      vert.append([x1* (FinalRatio),y1* (FinalRatio)])
-                  flag=1
-                poly = ShapelyPolygon(vert)
-                minx, miny, maxx, maxy = poly.bounds
-
-                 # Calculate the width and height of the bounding box
-                width = maxx - minx
-                height = maxy - miny
-
-                if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
-                   area1= round(poly.area,3)
-                   perimeter = round (poly.length,3)
-                   for i in range(len(hatched_areas)):
-                      if(area1 == hatched_areas[i][1]):
-                        flag2=1
-                   if(flag2==0):
-                       hatched_areas.append([vert,area1,perimeter])
-              else:
-                print(path.type)
+                vertices = []  # Reset vertices for each path
+
+                if str(path.type) == 'BoundaryPathType.POLYLINE':
+                    # Handle POLYLINE type HATCH
+                    vertices = [(vertex[0] * FinalRatio, vertex[1] * FinalRatio) for vertex in path.vertices]
+
+                    if len(vertices) > 3:
+                        poly = ShapelyPolygon(vertices)
+                        minx, miny, maxx, maxy = poly.bounds
+                        width = maxx - minx
+                        height = maxy - miny
+
+                        if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
+                            area1 = round(poly.area, 3)
+                            perimeter = round(poly.length, 3)
+                            normalized_vertices = normalize_vertices(vertices)
+
+                            rgb_color = get_hatch_color(entity)
+                            if(rgb_color == (255, 255, 255)):
+                                if(len(text_with_positions)>0):
+
+                                  for text, position, color in text_with_positions:
+                                    text_position = Point(position[0], position[1])
+
+                                    if poly.contains(text_position):
+                                      rgb_color = color
+                                      break
+
+                            duplicate_found = False
+                            for existing_vertices, existing_area in unique_shapes:
+                                if normalized_vertices == existing_vertices and areas_are_similar(area1, existing_area):
+                                    duplicate_found = True
+                                    break
+
+                            if not duplicate_found:
+                                # rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                                unique_shapes.append((normalized_vertices, area1))
+                                hatched_areas.append([vertices, area1, perimeter, rgb_color])
+
+                elif str(path.type) == 'BoundaryPathType.EDGE':
+                    # Handle EDGE type HATCH
+                    vert = []
+                    for edge in path.edges:
+                        x, y = edge.start
+                        x1, y1 = edge.end
+                        vert.append((x * FinalRatio, y * FinalRatio))
+                        vert.append((x1 * FinalRatio, y1 * FinalRatio))
+
+                    poly = ShapelyPolygon(vert)
+                    minx, miny, maxx, maxy = poly.bounds
+                    width = maxx - minx
+                    height = maxy - miny
+
+                    if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
+                        area1 = round(poly.area, 3)
+                        perimeter = round(poly.length, 3)
+
+                        normalized_vertices = normalize_vertices(vert)
+
+                        rgb_color = get_hatch_color(entity)
+                        if(rgb_color == (255, 255, 255)):
+                            if(len(text_with_positions)>0):
+                                for text, position, color in text_with_positions:
+                                      text_position = Point(position[0], position[1])
+
+                                      if poly.contains(text_position):
+                                        rgb_color = color
+                                        break
+
+                        duplicate_found = False
+                        for existing_vertices, existing_area in unique_shapes:
+                            if normalized_vertices == existing_vertices and areas_are_similar(area1, existing_area):
+                                duplicate_found = True
+                                break
+
+                        if not duplicate_found:
+                            # rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                            unique_shapes.append((normalized_vertices, area1))
+                            hatched_areas.append([vert, area1, perimeter, rgb_color])
+
+                else:
+                    print(f"Unhandled path type: {path.type}")
 
         elif entity.dxftype() == 'SOLID':
             vertices = [entity.dxf.vtx0 * (FinalRatio), entity.dxf.vtx1* (FinalRatio), entity.dxf.vtx2* (FinalRatio), entity.dxf.vtx3* (FinalRatio)]
@@ -273,44 +905,73 @@ def get_hatched_areas(filename,FinalRatio):
             width = maxx - minx
             height = maxy - miny
 
-            if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
-             hatched_areas.append([vertices,poly.area,poly.length])
+            if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
+              area1 = round(poly.area, 3)
+              perimeter = round(poly.length, 3)
+              normalized_vertices = normalize_vertices(vertices)
+
+              duplicate_found = False
+              for existing_vertices, existing_area in unique_shapes:
+                  if normalized_vertices == existing_vertices or areas_are_similar(area1, existing_area):
+                      duplicate_found = True
+                      break
+
+              if not duplicate_found:
+                  rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                  unique_shapes.append((normalized_vertices, area1))
+                  hatched_areas.append([vertices, area1, perimeter, rgb_color])
+
+
+
 
         elif entity.dxftype() == 'LWPOLYLINE':
+          vertices = []
+          lwpolyline = entity
+          points = lwpolyline.get_points()
+          flag = 0
 
-           vertices=[]
-           lwpolyline = entity
-           points = lwpolyline.get_points()
-           flag=0
+          # Collect vertices and apply the FinalRatio
+          for i in range(len(points)):
+              vertices.append([points[i][0] * FinalRatio, points[i][1] * FinalRatio])
 
-           for i in range(len(points)):
-             vertices.append([points[i][0]* (FinalRatio),points[i][1]* (FinalRatio)])
-           if(len(vertices)>3):
+        #   # Ensure there are more than 3 vertices
+          if len(vertices) > 3:
+              # Check if the polyline is closed
+              if vertices[0][0] == vertices[-1][0] or vertices[0][1] == vertices[-1][1]:
+                  poly = ShapelyPolygon(vertices)
+                  minx, miny, maxx, maxy = poly.bounds
 
-             if(vertices[0][0] == vertices[len(vertices)-1][0]  or vertices[0][1] == vertices[len(vertices)-1][1]):
+                  # Calculate width and height of the bounding box
+                  width = maxx - minx
+                  height = maxy - miny
 
-               poly=ShapelyPolygon(vertices)
-               minx, miny, maxx, maxy = poly.bounds
+                  # Check area and size constraints
+                  if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
+                      area1 = round(poly.area, 3)
+                      perimeter = round(poly.length, 3)
 
-               # Calculate the width and height of the bounding box
-               width = maxx - minx
-               height = maxy - miny
+                      normalized_vertices = normalize_vertices(vertices)
+
+                      duplicate_found = False
+                      for existing_vertices, existing_area in unique_shapes:
+                          if normalized_vertices == existing_vertices or areas_are_similar(area1, existing_area):
+                              duplicate_found = True
+                              break
+
+                      if not duplicate_found:
+                          rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                          unique_shapes.append((normalized_vertices, area1))
+                          hatched_areas.append([vertices, area1, perimeter, rgb_color])
 
-               if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
-                area1 = round(poly.area,3)
-                perimeter = round (poly.length,3)
-                for i in range(len(hatched_areas)):
-                  if(area1 == hatched_areas[i][1]):
-                     flag=1
-                if(flag==0):
-                   hatched_areas.append([vertices,area1,perimeter])
 
 
         elif entity.dxftype() == 'POLYLINE':
 
+          # print("In POLYLINE")
+
           flag=0
           vertices = [(v.dxf.location.x * (FinalRatio), v.dxf.location.y * (FinalRatio)) for v in entity.vertices]
-          print('Vertices:', vertices)
+          # print('Vertices:', vertices)
 
           if(len(vertices)>3):
 
@@ -323,14 +984,22 @@ def get_hatched_areas(filename,FinalRatio):
                width = maxx - minx
                height = maxy - miny
 
-               if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
+               if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                 area1 = round(poly.area,3)
                 perimeter = round (poly.length,3)
-                for i in range(len(hatched_areas)):
-                  if(area1 == hatched_areas[i][1]):
-                     flag=1
-                if(flag==0):
-                   hatched_areas.append([vertices,area1,perimeter])
+                normalized_vertices = normalize_vertices(vertices)
+
+                duplicate_found = False
+                for existing_vertices, existing_area in unique_shapes:
+                    if normalized_vertices == existing_vertices or areas_are_similar(area1, existing_area):
+                        duplicate_found = True
+                        break
+
+                if not duplicate_found:
+                    rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                    unique_shapes.append((normalized_vertices, area1))
+                    hatched_areas.append([vertices, area1, perimeter, rgb_color])
+
 
         elif entity.dxftype() == 'SPLINE':
           spline_entity = entity
@@ -348,17 +1017,28 @@ def get_hatched_areas(filename,FinalRatio):
             height = maxy - miny
 
 
-            if (poly.area > 1.5 and (height > 0.7 and width > 0.7)):
+            if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                 area1 = round(poly.area,3)
                 perimeter = round (poly.length,3)
-                hatched_areas.append([vertices,area1,perimeter])
+                normalized_vertices = normalize_vertices(vertices)
+
+                duplicate_found = False
+                for existing_vertices, existing_area in unique_shapes:
+                    if normalized_vertices == existing_vertices or areas_are_similar(area1, existing_area):
+                        duplicate_found = True
+                        break
+
+                if not duplicate_found:
+                    rgb_color = get_hatch_color(entity)  # Assuming this function exists
+                    unique_shapes.append((normalized_vertices, area1))
+                    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"""
 
-from math import sin, cos, radians
+
 
 def rotate_point(point, angle,pdfrotation,width,height, center_point=(0, 0)):
     """Rotates a point around center_point(origin by default)
@@ -399,43 +1079,39 @@ def rotate_polygon(polygon, angle, pdfrotation,width,height,center_point=(0, 0))
 #SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','R','G','B'])
 #loop 3la hatched areas and count the occurences of each shape w create a table bl hagat di
 
-def generate_color_array(length):
-    colorRanges = []
-    while len(colorRanges) < length:
-        # Generate random RGB values
-        r = random.randint(0, 255)
-        g = random.randint(0, 255)
-        b = random.randint(0, 255)
-        # Ensure no duplicate colors
-        if (r, g, b) not in colorRanges:
-            colorRanges.append((r, g, b))
-    return colorRanges
-
-def Create_DF(dxfpath,datadoc):
-    
-  FinalRatio= RetriveRatio(datadoc,dxfpath)
+
+def Create_DF(dxfpath,datadoc,hatched_areas,pdf_content=0):
     
-  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
+  if pdf_content:
+    FinalRatio= RetriveRatio(datadoc,dxfpath,pdf_content)
+  else:
+     FinalRatio= RetriveRatio(datadoc,dxfpath)
+
+  # hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
+  # print('hatched_areas',hatched_areas)
+  # hatched_areas=remove_duplicate_shapes(new_hatched_areas)
+
   # SimilarAreaDictionary= pd.DataFrame(columns=['Area', 'Total Area', 'Perimeter', 'Total Perimeter', 'Occurences', 'Color'])
   SimilarAreaDictionary= pd.DataFrame(columns=['Guess','Color','Occurences','Area','Total Area','Perimeter','Total Perimeter','Length','Total Length','Texts','Comments'])
+
+  # colorRanges2=generate_color_array(30000)
+  # colorRanges = [[255, 0, 0], [0, 0, 255], [0, 255, 255], [0, 64, 0], [255, 204, 0], [255, 128, 64], [255, 0, 128], [255, 128, 192], [128, 128, 255], [128, 64, 0],[0, 255, 0],[0, 200, 0],[255, 128, 255], [128, 0, 255], [0, 128, 192], [128, 0, 128],[128, 0, 0], [0, 128, 255], [149, 1, 70], [255, 182, 128], [222, 48, 71], [240, 0, 112], [255, 0, 255], [192, 46, 65], [0, 0, 128],[0, 128, 64],[255, 255, 0], [128, 0, 80], [255, 255, 128], [90, 255, 140],[255, 200, 20],[91, 16, 51], [90, 105, 138], [114, 10, 138], [36, 82, 78], [225, 105, 190], [108, 150, 170], [11, 35, 75], [42, 176, 170], [255, 176, 170], [209, 151, 15],[81, 27, 85], [226, 106, 122], [67, 119, 149], [159, 179, 140], [159, 179, 30],[255, 85, 198], [255, 27, 85], [188, 158, 8],[140, 188, 120], [59, 61, 52], [65, 81, 21], [212, 255, 174], [15, 164, 90],[41, 217, 245], [213, 23, 182], [11, 85, 169], [78, 153, 239], [0, 66, 141],[64, 98, 232], [140, 112, 255], [57, 33, 154], [194, 117, 252], [116, 92, 135], [74, 43, 98], [188, 13, 123], [129, 58, 91], [255, 128, 100], [171, 122, 145],  [255, 98, 98], [222, 48, 77]]
+  # colorUsed=[]
     
-  colorRanges2=generate_color_array(300)
-  colorRanges = [[255, 0, 0], [0, 0, 255], [0, 255, 255], [0, 64, 0], [255, 204, 0], [255, 128, 64], [255, 0, 128], [255, 128, 192], [128, 128, 255], [128, 64, 0],[0, 255, 0],[0, 200, 0],[255, 128, 255], [128, 0, 255], [0, 128, 192], [128, 0, 128],[128, 0, 0], [0, 128, 255], [149, 1, 70], [255, 182, 128], [222, 48, 71], [240, 0, 112], [255, 0, 255], [192, 46, 65], [0, 0, 128],[0, 128, 64],[255, 255, 0], [128, 0, 80], [255, 255, 128], [90, 255, 140],[255, 200, 20],[91, 16, 51], [90, 105, 138], [114, 10, 138], [36, 82, 78], [225, 105, 190], [108, 150, 170], [11, 35, 75], [42, 176, 170], [255, 176, 170], [209, 151, 15],[81, 27, 85], [226, 106, 122], [67, 119, 149], [159, 179, 140], [159, 179, 30],[255, 85, 198], [255, 27, 85], [188, 158, 8],[140, 188, 120], [59, 61, 52], [65, 81, 21], [212, 255, 174], [15, 164, 90],[41, 217, 245], [213, 23, 182], [11, 85, 169], [78, 153, 239], [0, 66, 141],[64, 98, 232], [140, 112, 255], [57, 33, 154], [194, 117, 252], [116, 92, 135], [74, 43, 98], [188, 13, 123], [129, 58, 91], [255, 128, 100], [171, 122, 145],  [255, 98, 98], [222, 48, 77]]
-  colorUsed=[]
   TotalArea=0
   TotalPerimeter=0
-  for i in range(len(hatched_areas)):
-      area = hatched_areas[i][1]  # area
-      perimeter = hatched_areas[i][2]  # perimeter
-      if(i < len(colorRanges)):
-        color = colorRanges[i]
-        colorUsed.append(color)
-      else:
-        color = colorRanges2[i]
-        colorUsed.append(color)
+  for shape in hatched_areas:
+      area = shape[1]  # area
+      perimeter = shape[2]  # perimeter
+      # if(i < len(colorRanges)):
+      #   color = colorRanges[i]
+      #   colorUsed.append(color)
+      # else:
+      #   color = colorRanges2[i]
+      #   colorUsed.append(color)
       TotalArea = area
       TotalPerimeter = perimeter
-      tol=2
+      tol=0
       condition1 = (SimilarAreaDictionary['Area'] >= area - tol) & (SimilarAreaDictionary['Area'] <= area +tol)
       condition2 = (SimilarAreaDictionary['Perimeter'] >= perimeter -tol) & (SimilarAreaDictionary['Perimeter'] <= perimeter +tol)
       combined_condition = condition1 & condition2
@@ -448,22 +1124,143 @@ def Create_DF(dxfpath,datadoc):
       else:
           TotalArea=area
           TotalPerimeter=perimeter
-          new_data = {'Area': area, 'Total Area': TotalArea ,'Perimeter': perimeter, 'Total Perimeter': TotalPerimeter, 'Occurences': 1, 'Color':color,'Comments':''} #add color here and read color to insert in
+          new_data = {'Area': area, 'Total Area': TotalArea ,'Perimeter': perimeter, 'Total Perimeter': TotalPerimeter, 'Occurences': 1, 'Color':shape[3],'Comments':''} #add color here and read color to insert in
           SimilarAreaDictionary = pd.concat([SimilarAreaDictionary, pd.DataFrame([new_data])], ignore_index=True)
 
   # print(SimilarAreaDictionary)
   return SimilarAreaDictionary
 """### Draw on Image and PDF"""
 
-def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
-  FinalRatio= RetriveRatio(datadoc,dxfpath)
-  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
-  img=pdftoimg(datadoc)
+def adjustannotations(OutputPdfStage1,text_with_positions):
+  input_pdf_path = OutputPdfStage1
+  output_pdf_path = "Final-WallsAdjusted.pdf"
+
+  # Load the input PDF
+  pdf_bytes_io = BytesIO(OutputPdfStage1)
+
+  reader = PdfReader(pdf_bytes_io)
+  writer = PdfWriter()
+
+  # Append all pages to the writer
+  writer.append_pages_from_reader(reader)
+
+  # Add metadata (optional)
+  metadata = reader.metadata
+  writer.add_metadata(metadata)
+
+  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.get("/IT"))
+
+              if obj.get("/Subtype") == "/Line":
+                # print("AWL ANNOT IF")
+                # Check the /IT value to differentiate annotations
+                # 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("/L"): DictionaryObject({
+                                NameObject("/G"): FloatObject(1),
+                                NameObject("/U"): TextStringObject("m"),  # Unit of measurement 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
+                    })
+
+
+
+  output_pdf_io = BytesIO()
+  writer.write(output_pdf_io)
+  output_pdf_io.seek(0)
+
+  print(f"Annotations updated and saved to {output_pdf_path}")
+  return output_pdf_io.read()
+
+  
+
+    
+def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,SearchArray,pdfpath=0,pdfname=0,pdf_content=0):
+  OutputPdfStage1='BB Trial.pdf'
+  if pdf_content:
+     FinalRatio= RetriveRatio(datadoc,dxfpath,pdf_content)
+  else:
+      FinalRatio= RetriveRatio(datadoc,dxfpath)
+    
+
+  # hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
+  # hatched_areas=remove_duplicate_shapes(new_hatched_areas)
+  if pdf_content:
+    img=pdftoimg(datadoc,pdf_content)
+  else:
+     img=pdftoimg(datadoc)
   flipped_horizontal=flip(img)
   allcnts = []
   imgg = flipped_horizontal
   # imgtransparent1=imgg.copy()
-  doc = fitz.open('pdf',datadoc)
+  if pdf_content:
+    doc = fitz.open(stream=pdf_content, filetype="pdf")
+  else:
+    doc = fitz.open('pdf',datadoc)
   page2 = doc[0]
   rotationOld=page2.rotation
   derotationMatrix=page2.derotation_matrix
@@ -480,17 +1277,30 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
     ratio =  pix.width/ img.shape[1]
     rotationangle = 270
 
+
+  hatched_areas,Legendarray = get_hatched_areas(datadoc,dxfpath,FinalRatio,rotationangle,SearchArray)
   allshapes=[]
   # Iterate through each polygon in metric units
   NewColors = []
-  SimilarAreaDictionary=Create_DF(dxfpath,datadoc)
+  if pdf_content:
+    SimilarAreaDictionary=Create_DF(dxfpath,datadoc,hatched_areas,pdf_content)
+  else:
+     SimilarAreaDictionary=Create_DF(dxfpath,datadoc,hatched_areas)
   i=0
+  flagcolor = 0
+  ColorCheck=[]
 
 
   for polygon in hatched_areas:
       cntPoints = []
       cntPoints1 = []
-      shapee = []
+      shapeePerimeter = []
+      shapeeArea = []
+
+      blackImgShapes = np.zeros(imgg.shape[:2], dtype="uint8")
+      blackImgShapes= cv2.cvtColor(blackImgShapes, cv2.COLOR_GRAY2BGR)
+
+      
       # Convert each vertex from metric to pixel coordinates
       for vertex in polygon[0]:
           x = (vertex[0]) *dxfratio
@@ -501,56 +1311,196 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
           cntPoints.append([int(x), int(y)])
           cntPoints1.append([x, y])
 
+      cv2.drawContours(blackImgShapes, [np.array(cntPoints)], -1, ([255,255,255]), thickness=-1)
+      x, y, w, h = cv2.boundingRect(np.array(cntPoints))
+      firstpoint = 0
+      for poi in np.array(cntPoints1):
+          if firstpoint == 0:
+            x2, y2 = poi
+            p2 = fitz.Point(x2,y2)
+            # p1 = fitz.Point(x1,y1)
+            p2=p2*derotationMatrix
+            shapeePerimeter.append([p2[0],p2[1]])
+            firstpoint = 1
+          else:
+            x1, y1 = poi
+            p1 = fitz.Point(x1,y1)
+            # p1 = fitz.Point(x1,y1)
+            p1=p1*derotationMatrix
+            print("P1 = ",p1)
+            shapeePerimeter.append([p1[0],p1[1]])
+
+      shapeePerimeter.append([p2[0],p2[1]])
+      shapeePerimeter=np.flip(shapeePerimeter,1)
+      shapeePerimeter=rotate_polygon(shapeePerimeter,rotationangle,rotationOld,width,height)
+
       for poi in np.array(cntPoints1):
-          x1, y1 = poi
-          p1 = fitz.Point(x1,y1)
-          # p1 = fitz.Point(x1,y1)
-          p1=p1*derotationMatrix
-          shapee.append([p1[0],p1[1]])
-
-      shapee=np.flip(shapee,1)
-      shapee=rotate_polygon(shapee,rotationangle,rotationOld,width,height)
-      tol=2
+            x1, y1 = poi
+            p1 = fitz.Point(x1,y1)
+            # p1 = fitz.Point(x1,y1)
+            p1=p1*derotationMatrix
+            print("P1 = ",p1)
+            shapeeArea.append([p1[0],p1[1]])
+
+      shapeeArea.append([p2[0],p2[1]])
+      shapeeArea=np.flip(shapeeArea,1)
+      shapeeArea=rotate_polygon(shapeeArea,rotationangle,rotationOld,width,height)
+
+      
+      tol=0
       condition1 = (SimilarAreaDictionary['Area'] >= polygon[1] - tol) & (SimilarAreaDictionary['Area'] <= polygon[1] +tol)
       condition2 = (SimilarAreaDictionary['Perimeter'] >= polygon[2] -tol) & (SimilarAreaDictionary['Perimeter'] <= polygon[2] +tol)
       combined_condition = condition1 & condition2
 
       if any(combined_condition):
-
+          flagcolor = 1
           index = np.where(combined_condition)[0][0]
           # print(SimilarAreaDictionary.at[index, 'Color'])
           NewColors=SimilarAreaDictionary.at[index, 'Color']
       else:
+        flagcolor = 2
         NewColors=SimilarAreaDictionary.at[i, 'Color']
-  
-      # cv2.drawContours(imgg, [np.array(cntPoints)], -1, (NewColors), thickness=2)
+
+      if(int(NewColors[0])==255 and int(NewColors[1])==255 and int(NewColors[2])==255):
+        WhiteImgFinal = cv2.bitwise_and(blackImgShapes,imgg)
+        flipped=flip(WhiteImgFinal)
+        
+
+        imgslice = WhiteImgFinal[y:y+h, x:x+w]
+        if(imgslice.shape[0] != 0 and imgslice.shape[1] != 0):
+            flippedSlice=flip(imgslice)
+            
+    
+        # Convert flippedSlice to PIL for color extraction
+            flippedSlice_pil = Image.fromarray(flippedSlice)
+    
+            # Define patch size for color sampling (e.g., 10x10 pixels)
+            patch_size = 100
+            patch_colors = []
+    
+            # Loop through patches in the image
+            for i in range(0, flippedSlice_pil.width, patch_size):
+                for j in range(0, flippedSlice_pil.height, patch_size):
+                    # Crop a patch from the original image
+                    patch = flippedSlice_pil.crop((i, j, i + patch_size, j + patch_size))
+                    patch_colors += patch.getcolors(patch_size * patch_size)
+    
+            # Calculate the dominant color from all patches
+            max_count = 0
+            dominant_color = None
+            tolerance = 5
+            black_threshold = 30  # Max RGB value for a color to be considered "black"
+            white_threshold = 225  # Min RGB value for a color to be considered "white"
+    
+            for count, color in patch_colors:
+                # Exclude colors within the black and white ranges
+                if not (all(c <= black_threshold for c in color) or all(c >= white_threshold for c in color)):
+                    # Update if the current color has a higher count than previous max
+                    if count > max_count:
+                        max_count = count
+                        dominant_color = color
+    
+            
+    
+            # Append dominant color to ColorCheck and update NewColors
+            if dominant_color is not None:
+                ColorCheck.append(dominant_color)
+    
+                NewColors = None
+    
+                for color in ColorCheck:
+                  # Check if the current color is within the tolerance
+                  print("color = ",color)
+                  print("dominant_color = ",dominant_color)
+                  if (abs(color[0] - dominant_color[0]) < 20 and
+                      abs(color[1] - dominant_color[1]) < 20 and
+                      abs(color[2] - dominant_color[2]) < 20):
+                      NewColors = (color[2], color[1], color[0])  # Set the new color
+                      break
+                  else:
+                      # If no color in ColorCheck meets the tolerance, use the dominant color
+                      NewColors = (dominant_color[2], dominant_color[1], dominant_color[0])
+    
+                if NewColors not in ColorCheck:
+                  ColorCheck.append(NewColors)
+    
+                
+                if flagcolor == 1:
+                    SimilarAreaDictionary.at[index, 'Color'] = NewColors
+                    # print(f"Updated Color at index {index} with {NewColors}.")
+                elif flagcolor == 2:
+                        SimilarAreaDictionary.at[i, 'Color'] = NewColors
+
+            
       cv2.drawContours(imgg, [np.array(cntPoints)], -1, ([NewColors[2],NewColors[1],NewColors[0]]), thickness=-1)
-      annot11 = page2.add_polygon_annot( points=shapee)  # 'Polygon'
+                    
+      annot11 = page2.add_polygon_annot( points=shapeeArea)  # 'Polygon'
       annot11.set_border(width=0.2)
       annot11.set_colors(stroke=(int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255), fill= (int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255) )
-      annot11.set_info(content='Area='+str(polygon[1])+' m^2',subject='ADR Team')
-      annot11.set_opacity(0.9)
+      annot11.set_info(content=str(polygon[1])+' sq m',subject='Area Measurement', title="ADR Team")
+      annot11.set_opacity(0.8)
       # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
       annot11.update()
 
 
 
-      annot12 = page2.add_polygon_annot( points=shapee)  # 'Polygon'
-      annot12.set_border(width=0.2)
+      annot12 = page2.add_polyline_annot( points=shapeePerimeter )  # 'Polygon'
+      annot12.set_border(width=0.8)
       annot12.set_colors(stroke=(int(NewColors[0])/255,int(NewColors[1])/255,int(NewColors[2])/255))
-      annot12.set_info(content='Perimeter='+str(polygon[2])+' m',subject='ADR Team')
+      annot12.set_info(content=str(polygon[2])+' m',subject='Perimeter Measurement', title="ADR Team")
       annot12.set_opacity(0.8)
       # annot.set_line_ends(fitz.PDF_ANNOT_LE_DIAMOND, fitz.PDF_ANNOT_LE_CIRCLE)
       annot12.update()
       i += 1
   alpha = 0.8  # Transparency factor.
-  
+
   page2.set_rotation(rotationOld)
   Correct_img=flip(imgg)
 
   image_new1 = cv2.addWeighted(Correct_img, alpha,  img, 1 - alpha, 0)
   SimilarAreaDictionary = SimilarAreaDictionary.fillna(' ')
-  gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr=google_sheet_Legend.legendGoogleSheets(SimilarAreaDictionary , pdfname,pdfpath)
+    
+  # Define white color to filter out
+  white_color = (255, 255, 255)
+
+  # Delete rows where 'Guess' equals white_color
+  SimilarAreaDictionary = SimilarAreaDictionary[SimilarAreaDictionary['Color'] != white_color]
+
+  # Reset the index to update row numbering
+  SimilarAreaDictionary.reset_index(drop=True, inplace=True)
+
+  grouped_df = SimilarAreaDictionary.groupby('Color').agg({
+            'Guess':'first',
+            'Occurences': 'sum',      # Sum of occurrences for each color
+            'Area':'first',
+            'Total Area': 'sum',           # Sum of areas for each color
+            'Perimeter':'first',
+            'Total Perimeter': 'sum',      # Sum of perimeters for each color
+            'Length':'first',
+            'Total Length':'first',
+            'Texts':'first',
+            'Comments':'first'
+      
+        }).reset_index()
+    
+  SimilarAreaDictionary = grouped_df
+  # doc.save(OutputPdfStage1)
+  modified_pdf_data = doc.tobytes()
+  # OutputPdfStage2=adjustannotations(modified_pdf_data)
+  OutputPdfStage2=adjustannotations(modified_pdf_data,Legendarray)
+
+
+  # with open("Adjusted_PDF.pdf", "wb") as f:
+  #   f.write(OutputPdfStage2)
+      
+  # doc2 = fitz.open(stream=OutputPdfStage2, filetype="pdf")
+  # doc2 = fitz.open(stream=OutputPdfStage2, filetype="pdf")
+      
+  doc2 =fitz.open('pdf',OutputPdfStage2)
+  if pdf_content:
+     gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr=google_sheet_Legend.legendGoogleSheets(SimilarAreaDictionary , pdfname,pdfpath,pdf_content)  
+  else:
+    gc,spreadsheet_service,spreadsheetId, spreadsheet_url , namepathArr=google_sheet_Legend.legendGoogleSheets(SimilarAreaDictionary , pdfname,pdfpath)
   # dbxTeam=tsadropboxretrieval.ADR_Access_DropboxTeam('user')
   # md, res =dbxTeam.files_download(path= pdfpath+pdfname)
   # data = res.content
@@ -558,7 +1508,8 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
   # list1=pd.DataFrame(columns=['content', 'creationDate', 'id', 'modDate', 'name', 'subject', 'title'])
   list1=pd.DataFrame(columns=['content',  'id',  'subject','color'])
 
-  for page in doc:    
+  # 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
@@ -569,63 +1520,21 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath,pdfname):
             fill_color = annot_color.get('fill')      # Fill color
             if fill_color:
               v='fill'
-              print('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 doc,image_new1, SimilarAreaDictionary ,spreadsheetId, spreadsheet_url , namepathArr , list1,hatched_areas
-
+  print('LISTTT',list1)
+  return doc2,image_new1, SimilarAreaDictionary ,spreadsheetId, spreadsheet_url , namepathArr , list1,hatched_areas
 
-def deletemarkupsDXF(list1, dbPath, path):
-    '''list1 : original markup pdf
-       list2 : deleted markup pdf
-       deletedrows : deleted markups - difference between both dfs
-    '''
+  # doc.save('Testing(2.7).pdf')
+  # return doc,image_new1#, SimilarAreaDictionary ,spreadsheetId, spreadsheet_url , namepathArr , list1,hatched_areas
 
-    myDict1 = eval(list1)
-    list1 = pd.DataFrame(myDict1)
+# datadoc='/content/3.3 - Ceiling finishes - Example 1 - Sheet 1.pdf' #pdf path here
+# dxfpath='/content/3.3 - Ceiling finishes - Example 1 - Sheet 1.dxf'#dxfpath here
+# dxfratio=28.3464527867108
+# doc,image_new1=mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio)
+# cv2_imshow(image_new1)
 
-    dbxTeam = tsadropboxretrieval.ADR_Access_DropboxTeam('user')
-    md, res = dbxTeam.files_download(path=dbPath + path)
-    data = res.content
-    doc = fitz.open("pdf", data)
-    
-    # Prepare a DataFrame for the annotations in the new PDF
-    list2 = pd.DataFrame(columns=['content', 'id', 'subject', 'color'])
-
-    for page in doc:
-        # 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:
-                # Check for fill or stroke color
-                stroke_color = annot_color.get('stroke')
-                fill_color = annot_color.get('fill')
-
-                v = 'stroke' if stroke_color else 'fill'
-                color = annot_color.get(v)
-                if color:
-                    # Convert color to tuple and multiply by 255 to get RGB values
-                    color_tuple = (int(color[0] * 255), int(color[1] * 255), int(color[2] * 255))
-                    # Append annotation data to list2
-                    list2.loc[len(list2)] = [annot.info['content'], annot.info['id'], annot.info['subject'], color_tuple]
-
-    # Ensure that colors are stored as tuples (which are hashable)
-    list1['color'] = list1['color'].apply(lambda x: tuple(x) if isinstance(x, list) else x)
-    
-    # Find the deleted rows by checking the difference between original and current annotations
-    deletedrows = pd.concat([list1, list2]).drop_duplicates(keep=False)
-
-    print(deletedrows, len(deletedrows))
-    flag = 0
-    if len(deletedrows) != 0:
-        flag = 1
-        deletedrows = deletedrows[['content', 'id', 'subject', 'color']]
-        # Drop rows where 'content' starts with 'Scale'
-        deletedrows = deletedrows.drop(deletedrows.index[deletedrows['content'].str.startswith('Scale')])
-    else:
-        flag = 0
-    
-    return deletedrows
+