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

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)
@@ -748,11 +904,11 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
     for i, knot in enumerate(uniqueKnots):
         howMany = currentGuess.order[0] - indices[i + 1] + indices[i] - nOrder
         if howMany > 0:
-            knotsToAdd += howMany * [knot]
+            knotsToAdd.append((knot, howMany))
         if howMany < 0:
-            knotsToRemove += [[knot, abs(howMany)]]
+            knotsToRemove.append((knot, abs(howMany)))
     currentGuess = currentGuess.insert_knots([knotsToAdd])
-    for [knot, howMany] in knotsToRemove:
+    for (knot, howMany) in knotsToRemove:
         ix = np.searchsorted(currentGuess.knots[0], knot, side = 'left')
         for iy in range(howMany):
             currentGuess, residual = currentGuess.remove_knot(ix, nLeft, nRight)
@@ -909,7 +1065,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
             knotsToAdd = []
             for knot0, knot1 in zip(currentGuess.knots[0][:-1], currentGuess.knots[0][1:]):
                 if knot0 < knot1:
-                    knotsToAdd += (currentGuess.order[0] - nOrder) * [0.5 * (knot0 + knot1)]
+                    knotsToAdd.append((0.5 * (knot0 + knot1), currentGuess.order[0] - nOrder))
             previousGuess = currentGuess
             currentGuess = currentGuess.insert_knots([knotsToAdd])