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

bspy/_spline_intersection.py

@@ -4,6 +4,7 @@ import numpy as np
 from bspy.manifold import Manifold
 from bspy.hyperplane import Hyperplane
 import bspy.spline
+import bspy.spline_block
 from bspy.solid import Solid, Boundary
 from collections import namedtuple
 from multiprocessing import Pool
@@ -75,14 +76,22 @@ def zeros_using_interval_newton(self):
         if derivativeBounds[0] * derivativeBounds[1] >= 0.0:    # Refine interval
             projectedLeftStep = max(0.0, adjustedLeftStep)
             projectedRightStep = min(1.0, adjustedRightStep)
+            provisionalZero = [0.5 * (projectedLeftStep + projectedRightStep)]
             if projectedLeftStep <= projectedRightStep:
                 if projectedRightStep - projectedLeftStep <= epsilon:
-                    myZeros = [0.5 * (projectedLeftStep + projectedRightStep)]
+                    myZeros = provisionalZero
                 else:
                     trimmedSpline = mySpline.trim(((projectedLeftStep, projectedRightStep),))
                     myZeros = refine(trimmedSpline, intervalSize, functionMax)
+                    if len(myZeros) == 0 and mySpline.order[0] == mySpline.nCoef[0] and \
+                       mySpline.coefs[0][0] * mySpline.coefs[0][-1] < 0.0:
+                        myZeros = provisionalZero
             else:
-               return []
+               if mySpline.order[0] == mySpline.nCoef[0] and \
+                  mySpline.coefs[0][0] * mySpline.coefs[0][-1] < 0.0:
+                   myZeros = provisionalZero
+               else:
+                   return []
         else:                           # . . . or split as needed
             myZeros = []
             if adjustedLeftStep > 0.0:
@@ -117,220 +126,208 @@ def zeros_using_interval_newton(self):
             return mySolution
     return refine(spline, 1.0, 1.0)
 
-def _convex_hull_2D(xData, yData, yBounds, epsilon = 1.0e-8):
+def _convex_hull_2D(xData, yData, yBounds, yOtherBounds):
     # Allow xData to be repeated for longer yData, but only if yData is a multiple.
     if not(yData.shape[0] % xData.shape[0] == 0): raise ValueError("Size of xData does not divide evenly in size of yData")
-
-    # Assign (x0, y0) to the lowest point.
-    yMinIndex = np.argmin(yData)
-    x0 = xData[yMinIndex % xData.shape[0]]
-    y0 = yData[yMinIndex]
+    yData = np.reshape(yData, (yData.shape[0] // xData.shape[0], xData.shape[0]))
 
     # 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)
-            x = next(xIter)
-        sortedPoints.append((math.atan2(y - y0, x - x0), x, y))
-    sortedPoints.sort()
-
-    # 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
-    for point in sortedPoints[1:]:
-        if previousPoint is not None and abs(previousPoint[0] - point[0]) < epsilon:
-            if previousDistance < 0.0:
-                previousDistance = (previousPoint[1] - x0) ** 2 + (previousPoint[2] - y0) ** 2
-            distance = (point[1] - x0) ** 2 + (point[2] - y0) ** 2
-            if distance > previousDistance:
-                trimmedPoints[-1] = point[1:]
-                previousPoint = point
-                previousDistance = distance
-        else:
-            trimmedPoints.append(point[1:])
-            previousPoint = point
-            previousDistance = -1.0
-
-    # Build the convex hull by moving counterclockwise around trimmed sorted points.
-    hullPoints = []
-    for point in trimmedPoints:
-        while len(hullPoints) > 1 and \
-            (hullPoints[-1][0] - hullPoints[-2][0]) * (point[1] - hullPoints[-2][1]) - \
-            (hullPoints[-1][1] - hullPoints[-2][1]) * (point[0] - hullPoints[-2][0]) <= 0.0:
-            hullPoints.pop()
-        hullPoints.append(point)
-
-    return hullPoints
-
-def _intersect_convex_hull_with_x_interval(hullPoints, epsilon, xInterval):
-    xMin = xInterval[1] + epsilon
-    xMax = xInterval[0] - epsilon
-    previousPoint = hullPoints[-1]
-    for point in hullPoints:
-        # Check for intersection with x axis.
-        if previousPoint[1] * point[1] <= epsilon:
-            determinant = point[1] - previousPoint[1]
-            if abs(determinant) > epsilon:
-                # Crosses x axis, determine intersection.
-                x = previousPoint[0] - previousPoint[1] * (point[0] - previousPoint[0]) / determinant
-                xMin = min(xMin, x)
-                xMax = max(xMax, x)
-            elif abs(point[1]) < epsilon:
-                # Touches at endpoint. (Previous point is checked earlier.)
-                xMin = min(xMin, point[0])
-                xMax = max(xMax, point[0])
-        previousPoint = point
-
-    if xMin - epsilon > xInterval[1] or xMax + epsilon < xInterval[0]:
+    yMinAdjustment = -yBounds[0] if yBounds[0] > 0.0 else 0.0
+    yMaxAdjustment = -yBounds[1] if yBounds[1] < 0.0 else 0.0
+    yMinAdjustment += yOtherBounds[0]
+    yMaxAdjustment += yOtherBounds[1]
+
+    # Calculate the yMin and yMax arrays corresponding to xData
+    yMin = np.min(yData, axis = 0) + yMinAdjustment
+    yMax = np.max(yData, axis = 0) + yMaxAdjustment
+
+    # Initialize lower and upper hulls
+    lowerHull = [[xData[0], yMin[0]], [xData[1], yMin[1]]]
+    upperHull = [[xData[0], yMax[0]], [xData[1], yMax[1]]]
+
+    # Add additional lower points one at a time, throwing out intermediates if necessary
+    for xNext, yNext in zip(xData[2:], yMin[2:]):
+        lowerHull.append([xNext, yNext])
+        while len(lowerHull) > 2 and \
+                (lowerHull[-2][0] - lowerHull[-3][0]) * (lowerHull[-1][1] - lowerHull[-2][1]) <= \
+                (lowerHull[-1][0] - lowerHull[-2][0]) * (lowerHull[-2][1] - lowerHull[-3][1]):
+            del lowerHull[-2]
+
+    # Do the same for the upper points
+    for xNext, yNext in zip(xData[2:], yMax[2:]):
+        upperHull.append([xNext, yNext])
+        while len(upperHull) > 2 and \
+                (upperHull[-2][0] - upperHull[-3][0]) * (upperHull[-1][1] - upperHull[-2][1]) >= \
+                (upperHull[-1][0] - upperHull[-2][0]) * (upperHull[-2][1] - upperHull[-3][1]):
+            del upperHull[-2]
+
+    # Return the two hulls
+    return lowerHull, upperHull
+
+def _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInterval):
+    xMin = xInterval[0]
+    xMax = xInterval[1]
+    sign = -1.0
+    for hull in [lowerHull, upperHull]:
+        sign = -sign
+        p0 = hull[0]
+        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:
+                    xMin = max(xMin, xNew - epsilon)
+                else:
+                    xMax = min(xMax, xNew + epsilon)
+            p0 = p1
+    if xMin > xMax:
         return None
     else:
-        return (min(max(xMin, xInterval[0]), xInterval[1]), max(min(xMax, xInterval[1]), xInterval[0]))
-
-Interval = namedtuple('Interval', ('spline', 'unknowns', 'scale', 'slope', 'intercept', 'epsilon', 'atMachineEpsilon'))
+        return [xMin, xMax]
+
+Interval = namedtuple('Interval', ('block', 'active', 'split', 'scale', 'bounds', 'xLeft', 'xRight', 'epsilon', 'atMachineEpsilon'))
+
+def _create_interval(block, active, split, scale, xLeft, xRight, epsilon):
+    nDep = 0
+    nInd = len(scale)
+    bounds = np.zeros((nInd, 2), scale.dtype)
+    newScale = np.empty_like(scale)
+    newBlock = []
+    for row in block:
+        newRow = []
+        # Reparametrize splines and sum bounds
+        for map, spline in row:
+            spline = spline.reparametrize(((0.0, 1.0),) * spline.nInd)
+            bounds[nDep:nDep + spline.nDep] += spline.range_bounds()
+            newRow.append((map, spline))
+        newBlock.append(newRow)
+
+        # Check row bounds for potential roots.
+        for dep in range(spline.nDep):
+            coefsMin = bounds[nDep, 0] * scale[nDep]
+            coefsMax = bounds[nDep, 1] * scale[nDep]
+            if coefsMax < -epsilon or coefsMin > epsilon:
+                # No roots in this interval.
+                return None
+            newScale[nDep] = max(-coefsMin, coefsMax)
+            # Rescale spline coefficients to max 1.0.
+            rescale = 1.0 / max(-bounds[nDep, 0], bounds[nDep, 1])
+            for map, spline in newRow:
+                spline.coefs[dep] *= rescale
+            bounds[nDep] *= rescale
+            nDep += 1
+
+    for iInd in range(nInd):
+        newSplit = (split + iInd + 1) % nInd
+        if active[newSplit]:
+            return Interval(newBlock, active, newSplit, newScale, bounds, xLeft, xRight, epsilon, np.dot(xRight - xLeft, xRight - xLeft) < np.finfo(xLeft.dtype).eps)
+
+    # No active variables left
+    return None
 
 # We use multiprocessing.Pool to call this function in parallel, so it cannot be nested and must take a single argument.
 def _refine_projected_polyhedron(interval):
     Crit = 0.85 # Required percentage decrease in domain per iteration.
     epsilon = interval.epsilon
-    evaluationEpsilon = np.sqrt(epsilon)
-    machineEpsilon = np.finfo(interval.spline.coefs.dtype).eps
     roots = []
     intervals = []
-
-    # Remove dependent variables that are near zero and compute newScale.
-    spline = interval.spline.copy()
-    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 coefsMin < -epsilon or coefsMax > epsilon:
-            # Dependent variable not near zero for entire interval.
-            keepDep.append(nDep)
-
-    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 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)
+    # Explore given independent variable to determine a tighter domain around roots.
+    xInterval = [0.0, 1.0]
+    iInd = interval.split
+    nDep = 0
+    for row in interval.block:
+        order = 0
+        for map, spline in row:
+            if iInd in map:
+                ind = map.index(iInd)
+                order = spline.order[ind]
+                # Move independent variable to the last (fastest) axis, adding 1 to account for the dependent variables.
+                coefs = np.moveaxis(spline.coefs, ind + 1, -1)
+                break
+            
+        # Skip this row if it doesn't contain this independent variable.
+        if order < 1:
+            nDep += spline.nDep # Assumes there is at least one spline per block row
+            continue
 
         # Compute the coefficients for f(x) = x for the independent variable and its knots.
-        degree = order - 1
-        xData = np.empty((nCoef,), knots.dtype)
-        xData[0] = knots[1]
-        for i in range(1, nCoef):
-            xData[i] = xData[i - 1] + (knots[i + degree] - knots[i])/degree
+        xData = spline.greville(ind)
         
-        # Loop through each dependent variable to compute the interval containing the root for this independent variable.
-        xInterval = (0.0, 1.0)
-        for yData, yBounds in zip(coefs, bounds):
+        # 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]):
             # Compute the 2D convex hull of the knot coefficients and the spline's coefficients
-            hull = _convex_hull_2D(xData, yData.ravel(), yBounds, epsilon)
-            if hull is None:
+            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(hull, epsilon, xInterval)
+            xInterval = _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInterval)
             if xInterval is None:
                 return roots, intervals
-        
-        domain.append(xInterval)
+            
+        nDep += spline.nDep
     
-    # Compute new slope, intercept, and unknowns.
-    domain = np.array(domain, spline.knots[0].dtype).T
-    width = domain[1] - domain[0]
-    newSlope = interval.slope.copy()
-    newIntercept = interval.intercept.copy()
-    newUnknowns = []
-    newDomain = domain.copy()
-    uvw = []
+    # Compute new interval bounds.
+
+    xNewLeft = interval.xLeft.copy()
+    xNewRight = interval.xRight.copy()
+    xNewLeft[iInd] = (1.0 - xInterval[0]) * interval.xLeft[iInd] + xInterval[0] * interval.xRight[iInd]
+    xNewRight[iInd] = (1.0 - xInterval[1]) * interval.xLeft[iInd] + xInterval[1] * interval.xRight[iInd]
+    newActive = interval.active.copy()
+    newActive[iInd] = (xNewRight[iInd] - xNewLeft[iInd] >= epsilon)
     nInd = 0
-    for i, w, d in zip(interval.unknowns, width, domain.T):
-        newSlope[i] = w * interval.slope[i]
-        newIntercept[i] = d[0] * interval.slope[i] + interval.intercept[i]
-        if newSlope[i] < epsilon:
-            uvw.append(0.5 * (d[0] + d[1]))
-            newDomain = np.delete(newDomain, nInd, axis=1)
-        else:
-            newUnknowns.append(i)
-            uvw.append(None)
+    for active in newActive:
+        if active:
             nInd += 1
 
-    # Iteration is complete if the interval actual width (slope) is either
-    # one iteration past being less than sqrt(machineEpsilon) or there are no remaining unknowns.
-    if interval.atMachineEpsilon or len(newUnknowns) == 0:
+    # Iteration is complete if the interval actual width is either
+    # one iteration past being less than sqrt(machineEpsilon) or there are no remaining independent variables.
+    if interval.atMachineEpsilon or nInd == 0:
         # Return the interval center and radius.
-        roots.append((newIntercept + 0.5 * newSlope, epsilon))
+        roots.append((0.5 * (xNewLeft + xNewRight), epsilon))
         return roots, intervals
 
-    # Contract spline as needed.
-    spline = spline.contract(uvw)
-
-    # Use interval newton for one-dimensional splines.
-    if spline.nInd == 1 and spline.nDep == 1:
-        i = newUnknowns[0]
-        for root in zeros_using_interval_newton(spline):
-            if not isinstance(root, tuple):
-                root = (root, root)
-            w = root[1] - root[0]
-            slope = newSlope.copy()
-            intercept = newIntercept.copy()
-            slope[i] = w * interval.slope[i]
-            intercept[i] = root[0] * interval.slope[i] + interval.intercept[i]
-            # Return the interval center and radius.
-            roots.append((intercept + 0.5 * slope, epsilon))
-        
-        return roots, intervals
+    # Split domain if not sufficient decrease in width
+    width = xInterval[1] - xInterval[0]
+    domains = [xInterval]
+    if width > Crit:
+        # Didn't get the required decrease in width, so split the domain.
+        leftDomain = xInterval
+        rightDomain = xInterval.copy()
+        leftDomain[1] = 0.5 * (leftDomain[0] + leftDomain[1])
+        rightDomain[0] = leftDomain[1]
+        domains = [leftDomain, rightDomain]
 
-    # Split domain in dimensions that aren't decreasing in width sufficiently.
-    width = newDomain[1] - newDomain[0]
-    domains = [newDomain]
-    for nInd, w in zip(range(spline.nInd), width):
-        if w > Crit:
-            # Didn't get the required decrease in width, so split the domain.
-            domainCount = len(domains) # Cache the domain list size, since we're increasing it mid loop
-            w *= 0.5 # Halve the domain width for this independent variable
-            for i in range(domainCount):
-                leftDomain = domains[i]
-                rightDomain = leftDomain.copy()
-                leftDomain[1][nInd] -= w # Alters domain in domains list
-                rightDomain[0][nInd] += w
-                domains.append(rightDomain)
-    
     # Add new intervals to interval stack.
     for domain in domains:
-        width = domain[1] - domain[0]
-        splitSlope = newSlope.copy()
-        splitIntercept = newIntercept.copy()
-        for i, w, d in zip(newUnknowns, width, domain.T):
-            splitSlope[i] = w * interval.slope[i]
-            splitIntercept[i] = d[0] * interval.slope[i] + interval.intercept[i]
-        intervals.append(Interval(spline.trim(domain.T).reparametrize(((0.0, 1.0),) * spline.nInd), newUnknowns, newScale, splitSlope, splitIntercept, epsilon, np.dot(splitSlope, splitSlope) < machineEpsilon))
+        xSplitLeft = xNewLeft.copy()
+        xSplitRight = xNewRight.copy()
+        xSplitLeft[iInd] = (1.0 - domain[0]) * interval.xLeft[iInd] + domain[0] * interval.xRight[iInd]
+        xSplitRight[iInd] = (1.0 - domain[1]) * interval.xLeft[iInd] + domain[1] * interval.xRight[iInd]
+        newBlock = []
+        for row in interval.block:
+            newRow = []
+            # Trim splines
+            for map, spline in row:
+                trimRegion = [(0.0, 1.0) for i in range(spline.nInd)]
+                if iInd in map:
+                    ind = map.index(iInd)
+                    trimRegion[ind] = domain
+                spline = spline.trim(trimRegion)
+                newRow.append((map, spline))
+            newBlock.append(newRow)
+        newInterval = _create_interval(newBlock, newActive, iInd,
+                                       interval.scale, xSplitLeft, xSplitRight, epsilon)
+        if newInterval:
+            if newInterval.block:
+                intervals.append(newInterval)
+            else:
+                roots.append((0.5 * (newInterval.xLeft + newInterval.xRight),
+                              0.5 * np.linalg.norm(newInterval.xRight - newInterval.xLeft)))
   
     return roots, intervals
 
@@ -340,33 +337,37 @@ class _Region:
         self.radius = radius
         self.count = count
 
-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.knots[0].dtype).eps
+def zeros_using_projected_polyhedron(self, epsilon=None, initialScale=None):
+    if self.nInd != self.nDep: raise ValueError("The number of independent variables (nInd) must match the number of dependent variables (nDep).")
+
+    # Determine epsilon and initialize roots.
+    machineEpsilon = np.finfo(self.knotsDtype).eps
     if epsilon is None:
         epsilon = 0.0
-    epsilon = max(epsilon, np.sqrt(machineEpsilon))
-    evaluationEpsilon = np.sqrt(epsilon)
+    epsilon = max(epsilon, np.sqrt(machineEpsilon)) if epsilon else np.sqrt(machineEpsilon)
+    evaluationEpsilon = max(np.sqrt(epsilon), np.finfo(self.coefsDtype).eps ** 0.25)
+    intervals = []
     roots = []
 
-    # Set initial spline, domain, and interval.
+    # Set initial interval.
     domain = self.domain().T
-    intervals = [Interval(self.trim(domain.T).reparametrize(((0.0, 1.0),) * self.nInd), [*range(self.nInd)], 1.0, domain[1] - domain[0], domain[0], epsilon, False)]
-    chunkSize = 8
-    #pool = Pool() # Pool size matches CPU count
+    initialScale = np.full(self.nDep, 1.0, self.coefsDtype) if initialScale is None else np.array(initialScale, self.coefsDtype)
+    newInterval = _create_interval(self.block, self.nInd * [True], -1, initialScale,
+                                   domain[0], domain[1], epsilon)
+    if newInterval:
+        if newInterval.block:
+            intervals.append(newInterval)
+        else:
+            roots.append(0.5 * (newInterval.xLeft + newInterval.xRight),
+                         0.5 * np.linalg.norm(newInterval.xRight - newInterval.xLeft))
 
     # Refine all the intervals, collecting roots as we go.
     while intervals:
-        nextIntervals = []
-        if False and len(intervals) > chunkSize:
-            for (newRoots, newIntervals) in pool.imap_unordered(_refine_projected_polyhedron, intervals, chunkSize):
-                roots += newRoots
-                nextIntervals += newIntervals
-        else:
-            for (newRoots, newIntervals) in map(_refine_projected_polyhedron, intervals):
-                roots += newRoots
-                nextIntervals += newIntervals
-        intervals = nextIntervals
+        interval = intervals.pop()
+        newRoots, newIntervals = _refine_projected_polyhedron(interval)
+        roots += newRoots
+        newIntervals.reverse()
+        intervals += newIntervals
 
     # Combine overlapping roots into regions.
     regions = []
@@ -375,16 +376,33 @@ def zeros_using_projected_polyhedron(self, epsilon=None):
         rootCenter = root[0]
         rootRadius = root[1]
 
+        # Take one Newton step on each root
+        value = self.evaluate(rootCenter)
+        residualNorm = np.linalg.norm(value)
+        try:
+            update = np.linalg.solve(self.jacobian(rootCenter), value)
+            if np.linalg.norm(update) < rootRadius:
+                rootCenter -= update
+        except:
+            pass
+
+        # Project back onto spline domain
+        selfDomain = self.domain()
+        rootCenter = np.maximum(np.minimum(rootCenter, selfDomain.T[1]), selfDomain.T[0])
+        value = self.evaluate(rootCenter)
+        newResidualNorm = np.linalg.norm(value)
+        rootRadius *= newResidualNorm / residualNorm
+        residualNorm = newResidualNorm
+
         # Ensure we have a real root (not a boundary special case).
-        if np.linalg.norm(self(rootCenter)) >= evaluationEpsilon:
+        if residualNorm >= evaluationEpsilon:
             continue
 
         # Expand the radius of the root based on the approximate distance from the center needed
         # to raise the value of the spline above evaluationEpsilon.
-        jacobian = self.jacobian(rootCenter)
-        minEigenvalue = np.sqrt(np.linalg.eigvalsh(jacobian.T @ jacobian)[0])
-        if minEigenvalue > epsilon:
-            rootRadius = max(rootRadius, evaluationEpsilon / minEigenvalue)
+        minSingularValue = np.linalg.svd(self.jacobian(rootCenter), False, False)[-1]
+        if minSingularValue > epsilon:
+            rootRadius = max(rootRadius, evaluationEpsilon / minSingularValue)
         
         # Intersect this root with the existing regions, expanding and combining them as appropriate.
         firstRegion = None
@@ -418,48 +436,68 @@ def zeros_using_projected_polyhedron(self, epsilon=None):
 
     return roots
 
-def contours(self):
-    if self.nInd - self.nDep != 1: raise ValueError("The number of free variables (self.nInd - self.nDep) must be one.")
+def _turning_point_determinant(self, uvw, cosTheta, sinTheta):
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", 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]])
+
+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
+    tangentSpace = self.jacobian(uvw).T
+    dTangentSpace = tangentSpace.copy()
+
+    wrt = [0] * self.nInd
+    for i in range(self.nInd):
+        wrt[i] = 1
+        for j in range(self.nInd):
+            wrt[j] = 1 if i != j else 2
+            dTangentSpace[j, :] = self.derivative(wrt, uvw) # tangentSpace and dTangentSpace are the transpose of the jacobian
+            gradient[i] += cosTheta * sign * np.linalg.det(dTangentSpace[[k for k in range(self.nInd) if k != 0]]) - \
+                sinTheta * sign * np.linalg.det(dTangentSpace[[k for k in range(self.nInd) if k != 1]])
+            dTangentSpace[j, :] = tangentSpace[j, :] # tangentSpace and dTangentSpace are the transpose of the jacobian
+            wrt[j] = 0 if i != j else 1
+        wrt[i] = 0
+    
+    return gradient
 
+def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
     Point = namedtuple('Point', ('d', 'det', 'onUVBoundary', 'turningPoint', 'uvw'))
-    epsilon = np.sqrt(np.finfo(self.coefs.dtype).eps)
-    evaluationEpsilon = np.sqrt(epsilon)
-
-    # Go through each nDep of the spline, checking bounds.
-    for coefs in self.coefs:
-        coefsMin = coefs.min()
-        coefsMax = coefs.max()
-        if coefsMax < -evaluationEpsilon or coefsMin > evaluationEpsilon:
+
+    # Go through each nDep of the spline block, checking bounds.
+    bounds = self.range_bounds()
+    for bound in bounds:
+        if bound[1] < -evaluationEpsilon or bound[0] > evaluationEpsilon:
             # No contours for this spline.
             return []
 
     # Record self's original domain and then reparametrize self's domain to [0, 1]^nInd.
     domain = self.domain().T
     self = self.reparametrize(((0.0, 1.0),) * self.nInd)
-    
-    # Construct self's tangents and normal.
-    tangents = []
-    for nInd in range(self.nInd):
-        tangents.append(self.differentiate(nInd))
-    normal = self.normal_spline((0, 1)) # We only need the first two indices
-
-    theta = np.sqrt(2) # Arbitrary starting value for theta (picked one in [0, pi/2] unlikely to be a stationary point)
-    # Try different theta values until no border or turning points are degenerate or we run out of attempts.
-    attempts = 3
-    while attempts > 0:
+
+    # Rescale self in all dimensions.
+    initialScale = np.max(np.abs(bounds), axis=1)
+    rescale = np.reciprocal(initialScale)
+    nDep = 0
+    for row in self.block:
+        for map, spline in row:
+            for coefs, scale in zip(spline.coefs, rescale[nDep:nDep + spline.nDep]):
+                coefs *= scale
+        nDep += spline.nDep
+
+    # Try arbitrary values for theta between [0, pi/2] that are unlikely to be a stationary points.
+    for theta in (1.0 / np.sqrt(2), np.pi / 6.0, 1.0/ np.e):
         points = []
-        theta *= 0.607
         cosTheta = np.cos(theta)
         sinTheta = np.sin(theta)
         abort = False
-        attempts -=1
-
-        # Construct the turning point determinant.
-        turningPointDeterminant = normal.dot((cosTheta, sinTheta))
 
         # Find intersections with u and v boundaries.
         def uvIntersections(nInd, boundary):
-            zeros = self.contract([None] * nInd + [boundary] + [None] * (self.nInd - nInd - 1)).zeros()
+            zeros = self.contract([None] * nInd + [boundary] + [None] * (self.nInd - nInd - 1)).zeros(epsilon, initialScale)
             abort = False
             for zero in zeros:
                 if isinstance(zero, tuple):
@@ -467,10 +505,24 @@ def contours(self):
                     break
                 uvw = np.insert(np.array(zero), nInd, boundary)
                 d = uvw[0] * cosTheta + uvw[1] * sinTheta
-                det = (0.5 - boundary) * normal(uvw)[nInd] * turningPointDeterminant(uvw)
+                n = self.normal(uvw, False, (0, 1))
+                tpd = _turning_point_determinant(self, uvw, cosTheta, sinTheta)
+                det = (0.5 - boundary) * n[nInd] * tpd
                 if abs(det) < epsilon:
                     abort = True
                     break
+                # Check for literal corner case.
+                otherInd = 1 - nInd
+                otherValue = uvw[otherInd]
+                if otherValue < epsilon or otherValue + epsilon > 1.0:
+                    otherDet = (0.5 - otherValue) * n[otherInd] * tpd
+                    if det * otherDet < 0.0:
+                        continue # Corner that starts and ends, ignore it
+                    elif max(otherValue, boundary) < epsilon and det < 0.0:
+                        continue # End point at (0, 0), ignore it
+                    elif min(otherValue, boundary) + epsilon > 1.0 and det > 0.0:
+                        continue # Start point at (1, 1), ignore it
+                # Append boundary point.
                 points.append(Point(d, det, True, False, uvw))
             return abort
         for nInd in range(2):
@@ -485,7 +537,7 @@ def contours(self):
 
         # Find intersections with other boundaries.
         def otherIntersections(nInd, boundary):
-            zeros = self.contract([None] * nInd + [boundary] + [None] * (self.nInd - nInd - 1)).zeros()
+            zeros = self.contract([None] * nInd + [boundary] + [None] * (self.nInd - nInd - 1)).zeros(epsilon, initialScale)
             abort = False
             for zero in zeros:
                 if isinstance(zero, tuple):
@@ -494,12 +546,13 @@ def contours(self):
                 uvw = np.insert(np.array(zero), nInd, boundary)
                 d = uvw[0] * cosTheta + uvw[1] * sinTheta
                 columns = np.empty((self.nDep, self.nInd - 1))
+                tangents = self.jacobian(uvw).T
                 i = 0
                 for j in range(self.nInd):
                     if j != nInd:
-                        columns[:, i] = tangents[j](uvw)
+                        columns[:, i] = tangents[j]
                         i += 1
-                duv = np.linalg.solve(columns, -tangents[nInd](uvw))
+                duv = np.linalg.solve(columns, -tangents[nInd])
                 det = np.arctan2((0.5 - boundary) * (duv[0] * cosTheta + duv[1] * sinTheta), (0.5 - boundary) * (duv[0] * cosTheta - duv[1] * sinTheta))
                 if abs(det) < epsilon:
                     abort = True
@@ -517,22 +570,79 @@ def contours(self):
             continue # Try a different theta
 
         # Find turning points by combining self and turningPointDeterminant into a system and processing its zeros.
-        systemSelf, systemTurningPointDeterminant = bspy.Spline.common_basis((self, turningPointDeterminant))
-        system = type(systemSelf)(self.nInd, self.nInd, systemSelf.order, systemSelf.nCoef, systemSelf.knots, \
-            np.concatenate((systemSelf.coefs, systemTurningPointDeterminant.coefs)), systemSelf.metadata)
-        zeros = system.zeros()
+
+        # First, add the null space constraint to the system: dot(self's gradient, (r * sinTheta, -r * cosTheta, c, d, ...) = 0.
+        # This introduces self.nInd - 1 new independent variables: r, c, d, ...
+        turningPointBlock = self.block.copy()
+        if self.nInd > 2:
+            rSpline = bspy.Spline(1, 1, (2,), (2,), ((0.0, 0.0, 1.0, 1.0),), ((0.0, 1.0),))
+        else:
+            rSpline = bspy.Spline.point([1.0])
+        otherSpline = bspy.Spline(1, 1, (2,), (2,), ((-1.0, -1.0, 1.0, 1.0),), ((-1.0, 1.0),))
+        # Track indices of other independent variables (c, d, ...).
+        otherNInd = self.nInd + 1 # Add one since r is always the first new variable (index for r is self.nInd)
+        otherDictionary = {}
+        # Go through each row building the null space constraint.
+        for row in self.block:
+            newRow = []
+            for map, spline in row:
+                newSpline = None # The spline's portion of the null space constraint starts with None
+                newMap = map.copy() # The map for spline's contribution to the null space constraint starts with its existing map
+                # Create addition indMap with existing independent variables for use in summing the dot product.
+                indMapForAdd = [(index, index) for index in range(spline.nInd)]
+                rIndex = None # Index of r in newSpline, which we need to track since rSpline may be added twice
+
+                # Add each term of spline's contribution to dot(self's gradient, (r * sinTheta, -r * cosTheta, c, d, ...). 
+                for i in range(spline.nInd):
+                    dSpline = spline.differentiate(i)
+                    nInd = map[i]
+                    if nInd < 2:
+                        factor = sinTheta if nInd == 0 else -cosTheta
+                        term = dSpline.multiply(factor * rSpline)
+                        if rIndex is None:
+                            # Adding rSpline for the first time, so add r to newMap and track its index.
+                            newMap.append(self.nInd)
+                            newSpline = term if newSpline is None else newSpline.add(term, indMapForAdd)
+                            rIndex = newSpline.nInd - 1
+                        else:
+                            # The same rSpline is being added again, so enhance the indMapForAdd to associate the two rSplines.
+                            newSpline = newSpline.add(term, indMapForAdd + [(rIndex, term.nInd - 1)])
+                    else:
+                        if nInd not in otherDictionary:
+                            otherDictionary[nInd] = otherNInd
+                            otherNInd += 1
+                        newMap.append(otherDictionary[nInd])
+                        term = dSpline.multiply(otherSpline)
+                        newSpline = term if newSpline is None else newSpline.add(term, indMapForAdd)
+
+                newMap = newMap[:newSpline.nInd]
+                newRow.append((newMap, newSpline))
+            turningPointBlock.append(newRow)
+
+        # Second, add unit vector constrain to the system.
+        # r^2 + c^2 + d^2 + ... = 1
+        rSquaredMinus1 = bspy.Spline(1, 1, (3,), (3,), ((0.0, 0.0, 0.0, 1.0, 1.0, 1.0),), ((-1.0, -1.0, 0.0),))
+        otherSquared = bspy.Spline(1, 1, (3,), (3,), ((-1.0, -1.0, -1.0, 1.0, 1.0, 1.0),), ((1.0, -1.0, 1.0),))
+        newRow = [((self.nInd,), rSquaredMinus1)]
+        assert otherNInd == 2 * self.nInd - 1
+        for nInd in range(self.nInd + 1, otherNInd):
+            newRow.append(((nInd,), otherSquared))
+        if self.nInd > 2:
+            turningPointBlock.append(newRow)
+        if self.nDep > 1:
+            turningPointInitialScale = np.append(initialScale, (1.0,) * (self.nDep + 1))
+        else:
+            turningPointInitialScale = np.append(initialScale, (1.0,))
+        
+        # Finally, find the zeros of the system (only the first self.nInd values are of interest).
+        zeros = bspy.spline_block.SplineBlock(turningPointBlock).zeros(epsilon, turningPointInitialScale)
         for uvw in zeros:
             if isinstance(uvw, tuple):
                 abort = True
                 break
+            uvw = uvw[:self.nInd] # Remove any new independent variables added by the turning point system
             d = uvw[0] * cosTheta + uvw[1] * sinTheta 
-            n = self.normal(uvw, False) # Computing all indices of the normal this time
-            wrt = [0] * self.nInd
-            det = 0.0
-            for nInd in range(self.nInd):
-                wrt[nInd] = 1
-                det += turningPointDeterminant.derivative(wrt, uvw) * n[nInd]
-                wrt[nInd] = 0
+            det = np.dot(self.normal(uvw, False), _turning_point_determinant_gradient(self, uvw, cosTheta, sinTheta))
             if abs(det) < epsilon:
                 abort = True
                 break
@@ -540,7 +650,7 @@ def contours(self):
         if not abort:
             break # We're done!
     
-    if attempts <= 0: raise ValueError("No contours. Degenerate equations.")
+    if abort: raise ValueError("No contours. Degenerate equations.")
 
     if not points:
         return [] # No contours
@@ -553,17 +663,14 @@ def contours(self):
     # a panel boundary: u * cosTheta + v * sinTheta = d. Basically, we add this panel boundary plane
     # to the contour condition. We'll define it for d = 0, and add the actual d later.
     # We didn't construct the panel system earlier, because we didn't have theta.
-    panelCoefs = np.empty((self.nDep + 1, *self.coefs.shape[1:]), self.coefs.dtype) # Note that self.nDep + 1 == self.nInd
-    panelCoefs[:self.nDep] = self.coefs
-    # The following value should be -d. We're setting it for d = 0 to start.
-    panelCoefs[self.nDep, 0, 0] = 0.0 
-    degree = self.order[0] - 1
-    for i in range(1, self.nCoef[0]):
-        panelCoefs[self.nDep, i, 0] = panelCoefs[self.nDep, i - 1, 0] + ((self.knots[0][degree + i] - self.knots[0][i]) / degree) * cosTheta
-    degree = self.order[1] - 1
-    for i in range(1, self.nCoef[1]):
-        panelCoefs[self.nDep, :, i] = panelCoefs[self.nDep, :, i - 1] + ((self.knots[1][degree + i] - self.knots[1][i]) / degree) * sinTheta
-    panel = type(self)(self.nInd, self.nInd, self.order, self.nCoef, self.knots, panelCoefs, self.metadata)
+    panelCoefs = np.array((((0.0, sinTheta), (cosTheta, cosTheta + sinTheta)),), self.coefsDtype)
+    panelSpline = bspy.spline.Spline(2, 1, (2, 2), (2, 2), 
+        (np.array((0.0, 0.0, 1.0, 1.0), self.knotsDtype), np.array((0.0, 0.0, 1.0, 1.0), self.knotsDtype)), 
+        panelCoefs)
+    panelBlock = self.block.copy()
+    panelBlock.append([panelSpline])
+    panel = bspy.spline_block.SplineBlock(panelBlock)
+    panelInitialScale = np.append(initialScale, 1.0)
 
     # Okay, we have everything we need to determine the contour topology and points along each contour.
     # We've done the first two steps of Grandine and Klein's algorithm:
@@ -574,10 +681,26 @@ 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.
+    # Remove duplicate points (typically appear at corners).
+    i = 0
+    while i < len(points):
+        previousPoint = points[i]
+        j = i + 1
+        while j < len(points):
+            point = points[j]
+            if point.d < previousPoint.d + epsilon:
+                if np.linalg.norm(point.uvw - previousPoint.uvw) < epsilon:
+                    del points[j]
+                else:
+                    j += 1
+            else:
+                break
+        i += 1
+
     # 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)
@@ -651,11 +774,11 @@ def contours(self):
             # points. Either insert two new contours in the list or delete two existing ones from
             # the list. Go back to Step (5).
             # First, construct panel, whose zeros lie along the panel boundary, u * cosTheta + v * sinTheta - d = 0.
-            panel.coefs[self.nDep] -= point.d
+            panelSpline.coefs = panelCoefs - point.d
 
             if point.turningPoint and point.uvw is None:
                 # For an inserted panel between two consecutive turning points, just find zeros along the panel.
-                panelPoints = panel.zeros()
+                panelPoints = panel.zeros(epsilon, panelInitialScale)
             elif point.turningPoint:
                 # Split panel below and above the known zero point.
                 # This avoids extra computation and the high-zero at the known zero point, while ensuring we match the turning point.
@@ -677,15 +800,15 @@ def contours(self):
                         np.linalg.norm(selfUU * sinTheta * sinTheta - 2.0 * selfUV * sinTheta * cosTheta + selfVV * cosTheta * cosTheta))
                     # Now, we can find the zeros of the split panel, checking to ensure each panel is within bounds first.
                     if point.uvw[0] + sinTheta * offset < 1.0 - epsilon and epsilon < point.uvw[1] - cosTheta * offset:
-                        panelPoints += panel.trim(((point.uvw[0] + sinTheta * offset, 1.0), (0.0, point.uvw[1] - cosTheta * offset)) + ((None, None),) * (self.nInd - 2)).zeros()
+                        panelPoints += panel.trim(((point.uvw[0] + sinTheta * offset, 1.0), (0.0, point.uvw[1] - cosTheta * offset)) + ((None, None),) * (self.nInd - 2)).zeros(epsilon, panelInitialScale)
                         expectedPanelPoints -= len(panelPoints) - 1 # Discount the turning point itself
                     if expectedPanelPoints > 0 and epsilon < point.uvw[0] - sinTheta * offset and point.uvw[1] + cosTheta * offset < 1.0 - epsilon:
-                        panelPoints += panel.trim(((0.0, point.uvw[0] - sinTheta * offset), (point.uvw[1] + cosTheta * offset, 1.0)) + ((None, None),) * (self.nInd - 2)).zeros()
+                        panelPoints += panel.trim(((0.0, point.uvw[0] - sinTheta * offset), (point.uvw[1] + cosTheta * offset, 1.0)) + ((None, None),) * (self.nInd - 2)).zeros(epsilon, panelInitialScale)
             else: # It's an other-boundary point.
                 # Only find extra zeros along the panel if any are expected (> 0 for starting point, > 1 for ending one).
                 expectedPanelPoints = len(currentContourPoints) - (0 if point.det > 0.0 else 1)
                 if expectedPanelPoints > 0:
-                    panelPoints = panel.zeros()
+                    panelPoints = panel.zeros(epsilon, panelInitialScale)
                     panelPoints.sort(key=lambda uvw: np.linalg.norm(point.uvw - uvw)) # Sort by distance from boundary point
                     while len(panelPoints) > expectedPanelPoints:
                         panelPoints.pop(0) # Drop points closest to the boundary point
@@ -693,8 +816,6 @@ def contours(self):
                 else:
                     panelPoints = [point.uvw]
 
-            # Add d back to prepare for next turning point.
-            panel.coefs[self.nDep] += point.d
             # Sort zero points by their position along the panel boundary (using vector orthogonal to its normal).
             panelPoints.sort(key=lambda uvw: uvw[1] * cosTheta - uvw[0] * sinTheta)
             # Go through panel points, adding them to existing contours, creating new ones, or closing old ones.
@@ -781,6 +902,45 @@ def contours(self):
     
     return splineContours
 
+def contours(self):
+    if self.nInd - self.nDep != 1: raise ValueError("The number of free variables (self.nInd - self.nDep) must be one.")
+    epsilon = np.sqrt(np.finfo(self.knotsDtype).eps)
+    evaluationEpsilon = max(np.sqrt(epsilon), np.finfo(self.coefsDtype).eps ** 0.25)
+
+    # Split the splines in the block to ensure C1 continuity within each block
+    blocks = self.split(minContinuity=1).ravel()
+
+    # For each block, find its contours and join them to the contours from previous blocks.
+    contours = []
+    for block in blocks:
+        splineContours = _contours_of_C1_spline_block(block, epsilon, evaluationEpsilon)
+        for newContour in splineContours:
+            newStart = newContour(0.0)
+            newFinish = newContour(1.0)
+            joined = False
+            for i, oldContour in enumerate(contours):
+                oldStart = oldContour(0.0)
+                oldFinish = oldContour(1.0)
+                if np.linalg.norm(newStart - oldFinish) < evaluationEpsilon:
+                    contours[i] = bspy.Spline.join((oldContour, newContour))
+                    joined = True
+                    break
+                if np.linalg.norm(newStart - oldStart) < evaluationEpsilon:
+                    contours[i] = bspy.Spline.join((oldContour, newContour.reverse()))
+                    joined = True
+                    break
+                if np.linalg.norm(newFinish - oldStart) < evaluationEpsilon:
+                    contours[i] = bspy.Spline.join((newContour, oldContour))
+                    joined = True
+                    break
+                if np.linalg.norm(newFinish - oldFinish) < evaluationEpsilon:
+                    contours[i] = bspy.Spline.join((newContour, oldContour.reverse()))
+                    joined = True
+                    break
+            if not joined:
+                contours.append(newContour)
+    return contours
+
 def intersect(self, other):
     intersections = []
     nDep = self.nInd # The dimension of the intersection's range
@@ -850,13 +1010,13 @@ def intersect(self, other):
     
     # Spline-Spline intersection.
     elif isinstance(other, bspy.Spline):
-        # Construct a new spline that represents the intersection.
-        spline = self.subtract(other)
+        # Construct a spline block that represents the intersection.
+        block = bspy.spline_block.SplineBlock([[self, -other]])
 
         # Curve-Curve intersection.
         if nDep == 1:
             # Find the intersection points and intervals.
-            zeros = spline.zeros()
+            zeros = block.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):
@@ -895,28 +1055,27 @@ def intersect(self, other):
         # 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']})")
+                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:
+                contours = block.contours()
+            except ValueError as e:
+                logging.info(e)
                 # 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)
+                block = bspy.spline_block.SplineBlock([[other, -self]])
                 if "Name" in self.metadata and "Name" in other.metadata:
-                    logging.info(f"intersect({other.metadata['Name']}, {self.metadata['Name']})")
-                contours = spline.contours()
+                    logging.info(f"intersect:{other.metadata['Name']}:{self.metadata['Name']}")
+                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))
             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)
@@ -950,7 +1109,7 @@ def complete_slice(self, slice, solid):
     if not slice.boundaries:
         if slice.dimension == 2:
             if "Name" in self.metadata:
-                logging.info(f"check containment: {self.metadata['Name']}")
+                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: