Update deploying_3_3.py

deploying_3_3.py

@@ -1206,7 +1206,7 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle,SearchArray):
             for path in entity.paths:
                 vertices = []  # Reset vertices for each path
 
-                if str(path.type) == 'BoundaryPathType.POLYLINE':
+                if path.type == 1:
                     # Handle POLYLINE type HATCH
                     vertices = [(vertex[0] * FinalRatio, vertex[1] * FinalRatio) for vertex in path.vertices]
 
@@ -1243,49 +1243,76 @@ def get_hatched_areas(datadoc,filename,FinalRatio,rotationangle,SearchArray):
                                 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 path.type == 2:
+                    # convert any spline edges to line edges (approximates splines)
+                  # factor controls approximation density: control_points_count * factor
+                  try:
+                      path.spline_edges_to_line_edges(factor=8)  # increase factor for finer approx
+                  except Exception:
+                      # defensive: some versions / unexpected objects might raise — ignore and continue
+                      pass
+
+                  vert = []
+                  # After conversion most edges will be LineEdge with .start and .end
+                  for edge in path.edges:
+                      # If edge has start/end attributes (LineEdge), use them
+                      if hasattr(edge, "start") and hasattr(edge, "end"):
+                          sx, sy = edge.start
+                          ex, ey = edge.end
+                          # append only start point; we'll append the end of the last edge too to close path
+                          vert.append((sx * FinalRatio, sy * FinalRatio))
+                      else:
+                          # fallback: try control_points or fit_points if present (rare after conversion)
+                          if hasattr(edge, "control_points") and edge.control_points:
+                              for cp in edge.control_points:
+                                  vert.append((cp[0] * FinalRatio, cp[1] * FinalRatio))
+                          elif hasattr(edge, "fit_points") and edge.fit_points:
+                              for fp in edge.fit_points:
+                                  vert.append((fp[0] * FinalRatio, fp[1] * FinalRatio))
+                          else:
+                              # last resort: try to string-represent and skip if nothing usable
+                              continue
+
+                  # After loop, ensure polygon is closed: append last edge.end if available
+                  if path.edges and hasattr(path.edges[-1], "end"):
+                      ex, ey = path.edges[-1].end
+                      vert.append((ex * FinalRatio, ey * FinalRatio))
+
+                  # remove possible duplicate consecutive points (optional)
+                  cleaned = []
+                  for p in vert:
+                      if not cleaned or (abs(cleaned[-1][0] - p[0]) > 1e-9 or abs(cleaned[-1][1] - p[1]) > 1e-9):
+                          cleaned.append(p)
+                  vert = cleaned
+
+                  # validate and use Shapely as before
+                  if len(vert) >= 3:
+                      poly = ShapelyPolygon(vert)
+                      minx, miny, maxx, maxy = poly.bounds
+                      width = maxx - minx
+                      height = maxy - miny
+
+                      if (poly.area > 0.1 and (height > 0.1 and width > 0.1)):
+                          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) and 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:
+                              unique_shapes.append((normalized_vertices, area1))
+                              hatched_areas.append([vert, area1, perimeter, rgb_color])
 
         elif entity.dxftype() == 'SOLID':
             vertices = [entity.dxf.vtx0 * (FinalRatio), entity.dxf.vtx1* (FinalRatio), entity.dxf.vtx2* (FinalRatio), entity.dxf.vtx3* (FinalRatio)]