bspy 4.4__tar.gz → 5.0.0__tar.gz

{bspy-4.4 → bspy-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bspy
-Version: 4.4
+Version: 5.0.0
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -50,7 +50,7 @@ The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has
 
 The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
 
-The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and compute cutouts of solids. Solids can be saved and loaded in json format.
 
 The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
 [OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves, surfaces, and solids. Spline surfaces with more 
@@ -86,3 +86,9 @@ a set of examples, including a jupyter notebook, can be found [here](https://git
 * Moved DrawableSpine methods for adjusting spline appearance to Viewer (see documentation for details)
 * Spline.bspline_values changed arguments (see documentation for details)
 * Spline.intersect changed return values (see documentation for details)
+
+### Release 5.0 breaking changes
+* Renamed Boundary.domain member to Boundary.trim
+* Renamed Solid.slice method to Solid.compute_cutout
+* Renamed Manifold.complete_slice method to Manifold.complete_cutout (also applies to Hyperplane and Spline classes)
+* Renamed Manifold.flip_normal method to Manifold.negate_normal (also applies to Hyperplane and Spline classes)

{bspy-4.4 → bspy-5.0.0}/README.md

@@ -18,7 +18,7 @@ The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has
 
 The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
 
-The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and compute cutouts of solids. Solids can be saved and loaded in json format.
 
 The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
 [OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves, surfaces, and solids. Spline surfaces with more 
@@ -54,3 +54,9 @@ a set of examples, including a jupyter notebook, can be found [here](https://git
 * Moved DrawableSpine methods for adjusting spline appearance to Viewer (see documentation for details)
 * Spline.bspline_values changed arguments (see documentation for details)
 * Spline.intersect changed return values (see documentation for details)
+
+### Release 5.0 breaking changes
+* Renamed Boundary.domain member to Boundary.trim
+* Renamed Solid.slice method to Solid.compute_cutout
+* Renamed Manifold.complete_slice method to Manifold.complete_cutout (also applies to Hyperplane and Spline classes)
+* Renamed Manifold.flip_normal method to Manifold.negate_normal (also applies to Hyperplane and Spline classes)

{bspy-4.4 → bspy-5.0.0}/bspy/_spline_domain.py

@@ -1,6 +1,34 @@
 import numpy as np
+import bspy
 from bspy.manifold import Manifold
 
+def arc_length_map(self, tolerance):
+    if self.nInd != 1:  raise ValueError("Spline doesn't have exactly one independent variable")
+
+    # Compute the length of the spline
+    curveLength = self.integral()
+    domain = self.domain()[0]
+    guess = bspy.Spline.line([0.0], [1.0])
+    guess = guess.elevate([4])
+
+    # Solve the ODE
+    def arcLengthF(t, uData):
+        uValue = (1.0 - uData[0][0]) * domain[0] + uData[0][0] * domain[1]
+        uValue = np.clip(uValue, domain[0], domain[1])
+        d1 = self.derivative([1], [uValue])
+        d2 = self.derivative([2], [uValue])
+        speed = np.sqrt(d1 @ d1)
+        d1d2 = d1 @ d2
+        return np.array([curveLength / speed]), np.array([-curveLength * d1d2 / speed ** 3]).reshape((1, 1, 1))
+    arcLengthMap = guess.solve_ode(1, 0, arcLengthF, tolerance)
+
+    # Adjust range to match domain
+
+    arcLengthMap *= (domain[1] - domain[0]) / arcLengthMap(1.0)[0]
+    arcLengthMap += domain[0]
+    arcLengthMap.coefs[0][-1] = domain[1]
+    return arcLengthMap
+
 def clamp(self, left, right):
     bounds = [[None, None] for i in range(self.nInd)]
 
@@ -404,12 +432,11 @@ def join(splineList):
         splDomain = spl.domain()[0]
         start2 = spl(splDomain[0])
         end2 = spl(splDomain[1])
-        gaps = [np.linalg.norm(vecDiff) for vecDiff in [start1 - start2, start1 - end2, end1 - start2, end1 - end2]]
-        minDist = min(*gaps)
-        if minDist == gaps[0] or minDist == gaps[1]:
-            workingSpline = workingSpline.reverse()
-        if minDist == gaps[1] or minDist == gaps[3]:
+        ixMin = np.argmin([np.linalg.norm(vecDiff) for vecDiff in [end1 - start2, end1 - end2, start1 - start2, start1 - end2]])
+        if ixMin == 1 or ixMin == 3:
             spl = spl.reverse()
+        if ixMin == 2 or ixMin == 3:
+            workingSpline = workingSpline.reverse()
         maxOrder = max(workingSpline.order[0], spl.order[0])
         workingSpline = workingSpline.elevate([maxOrder - workingSpline.order[0]])
         spl = spl.elevate([maxOrder - spl.order[0]])
@@ -610,6 +637,8 @@ def trim(self, newDomain):
             if multiplicity > 0:
                 newKnots.append((bounds[0], multiplicity))
                 noChange = False
+            if bounds[0] != knots[order - 1]:
+                noChange = False
 
         if not np.isnan(bounds[1]):
             if not(knots[order - 1] <= bounds[1] <= knots[-order]): raise ValueError("Invalid newDomain")
@@ -627,6 +656,8 @@ def trim(self, newDomain):
             if multiplicity > 0:
                 newKnots.append((bounds[1], multiplicity))
                 noChange = False
+            if bounds[1] != knots[-order]:
+                noChange = False
 
         newKnotsList.append(newKnots)
     

{bspy-4.4 → bspy-5.0.0}/bspy/_spline_evaluation.py

@@ -229,7 +229,7 @@ def normal(self, uvw, normalize=True, indices=None):
         nDep = self.nDep
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", False) else 1
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("negateNormal", False) else 1
     dtype = self.coefs.dtype if hasattr(self, "coefs") else self.coefsDtype
     if indices is None:
         indices = range(nDep)

{bspy-4.4 → bspy-5.0.0}/bspy/_spline_fitting.py

@@ -339,6 +339,7 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
     nInd = len(domain)
     midPoint = f(0.5 * (domain.T[0] + domain.T[1]))
     if not type(midPoint) is bspy.Spline:
+        midPoint = np.array(midPoint).flatten()
         nDep = len(midPoint)
 
     # Make sure order and knots conform to this
@@ -389,7 +390,10 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
             # Create a tuple for the u value (must be a tuple to use it as a dictionary key)
             uValue = tuple([uvw[i][indices[i]] for i in range(nInd)])
             if not uValue in fDictionary:
-                fDictionary[uValue] = f(np.array(uValue))
+                newValue = f(np.array(uValue))
+                if not type(newValue) is bspy.Spline:
+                    newValue = np.array(newValue).flatten()
+                fDictionary[uValue] = newValue
             fValues.append(fDictionary[uValue])
             iLast = nInd - 1
             while iLast >= 0:
@@ -1067,7 +1071,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = (), inclu
 
     # Is it time to give up?
 
-        if (not done or continuation < 1.0) and n > 1000:
+        if (not done or continuation < 1.0) and n > 10000:
             raise RuntimeError("Can't find solution with given initial guess")
 
     # Estimate the error

{bspy-4.4 → bspy-5.0.0}/bspy/_spline_intersection.py

@@ -174,7 +174,6 @@ def _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInter
         for p1 in hull[1:]:
             yDelta = p0[1] - p1[1]
             if p0[1] * p1[1] <= 0.0 and yDelta != 0.0:
-                yDelta = p0[1] - p1[1]
                 alpha = p0[1] / yDelta
                 xNew = p0[0] * (1.0 - alpha) + p1[0] * alpha
                 if sign * yDelta > 0.0:
@@ -255,14 +254,13 @@ def _refine_projected_polyhedron(interval):
 
         # Compute the coefficients for f(x) = x for the independent variable and its knots.
         xData = spline.greville(ind)
-        
+        if len(xData) == 1:
+            xData = spline.domain()[ind]
+
         # Loop through each dependent variable in this row to refine the interval containing the root for this independent variable.
-        for yData, ySplineBounds, yBounds in zip(coefs, spline.range_bounds(),
-                                                 interval.bounds[nDep:nDep + spline.nDep]):
+        for yData, ySplineBounds, yBounds in zip(coefs, spline.range_bounds(), interval.bounds[nDep:nDep + spline.nDep]):
             # Compute the 2D convex hull of the knot coefficients and the spline's coefficients
             lowerHull, upperHull = _convex_hull_2D(xData, yData.ravel(), yBounds, yBounds - ySplineBounds)
-            if lowerHull is None or upperHull is None:
-                return roots, intervals
             
             # Intersect the convex hull with the xInterval along the x axis (the knot coefficients axis).
             xInterval = _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInterval)
@@ -437,7 +435,7 @@ def zeros_using_projected_polyhedron(self, epsilon=None, initialScale=None):
     return roots
 
 def _turning_point_determinant(self, uvw, cosTheta, sinTheta):
-    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", False) else 1
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("negateNormal", False) else 1
     tangentSpace = self.jacobian(uvw).T
     return cosTheta * sign * np.linalg.det(tangentSpace[[j for j in range(self.nInd) if j != 0]]) - \
         sinTheta * sign * np.linalg.det(tangentSpace[[j for j in range(self.nInd) if j != 1]])
@@ -446,7 +444,7 @@ def _turning_point_determinant_gradient(self, uvw, cosTheta, sinTheta):
     dtype = self.coefs.dtype if hasattr(self, "coefs") else self.coefsDtype
     gradient = np.zeros(self.nInd, dtype)
 
-    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", False) else 1
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("negateNormal", False) else 1
     tangentSpace = self.jacobian(uvw).T
     dTangentSpace = tangentSpace.copy()
 
@@ -700,7 +698,7 @@ def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
 
     # 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.
+    # Start by negating 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)
@@ -943,7 +941,8 @@ def contours(self):
 
 def intersect(self, other):
     intersections = []
-    nDep = self.nInd # The dimension of the intersection's range
+    # Compute the number of degrees of freedom of the intersection.
+    dof = self.nInd + other.domain_dimension() - self.nDep
 
     # Spline-Hyperplane intersection.
     if isinstance(other, Hyperplane):
@@ -953,7 +952,7 @@ def intersect(self, other):
         spline = self.dot(other._normal) - np.atleast_1d(np.dot(other._normal, other._point))
 
         # Curve-Line intersection.
-        if nDep == 1:
+        if dof == 0:
             # 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.
@@ -974,39 +973,39 @@ def intersect(self, other):
                         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)
+                    firstPart = Solid(1, False)
+                    firstPart.add_boundary(Boundary(Hyperplane(-1.0, zero[0], 0.0), Solid(0, True)))
+                    firstPart.add_boundary(Boundary(Hyperplane(1.0, zero[1], 0.0), Solid(0, True)))
+                    secondPart = Solid(1, 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)))
+                    secondPart.add_boundary(Boundary(Hyperplane(-1.0, planeBounds[0], 0.0), Solid(0, True)))
+                    secondPart.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)))
+                    intersections.append(Manifold.Coincidence(firstPart, secondPart, 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:
+        elif dof == 1:
             # 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.
+                # The firstPart portion is the contour returned for the spline-plane intersection. 
+                firstPart = contour
+                # The secondPart 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))
+                secondPart = bspy.Spline.least_squares(tValues, np.array(points).T, contour.order, contour.knots)
+                intersections.append(Manifold.Crossing(firstPart, secondPart))
         else:
             return NotImplemented
     
@@ -1015,8 +1014,8 @@ def intersect(self, other):
         # Construct a spline block that represents the intersection.
         block = bspy.spline_block.SplineBlock([[self, -other]])
 
-        # Curve-Curve intersection.
-        if nDep == 1:
+        # Zero degrees of freedom, typically a Curve-Curve intersection.
+        if dof == 0:
             # Find the intersection points and intervals.
             zeros = block.zeros()
             # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
@@ -1041,23 +1040,23 @@ def intersect(self, other):
                         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)))
+                    firstPart = Solid(self.nInd, False)
+                    firstPart.add_boundary(Boundary(Hyperplane(-1.0, zero[0][0], 0.0), Solid(0, True)))
+                    firstPart.add_boundary(Boundary(Hyperplane(1.0, zero[1][0], 0.0), Solid(0, True)))
+                    secondPart = Solid(other.nInd, False)
+                    secondPart.add_boundary(Boundary(Hyperplane(-1.0, zero[0][1], 0.0), Solid(0, True)))
+                    secondPart.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)))
+                    intersections.append(Manifold.Coincidence(firstPart, secondPart, 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)))
+                    intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[:self.nInd], 0.0), Hyperplane(1.0, zero[self.nInd:], 0.0)))
         
-        # Surface-Surface intersection.
-        elif nDep == 2:
+        # One degree of freedom, typically a Surface-Surface intersection.
+        elif dof == 1:
             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.
@@ -1074,71 +1073,73 @@ def intersect(self, other):
                 contours = block.contours()
                 # Convert each contour into a Manifold.Crossing, swapping the manifolds back.
                 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))
+                    # Swap firstPart and secondPart, compared to not swapped.
+                    firstPart = bspy.Spline(contour.nInd, self.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[other.nInd:], contour.metadata)
+                    secondPart = bspy.Spline(contour.nInd, other.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[:other.nInd], contour.metadata)
+                    intersections.append(Manifold.Crossing(firstPart, secondPart))
             else:
                 # Convert each contour into a Manifold.Crossing.
                 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))
+                    firstPart = bspy.Spline(contour.nInd, self.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[:self.nInd], contour.metadata)
+                    secondPart = bspy.Spline(contour.nInd, other.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[self.nInd:], contour.metadata)
+                    intersections.append(Manifold.Crossing(firstPart, secondPart))
         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)
+    # If self and other have normals, ensure they are pointing in the correct direction.
+    if self.nInd + 1 == self.nDep and other.domain_dimension() + 1 == self.nDep:
+        # Ensure the normals point outwards for both Manifolds in each crossing intersection.
+        # Note that evaluating firstPart and secondPart 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):
+                firstPart = intersection.firstPart
+                secondPart = intersection.secondPart
+                if np.dot(self.tangent_space(firstPart.evaluate(domainPoint)) @ firstPart.normal(domainPoint), other.normal(secondPart.evaluate(domainPoint))) < 0.0:
+                    firstPart = firstPart.negate_normal()
+                if np.dot(other.tangent_space(secondPart.evaluate(domainPoint)) @ secondPart.normal(domainPoint), self.normal(firstPart.evaluate(domainPoint))) < 0.0:
+                    secondPart = secondPart.negate_normal()
+                intersections[i] = Manifold.Crossing(firstPart, secondPart)
 
     return intersections
 
-def complete_slice(self, slice, solid):
+def complete_cutout(self, cutout, solid):
     # Spline manifold domains have finite bounds.
-    slice.containsInfinity = False
+    cutout.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 not cutout.boundaries:
+        if cutout.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)
+                cutout.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)))
+    if cutout.dimension == 1:
+        cutout.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)))
+        if abs(cutout.boundaries[-1].manifold._point - bounds[0][1]) >= Manifold.minSeparation and \
+            cutout.boundaries[-1].manifold._normal < 0.0:
+            cutout.add_boundary(Boundary(Hyperplane(-cutout.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)))
+        if abs(cutout.boundaries[0].manifold._point - bounds[0][0]) >= Manifold.minSeparation and \
+            cutout.boundaries[0].manifold._normal > 0.0:
+            cutout.add_boundary(Boundary(Hyperplane(-cutout.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:
+    # For surfaces, intersect full spline domain with existing cutout boundaries.
+    if cutout.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.
+        # Define function for adding cutout points to full domain boundaries.
         def process_domain_point(boundary, domainPoint, adjustment):
             point = boundary.manifold.evaluate(domainPoint)
             # See if and where point touches full domain.
@@ -1147,24 +1148,24 @@ def complete_slice(self, slice, solid):
                 if abs(np.dot(newBoundary.manifold._normal, vector)) < Manifold.minSeparation:
                     # Add the point onto the new boundary (adjust normal evaluation point to move away from boundary).
                     normal = np.sign(newBoundary.manifold._tangentSpace.T @ boundary.manifold.normal(domainPoint + adjustment))
-                    newBoundary.domain.add_boundary(Boundary(Hyperplane(normal, newBoundary.manifold._tangentSpace.T @ vector, 0.0), Solid(0, True)))
+                    newBoundary.trim.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
+        for boundary in cutout.boundaries:
+            domainBoundaries = boundary.trim.boundaries
             domainBoundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), boundary.manifold.normal(0.0)))
             process_domain_point(boundary, domainBoundaries[0].manifold._point, Manifold.minSeparation)
             if len(domainBoundaries) > 1:
                 process_domain_point(boundary, domainBoundaries[-1].manifold._point, -Manifold.minSeparation)
         
-        # For touched boundaries, remove domain bounds that aren't needed and then add boundary to slice.
+        # For touched boundaries, remove domain bounds that aren't needed and then add boundary to cutout.
         boundaryWasTouched = False
         for newBoundary in fullDomain.boundaries:
             if newBoundary.touched:
                 boundaryWasTouched = True
-                domainBoundaries = newBoundary.domain.boundaries
+                domainBoundaries = newBoundary.trim.boundaries
                 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 \
@@ -1173,10 +1174,10 @@ def complete_slice(self, slice, solid):
                 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)
+                cutout.add_boundary(newBoundary)
         
         if boundaryWasTouched:
-            # Touch untouched boundaries that are connected to touched boundary endpoints and add them to slice.
+            # Touch untouched boundaries that are connected to touched boundary endpoints and add them to cutout.
             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
@@ -1184,21 +1185,21 @@ def complete_slice(self, slice, solid):
                     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:
+                        if leftBoundary.touched and abs(leftBoundary.trim.boundaries[map[2]].manifold._point - bound) < Manifold.minSeparation:
                             newBoundary.touched = True
-                            slice.add_boundary(newBoundary)
+                            cutout.add_boundary(newBoundary)
                             noTouches = False
-                        elif rightBoundary.touched and abs(rightBoundary.domain.boundaries[map[2]].manifold._point - bound) < Manifold.minSeparation:
+                        elif rightBoundary.touched and abs(rightBoundary.trim.boundaries[map[2]].manifold._point - bound) < Manifold.minSeparation:
                             newBoundary.touched = True
-                            slice.add_boundary(newBoundary)
+                            cutout.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.
+            # No cutout 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)
+                    cutout.add_boundary(newBoundary)
 
 def full_domain(self):
     return Hyperplane.create_hypercube(self.domain())