Update deploying_3_3.py

deploying_3_3.py

@@ -238,8 +238,335 @@ 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)
+
+
 """### Hatched areas"""
-def get_hatched_areas(filename,FinalRatio):
+def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
       doc = ezdxf.readfile(filename)
       doc.header['$MEASUREMENT'] = 1
       msp = doc.modelspace()
@@ -262,14 +589,15 @@ def get_hatched_areas(filename,FinalRatio):
                         width = maxx - minx
                         height = maxy - miny
 
-                        if poly.area > 0 and (height > 0.3 or width > 0.3):
+                        if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                             area1 = round(poly.area, 3)
                             perimeter = round(poly.length, 3)
 
                             # Append POLYLINE if vertices don't already exist
                             if not vertices_exist(hatched_areas, vertices, threshold):
+                                rgb_color = get_hatch_color(entity)
                                 # print(f"Appending POLYLINE with area: {area1} and perimeter: {perimeter}")
-                                hatched_areas.append([vertices, area1, perimeter])
+                                hatched_areas.append([vertices, area1, perimeter, rgb_color])
 
                 elif str(path.type) == 'BoundaryPathType.EDGE':
                     # Handle EDGE type HATCH
@@ -285,14 +613,15 @@ def get_hatched_areas(filename,FinalRatio):
                     width = maxx - minx
                     height = maxy - miny
 
-                    if poly.area > 0 and (height > 0.3 or width > 0.3):
+                    if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                         area1 = round(poly.area, 3)
                         perimeter = round(poly.length, 3)
 
                         # Append EDGE if vertices don't already exist
                         if not vertices_exist(hatched_areas, vert, threshold):
+                            rgb_color = get_hatch_color(entity)
                             # print(f"Appending EDGE with area: {area1} and perimeter: {perimeter}")
-                            hatched_areas.append([vert, area1, perimeter])
+                            hatched_areas.append([vert, area1, perimeter, rgb_color])
 
                 else:
                     print(f"Unhandled path type: {path.type}")
@@ -306,9 +635,10 @@ def get_hatched_areas(filename,FinalRatio):
             width = maxx - minx
             height = maxy - miny
 
-            if (poly.area > 0 and (height > 0.3 or width > 0.3)):
+            if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                if not vertices_exist(hatched_areas, vertices, threshold):#if not vertices_exist(hatched_areas, vertices):
-                hatched_areas.append([vertices,poly.area,poly.length])
+                rgb_color = get_hatch_color(entity)
+                hatched_areas.append([vertices,poly.area,poly.length,rgb_color])
 
 
 
@@ -334,7 +664,7 @@ def get_hatched_areas(filename,FinalRatio):
                   height = maxy - miny
 
                   # Check area and size constraints
-                  if poly.area > 0 and (height > 0.3 or width > 0.3):
+                  if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                       area1 = round(poly.area, 3)
                       perimeter = round(poly.length, 3)
 
@@ -343,7 +673,8 @@ def get_hatched_areas(filename,FinalRatio):
                       #         flag = 1
                       # if flag == 0:
                       if not vertices_exist(hatched_areas, vertices, threshold):#if not vertices_exist(hatched_areas, vertices):
-                          hatched_areas.append([vertices, area1, perimeter])
+                          rgb_color = get_hatch_color(entity)
+                          hatched_areas.append([vertices, area1, perimeter, rgb_color])
 
 
 
@@ -366,14 +697,13 @@ def get_hatched_areas(filename,FinalRatio):
                width = maxx - minx
                height = maxy - miny
 
-               if (poly.area > 0 and (height > 0.3 or width > 0.3)):
+               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])
+                if not vertices_exist(hatched_areas, vertices, threshold):#if not vertices_exist(hatched_areas, vertices):
+                  rgb_color = get_hatch_color(entity)
+                  hatched_areas.append([vertices, area1, perimeter,rgb_color])
+
 
         elif entity.dxftype() == 'SPLINE':
           spline_entity = entity
@@ -391,11 +721,12 @@ def get_hatched_areas(filename,FinalRatio):
             height = maxy - miny
 
 
-            if (poly.area > 0 and (height > 0.3 or width > 0.3)):
+            if (poly.area > 0.9 and (height > 0.7 and width > 0.7)):
                 area1 = round(poly.area,3)
                 perimeter = round (poly.length,3)
-                if not vertices_exist(hatched_areas, vertices):
-                  hatched_areas.append([vertices,area1,perimeter])
+                if not vertices_exist(hatched_areas, vertices, threshold):
+                  rgb_color = get_hatch_color(entity)
+                  hatched_areas.append([vertices,area1,perimeter,rgb_color])
 
       sorted_data = sorted(hatched_areas, key=lambda x: x[1])
       return sorted_data
@@ -443,50 +774,36 @@ 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):
+def Create_DF(dxfpath,datadoc,hatched_areas):
 
   FinalRatio= RetriveRatio(datadoc,dxfpath)
 
-  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
+  # 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(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=[]
+    
   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[1]  # 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
@@ -499,7 +816,7 @@ 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)
@@ -509,7 +826,7 @@ def Create_DF(dxfpath,datadoc):
 def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
   FinalRatio= RetriveRatio(datadoc,dxfpath)
 
-  hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
+  # hatched_areas = get_hatched_areas(dxfpath,FinalRatio)
   # hatched_areas=remove_duplicate_shapes(new_hatched_areas)
 
   img=pdftoimg(datadoc)
@@ -534,17 +851,25 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
     ratio =  pix.width/ img.shape[1]
     rotationangle = 270
 
+
+  hatched_areas = get_hatched_areas(datadoc,dxfpath,FinalRatio,rotationangle)
   allshapes=[]
   # Iterate through each polygon in metric units
   NewColors = []
-  SimilarAreaDictionary=Create_DF(dxfpath,datadoc)
+  SimilarAreaDictionary=Create_DF(dxfpath,datadoc,hatched_areas)
   i=0
+  flagcolor = 0
 
 
   for polygon in hatched_areas:
       cntPoints = []
       cntPoints1 = []
       shapee = []
+
+      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
@@ -555,6 +880,9 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
           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))
+
       for poi in np.array(cntPoints1):
           x1, y1 = poi
           p1 = fitz.Point(x1,y1)
@@ -564,19 +892,69 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
 
       shapee=np.flip(shapee,1)
       shapee=rotate_polygon(shapee,rotationangle,rotationOld,width,height)
-      tol=2
+      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']
 
+      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]
+        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 = 60
+        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 != None):
+            ColorCheck.append(dominant_color)
+            NewColors = (dominant_color[2], dominant_color[1], dominant_color[0])
+            if(flagcolor == 1):
+              SimilarAreaDictionary.at[index, 'Color'] = NewColors
+            elif(flagcolor == 2):
+              SimilarAreaDictionary.at[i, 'Color'] = NewColors
+
       # cv2.drawContours(imgg, [np.array(cntPoints)], -1, (NewColors), thickness=2)
       cv2.drawContours(imgg, [np.array(cntPoints)], -1, ([NewColors[2],NewColors[1],NewColors[0]]), thickness=-1)
       annot11 = page2.add_polygon_annot( points=shapee)  # 'Polygon'