bspy 4.1__py3-none-any.whl → 4.3__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 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.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

@@ -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
@@ -535,10 +582,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 +597,43 @@ 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]
-            newKnots += multiplicity * [bounds[0]]
+            if unique[i] - bounds[0] < epsilon:
+                bounds[0] = unique[i]
+                multiplicity = order - counts[i]
+            elif i > 0 and bounds[0] - unique[i - 1] < epsilon:
+                bounds[0] = unique[i - 1]
+                multiplicity = order - counts[i - 1]
+            else:
+                multiplicity = order
+            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")
             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]
-            newKnots += multiplicity * [bounds[1]]
+            if unique[i] - bounds[1] < epsilon:
+                bounds[1] = unique[i]
+                multiplicity = order - counts[i]
+            elif i > 0 and bounds[1] - unique[i - 1] < epsilon:
+                bounds[1] = unique[i - 1]
+                multiplicity = order - counts[i - i]
+            else:
+                multiplicity = order
+            if multiplicity > 0:
+                newKnots.append((bounds[1], multiplicity))
+                noChange = False
 
         newKnotsList.append(newKnots)
     
+    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)
-    for i in indices:
-        normal[i] = sign * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
-        sign *= -1
+        normal = np.empty(len(indices), dtype)
+    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:
@@ -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)