Intersect optimized

src/build123d/geometry.py

@@ -1182,6 +1182,20 @@ def is_inside(self, second_box: BoundBox) -> bool:
             and second_box.max.Z < self.max.Z
         )
 
+    def overlaps(self, other: BoundBox, tolerance: float = TOLERANCE) -> bool:
+        """Check if this bounding box overlaps with another.
+
+        Args:
+            other: BoundBox to check overlap with
+            tolerance: Distance tolerance for overlap detection
+
+        Returns:
+            True if bounding boxes overlap (share any volume), False otherwise
+        """
+        if self.wrapped is None or other.wrapped is None:
+            return False
+        return self.wrapped.Distance(other.wrapped) <= tolerance
+
     def to_align_offset(self, align: Align2DType | Align3DType) -> Vector:
         """Amount to move object to achieve the desired alignment"""
         return to_align_offset(self.min, self.max, align)

src/build123d/operations_part.py

@@ -230,16 +230,14 @@ def extrude(
                     )
                 )
 
+    if both and len(new_solids) > 1:
+        fused_solids = new_solids.pop().fuse(*new_solids)
+        new_solids = fused_solids if isinstance(fused_solids, list) else [fused_solids]
+    if clean:
+        new_solids = [solid.clean() for solid in new_solids]
+
     if context is not None:
         context._add_to_context(*new_solids, clean=clean, mode=mode)
-    else:
-        if len(new_solids) > 1:
-            fused_solids = new_solids.pop().fuse(*new_solids)
-            new_solids = (
-                fused_solids if isinstance(fused_solids, list) else [fused_solids]
-            )
-        if clean:
-            new_solids = [solid.clean() for solid in new_solids]
 
     return Part(ShapeList(new_solids).solids())
 

src/build123d/topology/composite.py

@@ -713,149 +713,88 @@ def get_type(
 
         return results
 
-    def intersect(
-        self, *to_intersect: Shape | Vector | Location | Axis | Plane
-    ) -> None | ShapeList[Vertex | Edge | Face | Solid]:
-        """Intersect Compound with Shape or geometry object
+    def _intersect(
+        self,
+        other: Shape | Vector | Location | Axis | Plane,
+        tolerance: float = 1e-6,
+        include_touched: bool = False,
+    ) -> ShapeList | None:
+        """Single-object intersection for Compound (OR semantics).
 
-        Args:
-            to_intersect (Shape | Vector | Location | Axis | Plane): objects to intersect
+        Distributes intersection over elements, collecting all results:
+            Compound([a, b]).intersect(s) = (a ∩ s) ∪ (b ∩ s)
+            Compound([a, b]).intersect(Compound([c, d])) = (a ∩ c) ∪ (a ∩ d) ∪ (b ∩ c) ∪ (b ∩ d)
 
-        Returns:
-            ShapeList[Vertex | Edge | Face | Solid] | None: ShapeList of vertices, edges,
-                faces, and/or solids.
-        """
+        Handles both build123d assemblies (children) and OCCT Compounds (list()).
+        Nested Compounds are handled by recursion.
 
-        def to_vector(objs: Iterable) -> ShapeList:
-            return ShapeList([Vector(v) if isinstance(v, Vertex) else v for v in objs])
-
-        def to_vertex(objs: Iterable) -> ShapeList:
-            return ShapeList([Vertex(v) if isinstance(v, Vector) else v for v in objs])
-
-        def bool_op(
-            args: Sequence,
-            tools: Sequence,
-            operation: BRepAlgoAPI_Common | BRepAlgoAPI_Section,
-        ) -> ShapeList:
-            # Wrap Shape._bool_op for corrected output
-            intersections: Shape | ShapeList = Shape()._bool_op(args, tools, operation)
-            if isinstance(intersections, ShapeList):
-                return intersections
-            if isinstance(intersections, Shape) and not intersections.is_null:
-                return ShapeList([intersections])
-            return ShapeList()
+        Args:
+            other: Shape or geometry object to intersect with
+            tolerance: tolerance for intersection detection
+            include_touched: if True, include boundary contacts
+                (only relevant when Solids are involved)
+        """
+        # Convert geometry objects
+        if isinstance(other, Vector):
+            other = Vertex(other)
+        elif isinstance(other, Location):
+            other = Vertex(other.position)
+        elif isinstance(other, Axis):
+            other = Edge(other)
+        elif isinstance(other, Plane):
+            other = Face(other)
+
+        # Get self elements: assembly children or OCCT direct children
+        self_elements = self.children if self.children else list(self)
+
+        if not self_elements:
+            return None
+
+        results: ShapeList = ShapeList()
+
+        # Distribute over elements (OR semantics for Compound arguments)
+        if isinstance(other, Compound):
+            other_elements = other.children if other.children else list(other)
+        else:
+            other_elements = [other]
 
-        def expand_compound(compound: Compound) -> ShapeList:
-            shapes = ShapeList(compound.children)
-            for shape_type in [Vertex, Edge, Wire, Face, Shell, Solid]:
-                shapes.extend(compound.get_type(shape_type))
-            return shapes
-
-        def filter_shapes_by_order(shapes: ShapeList, orders: list) -> ShapeList:
-            # Remove lower order shapes from list which *appear* to be part of
-            # a higher order shape using a lazy distance check
-            # (sufficient for vertices, may be an issue for higher orders)
-            order_groups = []
-            for order in orders:
-                order_groups.append(
-                    ShapeList([s for s in shapes if isinstance(s, order)])
+        for self_elem in self_elements:
+            for other_elem in other_elements:
+                intersection = self_elem._intersect(
+                    other_elem, tolerance, include_touched
                 )
+                if intersection:
+                    results.extend(intersection)
 
-            filtered_shapes = order_groups[-1]
-            for i in range(len(order_groups) - 1):
-                los = order_groups[i]
-                his: list = sum(order_groups[i + 1 :], [])
-                filtered_shapes.extend(
-                    ShapeList(
-                        lo
-                        for lo in los
-                        if all(lo.distance_to(hi) > TOLERANCE for hi in his)
-                    )
-                )
+        # Remove duplicates using Shape's __hash__
+        unique = ShapeList(set(results))
 
-            return filtered_shapes
-
-        common_set: ShapeList[Shape] = expand_compound(self)
-        target: ShapeList | Shape
-        for other in to_intersect:
-            # Conform target type
-            match other:
-                case Axis():
-                    # BRepAlgoAPI_Section seems happier if Edge isnt infinite
-                    bbox = self.bounding_box()
-                    dist = self.distance_to(other.position)
-                    dist = dist if dist >= 1 else 1
-                    target = Edge.make_line(
-                        other.position - other.direction * bbox.diagonal * dist,
-                        other.position + other.direction * bbox.diagonal * dist,
-                    )
-                case Plane():
-                    target = Face(other)
-                case Vector():
-                    target = Vertex(other)
-                case Location():
-                    target = Vertex(other.position)
-                case Compound():
-                    target = expand_compound(other)
-                case _ if issubclass(type(other), Shape):
-                    target = other
-                case _:
-                    raise ValueError(f"Unsupported type to_intersect: {type(other)}")
-
-            # Find common matches
-            common: list[Vertex | Edge | Wire | Face | Shell | Solid] = []
-            result: ShapeList
-            for obj in common_set:
-                if isinstance(target, Shape):
-                    target = ShapeList([target])
-                result = ShapeList()
-                for t in target:
-                    operation: BRepAlgoAPI_Section | BRepAlgoAPI_Common = (
-                        BRepAlgoAPI_Section()
-                    )
-                    result.extend(bool_op((obj,), (t,), operation))
-                    if (
-                        not isinstance(obj, Edge | Wire)
-                        and not isinstance(t, Edge | Wire)
-                    ) or (
-                        isinstance(obj, Solid | Compound)
-                        or isinstance(t, Solid | Compound)
-                    ):
-                        # Face + Edge combinations may produce an intersection
-                        # with Common but always with Section.
-                        # No easy way to deduplicate
-                        # Many Solid + Edge combinations need Common
-                        operation = BRepAlgoAPI_Common()
-                        result.extend(bool_op((obj,), (t,), operation))
-
-                if result:
-                    common.extend(result)
-
-            expanded: ShapeList = ShapeList()
-            if common:
-                for shape in common:
-                    if isinstance(shape, Compound):
-                        expanded.extend(expand_compound(shape))
-                    else:
-                        expanded.append(shape)
-
-            if expanded:
-                common_set = ShapeList()
-                for shape in expanded:
-                    if isinstance(shape, Wire):
-                        common_set.extend(shape.edges())
-                    elif isinstance(shape, Shell):
-                        common_set.extend(shape.faces())
-                    else:
-                        common_set.append(shape)
-                common_set = to_vertex(set(to_vector(common_set)))
-                common_set = filter_shapes_by_order(
-                    common_set, [Vertex, Edge, Face, Solid]
-                )
-            else:
-                return None
+        return unique if unique else None
+
+    def touch(
+        self, other: Shape, tolerance: float = 1e-6
+    ) -> ShapeList[Vertex | Edge | Face]:
+        """Distribute touch over compound elements.
+
+        Iterates over elements and collects touch results. Only Solid and
+        Face elements produce boundary contacts; other shapes return empty.
+
+        Args:
+            other: Shape to check boundary contacts with
+            tolerance: tolerance for contact detection
+
+        Returns:
+            ShapeList of boundary contact geometry (empty if no contact)
+        """
+        results: ShapeList = ShapeList()
+
+        # Get elements: assembly children or OCCT direct children
+        elements = self.children if self.children else list(self)
+
+        for elem in elements:
+            results.extend(elem.touch(other, tolerance))
 
-        return ShapeList(common_set)
+        return ShapeList(set(results))
 
     def project_to_viewport(
         self,