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

bspy/__init__.py

@@ -12,7 +12,7 @@ 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.spline_block` : Provides the `SplineBlock` class that processes an array-like collection of splines which represent a system of equations.
 
 `bspy.splineOpenGLFrame` : Provides the `SplineOpenGLFrame` class, a tkinter `OpenGLFrame` with shaders to display splines.
 

bspy/_spline_domain.py

@@ -310,26 +310,74 @@ def fold(self, foldedInd):
     coefficientlessSpline = type(self)(len(coefficientlessOrder), 0, coefficientlessOrder, coefficientlessNCoef, coefficientlessKnots, coefficientlessCoefs, self.metadata)
     return foldedSpline, coefficientlessSpline
 
-def insert_knots(self, newKnots):
-    if not(len(newKnots) == self.nInd): raise ValueError("Invalid newKnots")
-    knotsList = list(self.knots)
-    coefs = self.coefs
-    for ind, (order, knots) in enumerate(zip(self.order, self.knots)):
-        # We can't reference self.nCoef[ind] in this loop because we are expanding the knots and coefs arrays.
-        for knot in newKnots[ind]:
-            if knot < knots[order-1] or knot > knots[-order]:
-                raise ValueError(f"Knot insertion outside domain: {knot}")
-            if knot == knots[-order]:
-                position = len(knots) - order
+def insert_knots(self, newKnotList):
+    if not(len(newKnotList) == self.nInd): raise ValueError("Invalid newKnots")
+    knotsList = list(self.knots) # Create a new knot list
+    coefs = self.coefs # Set initial value for coefs to check later if it's changed
+
+    # Insert new knots into each independent variable.
+    for ind, (order, knots, newKnots) in enumerate(zip(self.order, self.knots, newKnotList)):
+        coefs = coefs.swapaxes(0, ind + 1) # Swap dependent and independent variable (swap back later)
+        degree = order - 1
+        for knot in newKnots:
+            # Determine new knot multiplicity.
+            if np.isscalar(knot):
+                multiplicity = 1
             else:
-                position = np.searchsorted(knots, knot, 'right')
-            coefs = coefs.swapaxes(0, ind + 1) # Swap dependent and independent variable (swap back later)
-            newCoefs = np.insert(coefs, position - 1, 0.0, axis=0)
-            for i in range(position - order + 1, position):
-                alpha = (knot - knots[i]) / (knots[i + order - 1] - knots[i])
-                newCoefs[i] = (1.0 - alpha) * coefs[i - 1] + alpha * coefs[i]
-            knotsList[ind] = knots = np.insert(knots, position, knot)
-            coefs = newCoefs.swapaxes(0, ind + 1)
+                multiplicity = knot[1]
+                knot = knot[0]
+                if multiplicity < 1:
+                    continue
+
+            # Check if knot and its total multiplicity is valid.
+            knot = knots.dtype.type(knot) # Cast to correct type
+            if knot < knots[degree] or knot > knots[-order]:
+                raise ValueError(f"Knot insertion outside domain: {knot}")
+            position = np.searchsorted(knots, knot, 'right')
+            oldMultiplicity = 0
+            for k in knots[position - 1::-1]:
+                if knot == k:
+                    oldMultiplicity += 1
+                else:
+                    break
+            if oldMultiplicity + multiplicity > order:
+                raise ValueError("Knot multiplicity > order")
+
+            # Initialize oldCoefs and expanded coefs array with multiplicity new coefficients, as well as some indices.
+            oldCoefs = coefs[position - order:position].copy()
+            lastKnotIndex = position - oldMultiplicity
+            firstCoefIndex = position - degree
+            coefs = np.insert(coefs, firstCoefIndex, oldCoefs[:multiplicity], axis=0)
+            # Compute inserted coefficients (multiplicity of them) and the degree - oldMultiplicity - 1 number of changed coefficients.
+            for j in range(multiplicity):
+                # Allocate new coefficients for the current multiplicity. 
+                size = degree - oldMultiplicity - j
+                if size < 1:
+                    # Full multiplicity knot, so use oldCoefs.
+                    coefs[firstCoefIndex + j] = oldCoefs[0]
+                else:
+                    # Otherwise, allocate space for newCoefs.
+                    newCoefs = np.empty((size, *coefs.shape[1:]), coefs.dtype)
+
+                    # Compute the new coefficients.
+                    for i, k in zip(range(size), range(lastKnotIndex - size, lastKnotIndex)):
+                        alpha = (knot - knots[k]) / (knots[k + degree - j] - knots[k])
+                        newCoefs[i] = (1.0 - alpha) * oldCoefs[i] + alpha * oldCoefs[i + 1]
+
+                    # Assign the ends of the new coefficients into their respective positions.
+                    coefs[firstCoefIndex + j] = newCoefs[0]
+                    if size > 1:
+                        coefs[lastKnotIndex + multiplicity - j - 2] = newCoefs[-1]
+                    oldCoefs = newCoefs
+            
+            # Assign remaining computed coefficients (the ones in the middle).
+            if size > 2:
+                coefs[firstCoefIndex + multiplicity:firstCoefIndex + multiplicity + size - 2] = newCoefs[1:-1]
+            
+            # Insert the inserted coefficients and inserted knots.
+            knotsList[ind] = knots = np.insert(knots, position, (knot,) * multiplicity)
+        
+        coefs = coefs.swapaxes(0, ind + 1) # Swap back
 
     if self.coefs is coefs:
         return self
@@ -452,7 +500,7 @@ def remove_knots(self, tolerance, nLeft = 0, nRight = 0):
         foldedIndices = list(filter(lambda x: x != id, indIndex))
         currentFold, foldedBasis = currentSpline.fold(foldedIndices)
         while True:
-            bestError = np.finfo(scaleDep[0].dtype).max
+            bestError = np.finfo(self.coefs.dtype).max
             bestSpline = currentFold
             ix = currentFold.order[0]
             while ix < currentFold.nCoef[0]:
@@ -518,66 +566,6 @@ 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]
@@ -614,17 +602,14 @@ def trim(self, newDomain):
             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 multiplicity > 0:
+                newKnots.append((bounds[0], multiplicity))
+                noChange = False
 
         if not np.isnan(bounds[1]):
             if not(knots[order - 1] <= bounds[1] <= knots[-order]): raise ValueError("Invalid newDomain")
@@ -634,19 +619,16 @@ def trim(self, newDomain):
             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]]
+            if multiplicity > 0:
+                newKnots.append((bounds[1], multiplicity))
+                noChange = False
 
         newKnotsList.append(newKnots)
-        if len(newKnots) > 0:
-            noChange = False
     
     if noChange:
         return self

bspy/_spline_evaluation.py

@@ -5,7 +5,7 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
     basis = np.zeros(splineOrder, knots.dtype)
     if knot is None:
         knot = np.searchsorted(knots, u, side = 'right')
-        knot = min(knot, len(knots) - splineOrder)
+        knot = min(max(knot, splineOrder), len(knots) - splineOrder)
     if derivativeOrder >= splineOrder:
         return knot, basis
     basis[-1] = 1.0
@@ -236,8 +236,8 @@ def normal(self, uvw, normalize=True, indices=None):
         normal = np.empty(nDep, dtype)
     else:
         normal = np.empty(len(indices), dtype)
-    for i in indices:
-        normal[i] = sign * ((-1) ** i) * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
+    for ix, i in enumerate(indices):
+        normal[ix] = sign * ((-1) ** i) * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
     
     # Normalize the result as needed.
     if normalize:

bspy/_spline_fitting.py

@@ -1,6 +1,7 @@
 import numpy as np
 import scipy as sp
 import bspy.spline
+import bspy.spline_block
 import math
 
 def circular_arc(radius, angle, tolerance = None):
@@ -12,14 +13,33 @@ def circular_arc(radius, angle, tolerance = None):
     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):
+    # Collect domains and check range bounds
+    domains = [None]
+    domain = None
+    for i, spline in enumerate(splines):
+        if domain is not None:
+            if len(domain) != spline.nDep:
+                raise ValueError(f"Domain dimension of spline {i-1} does not match range dimension of spline {i}")
+            rangeBounds = spline.range_bounds()
+            for ix in range(spline.nDep):
+                if rangeBounds[ix][0] < domain[ix][0] or rangeBounds[ix][1] > domain[ix][1]:
+                    raise ValueError(f"Range of spline {i} exceeds domain of spline {i-1}")
+            domains.append(domain)
+        domain = spline.domain()
+
     # Define the callback function
     def composition_of_splines(u):
-        for f in splines[::-1]:
-            u = f(u)
+        for spline, domain in zip(splines[::-1], domains[::-1]):
+            u = spline(u)
+            if domain is not None:
+                # We've already checked that the range of spline is within the domain
+                # of its successor, but numerics may cause the spline value to slightly 
+                # exceed its range, so we clip the spline value accordingly.
+                u = np.clip(u, domain[:, 0], domain[:, 1])
         return u
     
     # Approximate this composition
-    return bspy.Spline.fit(splines[-1].domain(), composition_of_splines, tolerance = tolerance)
+    return bspy.Spline.fit(domain, composition_of_splines, tolerance = tolerance)
 
 def cone(radius1, radius2, height, tolerance = None):
     if tolerance is None:
@@ -366,9 +386,10 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
         indices = nInd * [0]
         iLast = nInd
         while iLast >= 0:
+            # Create a tuple for the u value (must be a tuple to use it as a dictionary key)
             uValue = tuple([uvw[i][indices[i]] for i in range(nInd)])
             if not uValue in fDictionary:
-                fDictionary[uValue] = f(uValue)
+                fDictionary[uValue] = f(np.array(uValue))
             fValues.append(fDictionary[uValue])
             iLast = nInd - 1
             while iLast >= 0:
@@ -518,7 +539,7 @@ def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     
     return (1.0 - surfParam) * coons + surfParam * laplace
 
-def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
+def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-5):
     # Check validity of input
     if self.nInd != 2:  raise ValueError("Surface must have two independent variables")
     if len(uvStart) != 2:  raise ValueError("uvStart must have two components")
@@ -616,7 +637,7 @@ def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
     initialGuess = line(uvStart, uvEnd).elevate([2])
 
     # Solve the ODE and return the geodesic
-    solution = initialGuess.solve_ode(1, 1, geodesicCallback, 1.0e-5, (self, uvDomain))
+    solution = initialGuess.solve_ode(1, 1, geodesicCallback, tolerance, (self, uvDomain))
     return solution
 
 def least_squares(uValues, dataPoints, order = None, knots = None, compression = 0.0,
@@ -878,7 +899,7 @@ def section(xytk):
     # Join the pieces together and return
     return bspy.Spline.join(mySections)
 
-def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
+def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = (), includeEstimate = False):
     # Ensure that the ODE is properly formulated
 
     if nLeft < 0:  raise ValueError("Invalid number of left hand boundary conditions")
@@ -904,11 +925,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)
@@ -970,7 +991,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 residuals = np.append(residuals, np.zeros((nLeft * nDep,)))
                 collocationMatrix[bandWidth, 0 : nLeft * nDep] = 1.0
                 for iPoint, t in enumerate(collocationPoints[iFirstPoint : iNextPoint]):
-                    uData = np.array([workingSpline.derivative([i], t) for i in range(nOrder)]).T
+                    uData = np.array([workingSpline.derivative([i], t) for i in range(nOrder + 1 if includeEstimate else nOrder)]).T
                     F, F_u = FAndF_u(t, uData, *args)
                     residuals = np.append(residuals, workingSpline.derivative([nOrder], t) - continuation * F)
                     ix = None
@@ -1065,7 +1086,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])