bspy 3.0.1__tar.gz → 4.1__tar.gz

{bspy-3.0.1 → bspy-4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 3.0.1
+Version: 4.1
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -25,36 +25,38 @@ Requires-Python: >=3.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
+Requires-Dist: scipy
 Requires-Dist: PyOpenGL
 Requires-Dist: pyopengltk
 
 # BSpy
 Library for manipulating and rendering B-spline curves, surfaces, and multidimensional manifolds with non-uniform knots in each dimension.
 
+The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
+
 The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for 
 scalar and vector functions of single and multiple variables. It also has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
 Other methods add, subtract, and multiply splines, as well as confine spline curves to a given range. 
 There are methods to evaluate spline values, derivatives, integrals, normals, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. There are methods to manipulate the range of splines, including dot product, cross product, translate, rotate, scale, and transform. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
 
-The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
-[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Only tested on Windows systems.
+The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.
 
-The [DrawableSpline](https://ericbrec.github.io/BSpy/bspy/drawableSpline.html) class converts a 
-[Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) to a curve, surface, or solid that can be drawn in a 
-[SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html). Only 1D, 2D, and 3D splines can be converted. 
-Spline surfaces and solids with more than 3 dependent variables will have their added dimensions rendered as colors 
-(up to 6 dependent variables are supported).
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids.
 
-The [bspyApp](https://ericbrec.github.io/BSpy/bspy/bspyApp.html) class is a 
+The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
+[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Spline surfaces with more 
+than 3 dependent variables will have their added dimensions rendered as colors (up to 6 dependent variables are supported). Only tested on Windows systems.
+
+The [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) class is a 
 [tkinter.Tk](https://docs.python.org/3/library/tkinter.html) app that hosts a 
 [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html), 
-a listbox full of splines, and a set of controls to adjust and view the selected splines. Only tested on Windows systems.
+a tree view full of solids and splines, and a set of controls to adjust and view the selected solids and splines. Only tested on Windows systems.
 
-The [bspyGraphics](https://ericbrec.github.io/BSpy/bspy/bspyApp.html#bspyGraphics) class is a graphics engine to display splines.
-It launches a [bspyApp](https://ericbrec.github.io/BSpy/bspy/bspyApp.html) and issues commands to the app for use 
+The [Graphics](https://ericbrec.github.io/BSpy/bspy/viewer.html#Graphics) class is a graphics engine to display splines.
+It launches a [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) and issues commands to the viewer for use 
 in [jupyter](https://jupyter.org/) notebooks and other scripting environments. Only tested on Windows systems.
 
-![bspyApp rendering the Utah teapot](https://ericbrec.github.io/BSpy/bspyApp.png "bspyApp rendering the Utah teapot")
+![Viewer rendering the Utah teapot](https://ericbrec.github.io/BSpy/viewer.png "Viewer rendering the Utah teapot")
 
 The full documentation for BSpy can be found [here](https://ericbrec.github.io/BSpy), its GitHub project can be found 
 [here](https://github.com/ericbrec/BSpy), a test suite can be found [here](https://github.com/ericbrec/BSpy/tree/main/tests), and
@@ -65,3 +67,13 @@ a set of examples, including a jupyter notebook, can be found [here](https://git
 * Spline.common_basis is now a static method (see documentation for details)
 * Spline.least_squares changed arguments (see documentation for details)
 * Spline.load always returns a list of splines
+
+### Release 4.0 breaking changes
+* Removed Spline blossom method
+* Removed DrawableSpline class
+* Changed bspyApp class name to Viewer
+* Changed Viewer listbox to use extended selection (shift and ctrl keys)
+* Changed bspyGraphics class name to Graphics
+* Moved DrawableSpine methods for adjusting spline appearance to Viewer (see documentation for details)
+* Spline.bspline_values changed arguments (see documentation for details)
+* Spline.intersect changed return values (see documentation for details)

bspy-4.1/README.md

@@ -0,0 +1,48 @@
+# BSpy
+Library for manipulating and rendering B-spline curves, surfaces, and multidimensional manifolds with non-uniform knots in each dimension.
+
+The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
+
+The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for 
+scalar and vector functions of single and multiple variables. It also has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
+Other methods add, subtract, and multiply splines, as well as confine spline curves to a given range. 
+There are methods to evaluate spline values, derivatives, integrals, normals, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. There are methods to manipulate the range of splines, including dot product, cross product, translate, rotate, scale, and transform. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+
+The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.
+
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids.
+
+The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
+[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Spline surfaces with more 
+than 3 dependent variables will have their added dimensions rendered as colors (up to 6 dependent variables are supported). Only tested on Windows systems.
+
+The [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) class is a 
+[tkinter.Tk](https://docs.python.org/3/library/tkinter.html) app that hosts a 
+[SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html), 
+a tree view full of solids and splines, and a set of controls to adjust and view the selected solids and splines. Only tested on Windows systems.
+
+The [Graphics](https://ericbrec.github.io/BSpy/bspy/viewer.html#Graphics) class is a graphics engine to display splines.
+It launches a [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) and issues commands to the viewer for use 
+in [jupyter](https://jupyter.org/) notebooks and other scripting environments. Only tested on Windows systems.
+
+![Viewer rendering the Utah teapot](https://ericbrec.github.io/BSpy/viewer.png "Viewer rendering the Utah teapot")
+
+The full documentation for BSpy can be found [here](https://ericbrec.github.io/BSpy), its GitHub project can be found 
+[here](https://github.com/ericbrec/BSpy), a test suite can be found [here](https://github.com/ericbrec/BSpy/tree/main/tests), and
+a set of examples, including a jupyter notebook, can be found [here](https://github.com/ericbrec/BSpy/tree/main/examples).
+
+### Release 3.0 breaking changes
+* Removed accuracy as a member of Spline
+* Spline.common_basis is now a static method (see documentation for details)
+* Spline.least_squares changed arguments (see documentation for details)
+* Spline.load always returns a list of splines
+
+### Release 4.0 breaking changes
+* Removed Spline blossom method
+* Removed DrawableSpline class
+* Changed bspyApp class name to Viewer
+* Changed Viewer listbox to use extended selection (shift and ctrl keys)
+* Changed bspyGraphics class name to Graphics
+* Moved DrawableSpine methods for adjusting spline appearance to Viewer (see documentation for details)
+* Spline.bspline_values changed arguments (see documentation for details)
+* Spline.intersect changed return values (see documentation for details)

bspy-4.1/bspy/__init__.py

@@ -0,0 +1,26 @@
+"""
+BSpy is a python library for manipulating and rendering non-uniform B-splines.
+
+Available subpackages
+---------------------
+`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.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.splineOpenGLFrame import SplineOpenGLFrame
+from bspy.viewer import Viewer, Graphics

{bspy-3.0.1 → bspy-4.1}/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-3.0.1 → bspy-4.1}/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