Face sweep for free function API (#1622)

* Face sweep

* Add multisection support

* black fix

* Support lofting faces

* Add some tests

* Improve coverage

* Fix test

* Small doc tweaks

* Docstring tweak

* Docstring updates

Author: adam-urbanczyk

cadquery/occ_impl/shapes.py

@@ -4222,7 +4222,7 @@ def _get_edges(s: Shape) -> Iterable[Shape]:
 
 def _get_wire_lists(s: Sequence[Shape]) -> List[List[Wire]]:
     """
-    Get lists or wires for sweeping or lofting.
+    Get lists of wires for sweeping or lofting.
     """
 
     wire_lists: List[List[Wire]] = []
@@ -4237,6 +4237,23 @@ def _get_wire_lists(s: Sequence[Shape]) -> List[List[Wire]]:
     return wire_lists
 
 
+def _get_face_lists(s: Sequence[Shape]) -> List[List[Face]]:
+    """
+    Get lists of faces for sweeping or lofting.
+    """
+
+    face_lists: List[List[Face]] = []
+
+    for el in s:
+        if not face_lists:
+            face_lists = [[f] for f in el.Faces()]
+        else:
+            for face_list, f in zip(face_lists, el.Faces()):
+                face_list.append(f)
+
+    return face_lists
+
+
 def _normalize(s: Shape) -> Shape:
     """
     Apply some normalizations:
@@ -4482,7 +4499,7 @@ def rect(w: float, h: float) -> Shape:
 @multimethod
 def spline(*pts: VectorLike, tol: float = 1e-6, periodic: bool = False) -> Shape:
     """
-    Construct a polygon (closed polyline) from points.
+    Construct a spline from points.
     """
 
     data = _pts_to_harray(pts)
@@ -4910,74 +4927,165 @@ def offset(s: Shape, t: float, cap=True, tol: float = 1e-6) -> Shape:
 @multimethod
 def sweep(s: Shape, path: Shape, cap: bool = False) -> Shape:
     """
-    Sweep edge or wire along a path.
+    Sweep edge, wire or face along a path. For faces cap has no effect.
+    Do not mix faces with other types.
     """
 
     spine = _get_one_wire(path)
 
     results = []
 
-    for w in _get_wires(s):
-        builder = BRepOffsetAPI_MakePipeShell(spine.wrapped)
-        builder.Add(w.wrapped, False, False)
-        builder.Build()
+    # try to get faces
+    faces = s.Faces()
 
-        if cap:
-            builder.MakeSolid()
+    # if faces were supplied
+    if faces:
+        for f in faces:
+            tmp = sweep(f.outerWire(), path, True)
 
-        results.append(builder.Shape())
+            # if needed subtract two sweeps
+            inner_wires = f.innerWires()
+            if inner_wires:
+                tmp -= sweep(compound(inner_wires), path, True)
+
+            results.append(tmp.wrapped)
+
+    # otherwise sweep wires
+    else:
+        for w in _get_wires(s):
+            builder = BRepOffsetAPI_MakePipeShell(spine.wrapped)
+            builder.Add(w.wrapped, False, False)
+            builder.Build()
+
+            if cap:
+                builder.MakeSolid()
+
+            results.append(builder.Shape())
 
     return _compound_or_shape(results)
 
 
 @sweep.register
 def sweep(s: Sequence[Shape], path: Shape, cap: bool = False) -> Shape:
     """
-    Sweep edges or wires along a path, chaining sections are supported.
+    Sweep edges, wires or faces along a path, multiple sections are supported. 
+    For faces cap has no effect. Do not mix faces with other types.
     """
 
     spine = _get_one_wire(path)
 
     results = []
 
-    # construct sweeps
-    for el in _get_wire_lists(s):
+    # try to construct sweeps using faces
+    for el in _get_face_lists(s):
+        # build outer part
         builder = BRepOffsetAPI_MakePipeShell(spine.wrapped)
 
-        for w in el:
-            builder.Add(w.wrapped, False, False)
+        for f in el:
+            builder.Add(f.outerWire().wrapped, False, False)
 
         builder.Build()
+        builder.MakeSolid()
 
-        if cap:
-            builder.MakeSolid()
+        # build inner parts
+        builders_inner = []
 
-        results.append(builder.Shape())
+        # initialize builders
+        for w in el[0].innerWires():
+            builder_inner = BRepOffsetAPI_MakePipeShell(spine.wrapped)
+            builder_inner.Add(w.wrapped, False, False)
+            builders_inner.append(builder_inner)
+
+        # add remaining sections
+        for f in el[1:]:
+            for builder_inner, w in zip(builders_inner, f.innerWires()):
+                builder_inner.Add(w.wrapped, False, False)
+
+        # actually build
+        inner_parts = []
+
+        for builder_inner in builders_inner:
+            builder_inner.Build()
+            builder_inner.MakeSolid()
+            inner_parts.append(Shape(builder_inner.Shape()))
+
+        results.append((Shape(builder.Shape()) - compound(inner_parts)).wrapped)
+
+    # if no faces were provided try with wires
+    if not results:
+        # construct sweeps
+        for el in _get_wire_lists(s):
+            builder = BRepOffsetAPI_MakePipeShell(spine.wrapped)
+
+            for w in el:
+                builder.Add(w.wrapped, False, False)
+
+            builder.Build()
+
+            if cap:
+                builder.MakeSolid()
+
+            results.append(builder.Shape())
 
     return _compound_or_shape(results)
 
 
 @multimethod
 def loft(s: Sequence[Shape], cap: bool = False, ruled: bool = False) -> Shape:
     """
-    Loft edges or wires.
+    Loft edges, wires or faces. For faces cap has no effect. Do not mix faces with other types.
     """
 
     results = []
-
-    # construct lofts
     builder = BRepOffsetAPI_ThruSections()
 
-    for el in _get_wire_lists(s):
-        builder.Init(cap, ruled)
+    # try to construct lofts using faces
+    for el in _get_face_lists(s):
+        # build outer part
+        builder.Init(True, ruled)
 
-        for w in el:
-            builder.AddWire(w.wrapped)
+        for f in el:
+            builder.AddWire(f.outerWire().wrapped)
 
         builder.Build()
         builder.Check()
 
-        results.append(builder.Shape())
+        builders_inner = []
+
+        # initialize builders
+        for w in el[0].innerWires():
+            builder_inner = BRepOffsetAPI_ThruSections()
+            builder_inner.Init(True, ruled)
+            builder_inner.AddWire(w.wrapped)
+            builders_inner.append(builder_inner)
+
+        # add remaining sections
+        for f in el[1:]:
+            for builder_inner, w in zip(builders_inner, f.innerWires()):
+                builder_inner.AddWire(w.wrapped)
+
+        # actually build
+        inner_parts = []
+
+        for builder_inner in builders_inner:
+            builder_inner.Build()
+            builder_inner.Check()
+            inner_parts.append(Shape(builder_inner.Shape()))
+
+        results.append((Shape(builder.Shape()) - compound(inner_parts)).wrapped)
+
+    # otherwise construct using wires
+    if not results:
+        for el in _get_wire_lists(s):
+            builder.Init(cap, ruled)
+
+            for w in el:
+                builder.AddWire(w.wrapped)
+
+            builder.Build()
+            builder.Check()
+
+            results.append(builder.Shape())
 
     return _compound_or_shape(results)
 

doc/free-func.rst

@@ -197,26 +197,27 @@ Free function API currently supports :meth:`~cadquery.occ_impl.shapes.extrude`,
 .. cadquery::
 
     from cadquery.occ_impl.shapes import *
-
+    
     r = rect(1,0.5)
+    f = face(r, circle(0.2).moved(0.2), rect(0.2, 0.4).moved(-0.2))
     c = circle(0.2)
-    p = spline([(0,0,0), (0,1,2)], [(0,0,1), (0,1,1)])
-
+    p = spline([(0,0,0), (0,-1,2)], [(0,0,1), (0,-1,1)])
+    
     # extrude
     s1 = extrude(r, (0,0,2))
     s2 = extrude(fill(r), (0,0,1))
-
+    
     # sweep
     s3 = sweep(r, p)
-    s4 = sweep(r, p, cap=True)
-
+    s4 = sweep(f, p)
+    
     # loft
     s5 = loft(r, c.moved(z=2))
     s6 = loft(r, c.moved(z=1), cap=True)\
-
+    
     # revolve
     s7 = revolve(fill(r), (0.5, 0, 0), (0, 1, 0), 90)
-
+    
     results = (s1, s2, s3, s4, s5, s6, s7)
     result = compound([el.moved(2*i) for i,el in enumerate(results)])
 

tests/test_free_functions.py

@@ -488,23 +488,34 @@ def test_sweep():
     w1 = rect(1, 1)
     w2 = w1.moved(Location(0, 0, 1))
 
+    f1 = face(rect(1, 1), circle(0.25))
+    f2 = face(rect(2, 1), ellipse(0.9, 0.45)).moved(x=2, z=2, ry=90)
+    f3 = face(rect(1, 1))
+
     p1 = segment((0, 0, 0), (0, 0, 1))
     p2 = spline((w1.Center(), w2.Center()), ((-0.5, 0, 1), (0.5, 0, 1)))
+    p3 = spline((f1.Center(), f2.Center()), ((0, 0, 1), (1, 0, 0)))
 
-    r1 = sweep(w1, p1)
-    r2 = sweep((w1, w2), p1)
-    r3 = sweep(w1, p1, cap=True)
-    r4 = sweep((w1, w2), p1, cap=True)
-    r5 = sweep((w1, w2), p2, cap=True)
+    r1 = sweep(w1, p1)  # simple sweep
+    r2 = sweep((w1, w2), p1)  # multi-section sweep
+    r3 = sweep(w1, p1, cap=True)  # simple with cap
+    r4 = sweep((w1, w2), p1, cap=True)  # multi-section with cap
+    r5 = sweep((w1, w2), p2, cap=True)  # see above
+    r6 = sweep(f1, p3)  # simple face sweep
+    r7 = sweep((f1, f2), p3)  # multi-section face sweep
+    r8 = sweep(f3, p3)  # simplest face sweep (no inner wires)
 
-    assert_all_valid(r1, r2, r3, r4, r5)
+    assert_all_valid(r1, r2, r3, r4, r5, r6, r7, r8)
 
     assert r1.Area() == approx(4)
     assert r2.Area() == approx(4)
     assert r3.Volume() == approx(1)
     assert r4.Volume() == approx(1)
     assert r5.Volume() > 0
     assert len(r5.Faces()) == 6
+    assert len(r6.Faces()) == 7
+    assert len(r7.Faces()) == 7
+    assert len(r8.Faces()) == 6
 
 
 def test_loft():
@@ -516,16 +527,23 @@ def test_loft():
     w4 = segment((0, 0), (1, 0))
     w5 = w4.moved(0, 0, 1)
 
+    f1 = face(rect(2, 1), rect(0.5, 0.2).moved(x=0.5), rect(0.5, 0.2).moved(x=-0.5))
+    f2 = face(rect(3, 2), circle(0.5).moved(x=0.7), circle(0.5).moved(x=-0.7)).moved(
+        z=1
+    )
+
     r1 = loft(w1, w2, w3)  # loft
     r2 = loft(w1, w2, w3, ruled=True)  # ruled loft
     r3 = loft([w1, w2, w3])  # overload
     r4 = loft(w1, w2, w3, cap=True)  # capped loft
     r5 = loft(w4, w5)  # loft with open edges
+    r6 = loft(f1, f2)  # loft with faces
 
-    assert_all_valid(r1, r2, r3, r4, r5)
+    assert_all_valid(r1, r2, r3, r4, r5, r6)
 
     assert len(r1.Faces()) == 1
     assert len(r2.Faces()) == 2
     assert len((r1 - r3).Faces()) == 0
     assert r4.Volume() > 0
     assert r5.Area() == approx(1)
+    assert len(r6.Faces()) == 16