Update deploying_3_3.py

deploying_3_3.py

@@ -11,36 +11,14 @@ Original file is located at
 
 # pip install ezdxf
 
-from math import sqrt
+def normalize_vertices(vertices):
+    """Sort vertices to ensure consistent order."""
+    return tuple(sorted(tuple(v) for v in vertices))
 
-def distance(v1, v2):
-    """Calculate the Euclidean distance between two points."""
-    return sqrt((v1[0] - v2[0])**2 + (v1[1] - v2[1])**2)
+def areas_are_similar(area1, area2, tolerance=0.2):
+    """Check if two areas are within a given tolerance."""
+    return abs(area1 - area2) <= tolerance
 
-def normalize_vertices(vertices):
-    """Convert all vertices to tuples and sort them."""
-    return sorted([tuple(vertex) for vertex in vertices])
-
-def vertices_are_close(vertices1, vertices2, threshold=0.01):
-    """Check if all vertices in two sets are within a certain distance threshold."""
-    vertices1 = normalize_vertices(vertices1)
-    vertices2 = normalize_vertices(vertices2)
-
-    if len(vertices1) != len(vertices2):
-        return False
-
-    for v1, v2 in zip(vertices1, vertices2):
-        if distance(v1, v2) > threshold:
-            return False
-    return True
-
-def vertices_exist(hatched_areas, vertices, threshold=0.01):
-    """Check if a set of vertices exists in hatched_areas within a given threshold."""
-    for area in hatched_areas:
-        existing_vertices = area[0]
-        if vertices_are_close(existing_vertices, vertices, threshold):
-            return True
-    return False
 
 from ctypes import sizeof
 # -*- coding: utf-8 -*-wj
@@ -573,6 +551,7 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
       trial=0
       hatched_areas = []
       threshold=0.01
+      unique_shapes = []
       for entity in msp:
         if entity.dxftype() == 'HATCH':
             # print(f"Processing HATCH entity: {entity}")
@@ -592,11 +571,17 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
                         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)
 
-                            # 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}")
+                            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':
@@ -617,10 +602,17 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
                         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}")
+                        normalized_vertices = normalize_vertices(vert)
+
+                        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:
@@ -636,9 +628,21 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
             height = maxy - miny
 
             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):
-                rgb_color = get_hatch_color(entity)
-                hatched_areas.append([vertices,poly.area,poly.length,rgb_color])
+              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])
+
 
 
 
@@ -668,12 +672,17 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
                       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:
-                      if not vertices_exist(hatched_areas, vertices, threshold):#if not vertices_exist(hatched_areas, vertices):
-                          rgb_color = get_hatch_color(entity)
+                      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])
 
 
@@ -700,9 +709,18 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
                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, threshold):#if not vertices_exist(hatched_areas, vertices):
-                  rgb_color = get_hatch_color(entity)
-                  hatched_areas.append([vertices, area1, perimeter,rgb_color])
+                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':
@@ -724,9 +742,18 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle):
             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, threshold):
-                  rgb_color = get_hatch_color(entity)
-                  hatched_areas.append([vertices,area1,perimeter,rgb_color])
+                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
@@ -947,20 +974,58 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
         
 
         # 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):
-                print(SimilarAreaDictionary.at[index, 'Color'])
-                print(NewColors)
-                SimilarAreaDictionary.at[index, 'Color'] = NewColors
-            elif(flagcolor == 2):
-                print(SimilarAreaDictionary.at[index, 'Color'])
-                print(NewColors)
-                SimilarAreaDictionary.at[i, 'Color'] = 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)
+
+            
+            ConditionColor = (SimilarAreaDictionary['Color'] == NewColors)
+
+            if ConditionColor.any():
+                existing_index = SimilarAreaDictionary.loc[ConditionColor].index[0]
+    
+                if flagcolor == 1:
+                    SimilarAreaDictionary.at[existing_index, 'Total Area'] = SimilarAreaDictionary.at[existing_index, 'Total Area'] + SimilarAreaDictionary.at[index, 'Area']
+                    SimilarAreaDictionary.at[existing_index, 'Total Perimeter'] = SimilarAreaDictionary.at[existing_index, 'Total Perimeter'] + SimilarAreaDictionary.at[index, 'Perimeter']
+                    SimilarAreaDictionary.at[existing_index, 'Occurences']  = SimilarAreaDictionary.at[existing_index, 'Occurences'] + 1
+    
+    
+                elif flagcolor == 2:
+                    SimilarAreaDictionary.at[existing_index, 'Total Area'] = SimilarAreaDictionary.at[existing_index, 'Total Area'] + SimilarAreaDictionary.at[i, 'Area']
+                    SimilarAreaDictionary.at[existing_index, 'Total Perimeter'] = SimilarAreaDictionary.at[existing_index, 'Total Perimeter'] + SimilarAreaDictionary.at[i, 'Perimeter']
+                    SimilarAreaDictionary.at[existing_index, 'Occurences']  = SimilarAreaDictionary.at[existing_index, 'Occurences'] + 1
+
+
+
+            else:
+                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
+                    # print(f"Updated Color at index {i} with {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'
       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) )
@@ -986,6 +1051,16 @@ def mainFunctionDrawImgPdf(datadoc,dxfpath, dxfratio,pdfpath=0,pdfname=0):
 
   image_new1 = cv2.addWeighted(Correct_img, alpha,  img, 1 - alpha, 0)
   SimilarAreaDictionary = SimilarAreaDictionary.fillna(' ')
+    
+  # 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)
+    
   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)