bspy 4.2__py3-none-any.whl → 4.3__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,73 @@ 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.
+            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
@@ -518,66 +565,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 +601,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 +618,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

@@ -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

@@ -904,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)
@@ -1065,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])