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

bspy/__init__.py

@@ -1,19 +1,26 @@
 """
-bspy is a python library for manipulating and rendering non-uniform B-splines.
+BSpy is a python library for manipulating and rendering non-uniform B-splines.
 
 Available subpackages
 ---------------------
-`bspy.spline` : A class to model, represent, and process 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.drawableSpline` : A `Spline` that can be drawn within a `SplineOpenGLFrame`.
+`bspy.manifold` : Provides the `Manifold` base class for manifolds.
 
-`bspy.splineOpenGLFrame` : A tkinter `OpenGLFrame` with shaders to display a `DrawableSpline` list.
+`bspy.hyperplane` : Provides the `Hyperplane` subclass of `Manifold` that models hyperplanes.
 
-`bspy.bspyApp` : A 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.
+`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.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.
 """
+from bspy.solid import Solid, Boundary
+from bspy.manifold import Manifold
+from bspy.hyperplane import Hyperplane
 from bspy.spline import Spline
-from bspy.drawableSpline import DrawableSpline
 from bspy.splineOpenGLFrame import SplineOpenGLFrame
-from bspy.bspyApp import bspyApp, bspyGraphics
+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)]
@@ -12,10 +13,15 @@ def clamp(self, left, right):
     return self.trim(bounds)
 
 def common_basis(splines, indMap):
-    # Step 1: Compute the order for each aligned independent variable.
-    orders = []
+    # Fill out the default indMap.
     if indMap is None:
         indMap = [len(splines) * [iInd] for iInd in range(splines[0].nInd)]
+    
+    # Ensure all splines are clamped at both ends.
+    splines = [spline.clamp(tuple(range(spline.nInd)), tuple(range(spline.nInd))) for spline in splines]
+
+    # Step 1: Compute the order for each aligned independent variable.
+    orders = []
     for map in indMap:
         if not(len(map) == len(splines)): raise ValueError("Invalid map")
         order = 0
@@ -269,7 +275,7 @@ def extrapolate(self, newDomain, continuityOrder):
         # Swap dependent and independent variables back.
         dCoefs = dCoefs.swapaxes(1, ind + 2) 
 
-    return type(self)(self.nInd, self.nDep, self.order, nCoef, knots, dCoefs[0], self.metadata)
+    return type(self)(self.nInd, self.nDep, self.order, nCoef, knots, dCoefs[0], self.metadata).remove_knots()
 
 def fold(self, foldedInd):
     if not(0 <= len(foldedInd) <= self.nInd): raise ValueError("Invalid foldedInd")
@@ -306,29 +312,29 @@ def fold(self, foldedInd):
 
 def insert_knots(self, newKnots):
     if not(len(newKnots) == self.nInd): raise ValueError("Invalid newKnots")
-    knots = list(self.knots)
+    knotsList = list(self.knots)
     coefs = self.coefs
-    for ind in range(self.nInd):
+    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[ind][self.order[ind]-1] or knot > knots[ind][-self.order[ind]]:
+            if knot < knots[order-1] or knot > knots[-order]:
                 raise ValueError(f"Knot insertion outside domain: {knot}")
-            if knot == knots[ind][-self.order[ind]]:
-                position = len(knots[ind]) - self.order[ind]
+            if knot == knots[-order]:
+                position = len(knots) - order
             else:
-                position = np.searchsorted(knots[ind], knot, 'right')
+                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 - self.order[ind] + 1, position):
-                alpha = (knot - knots[ind][i]) / (knots[ind][i + self.order[ind] - 1] - knots[ind][i])
+            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]
-            knots[ind] = np.insert(knots[ind], position, knot)
+            knotsList[ind] = knots = np.insert(knots, position, knot)
             coefs = newCoefs.swapaxes(0, ind + 1)
 
     if self.coefs is coefs:
         return self
     else: 
-        return type(self)(self.nInd, self.nDep, self.order, coefs.shape[1:], knots, coefs, self.metadata)
+        return type(self)(self.nInd, self.nDep, self.order, coefs.shape[1:], knotsList, coefs, self.metadata)
 
 def join(splineList):
     # Make sure all the splines in the list are curves
@@ -368,13 +374,13 @@ def join(splineList):
                                             newKnots, newCoefs, workingSpline.metadata)
     return workingSpline.reparametrize([[0.0, 1.0]]).remove_knots()
 
-def remove_knot(self, iKnot):
+def remove_knot(self, iKnot, nLeft = 0, nRight = 0):
     if self.nInd != 1:  raise ValueError("Must have one independent variable")
     myOrder = self.order[0]
     if iKnot < myOrder or iKnot >= self.nCoef[0]:  raise ValueError("Must specify interior knots for removal")
     diag0 = []
-    diag1 = []
-    rhs = []
+    diag1 = [1.0]
+    rhs = [np.ndarray.copy(self.coefs[:, iKnot - myOrder])]
     myKnots = self.knots[0]
     thisKnot = myKnots[iKnot]
 
@@ -384,45 +390,57 @@ def remove_knot(self, iKnot):
         diag0.append(alpha)
         diag1.append(1.0 - alpha)
         rhs.append(np.ndarray.copy(self.coefs[:, iKnot - myOrder + ix]))
-    
-    # Adjust right hand side because first and last coefficients are known
+    diag0.append(1.0)
+    diag1.append(0.0)
+    rhs.append(np.ndarray.copy(self.coefs[:, iKnot]))
     rhs = np.array(rhs)
-    rhs[0] -= diag0[0] * self.coefs[:, iKnot - myOrder]
-    rhs[-1] -= diag1[-1] * self.coefs[:, iKnot]
+
+    # Take care of the extra known conditions on the left
+    extraLeft = max(0, nLeft - iKnot + myOrder)
+    for ix in range(extraLeft):
+        rhs[ix] /= diag1[ix]
+        rhs[ix + 1] -= diag0[ix] * rhs[ix]
+    
+    # Take care of the extra known conditions on the right
+    extraRight = max(0, nRight - self.nCoef[0] + iKnot + 1)
+    for ix in range(extraRight):
+        rhs[-1 - ix] /= diag0[-1 - ix]
+        rhs[-2 - ix] -= diag1[-2 - ix] * rhs[-1 - ix]
 
     # Use Givens rotations to factor the matrix and track right hand side
-    for ix in range(1, myOrder - 1):
-        cos = diag1[ix - 1]
+    for ix in range(extraLeft, myOrder - extraRight):
+        cos = diag1[ix]
         sin = diag0[ix]
         denom = np.sqrt(cos ** 2 + sin ** 2)
         cos /= denom
         sin /= denom
-        diag1[ix - 1] = denom
-        diag0[ix - 1] = sin * diag1[ix]
-        diag1[ix] *= cos
-        tempRow = cos * rhs[ix - 1] + sin * rhs[ix]
-        rhs[ix] = cos * rhs[ix] - sin * rhs[ix - 1]
-        rhs[ix - 1] = tempRow
+        diag1[ix] = denom
+        diag0[ix] = sin * diag1[ix + 1]
+        diag1[ix + 1] *= cos
+        tempRow = cos * rhs[ix] + sin * rhs[ix + 1]
+        rhs[ix + 1] = cos * rhs[ix + 1] - sin * rhs[ix]
+        rhs[ix] = tempRow
     
     # Perform back substitution
-    rhs[-2] /= diag1[-2] 
-    for ix in range(1, myOrder - 2):
-        rhs[-ix - 2] = (rhs[-ix - 2] - diag0[-ix - 2] * rhs[-ix - 1]) / diag1[-ix - 2]
+    for ix in range(1 + extraRight, myOrder - extraLeft):
+        rhs[-1 - ix] /= diag1[-1 - ix]
+        rhs[-2 - ix] -= diag0[-1 - ix] * rhs[-1 - ix]
+    rhs[-1 - myOrder + extraLeft] /= diag1[-1 - myOrder + extraLeft]
+    
+    # Save residual and adjust solution
+    residual = abs(rhs[-1 - extraRight])
+    for ix in range(extraRight):
+        rhs[-1 - extraRight+ ix] = rhs[-extraRight + ix]
     
     # Create new spline
     newNCoef = [self.nCoef[0] - 1]
-    newKnots = [list(self.knots[0][:iKnot]) + list(self.knots[0][iKnot + 1:])]
-    newCoefs = []
-    for ix in range(self.nDep):
-        oldCoefs = self.coefs[ix]
-        firstCoefs = oldCoefs[:iKnot - self.order[0] + 1]
-        lastCoefs = oldCoefs[iKnot:]
-        middleCoefs = rhs[:-1,ix]
-        newCoefs.append(list(firstCoefs) + list(middleCoefs) + list(lastCoefs))
+    newKnots = [np.delete(self.knots[0], iKnot)]
+    newCoefs = np.delete(self.coefs, iKnot - self.order[0] + 1, 1)
+    newCoefs[: , iKnot - self.order[0] : iKnot] = rhs[: -1].T
     withoutKnot = type(self)(self.nInd, self.nDep, self.order, newNCoef, newKnots, newCoefs)
-    return withoutKnot, abs(rhs[-1])
+    return withoutKnot, residual
 
-def remove_knots(self, tolerance):
+def remove_knots(self, tolerance, nLeft = 0, nRight = 0):
     scaleDep = [max(np.abs(bound[0]), np.abs(bound[1])) for bound in self.range_bounds()]
     scaleDep = [1.0 if factor == 0.0 else factor for factor in scaleDep]
     rScaleDep = np.array([1.0 / factor for factor in scaleDep])
@@ -435,12 +453,20 @@ def remove_knots(self, tolerance):
         currentFold, foldedBasis = currentSpline.fold(foldedIndices)
         while True:
             bestError = np.finfo(scaleDep[0].dtype).max
-            for ix in range(currentFold.order[0], currentFold.nCoef[0]):
-                newSpline, residual = currentFold.remove_knot(ix)
+            bestSpline = currentFold
+            ix = currentFold.order[0]
+            while ix < currentFold.nCoef[0]:
+                newSpline, residual = currentFold.remove_knot(ix, nLeft, nRight)
                 error = np.max(residual)
+                if error < 0.001 * tolerance:
+                    currentFold = newSpline
+                    continue
                 if error < bestError:
                     bestError = error
                     bestSpline = newSpline
+                ix += 1
+            if currentFold.nCoef[0] < bestSpline.nCoef[0]:
+                continue
             if bestError > tolerance:
                 break
             errorSpline = truthSpline - bestSpline.unfold(foldedIndices, foldedBasis)
@@ -508,6 +534,8 @@ 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
 
     # Step 1: Determine the knots to insert at the new domain bounds.
     newKnotsList = []
@@ -517,7 +545,7 @@ def trim(self, newDomain):
         leftBound = False # Do we have a left bound?
         newKnots = []
 
-        if bounds[0] is not None and not np.isnan(bounds[0]):
+        if not np.isnan(bounds[0]):
             if not(knots[order - 1] <= bounds[0] <= knots[-order]): raise ValueError("Invalid newDomain")
             leftBound = True
             multiplicity = order
@@ -526,7 +554,7 @@ def trim(self, newDomain):
                 multiplicity -= counts[i]
             newKnots += multiplicity * [bounds[0]]
 
-        if bounds[1] is not None and not np.isnan(bounds[1]):
+        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")
@@ -547,14 +575,22 @@ def trim(self, newDomain):
     knotsList = []
     coefIndex = [slice(None)] # First index is for nDep
     for (order, knots, bounds) in zip(spline.order, spline.knots, newDomain):
-        leftIndex = 0 if bounds[0] is None or np.isnan(bounds[0]) else np.searchsorted(knots, bounds[0])
-        rightIndex = len(knots) - order if bounds[1] is None or np.isnan(bounds[1]) else np.searchsorted(knots, bounds[1])
+        leftIndex = 0 if np.isnan(bounds[0]) else np.searchsorted(knots, bounds[0])
+        rightIndex = len(knots) - order if np.isnan(bounds[1]) else np.searchsorted(knots, bounds[1])
         knotsList.append(knots[leftIndex:rightIndex + order])
         coefIndex.append(slice(leftIndex, rightIndex))
     coefs = spline.coefs[tuple(coefIndex)]
 
     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,43 +1,12 @@
 import numpy as np
 
-def blossom(self, uvw):
-    def blossom_values(knot, knots, order, u):
-        basis = np.zeros(order, knots.dtype)
-        basis[-1] = 1.0
-        for degree in range(1, order):
-            b = order - degree
-            for i in range(knot - degree, knot):
-                alpha = (u[degree - 1] - knots[i]) / (knots[i + degree] - knots[i])
-                basis[b - 1] += (1.0 - alpha) * basis[b]
-                basis[b] *= alpha
-                b += 1
-        return basis
-
-    # Make work for scalar valued functions
-    uvw = np.atleast_1d(uvw)
-
-    # Check for evaluation point inside domain
-    dom = self.domain()
-    for ix in range(self.nInd):
-        if uvw[ix][0] < dom[ix][0] or uvw[ix][self.order[ix]-2] > dom[ix][1]:
-            raise ValueError(f"Spline evaluation outside domain: {uvw}")
-
-    # Grab all of the appropriate coefficients
-    mySection = [slice(0, self.nDep)]
-    myIndices = []
-    for iv in range(self.nInd):
-        ix = np.searchsorted(self.knots[iv], uvw[iv][0], 'right')
-        ix = min(ix, self.nCoef[iv])
-        myIndices.append(ix)
-        mySection.append(slice(ix - self.order[iv], ix))
-    myCoefs = self.coefs[tuple(mySection)]
-    for iv in range(self.nInd - 1, -1, -1):
-        bValues = blossom_values(myIndices[iv], self.knots[iv], self.order[iv], uvw[iv])
-        myCoefs = myCoefs @ bValues
-    return myCoefs
-
 def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs = False):
     basis = np.zeros(splineOrder, knots.dtype)
+    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
@@ -54,7 +23,7 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
             basis[b - 1] += -alpha * basis[b]
             basis[b] *= alpha
             b += 1
-    return basis
+    return knot, basis
 
 def curvature(self, uv):
     if self.nInd == 1:
@@ -87,16 +56,14 @@ def derivative(self, with_respect_to, uvw):
 
     # Grab all of the appropriate coefficients
     mySection = [slice(0, self.nDep)]
-    myIndices = []
+    bValues = []
     for iv in range(self.nInd):
-        ix = np.searchsorted(self.knots[iv], uvw[iv], 'right')
-        ix = min(ix, self.nCoef[iv])
-        myIndices.append(ix)
+        ix, indValues = bspline_values(None, self.knots[iv], self.order[iv], uvw[iv], with_respect_to[iv])
+        bValues.append(indValues)
         mySection.append(slice(ix - self.order[iv], ix))
     myCoefs = self.coefs[tuple(mySection)]
     for iv in range(self.nInd - 1, -1, -1):
-        bValues = bspline_values(myIndices[iv], self.knots[iv], self.order[iv], uvw[iv], with_respect_to[iv])
-        myCoefs = myCoefs @ bValues
+        myCoefs = myCoefs @ bValues[iv]
     return myCoefs
 
 def domain(self):
@@ -120,18 +87,28 @@ def evaluate(self, uvw):
 
     # Grab all of the appropriate coefficients
     mySection = [slice(0, self.nDep)]
-    myIndices = []
+    bValues = []
     for iv in range(self.nInd):
-        ix = np.searchsorted(self.knots[iv], uvw[iv], 'right')
-        ix = min(ix, self.nCoef[iv])
-        myIndices.append(ix)
+        ix, indValues = bspline_values(None, self.knots[iv], self.order[iv], uvw[iv])
+        bValues.append(indValues)
         mySection.append(slice(ix - self.order[iv], ix))
     myCoefs = self.coefs[tuple(mySection)]
     for iv in range(self.nInd - 1, -1, -1):
-        bValues = bspline_values(myIndices[iv], self.knots[iv], self.order[iv], uvw[iv])
-        myCoefs = myCoefs @ bValues
+        myCoefs = myCoefs @ bValues[iv]
     return myCoefs
 
+def greville(self, ind = 0):
+    if ind < 0 or ind >= self.nInd:  raise ValueError("Invalid independent variable")
+    myKnots = self.knots[ind]
+    knotAverages = 0
+    if self.order[ind] == 1:
+        knotAverages = 0.5 * (myKnots[1:] + myKnots[:-1])
+    else:
+        for ix in range(1, self.order[ind]):
+            knotAverages = knotAverages + myKnots[ix : ix + self.nCoef[ind]]
+        knotAverages /= (self.order[ind] - 1)
+    return knotAverages
+
 def integral(self, with_respect_to, uvw1, uvw2, returnSpline = False):
     # Make work for scalar valued functions
     uvw1 = np.atleast_1d(uvw1)
@@ -174,28 +151,24 @@ 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
+    tangentSpace = self.tangent_space(uvw)
     
-    # If self.nInd > self.nDep, transpose the tangent space and adjust the length of the normal.
-    nDep = self.nDep
-    if self.nInd > nDep:
-        tangentSpace = tangentSpace.T
+    # Record the larger dimension and ensure it comes first.
+    if self.nInd > self.nDep:
         nDep = self.nInd
+        tangentSpace = tangentSpace.T
+    else:
+        nDep = self.nDep
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = 1
+    sign = -1 if self.metadata.get("flipNormal", False) else 1
     if indices is None:
         indices = range(nDep)
         normal = np.empty(nDep, self.coefs.dtype)
     else:
         normal = np.empty(len(indices), self.coefs.dtype)
     for i in indices:
-        normal[i] = sign * np.linalg.det(np.delete(tangentSpace, i, 1))
+        normal[i] = sign * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
         sign *= -1
     
     # Normalize the result as needed.
@@ -207,4 +180,13 @@ 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)
+    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