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

bspy/__init__.py

@@ -3,14 +3,27 @@ BSpy is a python library for manipulating and rendering non-uniform B-splines.
 
 Available subpackages
 ---------------------
-`bspy.spline` : Provides the `Spline` class that models, represents, and processes piecewise polynomial tensor product
-    functions (spline functions) as linear combinations of B-splines.
+`bspy.solid` : Provides the `Solid` and `Boundary` classes that model solids.
+
+`bspy.manifold` : Provides the `Manifold` base class for manifolds.
+
+`bspy.hyperplane` : Provides the `Hyperplane` subclass of `Manifold` that models hyperplanes.
+
+`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 
     splines, and a set of controls to adjust and view the selected splines. It also provides the `Graphics` engine that creates 
-    an associated `Viewer`, allowing you to script splines and display them in the viewer."""
+    an associated `Viewer`, allowing you to script splines and display them in the viewer.
+"""
+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

@@ -1,4 +1,5 @@
 import numpy as np
+from bspy.manifold import Manifold
 
 def clamp(self, left, right):
     bounds = [[None, None] for i in range(self.nInd)]
@@ -517,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]
@@ -534,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)
@@ -547,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 = []
@@ -582,6 +666,14 @@ def trim(self, newDomain):
 
     return type(spline)(spline.nInd, spline.nDep, spline.order, coefs.shape[1:], knotsList, coefs, spline.metadata)
 
+def trimmed_range_bounds(self, domainBounds):
+    domainBounds = np.array(domainBounds, copy=True)
+    for original, trim in zip(self.domain(), domainBounds):
+        trim[0] = max(original[0], trim[0] - Manifold.minSeparation)
+        trim[1] = min(original[1], trim[1] + Manifold.minSeparation)
+    trimmedSpline = self.trim(domainBounds)
+    return trimmedSpline, trimmedSpline.range_bounds()
+
 def unfold(self, foldedInd, coefficientlessSpline):
     if not(len(foldedInd) == coefficientlessSpline.nInd): raise ValueError("Invalid coefficientlessSpline")
     unfoldedOrder = []

bspy/_spline_evaluation.py

@@ -1,11 +1,14 @@
 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)
-    basis[-1] = 1.0
     if knot is None:
         knot = np.searchsorted(knots, u, side = 'right')
         knot = min(knot, len(knots) - splineOrder)
+    if derivativeOrder >= splineOrder:
+        return knot, basis
+    basis[-1] = 1.0
     for degree in range(1, splineOrder - derivativeOrder):
         b = splineOrder - degree
         for i in range(knot - degree, knot):
@@ -23,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
@@ -36,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
@@ -105,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):
@@ -148,31 +218,26 @@ 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 = np.empty((self.nInd, self.nDep), self.coefs.dtype)
-    with_respect_to = [0] * self.nInd
-    for i in range(self.nInd):
-        with_respect_to[i] = 1
-        tangentSpace[i] = self.derivative(with_respect_to, uvw)
-        with_respect_to[i] = 0
+    # Evaluate the Jacobian at the point.
+    tangentSpace = self.jacobian(uvw)
     
     # Record the larger dimension and ensure it comes first.
     if self.nInd > self.nDep:
         nDep = self.nInd
+        tangentSpace = tangentSpace.T
     else:
         nDep = self.nDep
-        tangentSpace = tangentSpace.T
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = 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: