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

bspy/__init__.py

@@ -3,14 +3,24 @@ BSpy is a python library for manipulating and rendering non-uniform B-splines.
 
 Available subpackages
 ---------------------
-`bspy.spline` : Provides the `Spline` class that models, represents, and processes piecewise polynomial tensor product
-    functions (spline functions) as linear combinations of B-splines.
+`bspy.solid` : Provides the `Solid` and `Boundary` classes that model solids.
+
+`bspy.manifold` : Provides the `Manifold` base class for manifolds.
+
+`bspy.hyperplane` : Provides the `Hyperplane` subclass of `Manifold` that models hyperplanes.
+
+`bspy.spline` : Provides the `Spline` subclass of `Manifold` that models, represents, and processes 
+    piecewise polynomial tensor product functions (spline functions) as linear combinations of B-splines.
 
 `bspy.splineOpenGLFrame` : Provides the `SplineOpenGLFrame` class, a tkinter `OpenGLFrame` with shaders to display splines.
 
 `bspy.viewer` : Provides the `Viewer` tkinter app (`tkinter.Tk`) that hosts a `SplineOpenGLFrame`, a listbox full of 
     splines, and a set of controls to adjust and view the selected splines. It also provides the `Graphics` engine that creates 
-    an associated `Viewer`, allowing you to script splines and display them in the viewer."""
+    an associated `Viewer`, allowing you to script splines and display them in the viewer.
+"""
+from bspy.solid import Solid, Boundary
+from bspy.manifold import Manifold
+from bspy.hyperplane import Hyperplane
 from bspy.spline import Spline
 from bspy.splineOpenGLFrame import SplineOpenGLFrame
 from bspy.viewer import Viewer, Graphics

bspy/_spline_domain.py

@@ -1,4 +1,5 @@
 import numpy as np
+from bspy.manifold import Manifold
 
 def clamp(self, left, right):
     bounds = [[None, None] for i in range(self.nInd)]
@@ -582,6 +583,14 @@ def trim(self, newDomain):
 
     return type(spline)(spline.nInd, spline.nDep, spline.order, coefs.shape[1:], knotsList, coefs, spline.metadata)
 
+def trimmed_range_bounds(self, domainBounds):
+    domainBounds = np.array(domainBounds, copy=True)
+    for original, trim in zip(self.domain(), domainBounds):
+        trim[0] = max(original[0], trim[0] - Manifold.minSeparation)
+        trim[1] = min(original[1], trim[1] + Manifold.minSeparation)
+    trimmedSpline = self.trim(domainBounds)
+    return trimmedSpline, trimmedSpline.range_bounds()
+
 def unfold(self, foldedInd, coefficientlessSpline):
     if not(len(foldedInd) == coefficientlessSpline.nInd): raise ValueError("Invalid coefficientlessSpline")
     unfoldedOrder = []

bspy/_spline_evaluation.py

@@ -2,10 +2,12 @@ import numpy as np
 
 def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs = False):
     basis = np.zeros(splineOrder, knots.dtype)
-    basis[-1] = 1.0
     if knot is None:
         knot = np.searchsorted(knots, u, side = 'right')
         knot = min(knot, len(knots) - splineOrder)
+    if derivativeOrder >= splineOrder:
+        return knot, basis
+    basis[-1] = 1.0
     for degree in range(1, splineOrder - derivativeOrder):
         b = splineOrder - degree
         for i in range(knot - degree, knot):
@@ -149,22 +151,17 @@ def normal(self, uvw, normalize=True, indices=None):
     if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be one different than the number of dependent variables.")
 
     # Evaluate the tangents at the point.
-    tangentSpace = np.empty((self.nInd, self.nDep), self.coefs.dtype)
-    with_respect_to = [0] * self.nInd
-    for i in range(self.nInd):
-        with_respect_to[i] = 1
-        tangentSpace[i] = self.derivative(with_respect_to, uvw)
-        with_respect_to[i] = 0
+    tangentSpace = self.tangent_space(uvw)
     
     # Record the larger dimension and ensure it comes first.
     if self.nInd > self.nDep:
         nDep = self.nInd
+        tangentSpace = tangentSpace.T
     else:
         nDep = self.nDep
-        tangentSpace = tangentSpace.T
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = 1
+    sign = -1 if self.metadata.get("flipNormal", False) else 1
     if indices is None:
         indices = range(nDep)
         normal = np.empty(nDep, self.coefs.dtype)
@@ -183,4 +180,13 @@ def normal(self, uvw, normalize=True, indices=None):
 def range_bounds(self):
     # Assumes self.nDep is the first value in self.coefs.shape
     bounds = [[coefficient.min(), coefficient.max()] for coefficient in self.coefs]
-    return np.array(bounds, self.coefs.dtype)
+    return np.array(bounds, self.coefs.dtype)
+
+def tangent_space(self, uvw):
+    tangentSpace = np.empty((self.nDep, self.nInd), self.coefs.dtype)
+    wrt = [0] * self.nInd
+    for i in range(self.nInd):
+        wrt[i] = 1
+        tangentSpace[:, i] = self.derivative(wrt, uvw)
+        wrt[i] = 0
+    return tangentSpace

bspy/_spline_fitting.py

@@ -23,7 +23,7 @@ def cone(radius1, radius2, height, tolerance = None):
     return bspy.Spline.ruled_surface(bottom, top)
 
 # Courtesy of Michael Epton - Translated from his F77 code lgnzro
-def _legendre_polynomial_zeros(degree):
+def _legendre_polynomial_zeros(degree, mapToZeroOne = True):
     def legendre(degree, x):
         p = [1.0, x]
         pd = [0.0, 1.0]
@@ -35,6 +35,7 @@ def _legendre_polynomial_zeros(degree):
         return p, pd
     zval = 1.0
     z = []
+    zNegative = []
     for iRoot in range(degree // 2):
         done = False
         while True:
@@ -49,21 +50,28 @@ def _legendre_polynomial_zeros(degree):
             if dz < 1.0e-10:
                 done = True
         z.append(zval)
+        zNegative.append(-zval)
         zval -= 0.001
     if degree % 2 == 1:
-        z.append(0.0)
+        zNegative.append(0.0)
     z.reverse()
+    z = np.array(zNegative + z)
     w = []
     for zval in z:
         p, pd = legendre(degree, zval)
         w.append(2.0 / ((1.0 - zval ** 2) * pd[-1] ** 2))
+    w = np.array(w)
+    if mapToZeroOne:
+        z = 0.5 * (1.0 + z)
+        w = 0.5 * w
     return z, w
 
 def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     # Set up parameters for initial guess of x(t) and validate arguments.
     order = 4
     degree = order - 1
-    rhos, gaussWeights = _legendre_polynomial_zeros(degree - 1)
+    gaussNodes, gaussWeights = _legendre_polynomial_zeros(degree - 1)
+
     if not(len(knownXValues) >= 2): raise ValueError("There must be at least 2 known x values.")
     m = len(knownXValues) - 1
     nCoef = m * (degree - 1) + 2
@@ -96,6 +104,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
                     wrt[i] = 1
                     return F.derivative(wrt, x)
                 dF.append(splineDerivative)
+            FDomain = F.domain().T
         else:
             for i in range(nDep):
                 def fDerivative(x, i=i):
@@ -107,6 +116,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
                     xShift[i] += h2
                     return (np.array(F(xShift)) - fLeft) / h2
                 dF.append(fDerivative)
+            FDomain = np.array(nDep * [[-np.inf, np.inf]]).T
     else:
         if not(len(dF) == nDep): raise ValueError(f"Must provide {nDep} first derivatives.")
 
@@ -120,13 +130,9 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     for point in knownXValues[1:]:
         dt = np.linalg.norm(point - previousPoint)
         if not(dt > epsilon): raise ValueError("Points must be separated by at least epsilon.")
-        for rho in reversed(rhos):
-            tValues[i] = t + 0.5 * dt * (1.0 - rho)
-            GSamples[i] = 0.5 * (previousPoint + point - rho * (point - previousPoint))
-            i += 1
-        for rho in rhos[0 if degree % 2 == 1 else 1:]:
-            tValues[i] = t + 0.5 * dt * (1.0 + rho)
-            GSamples[i] = 0.5 * (previousPoint + point + rho * (point - previousPoint))
+        for gaussNode in gaussNodes:
+            tValues[i] = t + gaussNode * dt
+            GSamples[i] = (1.0 - gaussNode) * previousPoint + gaussNode * point
             i += 1
         t += dt
         knots += [t] * (order - 2)
@@ -184,6 +190,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
 
                 # Do the same for F(x(t)).
                 x = coefsMin + (compactCoefs.T @ bValues) * coefsMaxMinusMin
+                x = np.maximum(FDomain[0], np.minimum(FDomain[1], x))
                 FValues = F(x)
                 FSamplesNorm = max(FSamplesNorm, np.linalg.norm(FValues, np.inf))
                 if previousFSamplesNorm > 0.0 and FSamplesNorm > previousFSamplesNorm * (1.0 - evaluationEpsilon):
@@ -253,26 +260,14 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
             newKnot = 0.5 * (previousKnot + knot)
 
             # Place tValues at Gauss points for the intervals [previousKnot, newKnot] and [newKnot, knot].
-            for rho in reversed(rhos):
-                tValues[i] = t = 0.5 * (previousKnot + newKnot - rho * (newKnot - previousKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in rhos[0 if degree % 2 == 1 else 1:]:
-                tValues[i] = t = 0.5 * (previousKnot + newKnot + rho * (newKnot - previousKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in reversed(rhos):
-                tValues[i] = t = 0.5 * (newKnot + knot - rho * (knot - newKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
-            for rho in rhos[0 if degree % 2 == 1 else 1:]:
-                tValues[i] = t = 0.5 * (newKnot + knot + rho * (knot - newKnot))
-                GSamples[i] = x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
-                FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
-                i += 1
+            for knotInterval in [[previousKnot, newKnot], [newKnot, knot]]:
+                for gaussNode in gaussNodes:
+                    tValues[i] = t = (1.0 - gaussNode) * knotInterval[0] + gaussNode * knotInterval[1]
+                    x = compactCoefs.T @ bspy.Spline.bspline_values(ix, knots, order, t)[1]
+                    x = np.array([max(0.0, min(1.0, xi)) for xi in x])
+                    GSamples[i] = x
+                    FSamplesNorm = max(FSamplesNorm, np.linalg.norm(F(coefsMin + x * coefsMaxMinusMin), np.inf))
+                    i += 1
             
             newKnots += [newKnot] * (order - 2) # C1 continuity
             newKnots += [knot] * (order - 2) # C1 continuity
@@ -408,68 +403,47 @@ def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
     # Define the callback function for the ODE solver
     def geodesicCallback(t, u, surface, uvDomain):
         # Evaluate the surface information needed for the Christoffel symbols
-        u[0, 0] = max(uvDomain[0, 0], min(uvDomain[0, 1], u[0, 0]))
-        u[1, 0] = max(uvDomain[1, 0], min(uvDomain[1, 1], u[1, 0]))
+        u[:, 0] = np.maximum(uvDomain[:, 0], np.minimum(uvDomain[:, 1], u[:, 0]))
         su = surface.derivative([1, 0], u[:, 0])
         sv = surface.derivative([0, 1], u[:, 0])
         suu = surface.derivative([2, 0], u[:, 0])
         suv = surface.derivative([1, 1], u[:, 0])
         svv = surface.derivative([0, 2], u[:, 0])
+        suuu = surface.derivative([3, 0], u[:, 0])
+        suuv = surface.derivative([2, 1], u[:, 0])
+        suvv = surface.derivative([1, 2], u[:, 0])
+        svvv = surface.derivative([0, 3], u[:, 0])
 
-        # Calculate the first fundamental form
+        # Calculate the first fundamental form and derivatives
         E = su @ su
+        E_u = 2.0 * suu @ su
+        E_v = 2.0 * suv @ su
         F = su @ sv
+        F_u = suu @ sv + suv @ su
+        F_v = suv @ sv + svv @ su
         G = sv @ sv
+        G_u = 2.0 * suv @ sv
+        G_v = 2.0 * svv @ sv
         A = np.array([[E, F], [F, G]])
+        A_u = np.array([[E_u, F_u], [F_u, G_u]])
+        A_v = np.array([[E_v, F_v], [F_v, G_v]])
 
         # Compute right hand side entries
-        R_uuu = suu @ su
-        R_uuv = suu @ sv
-        R_uvu = suv @ su
-        R_uvv = suv @ sv
-        R_vvu = svv @ su
-        R_vvv = svv @ sv
-        R = np.array([[R_uuu, R_uvu, R_vvu], [R_uuv, R_uvv, R_vvv]])
+        R = np.array([[suu @ su, suv @ su, svv @ su], [suu @ sv, suv @ sv, svv @ sv]])
+        R_u = np.array([[suuu @ su + suu @ suu, suuv @ su + suv @ suu, suvv @ su + svv @ suu],
+                        [suuu @ sv + suu @ suv, suuv @ sv + suv @ suv, suvv @ sv + svv @ suv]])
+        R_v = np.array([[suuv @ su + suu @ suv, suvv @ su + suv @ suv, suvv @ su + svv @ suv],
+                        [suuv @ sv + suu @ svv, suvv @ sv + suv @ svv, svvv @ sv + svv @ svv]])
 
         # Solve for the Christoffel symbols
         luAndPivot = sp.linalg.lu_factor(A)
         Gamma = sp.linalg.lu_solve(luAndPivot, R)
+        Gamma_u = sp.linalg.lu_solve(luAndPivot, R_u - A_u @ Gamma)
+        Gamma_v = sp.linalg.lu_solve(luAndPivot, R_v - A_v @ Gamma)
 
         # Compute the right hand side for the ODE
         rhs = -np.array([Gamma[0, 0] * u[0, 1] ** 2 + 2.0 * Gamma[0, 1] * u[0, 1] * u[1, 1] + Gamma[0, 2] * u[1, 1] ** 2,
                          Gamma[1, 0] * u[0, 1] ** 2 + 2.0 * Gamma[1, 1] * u[0, 1] * u[1, 1] + Gamma[1, 2] * u[1, 1] ** 2])
-        
-        # Now we need the derivatives of the Christoffel symbols with respect to u
-        suuu = surface.derivative([3, 0], u[:, 0])
-        suuv = surface.derivative([2, 1], u[:, 0])
-        suvv = surface.derivative([1, 2], u[:, 0])
-        svvv = surface.derivative([0, 3], u[:, 0])
-        E_u = 2.0 * R_uuu
-        F_u = R_uuv + R_uvu
-        G_u = 2.0 * R_uvv
-        A_u = np.array([[E_u, F_u], [F_u, G_u]])
-        R_uuu_u = suuu @ su + suu @ suu
-        R_uuv_u = suuu @ sv + suu @ suv
-        R_uvu_u = suuv @ su + suv @ suu
-        R_uvv_u = suuv @ sv + suv @ suv
-        R_vvu_u = suvv @ su + svv @ suu
-        R_vvv_u = suvv @ sv + svv @ suv
-        R_u = np.array([[R_uuu_u, R_uvu_u, R_vvu_u], [R_uuv_u, R_uvv_u, R_vvv_u]])
-        Gamma_u = sp.linalg.lu_solve(luAndPivot, R_u - A_u @ Gamma)
-
-        # . . . And the derivatives of the Christoffel symbols with respect to v
-        E_v = 2.0 * R_uvu
-        F_v = R_uvv + R_vvu
-        G_v = 2.0 * R_vvv
-        A_v = np.array([[E_v, F_v], [F_v, G_v]])
-        R_uuu_v = suuv @ su + suu @ suv
-        R_uuv_v = suuv @ sv + suu @ svv
-        R_uvu_v = suvv @ su + suv @ suv
-        R_uvv_v = suvv @ sv + suv @ svv
-        R_vvu_v = svvv @ su + svv @ suv
-        R_vvv_v = svvv @ sv + svv @ svv
-        R_v = np.array([[R_uuu_v, R_uvu_v, R_vvu_v], [R_uuv_v, R_uvv_v, R_vvv_v]])
-        Gamma_v = sp.linalg.lu_solve(luAndPivot, R_v - A_v @ Gamma)
 
         # Compute the Jacobian matrix of the right hand side of the ODE
         jacobian = -np.array([[[Gamma_u[0, 0] * u[0, 1] ** 2 + 2.0 * Gamma_u[0, 1] * u[0, 1] * u[1, 1] + Gamma_u[0, 2] * u[1, 1] ** 2,
@@ -707,7 +681,10 @@ def section(xytk):
         onePlusCosTheta = 1.0 + math.cos(theta)
         r0 = 4.0 * startKappa * tangentDistances[0] ** 2 / (3.0 * tangentDistances[1] * crossTangents)
         r1 = 4.0 * endKappa * tangentDistances[1] ** 2 / (3.0 * tangentDistances[0] * crossTangents)
-        rhoCrit = (math.sqrt(1.0 + 4.0 * (r0 + r1)) - 1.0) / (2.0 * (r0 + r1))
+        if r0 != 0.0 or r1 != 0.0:
+            rhoCrit = (math.sqrt(1.0 + 4.0 * (r0 + r1)) - 1.0) / (2.0 * (r0 + r1))
+        else:
+            rhoCrit = 1.0
         rhoCritOfTheta = 3.0 * (math.sqrt(1.0 + 32.0 / (3.0 * onePlusCosTheta)) - 1.0) * onePlusCosTheta / 16.0
 
         # Determine quadratic polynomial
@@ -797,11 +774,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
         for knot0, knot1 in zip(currentGuess.knots[0][:-1], currentGuess.knots[0][1:]):
             if knot0 < knot1:
                 for gaussNode in gaussNodes:
-                    alpha = 0.5 * (1.0 - gaussNode)
-                    collocationPoints.append((1.0 - alpha) * knot0 + alpha * knot1)
-                    if abs(gaussNode) > 1.0e-5:
-                        collocationPoints.append(alpha * knot0 + (1.0 - alpha) * knot1)
-        collocationPoints = np.sort(collocationPoints)
+                    collocationPoints.append((1.0 - gaussNode) * knot0 + gaussNode * knot1)
         n = nDep * currentGuess.nCoef[0]
         bestGuess = np.reshape(currentGuess.coefs.T, (n,))
 
@@ -826,7 +799,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
             done = linear
             continuation = 1.0
             bestContinuation = 0.0
-            continuationBest = bestGuess
+            inCaseOfEmergency = bestGuess.copy()
             previous = 0.5 * np.finfo(bestGuess[0]).max
             iteration = 0
     
@@ -869,9 +842,10 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 update = sp.linalg.solve_banded((bandWidth, bandWidth), collocationMatrix, residuals)
                 bestGuess[nDep * (iFirstPoint + nLeft) : nDep * (iNextPoint + nLeft)] += update[nDep * nLeft : nDep * (iNextPoint - iFirstPoint + nLeft)]
                 updateSize = np.linalg.norm(update)
-                if updateSize > 1.25 * previous and iteration >= 4:
+                if updateSize > 1.25 * previous and iteration >= 4 or \
+                   updateSize > 0.01 and iteration > 50:
                     continuation = 0.5 * (continuation + bestContinuation)
-                    bestGuess = continuationBest
+                    bestGuess = inCaseOfEmergency.copy()
                     if continuation - bestContinuation < 0.01:
                         break
                     previous = 0.5 * np.finfo(bestGuess[0]).max
@@ -886,7 +860,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 if updateSize < math.sqrt(n) * scale * math.sqrt(np.finfo(update.dtype).eps):
                     if continuation < 1.0:
                         bestContinuation = continuation
-                        continuationBest = bestGuess
+                        inCaseOfEmergency = bestGuess.copy()
                         continuation = min(1.0, 1.2 * continuation)
                         previous = 0.5 * np.finfo(bestGuess[0]).max
                         iteration = 0

bspy/_spline_intersection.py

@@ -1,8 +1,10 @@
 import logging
 import math
 import numpy as np
+from bspy.manifold import Manifold
+from bspy.hyperplane import Hyperplane
 import bspy.spline
-from bspy.manifold import Manifold, Hyperplane
+from bspy.solid import Solid, Boundary
 from collections import namedtuple
 from multiprocessing import Pool
 
@@ -575,6 +577,7 @@ def contours(self):
     # 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)
@@ -768,10 +771,10 @@ 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)
@@ -779,12 +782,74 @@ def contours(self):
     return splineContours
 
 def intersect(self, other):
-    #assert self.range_dimension() == other.range_dimension() TODO: Put back this assertion
     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.
-    if isinstance(other, bspy.Spline):
+    elif isinstance(other, bspy.Spline):
         # Construct a new spline that represents the intersection.
         spline = self.subtract(other)
 
@@ -812,27 +877,25 @@ 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.
-                    # TODO: Remove the quoted section.
-                    """
                     left = Solid(nDep, False)
-                    left.boundaries.append(Boundary(Hyperplane(-1.0, zero[0][0], 0.0), Solid(0, True)))
-                    left.boundaries.append(Boundary(Hyperplane(1.0, zero[1][0], 0.0), Solid(0, True)))
+                    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.boundaries.append(Boundary(Hyperplane(-1.0, zero[0][1], 0.0), Solid(0, True)))
-                    right.boundaries.append(Boundary(Hyperplane(1.0, zero[1][1], 0.0), Solid(0, True)))
+                    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:
-            #logging.info(f"intersect_manifold({self.metadata['Name']}, {other.metadata['Name']})")
+            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:
@@ -845,7 +908,8 @@ def intersect(self, other):
             # Convert each contour into a Manifold.Crossing.
             if swap:
                 spline = other.subtract(self)
-                #logging.info(f"intersect_manifold({other.metadata['Name']}, {self.metadata['Name']})")
+                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.
@@ -864,15 +928,115 @@ def intersect(self, other):
 
     # 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.
-    # TODO: Remove quoted section.
-    """
     domainPoint = np.atleast_1d(0.5)
-    for intersection in intersections:
+    for i, intersection in enumerate(intersections):
         if isinstance(intersection, Manifold.Crossing):
-            if np.dot(self.tangent_space(intersection.left.point(domainPoint)) @ intersection.left.normal(domainPoint), other.normal(intersection.right.point(domainPoint))) < 0.0:
-                intersection.left.flip_normal()
-            if np.dot(other.tangent_space(intersection.right.point(domainPoint)) @ intersection.right.normal(domainPoint), self.normal(intersection.left.point(domainPoint))) < 0.0:
-                intersection.right.flip_normal()
-    """
+            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)
 
-    return intersections
+def full_domain(self):
+    return Hyperplane.create_hypercube(self.domain())