bspy 3.0.1__py3-none-any.whl → 4.1__py3-none-any.whl

bspy/_spline_intersection.py

@@ -1,13 +1,17 @@
+import logging
 import math
 import numpy as np
+from bspy.manifold import Manifold
+from bspy.hyperplane import Hyperplane
 import bspy.spline
+from bspy.solid import Solid, Boundary
 from collections import namedtuple
 from multiprocessing import Pool
 
 def zeros_using_interval_newton(self):
     if not(self.nInd == self.nDep): raise ValueError("The number of independent variables (nInd) must match the number of dependent variables (nDep).")
     if not(self.nInd == 1): raise ValueError("Only works for curves (nInd == 1).")
-    epsilon = np.finfo(self.coefs.dtype).eps
+    epsilon = np.finfo(self.knots[0].dtype).eps
 
     # Set initial spline and domain
  
@@ -40,23 +44,25 @@ def zeros_using_interval_newton(self):
         (myDomain,) = scaledSpline.domain()
         intervalSize *= myDomain[1] - myDomain[0]
         functionMax *= scaleFactor
-        mySpline = scaledSpline.reparametrize([[0.0, 1.0]])
-        midPoint = 0.5
-        [functionValue] = mySpline([midPoint])
+        midPoint = 0.5 * (myDomain[0] + myDomain[1])
+        [functionValue] = scaledSpline(midPoint)
 
         # Root found
 
         if intervalSize < epsilon or abs(functionValue) * functionMax < epsilon:
             if intervalSize < epsilon ** 0.25:
-                return [0.5 * (myDomain[0] + myDomain[1])]
+                return [midPoint]
             else:
-                myZeros = refine(mySpline.trim(((0.0, midPoint - np.sqrt(epsilon)),)), intervalSize, functionMax)
-                myZeros += [0.5 * (myDomain[0] + myDomain[1])]
-                myZeros += refine(mySpline.trim(((midPoint + np.sqrt(epsilon), 1.0),)), intervalSize, functionMax)
+                mySpline = scaledSpline.reparametrize([[0.0, 1.0]])
+                myZeros = refine(mySpline.trim(((0.0, 0.5 - np.sqrt(epsilon)),)), intervalSize, functionMax)
+                myZeros.append(midPoint)
+                myZeros += refine(mySpline.trim(((0.5 + np.sqrt(epsilon), 1.0),)), intervalSize, functionMax)
                 return myZeros
 
         # Calculate Newton update
 
+        mySpline = scaledSpline.reparametrize([[0.0, 1.0]])
+        midPoint = 0.5
         (derivativeBounds,) = mySpline.differentiate().range_bounds()
         if derivativeBounds[0] == 0.0:
             derivativeBounds[0] = epsilon
@@ -111,34 +117,24 @@ def zeros_using_interval_newton(self):
             return mySolution
     return refine(spline, 1.0, 1.0)
 
-def _convex_hull_2D(xData, yData, epsilon = 1.0e-8, evaluationEpsilon = 1.0e-4, xInterval = None):
+def _convex_hull_2D(xData, yData, yBounds, epsilon = 1.0e-8):
     # Allow xData to be repeated for longer yData, but only if yData is a multiple.
-    if not(len(yData) % len(xData) == 0): raise ValueError("Size of xData does not divide evenly in size of yData")
+    if not(yData.shape[0] % xData.shape[0] == 0): raise ValueError("Size of xData does not divide evenly in size of yData")
 
-    # Assign p0 to the leftmost lowest point. Also compute xMin, xMax, and yMax.
-    xMin = xMax = x0 = xData[0]
-    yMax = y0 = yData[0]
-    xIter = iter(xData[1:])
-    for y in yData[1:]:
-        x = next(xIter, None)
-        if x is None:
-            xIter = iter(xData)
-            x = next(xIter)
-            
-        if y < y0 or (y == y0 and x < x0):
-            (x0, y0) = (x, y)
-        xMin = min(xMin, x)
-        xMax = max(xMax, x)
-        yMax = max(yMax, y)
-
-    # Only return convex null if it contains y = 0 and x within xInterval.
-    if xInterval is not None and (y0 > evaluationEpsilon or yMax < -evaluationEpsilon or xMin > xInterval[1] or xMax < xInterval[0]):
-        return None
+    # Assign (x0, y0) to the lowest point.
+    yMinIndex = np.argmin(yData)
+    x0 = xData[yMinIndex % xData.shape[0]]
+    y0 = yData[yMinIndex]
+
+    # Calculate y adjustment as needed for values close to zero
+    yAdjustment = -yBounds[0] if yBounds[0] > 0.0 else -yBounds[1] if yBounds[1] < 0.0 else 0.0
+    y0 += yAdjustment
 
     # Sort points by angle around p0.
     sortedPoints = []
     xIter = iter(xData)
     for y in yData:
+        y += yAdjustment
         x = next(xIter, None)
         if x is None:
             xIter = iter(xData)
@@ -146,7 +142,7 @@ def _convex_hull_2D(xData, yData, epsilon = 1.0e-8, evaluationEpsilon = 1.0e-4,
         sortedPoints.append((math.atan2(y - y0, x - x0), x, y))
     sortedPoints.sort()
 
-    # Trim away points with the same angle (keep furthest point from p0), and then remove angle.
+    # Trim away points with the same angle (keep furthest point from p0), removing the angle from the list.
     trimmedPoints = [sortedPoints[0][1:]] # Ensure we keep the first point
     previousPoint = None
     previousDistance = -1.0
@@ -212,50 +208,49 @@ def _refine_projected_polyhedron(interval):
 
     # Remove dependent variables that are near zero and compute newScale.
     spline = interval.spline.copy()
-    coefs = spline.coefs
-    newScale = 0.0
-    nDep = 0
-    while nDep < len(coefs):
-        coefsMin = coefs[nDep].min() * interval.scale
-        coefsMax = coefs[nDep].max() * interval.scale
+    bounds = spline.range_bounds()
+    keepDep = []
+    for nDep, (coefsMin, coefsMax) in enumerate(bounds * interval.scale):
         if coefsMax < -epsilon or coefsMin > epsilon:
             # No roots in this interval.
             return roots, intervals
-        if -epsilon < coefsMin and coefsMax < epsilon:
-            # Near zero along this axis for entire interval.
-            coefs = np.delete(coefs, nDep, axis = 0)
-        else:
-            nDep += 1
-            newScale = max(newScale, abs(coefsMin), abs(coefsMax))
+        if coefsMin < -epsilon or coefsMax > epsilon:
+            # Dependent variable not near zero for entire interval.
+            keepDep.append(nDep)
 
-    if nDep == 0:
+    spline.nDep = len(keepDep)
+    if spline.nDep == 0:
         # Return the interval center and radius.
         roots.append((interval.intercept + 0.5 * interval.slope, 0.5 * np.linalg.norm(interval.slope)))
         return roots, intervals
 
-    # Rescale the spline to max 1.0.
-    spline.nDep = nDep
-    coefs *= interval.scale / newScale
-    spline.coefs = coefs
+    # Rescale remaining spline coefficients to max 1.0.
+    bounds = bounds[keepDep]
+    newScale = np.abs(bounds).max()
+    spline.coefs = spline.coefs[keepDep]
+    spline.coefs *= 1.0 / newScale
+    bounds *= 1.0 / newScale
+    newScale *= interval.scale
     
     # Loop through each independent variable to determine a tighter domain around roots.
     domain = []
+    coefs = spline.coefs
     for nInd, order, knots, nCoef, s in zip(range(spline.nInd), spline.order, spline.knots, spline.nCoef, interval.slope):
         # Move independent variable to the last (fastest) axis, adding 1 to account for the dependent variables.
         coefs = np.moveaxis(spline.coefs, nInd + 1, -1)
 
         # Compute the coefficients for f(x) = x for the independent variable and its knots.
         degree = order - 1
-        knotCoefs = np.empty((nCoef,), knots.dtype)
-        knotCoefs[0] = knots[1]
+        xData = np.empty((nCoef,), knots.dtype)
+        xData[0] = knots[1]
         for i in range(1, nCoef):
-            knotCoefs[i] = knotCoefs[i - 1] + (knots[i + degree] - knots[i])/degree
+            xData[i] = xData[i - 1] + (knots[i + degree] - knots[i])/degree
         
         # Loop through each dependent variable to compute the interval containing the root for this independent variable.
         xInterval = (0.0, 1.0)
-        for nDep in range(spline.nDep):
+        for yData, yBounds in zip(coefs, bounds):
             # Compute the 2D convex hull of the knot coefficients and the spline's coefficients
-            hull = _convex_hull_2D(knotCoefs, coefs[nDep].ravel(), epsilon, evaluationEpsilon, xInterval)
+            hull = _convex_hull_2D(xData, yData.ravel(), yBounds, epsilon)
             if hull is None:
                 return roots, intervals
             
@@ -267,7 +262,7 @@ def _refine_projected_polyhedron(interval):
         domain.append(xInterval)
     
     # Compute new slope, intercept, and unknowns.
-    domain = np.array(domain).T
+    domain = np.array(domain, spline.knots[0].dtype).T
     width = domain[1] - domain[0]
     newSlope = interval.slope.copy()
     newIntercept = interval.intercept.copy()
@@ -347,7 +342,7 @@ class _Region:
 
 def zeros_using_projected_polyhedron(self, epsilon=None):
     if not(self.nInd == self.nDep): raise ValueError("The number of independent variables (nInd) must match the number of dependent variables (nDep).")
-    machineEpsilon = np.finfo(self.coefs.dtype).eps
+    machineEpsilon = np.finfo(self.knots[0].dtype).eps
     if epsilon is None:
         epsilon = 0.0
     epsilon = max(epsilon, np.sqrt(machineEpsilon))
@@ -545,8 +540,10 @@ def contours(self):
         if not abort:
             break # We're done!
     
-    if attempts <= 0:
-        raise ValueError("No contours. Degenerate equations.")
+    if attempts <= 0: raise ValueError("No contours. Degenerate equations.")
+
+    if not points:
+        return [] # No contours
     
     # We've got all the contour points, now we bucket them into individual contours using the algorithm 
     # from Grandine, Thomas A., and Frederick W. Klein IV. "A new approach to the surface intersection problem." 
@@ -577,6 +574,21 @@ def contours(self):
     # (3) Take all the points found in Step (1) and Step (2) and order them by distance in the theta direction from the origin.
     points.sort()
 
+    # Extra step not in paper.
+    # Run a checksum on the points, ensuring starting and ending points balance.
+    # Start by flipping endpoints as needed, since we can miss turning points near endpoints.
+
+    if points[0].det < 0.0:
+        point = points[0]
+        points[0] = Point(point.d, -point.det, point.onUVBoundary, point.turningPoint, point.uvw)
+    if points[-1].det > 0.0:
+        point = points[-1]
+        points[-1] = Point(point.d, -point.det, point.onUVBoundary, point.turningPoint, point.uvw)
+    checksum = 0
+    for i, point in enumerate(points): # Ensure checksum stays non-negative front to back
+        checksum += (1 if point.det > 0 else -1) * (2 if point.turningPoint else 1)
+    if checksum != 0: raise ValueError("No contours. Inconsistent contour topology.")
+
     # Extra step not in the paper:
     # Add a panel between two consecutive open/close turning points to uniquely determine contours between them.
     if len(points) > 1:
@@ -746,6 +758,7 @@ def contours(self):
                                 currentContourPoints[index] = [upperConnection] + upperHalf + [point.uvw] + lowerHalf + currentContourPoints[index][2:]
                         else: 
                             # It's an ending point on an other boundary (same steps as uv boundary).
+                            adjustment = -1
                             fullList = currentContourPoints.pop(i) + [point.uvw]
                             connection = fullList.pop(0)
                             if connection == 0:
@@ -758,12 +771,272 @@ def contours(self):
                     currentContourPoints[i + adjustment].append(uvw)
 
     # We've determined a bunch of points along all the contours, including starting and ending points.
-    # Now we just need to create splines for those contours using the Spline.contour method.
+    # Now we just need to create splines for those contours using the bspy.Spline.contour method.
     splineContours = []
     for points in contourPoints:
-        contour = bspy.spline.Spline.contour(self, points)
+        contour = bspy.Spline.contour(self, points)
         # Transform the contour to self's original domain.
         contour.coefs = (contour.coefs.T * (domain[1] - domain[0]) + domain[0]).T
         splineContours.append(contour)
     
-    return splineContours
+    return splineContours
+
+def intersect(self, other):
+    intersections = []
+    nDep = self.nInd # The dimension of the intersection's range
+
+    # Spline-Hyperplane intersection.
+    if isinstance(other, Hyperplane):
+        # Compute the projection onto the hyperplane to map Spline-Hyperplane intersection points to the domain of the Hyperplane.
+        projection = np.linalg.inv(other._tangentSpace.T @ other._tangentSpace) @ other._tangentSpace.T
+        # Construct a new spline that represents the intersection.
+        spline = self.dot(other._normal) - np.atleast_1d(np.dot(other._normal, other._point))
+
+        # Curve-Line intersection.
+        if nDep == 1:
+            # Find the intersection points and intervals.
+            zeros = spline.zeros()
+            # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
+            for zero in zeros:
+                if isinstance(zero, tuple):
+                    # Intersection is an interval, so create a Manifold.Coincidence.
+                    planeBounds = (projection @ (self((zero[0],)) - other._point), projection @ (self((zero[1],)) - other._point))
+
+                    # First, check for crossings at the boundaries of the coincidence, since splines can have discontinuous tangents.
+                    # We do this first because later we may change the order of the plane bounds.
+                    (bounds,) = self.domain()
+                    epsilon = 0.1 * Manifold.minSeparation
+                    if zero[0] - epsilon > bounds[0]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[0] - epsilon, 0.0), Hyperplane(1.0, planeBounds[0], 0.0)))
+                    if zero[1] + epsilon < bounds[1]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[1] + epsilon, 0.0), Hyperplane(1.0, planeBounds[1], 0.0)))
+
+                    # Now, create the coincidence.
+                    left = Solid(nDep, False)
+                    left.add_boundary(Boundary(Hyperplane(-1.0, zero[0], 0.0), Solid(0, True)))
+                    left.add_boundary(Boundary(Hyperplane(1.0, zero[1], 0.0), Solid(0, True)))
+                    right = Solid(nDep, False)
+                    if planeBounds[0] > planeBounds[1]:
+                        planeBounds = (planeBounds[1], planeBounds[0])
+                    right.add_boundary(Boundary(Hyperplane(-1.0, planeBounds[0], 0.0), Solid(0, True)))
+                    right.add_boundary(Boundary(Hyperplane(1.0, planeBounds[1], 0.0), Solid(0, True)))
+                    alignment = np.dot(self.normal((zero[0],)), other._normal) # Use the first zero, since B-splines are closed on the left
+                    width = zero[1] - zero[0]
+                    transform = (planeBounds[1] - planeBounds[0]) / width
+                    translation = (planeBounds[0] * zero[1] - planeBounds[1] * zero[0]) / width
+                    intersections.append(Manifold.Coincidence(left, right, alignment, np.atleast_2d(transform), np.atleast_2d(1.0 / transform), np.atleast_1d(translation)))
+                else:
+                    # Intersection is a point, so create a Manifold.Crossing.
+                    intersections.append(Manifold.Crossing(Hyperplane(1.0, zero, 0.0), Hyperplane(1.0, projection @ (self((zero,)) - other._point), 0.0)))
+
+        # Surface-Plane intersection.
+        elif nDep == 2:
+            # Find the intersection contours, which are returned as splines.
+            contours = spline.contours()
+            # Convert each contour into a Manifold.Crossing.
+            for contour in contours:
+                # The left portion is the contour returned for the spline-plane intersection. 
+                left = contour
+                # The right portion is the contour projected onto the plane's domain, which we compute with samples and a least squares fit.
+                tValues = np.linspace(0.0, 1.0, contour.nCoef[0] + 5) # Over-sample a bit to reduce the condition number and avoid singular matrix
+                points = []
+                for t in tValues:
+                    zero = contour((t,))
+                    points.append(projection @ (self(zero) - other._point))
+                right = bspy.Spline.least_squares(tValues, np.array(points).T, contour.order, contour.knots)
+                intersections.append(Manifold.Crossing(left, right))
+        else:
+            return NotImplemented
+    
+    # Spline-Spline intersection.
+    elif isinstance(other, bspy.Spline):
+        # Construct a new spline that represents the intersection.
+        spline = self.subtract(other)
+
+        # Curve-Curve intersection.
+        if nDep == 1:
+            # Find the intersection points and intervals.
+            zeros = spline.zeros()
+            # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
+            for zero in zeros:
+                if isinstance(zero, tuple):
+                    # Intersection is an interval, so create a Manifold.Coincidence.
+
+                    # First, check for crossings at the boundaries of the coincidence, since splines can have discontinuous tangents.
+                    # We do this first to match the approach for Curve-Line intersections.
+                    (boundsSelf,) = self.domain()
+                    (boundsOther,) = other.domain()
+                    epsilon = 0.1 * Manifold.minSeparation
+                    if zero[0][0] - epsilon > boundsSelf[0]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[0][0] - epsilon, 0.0), Hyperplane(1.0, zero[0][1], 0.0)))
+                    elif zero[0][1] - epsilon > boundsOther[0]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[0][0], 0.0), Hyperplane(1.0, zero[0][1] - epsilon, 0.0)))
+                    if zero[1][0] + epsilon < boundsSelf[1]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[1][0] + epsilon, 0.0), Hyperplane(1.0, zero[1][1], 0.0)))
+                    elif zero[1][1] + epsilon < boundsOther[1]:
+                        intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[1][0], 0.0), Hyperplane(1.0, zero[1][1] + epsilon, 0.0)))
+
+                    # Now, create the coincidence.
+                    left = Solid(nDep, False)
+                    left.add_boundary(Boundary(Hyperplane(-1.0, zero[0][0], 0.0), Solid(0, True)))
+                    left.add_boundary(Boundary(Hyperplane(1.0, zero[1][0], 0.0), Solid(0, True)))
+                    right = Solid(nDep, False)
+                    right.add_boundary(Boundary(Hyperplane(-1.0, zero[0][1], 0.0), Solid(0, True)))
+                    right.add_boundary(Boundary(Hyperplane(1.0, zero[1][1], 0.0), Solid(0, True)))
+                    alignment = np.dot(self.normal(zero[0][0]), other.normal(zero[0][1])) # Use the first zeros, since B-splines are closed on the left
+                    width = zero[1][0] - zero[0][0]
+                    transform = (zero[1][1] - zero[0][1]) / width
+                    translation = (zero[0][1] * zero[1][0] - zero[1][1] * zero[0][0]) / width
+                    intersections.append(Manifold.Coincidence(left, right, alignment, np.atleast_2d(transform), np.atleast_2d(1.0 / transform), np.atleast_1d(translation)))
+                else:
+                    # Intersection is a point, so create a Manifold.Crossing.
+                    intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[:nDep], 0.0), Hyperplane(1.0, zero[nDep:], 0.0)))
+        
+        # Surface-Surface intersection.
+        elif nDep == 2:
+            if "Name" in self.metadata and "Name" in other.metadata:
+                logging.info(f"intersect({self.metadata['Name']}, {other.metadata['Name']})")
+            # Find the intersection contours, which are returned as splines.
+            swap = False
+            try:
+                # First try the intersection as is.
+                contours = spline.contours()
+            except ValueError:
+                # If that fails, swap the manifolds. Worth a shot since intersections are touchy.
+                swap = True
+
+            # Convert each contour into a Manifold.Crossing.
+            if swap:
+                spline = other.subtract(self)
+                if "Name" in self.metadata and "Name" in other.metadata:
+                    logging.info(f"intersect({other.metadata['Name']}, {self.metadata['Name']})")
+                contours = spline.contours()
+                for contour in contours:
+                    # Swap left and right, compared to not swapped.
+                    left = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[nDep:], contour.metadata)
+                    right = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[:nDep], contour.metadata)
+                    intersections.append(Manifold.Crossing(left, right))
+            else:
+                for contour in contours:
+                    left = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[:nDep], contour.metadata)
+                    right = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[nDep:], contour.metadata)
+                    intersections.append(Manifold.Crossing(left, right))
+        else:
+            return NotImplemented
+    else:
+        return NotImplemented
+
+    # Ensure the normals point outwards for both Manifolds in each crossing intersection.
+    # Note that evaluating left and right at 0.5 is always valid because either they are points or curves with [0.0, 1.0] domains.
+    domainPoint = np.atleast_1d(0.5)
+    for i, intersection in enumerate(intersections):
+        if isinstance(intersection, Manifold.Crossing):
+            left = intersection.left
+            right = intersection.right
+            if np.dot(self.tangent_space(left.evaluate(domainPoint)) @ left.normal(domainPoint), other.normal(right.evaluate(domainPoint))) < 0.0:
+                left = left.flip_normal()
+            if np.dot(other.tangent_space(right.evaluate(domainPoint)) @ right.normal(domainPoint), self.normal(left.evaluate(domainPoint))) < 0.0:
+                right = right.flip_normal()
+            intersections[i] = Manifold.Crossing(left, right)
+
+    return intersections
+
+def complete_slice(self, slice, solid):
+    # Spline manifold domains have finite bounds.
+    slice.containsInfinity = False
+    bounds = self.domain()
+
+    # If manifold (self) has no intersections with solid, just check containment.
+    if not slice.boundaries:
+        if slice.dimension == 2:
+            if "Name" in self.metadata:
+                logging.info(f"check containment: {self.metadata['Name']}")
+        domain = bounds.T
+        if solid.contains_point(self(0.5 * (domain[0] + domain[1]))):
+            for boundary in Hyperplane.create_hypercube(bounds).boundaries:
+                slice.add_boundary(boundary)
+        return
+
+    # For curves, add domain bounds as needed.
+    if slice.dimension == 1:
+        slice.boundaries.sort(key=lambda b: (b.manifold.evaluate(0.0), b.manifold.normal(0.0)))
+        # First, check right end since we add new boundary to the end.
+        if abs(slice.boundaries[-1].manifold._point - bounds[0][1]) >= Manifold.minSeparation and \
+            slice.boundaries[-1].manifold._normal < 0.0:
+            slice.add_boundary(Boundary(Hyperplane(-slice.boundaries[-1].manifold._normal, bounds[0][1], 0.0), Solid(0, True)))
+        # Next, check left end since it's still untouched.
+        if abs(slice.boundaries[0].manifold._point - bounds[0][0]) >= Manifold.minSeparation and \
+            slice.boundaries[0].manifold._normal > 0.0:
+            slice.add_boundary(Boundary(Hyperplane(-slice.boundaries[0].manifold._normal, bounds[0][0], 0.0), Solid(0, True)))
+
+    # For surfaces, intersect full spline domain with existing slice boundaries.
+    if slice.dimension == 2:
+        fullDomain = Hyperplane.create_hypercube(bounds)
+        for newBoundary in fullDomain.boundaries: # Mark full domain boundaries as untouched
+            newBoundary.touched = False
+
+        # Define function for adding slice points to full domain boundaries.
+        def process_domain_point(boundary, domainPoint):
+            point = boundary.manifold.evaluate(domainPoint)
+            # See if and where point touches full domain.
+            for newBoundary in fullDomain.boundaries:
+                vector = point - newBoundary.manifold._point
+                if abs(np.dot(newBoundary.manifold._normal, vector)) < Manifold.minSeparation:
+                    # Add the point onto the new boundary.
+                    normal = np.sign(newBoundary.manifold._tangentSpace.T @ boundary.manifold.normal(domainPoint))
+                    newBoundary.domain.add_boundary(Boundary(Hyperplane(normal, newBoundary.manifold._tangentSpace.T @ vector, 0.0), Solid(0, True)))
+                    newBoundary.touched = True
+                    break
+
+        # Go through existing boundaries and check if either of their endpoints lies on the spline's bounds.
+        for boundary in slice.boundaries:
+            domainBoundaries = boundary.domain.boundaries
+            domainBoundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), boundary.manifold.normal(0.0)))
+            process_domain_point(boundary, domainBoundaries[0].manifold._point)
+            if len(domainBoundaries) > 1:
+                process_domain_point(boundary, domainBoundaries[-1].manifold._point)
+        
+        # For touched boundaries, remove domain bounds that aren't needed and then add boundary to slice.
+        boundaryWasTouched = False
+        for newBoundary in fullDomain.boundaries:
+            if newBoundary.touched:
+                boundaryWasTouched = True
+                domainBoundaries = newBoundary.domain.boundaries
+                assert len(domainBoundaries) > 2
+                domainBoundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), boundary.manifold.normal(0.0)))
+                # Ensure domain endpoints don't overlap and their normals are consistent.
+                if abs(domainBoundaries[0].manifold._point - domainBoundaries[1].manifold._point) < Manifold.minSeparation or \
+                    domainBoundaries[1].manifold._normal < 0.0:
+                    del domainBoundaries[0]
+                if abs(domainBoundaries[-1].manifold._point - domainBoundaries[-2].manifold._point) < Manifold.minSeparation or \
+                    domainBoundaries[-2].manifold._normal > 0.0:
+                    del domainBoundaries[-1]
+                slice.add_boundary(newBoundary)
+        
+        if boundaryWasTouched:
+            # Touch untouched boundaries that are connected to touched boundary endpoints and add them to slice.
+            boundaryMap = ((2, 3, 0), (2, 3, -1), (0, 1, 0), (0, 1, -1)) # Map of which full domain boundaries touch each other
+            while True:
+                noTouches = True
+                for map, newBoundary, bound in zip(boundaryMap, fullDomain.boundaries, bounds.flatten()):
+                    if not newBoundary.touched:
+                        leftBoundary = fullDomain.boundaries[map[0]]
+                        rightBoundary = fullDomain.boundaries[map[1]]
+                        if leftBoundary.touched and abs(leftBoundary.domain.boundaries[map[2]].manifold._point - bound) < Manifold.minSeparation:
+                            newBoundary.touched = True
+                            slice.add_boundary(newBoundary)
+                            noTouches = False
+                        elif rightBoundary.touched and abs(rightBoundary.domain.boundaries[map[2]].manifold._point - bound) < Manifold.minSeparation:
+                            newBoundary.touched = True
+                            slice.add_boundary(newBoundary)
+                            noTouches = False
+                if noTouches:
+                    break
+        else:
+            # No slice boundaries touched the full domain (a hole), so only add full domain if it is contained in the solid.
+            if solid.contains_point(self.evaluate(bounds[:,0])):
+                for newBoundary in fullDomain.boundaries:
+                    slice.add_boundary(newBoundary)
+
+def full_domain(self):
+    return Hyperplane.create_hypercube(self.domain())