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

bspy/__init__.py

@@ -1,5 +1,5 @@
 """
-bspy is a python library for manipulating and rendering non-uniform b-splines.
+bspy is a python library for manipulating and rendering non-uniform B-splines.
 
 Available subpackages
 ---------------------

bspy/_spline_domain.py

@@ -11,10 +11,11 @@ def clamp(self, left, right):
 
     return self.trim(bounds)
 
-def common_basis(self, splines, indMap):
+def common_basis(splines, indMap):
     # Step 1: Compute the order for each aligned independent variable.
     orders = []
-    splines = (self, *splines)
+    if indMap is None:
+        indMap = [len(splines) * [iInd] for iInd in range(splines[0].nInd)]
     for map in indMap:
         if not(len(map) == len(splines)): raise ValueError("Invalid map")
         order = 0
@@ -161,7 +162,7 @@ def elevate_and_insert_knots(self, m, newKnots):
         # Set new coefs to the elevated zeroth derivative coefficients with variables swapped back.
         coefs = coefs[0].swapaxes(0, ind + 1)
     
-    return type(self)(self.nInd, self.nDep, order, nCoef, knots, coefs, self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, order, nCoef, knots, coefs, self.metadata)
 
 def extrapolate(self, newDomain, continuityOrder):
     if not(len(newDomain) == self.nInd): raise ValueError("Invalid newDomain")
@@ -268,10 +269,10 @@ def extrapolate(self, newDomain, continuityOrder):
         # Swap dependent and independent variables back.
         dCoefs = dCoefs.swapaxes(1, ind + 2) 
 
-    return type(self)(self.nInd, self.nDep, self.order, nCoef, knots, dCoefs[0], self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, self.order, nCoef, knots, dCoefs[0], self.metadata)
 
 def fold(self, foldedInd):
-    if not(0 <= len(foldedInd) < self.nInd): raise ValueError("Invalid foldedInd")
+    if not(0 <= len(foldedInd) <= self.nInd): raise ValueError("Invalid foldedInd")
     foldedOrder = []
     foldedNCoef = []
     foldedKnots = []
@@ -299,8 +300,8 @@ def fold(self, foldedInd):
     foldedCoefs = np.moveaxis(self.coefs, coefficientMoveFrom, coefficientMoveTo).reshape((foldedNDep, *foldedNCoef))
     coefficientlessCoefs = np.empty((0, *coefficientlessNCoef), self.coefs.dtype)
 
-    foldedSpline = type(self)(len(foldedOrder), foldedNDep, foldedOrder, foldedNCoef, foldedKnots, foldedCoefs, self.accuracy, self.metadata)
-    coefficientlessSpline = type(self)(len(coefficientlessOrder), 0, coefficientlessOrder, coefficientlessNCoef, coefficientlessKnots, coefficientlessCoefs, self.accuracy, self.metadata)
+    foldedSpline = type(self)(len(foldedOrder), foldedNDep, foldedOrder, foldedNCoef, foldedKnots, foldedCoefs, self.metadata)
+    coefficientlessSpline = type(self)(len(coefficientlessOrder), 0, coefficientlessOrder, coefficientlessNCoef, coefficientlessKnots, coefficientlessCoefs, self.metadata)
     return foldedSpline, coefficientlessSpline
 
 def insert_knots(self, newKnots):
@@ -327,7 +328,7 @@ def insert_knots(self, newKnots):
     if self.coefs is coefs:
         return self
     else: 
-        return type(self)(self.nInd, self.nDep, self.order, coefs.shape[1:], knots, coefs, self.accuracy, self.metadata)
+        return type(self)(self.nInd, self.nDep, self.order, coefs.shape[1:], knots, coefs, self.metadata)
 
 def join(splineList):
     # Make sure all the splines in the list are curves
@@ -364,7 +365,7 @@ def join(splineList):
         newKnots = [list(workingSpline.knots[0]) + list(spl.knots[0][maxOrder:])]
         newCoefs = [list(workingCoefs) + list(splCoefs) for workingCoefs, splCoefs in zip(workingSpline.coefs, spl.coefs)]
         workingSpline = type(workingSpline)(1, numDep, workingSpline.order, [workingSpline.nCoef[0] + spl.nCoef[0]],
-                                            newKnots, newCoefs, max(workingSpline.accuracy, spl.accuracy), workingSpline.metadata)
+                                            newKnots, newCoefs, workingSpline.metadata)
     return workingSpline.reparametrize([[0.0, 1.0]]).remove_knots()
 
 def remove_knot(self, iKnot):
@@ -377,7 +378,7 @@ def remove_knot(self, iKnot):
     myKnots = self.knots[0]
     thisKnot = myKnots[iKnot]
 
-    # Form the bidiagonal system
+    # Form the bi-diagonal system
     for ix in range(1, myOrder):
         alpha = (myKnots[iKnot + ix] - thisKnot) / (myKnots[iKnot + ix] - myKnots[iKnot + ix - myOrder])
         diag0.append(alpha)
@@ -470,7 +471,7 @@ def reparametrize(self, newDomain):
             for i in range(1-order, 0):
                 knots[i] = max(knots[i], nD[1])
         knotList.append(knots)
-    return type(self)(self.nInd, self.nDep, self.order, self.nCoef, knotList, self.coefs, self.accuracy, self.metadata)   
+    return type(self)(self.nInd, self.nDep, self.order, self.nCoef, knotList, self.coefs, self.metadata)   
 
 def reverse(self, variable = 0):
     # Check to make sure variable is in range
@@ -488,8 +489,8 @@ def reverse(self, variable = 0):
     newCoefs = []
     for iDep in range(folded.nDep):
         newCoefs.append(self.coefs[iDep][::-1])
-    newfolded = type(self)(folded.nInd, folded.nDep, folded.order, folded.nCoef, (newKnots,), newCoefs, folded.accuracy, folded.metadata)
-    return newfolded.unfold(myIndices, basisInfo)
+    newFolded = type(self)(folded.nInd, folded.nDep, folded.order, folded.nCoef, (newKnots,), newCoefs, folded.metadata)
+    return newFolded.unfold(myIndices, basisInfo)
 
 def transpose(self, axes=None):
     if axes is None:
@@ -503,7 +504,7 @@ def transpose(self, axes=None):
         nCoef.append(self.nCoef[axis])
         knots.append(self.knots[axis])
         coefAxes.append(axis + 1)
-    return type(self)(self.nInd, self.nDep, order, nCoef, knots, np.transpose(self.coefs, coefAxes), self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, order, nCoef, knots, np.transpose(self.coefs, coefAxes), self.metadata)
 
 def trim(self, newDomain):
     if not(len(newDomain) == self.nInd): raise ValueError("Invalid newDomain")
@@ -552,7 +553,7 @@ def trim(self, newDomain):
         coefIndex.append(slice(leftIndex, rightIndex))
     coefs = spline.coefs[tuple(coefIndex)]
 
-    return type(spline)(spline.nInd, spline.nDep, spline.order, coefs.shape[1:], knotsList, coefs, spline.accuracy, spline.metadata)
+    return type(spline)(spline.nInd, spline.nDep, spline.order, coefs.shape[1:], knotsList, coefs, spline.metadata)
 
 def unfold(self, foldedInd, coefficientlessSpline):
     if not(len(foldedInd) == coefficientlessSpline.nInd): raise ValueError("Invalid coefficientlessSpline")
@@ -582,5 +583,5 @@ def unfold(self, foldedInd, coefficientlessSpline):
     coefficientMoveFrom = range(1, coefficientlessSpline.nInd + 1)
     unfoldedCoefs = np.moveaxis(self.coefs.reshape(unfoldedNDep, *coefficientlessSpline.nCoef, *self.nCoef), coefficientMoveFrom, coefficientMoveTo)
 
-    unfoldedSpline = type(self)(len(unfoldedOrder), unfoldedNDep, unfoldedOrder, unfoldedNCoef, unfoldedKnots, unfoldedCoefs, self.accuracy, self.metadata)
+    unfoldedSpline = type(self)(len(unfoldedOrder), unfoldedNDep, unfoldedOrder, unfoldedNCoef, unfoldedKnots, unfoldedCoefs, self.metadata)
     return unfoldedSpline

bspy/_spline_evaluation.py

@@ -62,19 +62,23 @@ def curvature(self, uv):
             self = self.graph()
         fp = self.derivative([1], uv)
         fpp = self.derivative([2], uv)
-        fpdotfp = fp @ fp
-        fpdotfpp = fp @ fpp
-        denom = fpdotfp ** 1.5
+        fpDotFp = fp @ fp
+        fpDotFpp = fp @ fpp
+        denom = fpDotFp ** 1.5
         if self.nDep == 2:
-            numer = fp[0] * fpp[1] - fp[1] * fpp[0]
+            numerator = fp[0] * fpp[1] - fp[1] * fpp[0]
         else:
-            numer = np.sqrt((fpp @ fpp) * fpdotfp - fpdotfpp ** 2)
-        return numer / denom 
+            numerator = np.sqrt((fpp @ fpp) * fpDotFp - fpDotFpp ** 2)
+        return numerator / denom 
 
 def derivative(self, with_respect_to, uvw):
     # Make work for scalar valued functions
     uvw = np.atleast_1d(uvw)
 
+    # Check for the correct number of independent variables
+    if len(uvw) != self.nInd:
+        raise ValueError(f"Incorrect number of parameter values: {len(uvw)}")
+
     # Check for evaluation point inside domain
     dom = self.domain()
     for ix in range(self.nInd):
@@ -104,6 +108,10 @@ def evaluate(self, uvw):
     # Make work for scalar valued functions
     uvw = np.atleast_1d(uvw)
 
+    # Check for the correct number of independent variables
+    if len(uvw) != self.nInd:
+        raise ValueError(f"Incorrect number of parameter values: {len(uvw)}")
+
     # Check for evaluation point inside domain
     dom = self.domain()
     for ix in range(self.nInd):

bspy/_spline_fitting.py

@@ -10,6 +10,17 @@ def circular_arc(radius, angle, tolerance = None):
     samples = int(max(np.ceil(((1.1536e-5 * radius / tolerance)**(1/8)) * angle / 90), 2.0)) + 1
     return bspy.Spline.section([(radius * np.cos(u * angle * np.pi / 180), radius * np.sin(u * angle * np.pi / 180), 90 + u * angle, 1.0 / radius) for u in np.linspace(0.0, 1.0, samples)])
 
+def cone(radius1, radius2, height, tolerance = None):
+    if tolerance is None:
+        tolerance = 1.0e-12
+    bigRadius = max(radius1, radius2)
+    radius1 /= bigRadius
+    radius2 /= bigRadius
+    bottom = [[1.0, 0.0], [0.0, 1.0], [0.0, 0.0]] @ bspy.Spline.circular_arc(bigRadius, 360.0, tolerance)
+    top = radius2 * bottom + [0.0, 0.0, height]
+    bottom = radius1 * bottom
+    return bspy.Spline.ruled_surface(bottom, top)
+
 # Courtesy of Michael Epton - Translated from his F77 code lgnzro
 def _legendre_polynomial_zeros(degree):
     def legendre(degree, x):
@@ -271,11 +282,18 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
 
     # Rescale x(t) back to original data points.
     coefs = (coefsMin + coefs.T * coefsMaxMinusMin).T
-    spline = bspy.Spline(1, nDep, (order,), (nCoef,), (knots,), coefs, epsilon, metadata)
+    spline = bspy.Spline(1, nDep, (order,), (nCoef,), (knots,), coefs, metadata)
     if isinstance(F, bspy.Spline):
         spline = spline.confine(F.domain())
     return spline
 
+def cylinder(radius, height, tolerance = None):
+    if tolerance is None:
+        tolerance = 1.0e-12
+    bottom = [[1.0, 0.0], [0.0, 1.0], [0.0, 0.0]] @ bspy.Spline.circular_arc(radius, 360.0, tolerance)
+    top = bottom + [0.0, 0.0, height]
+    return bspy.Spline.ruled_surface(bottom, top)
+
 def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     if bottom.nInd != 1 or right.nInd != 1 or top.nInd != 1 or left.nInd != 1:
         raise ValueError("Input curves must have one independent variable")
@@ -328,7 +346,7 @@ def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     biLinear = bspy.Spline.ruled_surface(bottomLine, topLine)
     coons = bottomTop.add(leftRight, ((0,1), (1,0))) - biLinear
 
-    # Determine the Greville absiccae to use as collocation points
+    # Determine the Greville abscissae to use as collocation points
 
     uPts = coons.greville(0)[1 : -1]
     vPts = coons.greville(1)[1 : -1]
@@ -365,143 +383,153 @@ def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     
     return (1.0 - surfParam) * coons + surfParam * laplace
 
-def least_squares(nInd, nDep, order, dataPoints, knotList = None, compression = 0, metadata = {}):
-    if not(nInd >= 0): raise ValueError("nInd < 0")
-    if not(nDep >= 0): raise ValueError("nDep < 0")
-    if not(len(order) == nInd): raise ValueError("len(order) != nInd")
-    if not(0 <= compression < 100): raise ValueError("compression not between 0 and 99")
-    totalOrder = 1
-    for ord in order:
-        totalOrder *= ord
-
-    totalDataPoints = len(dataPoints)
-    for point in dataPoints:
-        if not(len(point) == nInd + nDep or len(point) == nInd + nDep * (nInd + 1)): raise ValueError(f"Data points do not have {nInd + nDep} values")
-        if len(point) == nInd + nDep * (nInd + 1):
-            totalDataPoints += nInd
-
-    if knotList is None:
-        # Compute the target number of coefficients and the actual number of samples in each independent variable.
-        targetTotalCoef = len(dataPoints) * (100 - compression) / 100.0
-        totalCoef = 1
-        knotSamples = np.array([point[:nInd] for point in dataPoints], type(dataPoints[0][0])).T
-        knotList = []
-        for knotSample in knotSamples:
-            knots = np.unique(knotSample)
-            knotList.append(knots)
-            totalCoef *= len(knots)
-        
-        # Scale the number of coefficients for each independent variable so that the total closely matches the target.
-        scaling = min((targetTotalCoef / totalCoef) ** (1.0 / nInd), 1.0)
-        nCoef = []
-        totalCoef = 1
-        for knots in knotList:
-            nCf = int(math.ceil(len(knots) * scaling))
-            nCoef.append(nCf)
-            totalCoef *= nCf
-        
-        # Compute "ideal" knots for each independent variable, based on the number of coefficients and the sample values.
-        # Piegl, Les A., and Wayne Tiller. "Surface approximation to scanned data." The visual computer 16 (2000): 386-395.
-        newKnotList = []
-        for iInd, ord, nCf, knots in zip(range(nInd), order, nCoef, knotList):
-            degree = ord - 1
-            newKnots = [knots[0]] * ord
-            inc = len(knots)/nCf
-            low = 0
-            d = -1
-            w = np.empty((nCf,), float)
-            for i in range(nCf):
-                d += inc
-                high = int(d + 0.5 + 1) # Paper's algorithm sets high to d + 0.5, but only references high + 1
-                w[i] = np.mean(knots[low:high])
-                low = high
-            for i in range(1, nCf - degree):
-                newKnots.append(np.mean(w[i:i + degree]))
-            newKnots += [knots[-1]] * ord
-            newKnotList.append(np.array(newKnots, knots.dtype))
-        knotList = newKnotList
+def least_squares(uValues, dataPoints, order = None, knots = None, compression = 0.0,
+                  tolerance = None, fixEnds = False, metadata = {}):
+
+    # Preprocess all the input if everything is a spline
+    
+    dataPoints = np.array(dataPoints)
+    flatView = np.ravel(dataPoints)
+    splineInput = False
+    if type(flatView[0]) is bspy.Spline:
+        splineInput = True
+        nInd = flatView[0].nInd
+        nDep = flatView[0].nDep
+        splineDomain = flatView[0].domain()
+        for spline in flatView:
+            if spline.nInd != nInd:  raise ValueError("Input splines have different number of independent variables")
+            if spline.nDep != nDep:  raise ValueError("Input splines have different number of dependent variables")
+            if not np.array_equal(spline.domain(), splineDomain):  raise ValueError("Input splines have different domains")
+        commonSplines = bspy.Spline.common_basis(flatView)
+        foldedData = []
+        for spline in commonSplines:
+            folded, unfoldInfo = spline.fold(list(range(nInd)))
+            foldedData.append(folded())
+        foldedData = np.array(foldedData).T
+        dataPoints = np.reshape(foldedData, (foldedData.shape[0],) + dataPoints.shape)
+
+    # Preprocess the parameters values for the points
+
+    if np.isscalar(uValues[0]):
+        nInd = 1
+        uValues = [uValues]
     else:
-        if not(len(knotList) == nInd): raise ValueError("len(knots) != nInd") # The documented interface uses the argument 'knots' instead of 'knotList'
-        nCoef = [len(knotList[i]) - order[i] for i in range(nInd)]
-        totalCoef = 1
-        newKnotList = []
-        for knots, ord, nCf in zip(knotList, order, nCoef):
-            for i in range(nCf):
-                if not(knots[i] <= knots[i + 1] and knots[i] < knots[i + ord]): raise ValueError("Improperly ordered knot sequence")
-            totalCoef *= nCf
-            newKnotList.append(np.array(knots))
-        if not(totalCoef <= totalDataPoints): raise ValueError(f"Insufficient number of data points. You need at least {totalCoef}.")
-        knotList = newKnotList
+        nInd = len(uValues)
+    domain = []
+    for iInd in range(nInd):
+        uMin = np.min(uValues[iInd])
+        uMax = np.max(uValues[iInd])
+        domain.append([uMin, uMax])
+        for i in range(len(uValues[iInd]) - 1):
+            if uValues[iInd][i] > uValues[iInd][i + 1]:  raise ValueError("Independent variable values are out of order")
     
-    # Initialize A and b from the likely overdetermined equation, A x = b, where A contains the bspline values at the independent variables,
-    # b contains point values for the dependent variables, and the x contains the desired coefficients.
-    A = np.zeros((totalDataPoints, totalCoef), type(dataPoints[0][0]))
-    b = np.empty((totalDataPoints, nDep), A.dtype)
-
-    # Fill in the bspline values in A and the dependent point values in b at row at a time.
-    # Note that if a data point also specifies first derivatives, it fills out nInd + 1 rows (the point and its derivatives).
-    row = 0
-    for point in dataPoints:
-        hasDerivatives = len(point) == nInd + nDep * (nInd + 1)
-
-        # Compute the bspline values (and their first derivatives as needed).
-        bValueData = []
-        for knots, ord, nCf, u in zip(knotList, order, nCoef, point[:nInd]):
-            ix = np.searchsorted(knots, u, 'right')
-            ix = min(ix, nCf)
-            bValueData.append((ix, bspy.Spline.bspline_values(ix, knots, ord, u), \
-                bspy.Spline.bspline_values(ix, knots, ord, u, 1) if hasDerivatives else None))
-        
-        # Compute the values for the A array.
-        # It's a little tricky because we have to multiply nInd different bspline arrays of different sizes
-        # and index into flattened A array. The solution is to loop through the total number of entries
-        # being changed (totalOrder), and compute the array indices via mods and multiplies.
-        indices = [0] * nInd
-        for i in range(totalOrder):
-            column = 0
-            bValues = np.ones((nInd + 1,), A.dtype)
-            for j, ord, nCf, index, (ix, values, dValues) in zip(range(1, nInd + 1), order, nCoef, indices, bValueData):
-                column = column * nCf + ix - ord + index
-                # Compute the bspline value for this specific element of A.
-                bValues[0] *= values[index]
-                if hasDerivatives:
-                    # Compute the first derivative values for each independent variable.
-                    for k in range(1, nInd + 1):
-                        bValues[k] *= dValues[index] if k == j else values[index]
-
-            # Assign all the values and derivatives.
-            A[row, column] = bValues[0]
-            if hasDerivatives:
-                for k in range(1, nInd + 1):
-                    A[row + k, column] = bValues[k]
-
-            # Increment the bspline indices.
-            for j in range(nInd - 1, -1, -1):
-                indices[j] = (indices[j] + 1) % order[j]
-                if indices[j] > 0:
-                    break
+    # Preprocess the data points
 
-        # Assign values for the b array.
-        b[row, :] = point[nInd:nInd + nDep]
-        if hasDerivatives:
-            for k in range(1, nInd + 1):
-                b[row + k, :] = point[nInd + nDep * k:nInd + nDep * (k + 1)]
+    if len(dataPoints.shape) != nInd + 1:  raise ValueError("dataPoints has the wrong shape")
+    nDep = dataPoints.shape[0]
+    pointsPerDirection = list(dataPoints.shape)[1:]
+    nPoints = 1
+    for i, nu in enumerate(pointsPerDirection):
+        if nu != len(uValues[i]):  raise ValueError("Wrong number of parameter values in one or more directions")
+        nPoints *= nu
 
-        # Increment the row before filling in the next data point
-        row += nInd + 1 if hasDerivatives else 1
-    
-    # Yay, the A and b arrays are ready to solve.
-    # Now, we call numpy's least squares solver.
-    coefs, residuals, rank, s = np.linalg.lstsq(A, b, rcond=None)
+    # Make sure the order makes sense
+
+    if order is None:
+        order = [min(4, nu) for nu in pointsPerDirection]
+    for nP, nOrder in zip(pointsPerDirection, order):
+        if nP < nOrder:  raise ValueError("Not enough points in one or more directions")
+
+    # Determine the (initial) knots array
 
-    # Reshape the coefs array to match nCoef (un-flatten) and move the dependent variables to the front.
-    coefs = np.moveaxis(coefs.reshape((*nCoef, nDep)), -1, 0)
+    if not(0.0 <= compression <= 1.0):  raise ValueError("compression not between 0.0 and 1.0")
+    if tolerance is None:
+        tolerance = np.finfo(float).max
+    else:
+        compression = 1.0
+    if knots is None:
+        knots = [np.array(order[iInd] * [domain[iInd][0]] + order[iInd] * [domain[iInd][1]]) for iInd in range(nInd)]
+        for iInd, (nP, nOrder) in enumerate(zip(pointsPerDirection, order)):
+            knotsToAdd = int((nP - nOrder) * (1.0 - compression) + 0.9999999999)
+            addSpots = np.linspace(0.0, nP - 1.0, knotsToAdd + 2)[1 : -1]
+            newKnots = []
+            for newSpot in addSpots:
+                ix = int(newSpot)
+                alpha = newSpot - ix
+                newKnots.append((1.0 - alpha) * uValues[iInd][ix] + alpha * uValues[iInd][ix + 1])
+            knots[iInd] = np.sort(np.append(knots[iInd], newKnots))
+    else:
+        knots = tuple(np.array(kk) for kk in knots)
+    for iInd in range(nInd):
+        if domain[iInd][0] < knots[iInd][order[iInd] - 1] or \
+           domain[iInd][1] > knots[iInd][-order[iInd]]:  raise ValueError("One or more dataPoints are outside the domain of the spline")
 
-    # Return the resulting spline, computing the accuracy based on system epsilon and the norm of the residuals.
-    maxError = np.finfo(coefs.dtype).eps
-    if residuals.size > 0:
-        maxError = max(maxError, residuals.sum())
-    return bspy.Spline(nInd, nDep, order, nCoef, knotList, coefs, np.sqrt(maxError), metadata)
+    # Loop through each independent variable and fit all of the data
+    
+    for iInd in range(nInd):
+        nRows = pointsPerDirection[iInd]
+        b = np.swapaxes(dataPoints, 0, iInd + 1)
+        loopDep = nDep * nPoints // nRows
+        b = np.reshape(b, (nRows, loopDep))
+        done = False
+        while not done:
+            nCols = len(knots[iInd]) - order[iInd]
+            A = np.zeros((nRows, nCols))
+            u = -np.finfo(float).max
+            fixedRows = []
+            for iRow in range(nRows):
+                uNew = uValues[iInd][iRow]
+                if uNew != u:
+                    iDerivative = 0
+                    u = uNew
+                    ix = np.searchsorted(knots[iInd], u, 'right')
+                    ix = min(ix, nCols)
+                else:
+                    iDerivative += 1
+                row = bspy.Spline.bspline_values(ix, knots[iInd], order[iInd], u, iDerivative)
+                A[iRow, ix - order[iInd] : ix] = row
+                if fixEnds and (u == uValues[iInd][0] or u == uValues[iInd][-1]):
+                    fixedRows.append(iRow)
+            nInterpolationConditions = len(fixedRows)
+            if nInterpolationConditions != 0:
+                C = np.take(A, fixedRows, 0)
+                d = np.take(b, fixedRows, 0)
+                AUse = np.delete(A, fixedRows, 0)
+                bUse = np.delete(b, fixedRows, 0)
+                U, Sigma, VT = np.linalg.svd(C)
+                d = U.T @ d
+                for iRow in range(nInterpolationConditions):
+                    d[iRow] = d[iRow] / Sigma[iRow]
+                rangeCols = np.take(VT.T, range(nInterpolationConditions), 1)
+                nullspace = np.delete(VT.T, range(nInterpolationConditions), 1)
+                x1 = rangeCols @ d
+                b1 = bUse - AUse @ x1
+                xNullspace, residuals, rank, s = np.linalg.lstsq(AUse @ nullspace, b1, rcond = None)
+                x = x1 + nullspace @ xNullspace
+            else:
+                x, residuals, rank, s = np.linalg.lstsq(A, b, rcond = None)
+            residuals = b - A @ x
+            maxError = 0.0
+            for iRow in range(nRows):
+                rowError = np.linalg.norm(residuals[iRow, :])
+                if rowError > maxError:
+                    maxError = rowError
+                    maxRow = iRow
+            if maxError <= tolerance / nInd:
+                done = True
+            else:
+                ix = np.searchsorted(knots[iInd], uValues[iInd][maxRow], 'right')
+                ix = min(ix, nCols)
+                knots[iInd] = np.sort(np.append(knots[iInd], 0.5 * (knots[iInd][ix - 1] + knots[iInd][ix])))
+        pointsPerDirection[iInd] = nDep
+        x = np.reshape(x, [nCols] + pointsPerDirection)
+        dataPoints = np.swapaxes(x, 0, iInd + 1)
+        pointsPerDirection[iInd] = nCols
+        nPoints = nCols * nPoints // nRows
+    splineFit = bspy.Spline(nInd, nDep, order, pointsPerDirection, knots, dataPoints, metadata = metadata)
+    if splineInput:
+        splineFit = splineFit.unfold(range(unfoldInfo.nInd), unfoldInfo)
+    return splineFit
 
 def line(startPoint, endPoint):
     startPoint = bspy.Spline.point(startPoint)
@@ -528,14 +556,15 @@ def ruled_surface(curve1, curve2):
     # Ensure that the splines are compatible
     if curve1.nInd != curve2.nInd:  raise ValueError("Splines must have the same number of independent variables")
     if curve1.nDep != curve2.nDep:  raise ValueError("Splines must have the same number of dependent variables")
-    indMap = [(ix, ix) for ix in range(curve1.nInd)]
-    [newCurve1, newCurve2] = curve1.common_basis([curve2], indMap)
+    [newCurve1, newCurve2] = bspy.Spline.common_basis([curve1, curve2])
 
     # Generate the ruled spline between them
+    myCoefs1 = np.reshape(newCurve1.coefs, newCurve1.coefs.shape + (1,))
+    myCoefs2 = np.reshape(newCurve2.coefs, newCurve2.coefs.shape + (1,))
+    newCoefs = np.append(myCoefs1, myCoefs2, newCurve1.nInd + 1)
     return bspy.Spline(curve1.nInd + 1, curve1.nDep, list(newCurve1.order) + [2],
                        list(newCurve1.nCoef) + [2], list(newCurve1.knots) + [[0.0, 0.0, 1.0, 1.0]],
-                       [np.array([coef1, coef2]).T for coef1, coef2 in zip(newCurve1.coefs, newCurve2.coefs)],
-                       accuracy = max(newCurve1.accuracy, newCurve2.accuracy))
+                       newCoefs)
 
 def section(xytk):    
     def twoPointSection(startPointX, startPointY, startAngle, startKappa, endPointX, endPointY, endAngle, endKappa):

bspy/_spline_intersection.py

@@ -522,9 +522,9 @@ 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 = self.common_basis((turningPointDeterminant,), [(nInd, nInd) for nInd in range(self.nInd)])
+        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.accuracy, systemSelf.metadata)
+            np.concatenate((systemSelf.coefs, systemTurningPointDeterminant.coefs)), systemSelf.metadata)
         zeros = system.zeros()
         for uvw in zeros:
             if isinstance(uvw, tuple):
@@ -566,7 +566,7 @@ def contours(self):
     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.accuracy, self.metadata)
+    panel = type(self)(self.nInd, self.nInd, self.order, self.nCoef, self.knots, panelCoefs, self.metadata)
 
     # 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: