Add extend, speed up distance and improve imprint (#1797)

* Add extend and speed up distance calc

* Add conversion to NURBS

* Add checks to extend

* Remove checks

* Add test and defaults

* Better coverage

* Ignore coverege of a failed imprint

* Better coverage

* Remove pragma

* Fixture cleanup

* Add replace

* Fix replace and add remove to Shape

* Add addCavity

* Add more tests

* Coverage fix

* Actually faster distance

* Apply suggestion.

* Fix docstring

---------

Co-authored-by: adam-urbanczyk <13981538+adam-urbanczyk@users.noreply.github.com>

Author: adam-urbanczyk

cadquery/occ_impl/shapes.py

@@ -15,6 +15,8 @@
     Protocol,
 )
 
+from typing_extensions import Self
+
 from io import BytesIO
 
 from vtkmodules.vtkCommonDataModel import vtkPolyData
@@ -192,7 +194,11 @@
 
 from OCP.ShapeUpgrade import ShapeUpgrade_UnifySameDomain
 
-from OCP.BRepTools import BRepTools, BRepTools_WireExplorer
+from OCP.BRepTools import (
+    BRepTools,
+    BRepTools_WireExplorer,
+    BRepTools_ReShape,
+)
 
 from OCP.LocOpe import LocOpe_DPrism
 
@@ -1397,14 +1403,19 @@ def distance(self, other: "Shape") -> float:
         Minimal distance between two shapes
         """
 
-        return BRepExtrema_DistShapeShape(self.wrapped, other.wrapped).Value()
+        dist_calc = BRepExtrema_DistShapeShape(self.wrapped, other.wrapped)
+        dist_calc.SetMultiThread(True)
+
+        return dist_calc.Value()
 
     def distances(self, *others: "Shape") -> Iterator[float]:
         """
         Minimal distances to between self and other shapes
         """
 
         dist_calc = BRepExtrema_DistShapeShape()
+        dist_calc.SetMultiThread(True)
+
         dist_calc.LoadS1(self.wrapped)
 
         for s in others:
@@ -1689,6 +1700,40 @@ def __setstate__(self, data: Tuple[BytesIO, bool]):
         self.wrapped = wrapped
         self.forConstruction = data[1]
 
+    def replace(self, old: "Shape", *new: "Shape") -> Self:
+        """
+        Replace old subshape with new subshapes.
+        """
+
+        tools: List[Shape] = []
+
+        for el in new:
+            if isinstance(el, Compound):
+                tools.extend(el)
+            else:
+                tools.append(el)
+
+        bldr = BRepTools_ReShape()
+        bldr.Replace(old.wrapped, compound(tools).wrapped)
+
+        rv = bldr.Apply(self.wrapped)
+
+        return self.__class__(rv)
+
+    def remove(self, *subshape: "Shape") -> Self:
+        """
+        Remove subshapes.
+        """
+
+        bldr = BRepTools_ReShape()
+
+        for el in subshape:
+            bldr.Remove(el.wrapped)
+
+        rv = bldr.Apply(self.wrapped)
+
+        return self.__class__(rv)
+
 
 class ShapeProtocol(Protocol):
     @property
@@ -3484,6 +3529,32 @@ def isolines(
 
         return [self.isoline(p, direction) for p in params]
 
+    def extend(
+        self,
+        d: float,
+        umin: bool = True,
+        umax: bool = True,
+        vmin: bool = True,
+        vmax: bool = True,
+    ) -> "Face":
+        """
+        Extend a face. Does not work well in periodic directions.
+        
+        :param d: length of the extension.
+        :param umin: extend along the umin isoline.
+        :param umax: extend along the umax isoline.
+        :param vmin: extend along the vmin isoline.
+        :param vmax: extend along the vmax isoline.
+        """
+
+        # convert to NURBS if needed
+        tmp = self.toNURBS() if self.geomType() != "BSPLINE" else self
+
+        rv = TopoDS_Face()
+        BRepLib.ExtendFace_s(tmp.wrapped, d, umin, umax, vmin, vmax, rv)
+
+        return self.__class__(rv)
+
 
 class Shell(Shape):
     """
@@ -4357,6 +4428,25 @@ def innerShells(self) -> List[Shell]:
 
         return [s for s in self.Shells() if not s.isSame(outer)]
 
+    def addCavity(self, *shells: Union[Shell, "Solid"]) -> Self:
+        """
+        Add one or more cavities.
+        """
+
+        builder = BRepBuilderAPI_MakeSolid(self.wrapped)
+
+        # if a solid is provided only outer shell is added
+        for sh in shells:
+            builder.Add(
+                sh.wrapped if isinstance(sh, Shell) else sh.outerShell().wrapped
+            )
+
+        # fix orientations
+        sf = ShapeFix_Solid(builder.Solid())
+        sf.Perform()
+
+        return self.__class__(sf.Solid())
+
 
 class CompSolid(Shape, Mixin3D):
     """
@@ -4385,13 +4475,15 @@ def _makeCompound(listOfShapes: Iterable[TopoDS_Shape]) -> TopoDS_Compound:
 
         return comp
 
-    def remove(self, shape: Shape):
+    def remove(self, *shape: Shape):
         """
-        Remove the specified shape.
+        Remove the specified shapes.
         """
 
         comp_builder = TopoDS_Builder()
-        comp_builder.Remove(self.wrapped, shape.wrapped)
+
+        for s in shape:
+            comp_builder.Remove(self.wrapped, s.wrapped)
 
     @classmethod
     def makeCompound(cls, listOfShapes: Iterable[Shape]) -> "Compound":
@@ -5672,11 +5764,17 @@ def imprint(
         # collect shapes present in the history dict
         for k, v in history.items():
             if isinstance(k, str):
-                history[k] = _compound_or_shape(list(images.Find(v.wrapped)))
+                try:
+                    history[k] = _compound_or_shape(list(images.Find(v.wrapped)))
+                except Standard_NoSuchObject:
+                    pass
 
         # store all top-level shape relations
         for s in shapes:
-            history[s] = _compound_or_shape(list(images.Find(s.wrapped)))
+            try:
+                history[s] = _compound_or_shape(list(images.Find(s.wrapped)))
+            except Standard_NoSuchObject:
+                pass
 
     return _compound_or_shape(builder.Shape())
 
@@ -5928,6 +6026,7 @@ def sweep(
     def _make_builder():
 
         rv = BRepOffsetAPI_MakePipeShell(spine.wrapped)
+
         if aux:
             rv.SetMode(_get_one_wire(aux).wrapped, True)
         else:
@@ -6142,6 +6241,15 @@ def closest(s1: Shape, s2: Shape) -> Tuple[Vector, Vector]:
     """
     Closest points between two shapes.
     """
-    ext = BRepExtrema_DistShapeShape(s1.wrapped, s2.wrapped)
+    # configure
+    ext = BRepExtrema_DistShapeShape()
+    ext.SetMultiThread(True)
+
+    # load shapes
+    ext.LoadS1(s1.wrapped)
+    ext.LoadS2(s2.wrapped)
+
+    # perform
+    assert ext.Perform()
 
     return Vector(ext.PointOnShape1(1)), Vector(ext.PointOnShape2(1))

tests/test_free_functions.py

@@ -51,7 +51,7 @@
 
 from OCP.BOPAlgo import BOPAlgo_CheckStatus
 
-from pytest import approx, raises
+from pytest import approx, raises, fixture
 from math import pi
 
 #%% test utils
@@ -430,6 +430,7 @@ def test_imprint():
 
     assert len(res_glue_full.Faces()) == len(compound(b1, b2).Faces()) - 1
 
+    # imprint with history
     history = dict(b1=b1, b3=b3)
     res_glue_partial = imprint(b1, b3, glue="partial", history=history)
 
@@ -439,6 +440,45 @@ def test_imprint():
     assert len(b1_imp.Faces()) == len(b1.Faces()) + 1
     assert len(res_glue_partial.Faces()) == len(b1_imp.Faces() + b3_imp.Faces()) - 1
 
+    # imprint with faulty history
+    history = dict(b2=b2)
+    # this does not raise!
+    res_glue_partial = imprint(b1, b3, glue="partial", history=history)
+
+    assert b2 not in history
+
+
+@fixture
+def patch_find(monkeypatch):
+    """
+    Fixture for throwing exception during imprinting.
+    """
+
+    from OCP.TopTools import TopTools_DataMapOfShapeListOfShape
+    from OCP.Standard import Standard_NoSuchObject
+    from OCP.BOPAlgo import BOPAlgo_Builder
+
+    def dummy(x):
+
+        raise ValueError("A")
+        raise Standard_NoSuchObject
+
+    class DummyMap(TopTools_DataMapOfShapeListOfShape):
+        def Find(self, x):
+            raise Standard_NoSuchObject
+
+    monkeypatch.setattr(BOPAlgo_Builder, "Images", lambda x: DummyMap())
+
+
+def test_imprint_error(patch_find):
+
+    b1 = box(1, 1, 1)
+    b2 = b1.moved(x=1)
+
+    history = {}
+
+    _ = imprint(b1, b2, history=history)
+
 
 def test_setThreads():
 

tests/test_shapes.py

@@ -13,6 +13,7 @@
     cylinder,
     ellipse,
     spline,
+    sweep,
 )
 
 from pytest import approx, raises
@@ -255,3 +256,52 @@ def test_isolines():
 
     assert isos_u[0].Length() == approx(2)
     assert isos_v[0].Length() == approx(pi)
+
+
+def test_extend():
+
+    f = sweep(spline((0, 0), (0, 1), (2, 0)), spline((0, 0, 0), (0, 1, 1), (0, 1, 5)))
+    f_ext = f.extend(1)
+
+    assert f_ext.Area() > f.Area()
+
+
+def test_remove():
+
+    b = box(2, 2, 2) - box(1, 1, 1).moved(z=0.5)
+
+    assert len(b.Faces()) == 12
+
+    br = b.remove(*b.innerShells())
+
+    assert len(br.Faces()) == 6
+    assert br.isValid()
+
+
+def test_addCavity():
+
+    b1 = box(2, 2, 2)
+    b2 = box(1, 1, 1).moved(z=0.5)
+
+    br = b1.addCavity(b2)
+
+    assert len(br.Faces()) == 12
+    assert len(br.Shells()) == 2
+    assert br.isValid()
+
+
+def test_replace():
+
+    b = box(1, 1, 1)
+    f_top = b.faces(">Z")
+    f_top_split = f_top / plane(0.5, 0.5).moved(f_top.Center())
+
+    br1 = b.replace(f_top, f_top_split)
+
+    assert len(br1.Faces()) == len(b.Faces()) + 1
+    assert br1.isValid()
+
+    br2 = b.replace(f_top, *f_top_split)  # invoke with individual faces
+
+    assert len(br2.Faces()) == len(b.Faces()) + 1
+    assert br2.isValid()