bspy 4.2__py3-none-any.whl → 4.4__py3-none-any.whl

bspy/_spline_intersection.py

@@ -126,104 +126,83 @@ def zeros_using_interval_newton(self):
             return mySolution
     return refine(spline, 1.0, 1.0)
 
-def _convex_hull_2D(xData, yData, yBounds, yOtherBounds, 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 = yOtherBounds[0] + 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
-    additionalPoint = yOtherBounds[1] > yOtherBounds[0] + epsilon
-
-    # 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(yOtherBounds[0] + y - y0, x - x0), x, yOtherBounds[0] + y))
-        if additionalPoint:
-            sortedPoints.append((math.atan2(yOtherBounds[1] + y - y0, x - x0), x, yOtherBounds[1] + 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]))
+        return [xMin, xMax]
 
-Interval = namedtuple('Interval', ('block', 'unknowns', 'scale', 'bounds', 'slope', 'intercept', 'epsilon', 'atMachineEpsilon'))
+Interval = namedtuple('Interval', ('block', 'active', 'split', 'scale', 'bounds', 'xLeft', 'xRight', 'epsilon', 'atMachineEpsilon'))
 
-def _create_interval(domain, block, unknowns, scale, slope, intercept, epsilon):
+def _create_interval(block, active, split, scale, xLeft, xRight, epsilon):
     nDep = 0
-    bounds = np.zeros((len(scale), 2), scale.dtype)
+    nInd = len(scale)
+    bounds = np.zeros((nInd, 2), scale.dtype)
     newScale = np.empty_like(scale)
     newBlock = []
     for row in block:
         newRow = []
-        nInd = 0
-        keepDep = []
-        # Trim and reparametrize splines, and sum bounds.
-        for spline in row:
-            spline = spline.trim(domain[nInd:nInd + spline.nInd]).reparametrize(((0.0, 1.0),) * spline.nInd)
+        # 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()
-            nInd += spline.nInd
-            newRow.append(spline)
+            newRow.append((map, spline))
+        newBlock.append(newRow)
 
         # Check row bounds for potential roots.
         for dep in range(spline.nDep):
@@ -232,30 +211,21 @@ def _create_interval(domain, block, unknowns, scale, slope, intercept, epsilon):
             if coefsMax < -epsilon or coefsMin > epsilon:
                 # No roots in this interval.
                 return None
-            if coefsMin < -epsilon or coefsMax > epsilon:
-                # Dependent variable not near zero for entire interval.
-                keepDep.append(dep)
-                newScale[nDep] = max(-coefsMin, coefsMax)
-                # Rescale spline coefficients to max 1.0.
-                rescale = 1.0 / max(-bounds[nDep, 0], bounds[nDep, 1])
-                for spline in newRow:
-                    spline.coefs[dep] *= rescale
-                bounds[nDep] *= rescale
-                nDep += 1
-            else:
-                # Dependent variable near zero for entire interval.
-                bounds = np.delete(bounds, nDep, 0)
-                scale = np.delete(scale, nDep, 0)
-        
-        if keepDep:
-            # Remove dependent variables that are zero over the domain
-            for spline in newRow:
-                spline.nDep = len(keepDep)
-                spline.coefs = spline.coefs[keepDep]
-
-            newBlock.append(newRow)
-
-    return Interval(newBlock, unknowns, newScale[:nDep], bounds, slope, intercept, epsilon, np.dot(slope, slope) < np.finfo(slope.dtype).eps)
+            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):
@@ -264,135 +234,100 @@ def _refine_projected_polyhedron(interval):
     roots = []
     intervals = []
     
-    # Loop through each independent variable to determine a tighter domain around roots.
-    # The interval block's remaining number of independent variables (nInd) is len(interval.unknowns).
-    # The interval block's remaining number of dependent variables (nDep) is len(interval.scale).
-    domain = []
-    for nInd in range(len(interval.unknowns)):
-        # Loop through each dependent variable to compute the interval containing the root for this independent variable.
-        xInterval = (0.0, 1.0)
-        nDep = 0
-        for row in interval.block:
-            rowInd = 0
-            order = 0
-            for spline in row:
-                if rowInd <= nInd < rowInd + spline.nInd:
-                    order = spline.order[nInd - rowInd]
-                    nCoef = spline.nCoef[nInd - rowInd]
-                    knots = spline.knots[nInd - rowInd]
-                    # Move independent variable to the last (fastest) axis, adding 1 to account for the dependent variables.
-                    coefs = np.moveaxis(spline.coefs, nInd - rowInd + 1, -1)
-                    break
-                rowInd += spline.nInd
+    # 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 contains this independent variable.
-            if order < 1:
-                continue
+        # 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
+        # Compute the coefficients for f(x) = x for the independent variable and its knots.
+        xData = spline.greville(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]):
+            # 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
             
-            # 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, yBounds - ySplineBounds, epsilon)
-                if hull 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)
-                if xInterval 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)
+            if xInterval is None:
+                return roots, intervals
             
-            nDep += spline.nDep
-        
-        domain.append(xInterval)
+        nDep += spline.nDep
     
-    # Compute new slope, intercept, and unknowns.
-    domain = np.array(domain, interval.slope.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
+    # 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 matrix as needed.
-    if newDomain.shape[1] < domain.shape[1]:
-        for row in interval.block:
-            rowInd = 0
-            for i, spline in enumerate(row):
-                row[i] = spline.contract(uvw[rowInd:rowInd + spline.nInd])
-                rowInd += spline.nInd
-
-    # Special case optimization: Use interval newton for one-dimensional splines.
-    if nInd == 1 and nDep == 1 and len(interval.block[0]) == 1:
-        spline = interval.block[0][0]
-        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 enumerate(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]
-        newInterval = _create_interval(domain.T, interval.block, newUnknowns, interval.scale, splitSlope, splitIntercept, epsilon)
+        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((newInterval.intercept + 0.5 * newInterval.slope, 0.5 * np.linalg.norm(newInterval.slope)))
+                roots.append((0.5 * (newInterval.xLeft + newInterval.xRight),
+                              0.5 * np.linalg.norm(newInterval.xRight - newInterval.xLeft)))
   
     return roots, intervals
 
@@ -417,27 +352,22 @@ def zeros_using_projected_polyhedron(self, epsilon=None, initialScale=None):
     # Set initial interval.
     domain = self.domain().T
     initialScale = np.full(self.nDep, 1.0, self.coefsDtype) if initialScale is None else np.array(initialScale, self.coefsDtype)
-    newInterval = _create_interval(domain.T, self.block, [*range(self.nInd)], initialScale, domain[1] - domain[0], domain[0], epsilon)
+    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((newInterval.intercept + 0.5 * newInterval.slope, 0.5 * np.linalg.norm(newInterval.slope)))
-    chunkSize = 8
-    #pool = Pool() # Pool size matches CPU count
+            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 = []
@@ -446,17 +376,33 @@ def zeros_using_projected_polyhedron(self, epsilon=None, initialScale=None):
         rootCenter = root[0]
         rootRadius = root[1]
 
-        # Ensure we have a real root (not a boundary special case).
+        # Take one Newton step on each root
         value = self.evaluate(rootCenter)
-        if np.linalg.norm(value) >= evaluationEpsilon:
+        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 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
@@ -490,6 +436,34 @@ 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
+    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'))
 
@@ -505,18 +479,14 @@ def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
     self = self.reparametrize(((0.0, 1.0),) * self.nInd)
 
     # Rescale self in all dimensions.
-    nDep = 0
     initialScale = np.max(np.abs(bounds), axis=1)
     rescale = np.reciprocal(initialScale)
+    nDep = 0
     for row in self.block:
-        nInd = 0
-        for spline in row:
-            for coefs, scale in zip(spline.coefs, rescale):
+        for map, spline in row:
+            for coefs, scale in zip(spline.coefs, rescale[nDep:nDep + spline.nDep]):
                 coefs *= scale
         nDep += spline.nDep
-    
-    # Construct self's normal.
-    normal = self.normal_spline((0, 1)) # We only need the first two indices
 
     # 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):
@@ -525,9 +495,6 @@ def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
         sinTheta = np.sin(theta)
         abort = False
 
-        # 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(epsilon, initialScale)
@@ -538,8 +505,8 @@ def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
                     break
                 uvw = np.insert(np.array(zero), nInd, boundary)
                 d = uvw[0] * cosTheta + uvw[1] * sinTheta
-                n = normal(uvw)
-                tpd = 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
@@ -603,21 +570,79 @@ def _contours_of_C1_spline_block(self, epsilon, evaluationEpsilon):
             continue # Try a different theta
 
         # Find turning points by combining self and turningPointDeterminant into a system and processing its 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()
-        turningPointBlock.append([turningPointDeterminant])
-        zeros = bspy.spline_block.SplineBlock(turningPointBlock).zeros(epsilon, np.append(initialScale, 1.0))
+        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
@@ -883,22 +908,9 @@ def contours(self):
     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]
-    for i, row in enumerate(self.block):
-        for j, spline in enumerate(row):
-            splines = spline.split(minContinuity = 1)
-            if splines.size == 1 and self.size == 1:
-                break # Special case of a block with one C1 spline 
-            newBlocks = []
-            for spline in splines.ravel():
-                for block in blocks:
-                    newBlock = block.block.copy()
-                    newRow = newBlock[i].copy()
-                    newBlock[i] = newRow
-                    newRow[j] = spline
-                    newBlocks.append(bspy.spline_block.SplineBlock(newBlock))
-            blocks = newBlocks
+    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)
@@ -946,6 +958,8 @@ def intersect(self, other):
             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) and zero[1] - zero[0] < Manifold.minSeparation:
+                    zero = 0.5 * (zero[0] + zero[1])
                 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))
@@ -1007,6 +1021,8 @@ def intersect(self, other):
             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) and zero[1] - zero[0] < Manifold.minSeparation:
+                    zero = 0.5 * (zero[0] + zero[1])
                 if isinstance(zero, tuple):
                     # Intersection is an interval, so create a Manifold.Coincidence.
 
@@ -1123,14 +1139,14 @@ def complete_slice(self, slice, solid):
             newBoundary.touched = False
 
         # Define function for adding slice points to full domain boundaries.
-        def process_domain_point(boundary, domainPoint):
+        def process_domain_point(boundary, domainPoint, adjustment):
             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))
+                    # 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.touched = True
                     break
@@ -1139,9 +1155,9 @@ def complete_slice(self, slice, solid):
         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)
+            process_domain_point(boundary, domainBoundaries[0].manifold._point, Manifold.minSeparation)
             if len(domainBoundaries) > 1:
-                process_domain_point(boundary, domainBoundaries[-1].manifold._point)
+                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.
         boundaryWasTouched = False
@@ -1149,7 +1165,6 @@ def complete_slice(self, slice, solid):
             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 \