use shapely.ops.unary_union

Author: xmarduel

.vscode/launch.json

@@ -4,6 +4,7 @@
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
+
         {
             "name": "OPENGL DEMO1",
             "type": "python",
@@ -64,6 +65,15 @@
             "cwd": "C:\\Users\\xavie\\Documents\\GITHUB\\pycut",
             "args": ["-job", "C:\\Users\\xavie\\Documents\\GITHUB\\pycut\\jobs\\cnc_three_rects_with_circle.json"]
         },
+        {
+            "name": "PYCUT JOB ALL LETTERS",
+            "type": "python",
+            "request": "launch",
+            "program": "pycut.py",
+            "console": "integratedTerminal",
+            "cwd": "C:\\Users\\xavie\\Documents\\GITHUB\\pycut",
+            "args": ["-job", "C:\\Users\\xavie\\Documents\\GITHUB\\pycut\\jobs\\cnc_all_letters.json"]
+        },
         {
             "name": "PYCUT GEAR 40",
             "type": "python",

cam.py

@@ -33,7 +33,7 @@
 class CamPath:
     '''
     CamPath has this format: {
-      path:               Shapely path
+      path:               Shapely LineString
       safeToClose:        Is it safe to close the path without retracting?
     }
     '''
@@ -67,31 +67,31 @@ def pocket(cls, geometry: shapely.geometry.MultiPolygon, cutterDia: float, overl
         cutterDia is in "UserUnit" units. 
         overlap is in the range [0, 1).
         '''
-        # use polygons exteriors lines - offset them and and diff with the interiors if any
+        #new_algo = False
+        #if new_algo:
+        #    for poly in geometry.geoms:
+        #        pc = PocketCalculator(poly, cutterDia, overlap, climb)
+        #        pc.calculate()
+        #        return pc.camPath
+
+        # use polygons exteriors lines - offset them and and diff with the offseted interiors if any
         geometry = ShapelyUtils.orientMultiPolygon(geometry)
 
         MatplotLibUtils.MatplotlibDisplay("geom pocket init", geometry)
 
         # the exterior
         multi_offset, current = ShapelyUtils.offsetMultiPolygon(geometry, cutterDia / 2, 'left', ginterior=True)
-        
-        current = ShapelyUtils.simplifyMultiPoly(current, 0.001)
-        current = ShapelyUtils.orientMultiPolygon(current)
 
         for geom in current.geoms:
             MatplotLibUtils.MatplotlibDisplay("geom pocket init after simplify", geom)
-
-        if not current:
-            return []
 
         if len(current.geoms) == 0:
             # cannot offset ! maybe geometry too narrow for the cutter
             return []
 
         # bound must be the exterior enveloppe + the interiors polygons
-        #bounds = geometry 
-
         # no! the bounds are from the first offset with width cutterDia / 2
+        #bounds = geometry 
         bounds = shapely.geometry.MultiPolygon(current)
 
         allPaths : List[shapely.geometry.LineString] = []

misc_private/shapely/svgpathtools.bug.py

@@ -0,0 +1,56 @@
+import svgpathtools
+import math
+
+pt1 = [335.4321, 69.71516199999999]
+pt2 = [335.27971, 69.86756199999999]
+
+ctrl = [335.33051, 69.816762]
+
+def test1():
+    st = (335.43211+69.71516199999999j)
+    end = (335.27971+69.86756199999999j)
+    ct = (335.33051+69.816762j)
+    zz = svgpathtools.QuadraticBezier(st, ct, end)
+
+    try:
+        d1 = zz.length()
+        print("test1:", d1)
+    except :
+        print("test1 exception")
+
+def test2():
+    st = (335.43211+69.715162j)
+    ct = (335.33051+69.816762j)
+    end = (335.27971+69.867562j)
+
+    zz = svgpathtools.QuadraticBezier(st, ct, end)
+  
+    try:
+        d1 = zz.length()
+        print("test2:", d1)
+    except :
+        print("test2 exception")
+
+
+
+if __name__ == '__main__':
+
+    dx = pt1[0]-pt2[0]
+    dy = pt1[1]-pt2[1]
+
+    print("dist(pt1-pt2) = ", math.sqrt(dx*dx+dy*dy))
+
+    test1()
+    test2()
+
+
+
+
+
+
+
+
+
+
+
+

misc_private/shapely/test_multipoly.py

@@ -0,0 +1,79 @@
+
+
+import matplotlib.pyplot as plt
+
+import shapely
+from shapely.geometry import LineString, Polygon, LinearRing, MultiPolygon
+from shapely.ops import unary_union
+'''
+
+
+'''
+
+print("")
+print("")
+print("")
+print("")
+print("")
+print("")
+
+# -------- SETUP INITIAL LINESTRING/LINEARRINF AND POLYGONS ---------------
+
+# we give two list of coords with "opposite directions"
+ 
+coords1 = [(0,0), (2,0), (2,2), (0,2)]
+coords2 = [(4,0), (6,0), (6,2), (4,2)]
+coords3 = [(5,0), (7,0), (7,2), (6,2)]
+coords4 = [(8,0), (9,0), (9,2), (8,2)]
+
+p1 = Polygon(coords1)
+p2 = Polygon(coords2) 
+p3 = Polygon(coords3)
+p4 = Polygon(coords4)
+
+
+res = unary_union([p1,p2,p3, p4])
+print(res)
+
+
+plt.title("unary_union")
+for poly in res.geoms:
+    if poly.geom_type == 'Polygon':
+        xx, yy = poly.exterior.coords.xy
+        plt.plot(xx,yy, 'bo-', label="poly")
+plt.legend()
+plt.show()
+
+# ---------------------------------------------------------
+
+# we give two list of coords with "opposite directions"
+ 
+coords1 = [(0,0), (2,0), (2,2), (0,2)]
+coords2 = [(4,0), (6,0), (6,2), (4,2)]
+coords3 = [(1,1), (5,1), (5,3), (1,3)]
+
+p1 = Polygon(coords1)
+p2 = Polygon(coords2) 
+p3 = Polygon(coords3)
+
+p1p2 = MultiPolygon([p1, p2])
+p1p3 = MultiPolygon([p1, p3])
+p2p3 = MultiPolygon([p2, p3])
+
+print("p1p2 valid ?", p1p2.is_valid)
+print("p1p3 valid ?", p1p3.is_valid)
+print("p2p3 valid ?", p2p3.is_valid)
+
+p2up3 = p2.union(p3)
+
+print("p2up3 valid ?", p2up3.is_valid)
+
+res = unary_union([p1,p2,p3])
+print(res)
+
+if res.geom_type == 'Polygon':
+    plt.title("unary_union")
+    xx, yy = res.exterior.coords.xy
+    plt.plot(xx,yy, 'bo-', label="poly")
+    plt.legend()
+    plt.show()