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

bspy/__init__.py

@@ -12,6 +12,8 @@ Available subpackages
 `bspy.spline` : Provides the `Spline` subclass of `Manifold` that models, represents, and processes 
     piecewise polynomial tensor product functions (spline functions) as linear combinations of B-splines.
 
+`bspy.spline_block` : Provides the `SplineBlock` class that represents and processes an array-like collection of splines.
+
 `bspy.splineOpenGLFrame` : Provides the `SplineOpenGLFrame` class, a tkinter `OpenGLFrame` with shaders to display splines.
 
 `bspy.viewer` : Provides the `Viewer` tkinter app (`tkinter.Tk`) that hosts a `SplineOpenGLFrame`, a listbox full of 
@@ -22,5 +24,6 @@ from bspy.solid import Solid, Boundary
 from bspy.manifold import Manifold
 from bspy.hyperplane import Hyperplane
 from bspy.spline import Spline
+from bspy.spline_block import SplineBlock
 from bspy.splineOpenGLFrame import SplineOpenGLFrame
 from bspy.viewer import Viewer, Graphics

bspy/_spline_domain.py

@@ -518,6 +518,66 @@ def reverse(self, variable = 0):
     newFolded = type(self)(folded.nInd, folded.nDep, folded.order, folded.nCoef, (newKnots,), newCoefs, folded.metadata)
     return newFolded.unfold(myIndices, basisInfo)
 
+def split(self, minContinuity = 0, breaks = None):
+    if minContinuity < 0: raise ValueError("minContinuity must be >= 0")
+    if breaks is not None and len(breaks) != self.nInd: raise ValueError("Invalid breaks")
+    if self.nInd < 1: return self
+
+    # Step 1: Determine the knots to insert.
+    newKnotsList = []
+    for i, order, knots in zip(range(self.nInd), self.order, self.knots):
+        unique, counts = np.unique(knots, return_counts=True)
+        newKnots = []
+        for knot, count in zip(unique, counts):
+            assert count <= order
+            if count > order - 1 - minContinuity:
+                newKnots += [knot] * (order - count)
+        if breaks is not None:
+            for knot in breaks[i]:
+                if knot not in unique:
+                    newKnots += [knot] * order
+        newKnotsList.append(newKnots)    
+    
+    # Step 2: Insert the knots.
+    spline = self.insert_knots(newKnotsList)
+    if spline is self:
+        return np.full((1,) * spline.nInd, spline)
+
+    # Step 3: Store the indices of the full order knots.
+    indexList = []
+    splineCount = []
+    totalSplineCount = 1
+    for order, knots in zip(spline.order, spline.knots):
+        unique, counts = np.unique(knots, return_counts=True)
+        indices = np.searchsorted(knots, unique)
+        fullOrder = []
+        for ix, count in zip(indices, counts):
+            if count == order:
+                fullOrder.append(ix)
+        indexList.append(fullOrder)
+        splines = len(fullOrder) - 1
+        splineCount.append(splines)
+        totalSplineCount *= splines
+
+    # Step 4: Slice up the spline.
+    splineArray = np.empty(totalSplineCount, object)
+    for i in range(totalSplineCount):
+        knotsList = []
+        coefIndex = [slice(None)] # First index is for nDep
+        ix = i
+        for order, knots, splines, indices in zip(spline.order, spline.knots, splineCount, indexList):
+            j = ix % splines
+            ix = ix // splines
+            leftIndex = indices[j]
+            rightIndex = indices[j + 1]
+            knotsList.append(knots[leftIndex:rightIndex + order])
+            coefIndex.append(slice(leftIndex, rightIndex))
+        coefs = spline.coefs[tuple(coefIndex)]
+        splineArray[i] = type(spline)(spline.nInd, spline.nDep, spline.order, coefs.shape[1:], knotsList, coefs, spline.metadata)
+
+    # Return the transpose because we put the splines into splineArray dimensions in reverse order.
+    return splineArray.reshape(tuple(reversed(splineCount))).T
+
 def transpose(self, axes=None):
     if axes is None:
         axes = range(self.nInd)[::-1]
@@ -535,10 +595,12 @@ def transpose(self, axes=None):
 def trim(self, newDomain):
     if not(len(newDomain) == self.nInd): raise ValueError("Invalid newDomain")
     if self.nInd < 1: return self
-    newDomain = np.array(newDomain, self.knots[0].dtype) # Force dtype and convert None to nan
+    newDomain = np.array(newDomain, self.knots[0].dtype, copy=True) # Force dtype and convert None to nan
+    epsilon = np.finfo(newDomain.dtype).eps
 
     # Step 1: Determine the knots to insert at the new domain bounds.
     newKnotsList = []
+    noChange = True
     for (order, knots, bounds) in zip(self.order, self.knots, newDomain):
         if not(len(bounds) == 2): raise ValueError("Invalid newDomain")
         unique, counts = np.unique(knots, return_counts=True)
@@ -548,28 +610,49 @@ def trim(self, newDomain):
         if not np.isnan(bounds[0]):
             if not(knots[order - 1] <= bounds[0] <= knots[-order]): raise ValueError("Invalid newDomain")
             leftBound = True
-            multiplicity = order
             i = np.searchsorted(unique, bounds[0])
-            if unique[i] == bounds[0]:
-                multiplicity -= counts[i]
+            if unique[i] - bounds[0] < epsilon:
+                bounds[0] = unique[i]
+                multiplicity = order - counts[i]
+                if i > 0:
+                    noChange = False
+            elif i > 0 and bounds[0] - unique[i - 1] < epsilon:
+                bounds[0] = unique[i - 1]
+                multiplicity = order - counts[i - 1]
+                if i - 1 > 0:
+                    noChange = False
+            else:
+                multiplicity = order
+        
             newKnots += multiplicity * [bounds[0]]
 
         if not np.isnan(bounds[1]):
             if not(knots[order - 1] <= bounds[1] <= knots[-order]): raise ValueError("Invalid newDomain")
             if leftBound:
                 if not(bounds[0] < bounds[1]): raise ValueError("Invalid newDomain")
-            multiplicity = order
             i = np.searchsorted(unique, bounds[1])
-            if unique[i] == bounds[1]:
-                multiplicity -= counts[i]
+            if unique[i] - bounds[1] < epsilon:
+                bounds[1] = unique[i]
+                multiplicity = order - counts[i]
+                if i < len(unique) - 1:
+                    noChange = False
+            elif i > 0 and bounds[1] - unique[i - 1] < epsilon:
+                bounds[1] = unique[i - 1]
+                multiplicity = order - counts[i - i]
+                noChange = False # i < len(unique) - 1
+            else:
+                multiplicity = order
             newKnots += multiplicity * [bounds[1]]
 
         newKnotsList.append(newKnots)
+        if len(newKnots) > 0:
+            noChange = False
+    
+    if noChange:
+        return self
     
     # Step 2: Insert the knots.
     spline = self.insert_knots(newKnotsList)
-    if spline is self:
-        return spline
 
     # Step 3: Trim the knots and coefficients.
     knotsList = []

bspy/_spline_evaluation.py

@@ -1,4 +1,5 @@
 import numpy as np
+import scipy as sp
 
 def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs = False):
     basis = np.zeros(splineOrder, knots.dtype)
@@ -25,10 +26,61 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
             b += 1
     return knot, basis
 
+def composed_integral(self, integrand = None, domain = None):
+    # Determine domain and check its validity
+    actualDomain = self.domain()
+    if domain is None:
+        domain = actualDomain
+    else:
+        for iInd in range(self.nInd):
+            if domain[iInd, 0] < actualDomain[iInd, 0] or \
+               domain[iInd, 1] > actualDomain[iInd, 1]:
+                raise ValueError("Can't integrate beyond the domain of the spline")
+
+    # Determine breakpoints for quadrature intervals; require functions to be analytic
+
+    uniqueKnots = []
+    for iInd in range(self.nInd):
+        iStart = np.searchsorted(self.knots[iInd], domain[iInd, 0], side = 'right')
+        iEnd = np.searchsorted(self.knots[iInd], domain[iInd, 1], side = 'right')
+        uniqueKnots.append(np.unique(np.insert(self.knots[iInd], [iStart, iEnd], domain[iInd])[iStart : iEnd + 2]))
+
+    # Set integrand function if none is given
+    if integrand is None:
+        integrand = lambda x : 1.0
+
+    # Set tolerance
+    tolerance = 1.0e-13 / self.nInd
+
+    # Establish the callback function
+    def composedIntegrand(u, nIndSoFar, uValues):
+        uValues[nIndSoFar] = u
+        nIndSoFar += 1
+        if self.nInd == nIndSoFar:
+            total = integrand(self(uValues)) * \
+                    np.prod(np.linalg.svd(self.jacobian(uValues), compute_uv = False))
+        else:
+            total = 0.0
+            for ix in range(len(uniqueKnots[nIndSoFar]) - 1):
+                value = sp.integrate.quad(composedIntegrand, uniqueKnots[nIndSoFar][ix],
+                                          uniqueKnots[nIndSoFar][ix + 1], (nIndSoFar, uValues),
+                                          epsabs = tolerance, epsrel = tolerance)
+                total += value[0]
+        return total    
+    
+    # Compute the value by calling the callback routine
+    total = composedIntegrand(0.0, -1, self.nInd * [0.0])
+    return total
+
+def continuity(self):
+    multiplicity = np.array([np.max(np.unique(knots, return_counts = True)[1][1 : -1]) for knots in self.knots])
+    continuity = self.order - multiplicity - 1
+    return continuity
+
 def curvature(self, uv):
+    if self.nDep == 1:
+        self = self.graph()
     if self.nInd == 1:
-        if self.nDep == 1:
-            self = self.graph()
         fp = self.derivative([1], uv)
         fpp = self.derivative([2], uv)
         fpDotFp = fp @ fp
@@ -38,7 +90,21 @@ def curvature(self, uv):
             numerator = fp[0] * fpp[1] - fp[1] * fpp[0]
         else:
             numerator = np.sqrt((fpp @ fpp) * fpDotFp - fpDotFpp ** 2)
-        return numerator / denom 
+        return numerator / denom
+    if self.nInd == 2:
+        su = self.derivative([1, 0], uv)
+        sv = self.derivative([0, 1], uv)
+        normal = self.normal(uv)
+        suu = self.derivative([2, 0], uv)
+        suv = self.derivative([1, 1], uv)
+        svv = self.derivative([0, 2], uv)
+        E = su @ su
+        F = su @ sv
+        G = sv @ sv
+        L = suu @ normal
+        M = suv @ normal
+        N = svv @ normal
+        return (L * N - M ** 2) / (E * G - F ** 2)
 
 def derivative(self, with_respect_to, uvw):
     # Make work for scalar valued functions
@@ -107,6 +173,8 @@ def greville(self, ind = 0):
         for ix in range(1, self.order[ind]):
             knotAverages = knotAverages + myKnots[ix : ix + self.nCoef[ind]]
         knotAverages /= (self.order[ind] - 1)
+    domain = self.domain()[ind]
+    knotAverages = np.minimum(domain[1], np.maximum(domain[0], knotAverages))
     return knotAverages
 
 def integral(self, with_respect_to, uvw1, uvw2, returnSpline = False):
@@ -150,8 +218,8 @@ def normal(self, uvw, normalize=True, indices=None):
 
     if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be one different than the number of dependent variables.")
 
-    # Evaluate the tangents at the point.
-    tangentSpace = self.tangent_space(uvw)
+    # Evaluate the Jacobian at the point.
+    tangentSpace = self.jacobian(uvw)
     
     # Record the larger dimension and ensure it comes first.
     if self.nInd > self.nDep:
@@ -161,15 +229,15 @@ def normal(self, uvw, normalize=True, indices=None):
         nDep = self.nDep
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = -1 if self.metadata.get("flipNormal", False) else 1
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", False) else 1
+    dtype = self.coefs.dtype if hasattr(self, "coefs") else self.coefsDtype
     if indices is None:
         indices = range(nDep)
-        normal = np.empty(nDep, self.coefs.dtype)
+        normal = np.empty(nDep, dtype)
     else:
-        normal = np.empty(len(indices), self.coefs.dtype)
+        normal = np.empty(len(indices), dtype)
     for i in indices:
-        normal[i] = sign * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
-        sign *= -1
+        normal[i] = sign * ((-1) ** i) * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
     
     # Normalize the result as needed.
     if normalize:
@@ -180,13 +248,4 @@ def normal(self, uvw, normalize=True, indices=None):
 def range_bounds(self):
     # Assumes self.nDep is the first value in self.coefs.shape
     bounds = [[coefficient.min(), coefficient.max()] for coefficient in self.coefs]
-    return np.array(bounds, self.coefs.dtype)
-
-def tangent_space(self, uvw):
-    tangentSpace = np.empty((self.nDep, self.nInd), self.coefs.dtype)
-    wrt = [0] * self.nInd
-    for i in range(self.nInd):
-        wrt[i] = 1
-        tangentSpace[:, i] = self.derivative(wrt, uvw)
-        wrt[i] = 0
-    return tangentSpace
+    return np.array(bounds, self.coefs.dtype)

bspy/_spline_fitting.py

@@ -11,6 +11,16 @@ 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 composition(splines, tolerance):
+    # Define the callback function
+    def composition_of_splines(u):
+        for f in splines[::-1]:
+            u = f(u)
+        return u
+    
+    # Approximate this composition
+    return bspy.Spline.fit(splines[-1].domain(), composition_of_splines, tolerance = tolerance)
+
 def cone(radius1, radius2, height, tolerance = None):
     if tolerance is None:
         tolerance = 1.0e-12
@@ -88,48 +98,57 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         FValues = F(knownXValue)
         if not(len(FValues) == nDep - 1 and np.linalg.norm(FValues) < evaluationEpsilon):
             raise ValueError(f"F(known x) must be a zero vector of length {nDep - 1}.")
-    coefsMin = knownXValues.min(axis=0)
-    coefsMaxMinusMin = knownXValues.max(axis=0) - coefsMin
-    coefsMaxMinusMin = np.where(coefsMaxMinusMin < 1.0, 1.0, coefsMaxMinusMin)
+
+    # Record domain of F and scaling of coefficients.
+    if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
+        FDomain = F.domain().T
+        coefsMin = FDomain[0]
+        coefsMaxMinusMin = FDomain[1] - FDomain[0]
+    else:
+        FDomain = np.array(nDep * [[-np.inf, np.inf]]).T
+        coefsMin = knownXValues.min(axis=0)
+        coefsMaxMinusMin = knownXValues.max(axis=0) - coefsMin
+        coefsMaxMinusMin = np.where(coefsMaxMinusMin < 1.0, 1.0, coefsMaxMinusMin)
+
+    # Rescale known values.
     coefsMaxMinMinReciprocal = np.reciprocal(coefsMaxMinusMin)
     knownXValues = (knownXValues - coefsMin) * coefsMaxMinMinReciprocal # Rescale to [0 , 1]
 
-    # Establish the first derivatives of F.
+    # Establish the Jacobian of F.
     if dF is None:
-        dF = []
-        if isinstance(F, bspy.Spline):
-            for i in range(nDep):
-                def splineDerivative(x, i=i):
-                    wrt = [0] * nDep
-                    wrt[i] = 1
-                    return F.derivative(wrt, x)
-                dF.append(splineDerivative)
-            FDomain = F.domain().T
+        if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
+            dF = F.jacobian
         else:
-            for i in range(nDep):
-                def fDerivative(x, i=i):
+            def fJacobian(x):
+                value = np.empty((nDep - 1, nDep), float)
+                for i in range(nDep):
                     h = epsilon * (1.0 + abs(x[i]))
                     xShift = np.array(x, copy=True)
                     xShift[i] -= h
                     fLeft = np.array(F(xShift))
                     h2 = h * 2.0
                     xShift[i] += h2
-                    return (np.array(F(xShift)) - fLeft) / h2
-                dF.append(fDerivative)
-            FDomain = np.array(nDep * [[-np.inf, np.inf]]).T
-    else:
+                    value[:, i] = (np.array(F(xShift)) - fLeft) / h2
+                return value
+            dF = fJacobian
+    elif not callable(dF):
         if not(len(dF) == nDep): raise ValueError(f"Must provide {nDep} first derivatives.")
+        def fJacobian(x):
+            value = np.empty((nDep - 1, nDep), float)
+            for i in range(nDep):
+                value[:, i] = dF[i]
+            return value
+        dF = fJacobian
 
     # Construct knots, t values, and GSamples.
     tValues = np.empty(nUnknownCoefs, contourDtype)
     GSamples = np.empty((nUnknownCoefs, nDep), contourDtype)
-    t = 0.0 # We start with t measuring contour length.
+    t = 0.0 # t ranges from 0 to 1
+    dt = 1.0 / m
     knots = [t] * order
     i = 0
     previousPoint = knownXValues[0]
     for point in knownXValues[1:]:
-        dt = np.linalg.norm(point - previousPoint)
-        if not(dt > epsilon): raise ValueError("Points must be separated by at least epsilon.")
         for gaussNode in gaussNodes:
             tValues[i] = t + gaussNode * dt
             GSamples[i] = (1.0 - gaussNode) * previousPoint + gaussNode * point
@@ -138,8 +157,8 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         knots += [t] * (order - 2)
         previousPoint = point
     knots += [t] * 2 # Clamp last knot
-    knots = np.array(knots, contourDtype) / t # Rescale knots
-    tValues /= t # Rescale t values
+    knots = np.array(knots, contourDtype)
+    knots[nCoef:] = 1.0 # Ensure last knot is exactly 1.0
     assert i == nUnknownCoefs
     
     # Start subdivision loop.
@@ -167,8 +186,6 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         # Array to hold the Jacobian of the FSamples with respect to the coefficients.
         # The Jacobian is banded due to B-spline local support, so initialize it to zero.
         dFCoefs = np.zeros((nUnknownCoefs, nDep, nCoef, nDep), contourDtype)
-        # Working array to hold the transpose of the Jacobian of F for a particular x(t).
-        dFX = np.empty((nDep, nDep - 1), contourDtype)
 
         # Start Newton's method loop.
         previousFSamplesNorm = 0.0
@@ -201,9 +218,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
                 FSamples[i, -1] = dotValues
 
                 # Compute the Jacobian of FSamples with respect to the coefficients of x(t).
-                for j in range(nDep):
-                    dFX[j] = dF[j](x) * coefsMaxMinusMin[j]
-                FValues = np.outer(dFX.T, bValues).reshape(nDep - 1, nDep, order).swapaxes(1, 2)
+                FValues = np.outer(dF(x) * coefsMaxMinusMin, bValues).reshape(nDep - 1, nDep, order).swapaxes(1, 2)
                 dotValues = (np.outer(d2Values, compactCoefs.T @ dValues) + np.outer(dValues, compactCoefs.T @ d2Values)).reshape(order, nDep)
                 dFCoefs[i, :-1, ix - order:ix, :] = FValues
                 dFCoefs[i, -1, ix - order:ix, :] = dotValues
@@ -274,7 +289,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
             previousKnot = knot
         
         # Test if F(GSamples) is close enough to zero.
-        if FSamplesNorm / np.linalg.norm(dHCoefs, np.inf) < epsilon:
+        if FSamplesNorm < evaluationEpsilon:
             break # We're done! Exit subdivision loop and return x(t).
 
         # Otherwise, update nCoef and knots array, and then re-run Newton's method.
@@ -287,7 +302,7 @@ def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
     # Rescale x(t) back to original data points.
     coefs = (coefsMin + coefs * coefsMaxMinusMin).T
     spline = bspy.Spline(1, nDep, (order,), (nCoef,), (knots,), coefs, metadata)
-    if isinstance(F, bspy.Spline):
+    if isinstance(F, (bspy.Spline, bspy.SplineBlock)):
         spline = spline.confine(F.domain())
     return spline
 
@@ -298,6 +313,122 @@ def cylinder(radius, height, tolerance = None):
     top = bottom + [0.0, 0.0, height]
     return bspy.Spline.ruled_surface(bottom, top)
 
+def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
+    # Determine number of independent variables
+    domain = np.array(domain)
+    nInd = len(domain)
+    midPoint = f(0.5 * (domain.T[0] + domain.T[1]))
+    if not type(midPoint) is bspy.Spline:
+        nDep = len(midPoint)
+
+    # Make sure order and knots conform to this
+    if order is None:
+        order = nInd * [4]
+    if len(order) != nInd:
+        raise ValueError("Inconsistent number of independent variables")
+
+    # Establish the initial knot sequence
+    if knots is None:
+        knots = np.array([order[iInd] * [domain[iInd, 0]] + order[iInd] * [domain[iInd, 1]] for iInd in range(nInd)])
+    
+    # Determine initial nCoef
+    nCoef = [len(knotVector) - iOrder for iOrder, knotVector in zip(order, knots)]
+
+    # Define function to insert midpoints
+    def addMidPoints(u):
+        newArray = np.empty([2, len(u)])
+        newArray[0] = u
+        newArray[1, :-1] = 0.5 * (u[1:] + u[:-1])
+        return newArray.T.flatten()[:-1]
+    
+    # Track the current spline space we're fitting in
+    currentSpace = bspy.Spline(nInd, 0, order, nCoef, knots, [])
+
+    # Generate the Greville points for these knots
+    uvw = [currentSpace.greville(iInd) for iInd in range(nInd)]
+
+    # Enrich the sample points
+    for iInd in range(nInd):
+        uvw[iInd][0] = knots[iInd][order[iInd] - 1]
+        uvw[iInd][-1] = knots[iInd][nCoef[iInd]]
+        for iLevel in range(1):
+            uvw[iInd] = addMidPoints(uvw[iInd])
+
+    # Initialize the dictionary of function values
+
+    fDictionary = {}
+
+    # Keep looping until done
+    while True:
+
+        # Evaluate the function on this data set
+        fValues = []
+        indices = nInd * [0]
+        iLast = nInd
+        while iLast >= 0:
+            uValue = tuple([uvw[i][indices[i]] for i in range(nInd)])
+            if not uValue in fDictionary:
+                fDictionary[uValue] = f(uValue)
+            fValues.append(fDictionary[uValue])
+            iLast = nInd - 1
+            while iLast >= 0:
+                indices[iLast] += 1
+                if indices[iLast] < len(uvw[iLast]):
+                    break
+                indices[iLast] = 0
+                iLast -= 1
+
+        # Adjust the ordering
+        pointShape = [len(uvw[i]) for i in range(nInd)]
+        if type(midPoint) is bspy.Spline:
+            fValues = np.array(fValues).reshape(pointShape)
+        else:
+            fValues = np.array(fValues).reshape(pointShape + [nDep]).transpose([nInd] + list(range(nInd)))
+
+        # Call the least squares fitter on this data
+        bestSoFar = bspy.Spline.least_squares(uvw, fValues, order, currentSpace.knots, fixEnds = True)
+
+        # Determine the maximum error
+        maxError = 0.0
+        for key in fDictionary:
+            if type(midPoint) is bspy.Spline:
+                sampled = bestSoFar.contract(midPoint.nInd * [None] + list(key)).coefs
+                trueCoefs = fDictionary[key].coefs
+                thisError = np.max(np.linalg.norm(sampled - trueCoefs, axis = 0))
+            else:
+                thisError = np.linalg.norm(fDictionary[key] - bestSoFar(key))
+            if thisError > maxError:
+                maxError = thisError
+                maxKey = key
+        if maxError <= tolerance:
+            break
+
+        # Split the interval and try again
+        maxGap = 0.0
+        for iInd in range(nInd):
+            insert = bspy.Spline.bspline_values(None, currentSpace.knots[iInd], order[iInd], maxKey[iInd])[0]
+            leftKnot = currentSpace.knots[iInd][insert - 1]
+            rightKnot = currentSpace.knots[iInd][insert]
+            if rightKnot - leftKnot > maxGap:
+                maxGap = rightKnot - leftKnot
+                iFirst = np.searchsorted(uvw[iInd], leftKnot, side = 'right')
+                iLast = np.searchsorted(uvw[iInd], rightKnot, side = 'right')
+                maxLeft = leftKnot
+                maxRight = rightKnot
+                maxInd = iInd
+        splitAt = 0.5 * (maxLeft + maxRight)
+        newKnots = [[] for iInd in range(nInd)]
+        newKnots[maxInd] = [splitAt]
+        currentSpace = currentSpace.insert_knots(newKnots)
+
+        # Add samples for the new knot
+        uvw[maxInd] = np.array(list(uvw[maxInd][:iFirst - 1]) +
+                               list(addMidPoints(uvw[maxInd][iFirst - 1:iLast])) +
+                               list(uvw[maxInd][iLast:]))
+
+    # Return the best spline found so far
+    return bestSoFar
+
 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")
@@ -414,26 +545,51 @@ def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
         suvv = surface.derivative([1, 2], u[:, 0])
         svvv = surface.derivative([0, 3], u[:, 0])
 
+        # Calculate inner products
+        su_su = su @ su
+        su_sv = su @ sv
+        sv_sv = sv @ sv
+        suu_su = suu @ su
+        suu_sv = suu @ sv
+        suv_su = suv @ su
+        suv_sv = suv @ sv
+        svv_su = svv @ su
+        svv_sv = svv @ sv
+        suu_suu = suu @ suu
+        suu_suv = suu @ suv
+        suu_svv = suu @ svv
+        suv_suv = suv @ suv
+        suv_svv = suv @ svv
+        svv_svv = svv @ svv
+        suuu_su = suuu @ su
+        suuu_sv = suuu @ sv
+        suuv_su = suuv @ su
+        suuv_sv = suuv @ sv
+        suvv_su = suvv @ su
+        suvv_sv = suvv @ sv
+        svvv_su = svvv @ su
+        svvv_sv = svvv @ sv
+
         # Calculate the first fundamental form and derivatives
-        E = su @ su
-        E_u = 2.0 * suu @ su
-        E_v = 2.0 * suv @ su
-        F = su @ sv
-        F_u = suu @ sv + suv @ su
-        F_v = suv @ sv + svv @ su
-        G = sv @ sv
-        G_u = 2.0 * suv @ sv
-        G_v = 2.0 * svv @ sv
+        E = su_su
+        E_u = 2.0 * suu_su
+        E_v = 2.0 * suv_su
+        F = su_sv
+        F_u = suu_sv + suv_su
+        F_v = suv_sv + svv_su
+        G = sv_sv
+        G_u = 2.0 * suv_sv
+        G_v = 2.0 * svv_sv
         A = np.array([[E, F], [F, G]])
         A_u = np.array([[E_u, F_u], [F_u, G_u]])
         A_v = np.array([[E_v, F_v], [F_v, G_v]])
 
         # Compute right hand side entries
-        R = np.array([[suu @ su, suv @ su, svv @ su], [suu @ sv, suv @ sv, svv @ sv]])
-        R_u = np.array([[suuu @ su + suu @ suu, suuv @ su + suv @ suu, suvv @ su + svv @ suu],
-                        [suuu @ sv + suu @ suv, suuv @ sv + suv @ suv, suvv @ sv + svv @ suv]])
-        R_v = np.array([[suuv @ su + suu @ suv, suvv @ su + suv @ suv, suvv @ su + svv @ suv],
-                        [suuv @ sv + suu @ svv, suvv @ sv + suv @ svv, svvv @ sv + svv @ svv]])
+        R = np.array([[suu_su, suv_su, svv_su], [suu_sv, suv_sv, svv_sv]])
+        R_u = np.array([[suuu_su + suu_suu, suuv_su + suu_suv, suvv_su + suu_svv],
+                        [suuu_sv + suu_suv, suuv_sv + suv_suv, suvv_sv + suv_svv]])
+        R_v = np.array([[suuv_su + suu_suv, suvv_su + suv_suv, svvv_su + suv_svv],
+                        [suuv_sv + suu_svv, suvv_sv + suv_svv, svvv_sv + svv_svv]])
 
         # Solve for the Christoffel symbols
         luAndPivot = sp.linalg.lu_factor(A)