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

bspy/spline_block.py

@@ -0,0 +1,460 @@
+import numpy as np
+import bspy.spline
+import bspy._spline_domain
+import bspy._spline_evaluation
+import bspy._spline_intersection
+import bspy._spline_fitting
+import bspy._spline_operations
+
+class SplineBlock:
+    """
+    A class to process an array-like collection of splines that represent a system of equations. 
+
+    Parameters
+    ----------
+    block : an array-like collection of rows of splines (a list of lists)
+        The block of splines represents a system of equations. Splines in the same row are treated as if they are added together. 
+        Each row need not have the same number of splines, but all splines in a row must have the same 
+        number of dependent variables (same nDep). Corresponding independent variables must have the same domain.
+
+        For example, say you wanted to represent the system: 
+        F(u, v, w) + G(u) = 0, h(u, v) = 0, where F and G are 2D vector functions and h is a scalar function. 
+        After fitting F, G, and h with splines, you'd form the following spline block: [[F, G], [h]].
+
+        You may optionally supply maps for independent variables to represent complex systems of equations. For example, 
+        say you wanted to represent a similar systems as before, but with a more complicated relationship between the 
+        independent variables: F(u, v, w) + G(v, s) = 0, h(u, t, w, s) = 0. 
+        First, you'd assign consecutive indices for each variable starting at zero. For example, (s, t, u, v, w) could be indexed as (0, 1, 2, 3, 4, 5). 
+        Then, you'd provide maps for each spline's independent variables to form the following spline block: 
+        [[([3, 4, 5], F), ([4, 0], G)], [([3, 1, 5, 0], h)]]. 
+        Notice how each spline from the first example is replaced by a (map, spline) tuple in the complex second example.
+    """
+
+    @staticmethod
+    def _map_args(map, args):
+        return [arg[map] if isinstance(arg, np.ndarray) else [arg[index] for index in map] for arg in args]
+    
+    def _block_evaluation(self, returnShape, splineFunction, args):
+        value = np.zeros(returnShape, self.coefsDtype)
+        nDep = 0
+        for row in self.block:
+            for map, spline in row:
+                value[nDep:nDep + spline.nDep] += splineFunction(spline, *SplineBlock._map_args(map, args))
+            nDep += spline.nDep
+        return value
+    
+    def _block_operation(self, splineFunction, args):
+        newBlock = []
+        for row in self.block:
+            newRow = []
+            for map, spline in row:
+                newRow.append((map, splineFunction(spline, *SplineBlock._map_args(map, args))))
+            newBlock.append(newRow)
+        return SplineBlock(newBlock)
+    
+    def __init__(self, block):
+        if isinstance(block, bspy.spline.Spline):
+            block = [[block]]
+        elif isinstance(block[0], bspy.spline.Spline) or (len(block) > 1 and isinstance(block[1], bspy.spline.Spline)):
+            block = [block]
+
+        self.block = []
+        self.nInd = 0
+        self.nDep = 0
+        self.knotsDtype = None
+        self.coefsDtype = None
+        self.size = 0
+        domain = {}
+        for row in block:
+            rowInd = 0
+            rowDep = 0
+            indSet = set()
+            newRow = []
+            for entry in row:
+                if isinstance(entry, bspy.spline.Spline):
+                    spline = entry
+                    map = list(range(rowInd, rowInd + spline.nInd))
+                else:
+                    (map, spline) = entry
+                    map = list(map) # Convert to list and make a copy
+                rowInd += spline.nInd
+                if rowDep == 0:
+                    rowDep = spline.nDep
+                    if self.nDep == 0:
+                        self.knotsDtype = spline.knots[0].dtype
+                        self.coefsDtype = spline.coefs.dtype
+                elif rowDep != spline.nDep:
+                    raise ValueError("All splines in the same row must have the same nDep")
+                d = spline.domain()
+                for ind, i in enumerate(map):
+                    if i in indSet:
+                        raise ValueError(f"Multiple splines in the same row map to independent variable {i}")
+                    else:
+                        indSet.add(i)
+                    if i in domain:
+                        if domain[i][0] != d[ind, 0] or domain[i][1] != d[ind, 1]:
+                            raise ValueError("Domains of independent variables must match")
+                    else:
+                        domain[i] = d[ind]
+                newRow.append((map, spline))
+            
+            if rowDep > 0:
+                self.nDep += rowDep
+                self.size += len(row)
+                self.block.append(newRow)
+
+        self.nInd = len(domain)
+        self._domain = []
+        for i in range(self.nInd):
+            if i in domain:
+                self._domain.append(domain[i])
+            else:
+                raise ValueError(f"Block is missing independent variable {i}")
+        self._domain = np.array(self._domain, self.knotsDtype)
+
+    def __call__(self, uvw):
+        return self.evaluate(uvw)
+
+    def __repr__(self):
+        return f"SplineBlock({self.block})"
+
+    def contours(self):
+        """
+        Find all the contour curves of a block of splines whose `nInd` is one larger than its `nDep`.
+
+        Returns
+        -------
+        curves : `iterable`
+            A collection of `Spline` curves, `u(t)`, each of whose domain is [0, 1], whose range is
+            in the parameter space of the given spline, and which satisfy `self(u(t)) = 0`. 
+
+        See Also
+        --------
+        `zeros` : Find the roots of a block of splines (nInd must match nDep).
+
+        Notes
+        -----
+        Uses `zeros` to find all intersection points and `Spline.contour` to find individual intersection curves. 
+        The algorithm used to to find all intersection curves is from Grandine, Thomas A., and Frederick W. Klein IV. 
+        "A new approach to the surface intersection problem." Computer Aided Geometric Design 14, no. 2 (1997): 111-134.
+        """
+        return bspy._spline_intersection.contours(self)
+
+    def contract(self, uvw):
+        """
+        Contract a spline block by assigning a fixed value to one or more of its independent variables.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable to contract.
+            A value of `None` for an independent variable indicates that variable should remain unchanged.
+
+        Returns
+        -------
+        block : `SplineBlock`
+            The contracted spline block.
+        """
+        # First, remap the remaining independent variables (the ones not fixed by uvw).
+        remap = []
+        newIndex = 0
+        for value in uvw:
+            if value is None:
+                remap.append(newIndex)
+                newIndex += 1
+            else:
+                remap.append(None)
+
+        # Next, rebuild the block with contracted splines.
+        newBlock = []
+        for row in self.block:
+            newRow = []
+            for map, spline in row:
+                spline = spline.contract([uvw[index] for index in map])
+                map = [remap[ind] for ind in map if uvw[ind] is None]
+                newRow.append((map, spline))
+            newBlock.append(newRow)
+        return SplineBlock(newBlock)
+
+    def derivative(self, with_respect_to, uvw):
+        """
+        Compute the derivative of the spline block at given parameter values.
+
+        Parameters
+        ----------
+        with_respect_to : `iterable`
+            An iterable of length `nInd` that specifies the integer order of derivative for each independent variable.
+            A zero-order derivative just evaluates the spline normally.
+        
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the derivative of the spline block at the given parameter values (array of size nDep).
+        """
+        return self._block_evaluation(self.nDep, bspy._spline_evaluation.derivative, (with_respect_to, uvw))
+
+    def domain(self):
+        """
+        Return the domain of a spline block.
+
+        Returns
+        -------
+        bounds : `numpy.array`
+            nInd x 2 array of the lower and upper bounds on each of the independent variables.
+        """
+        return self._domain
+    
+    def evaluate(self, uvw):
+        """
+        Compute the value of the spline block at given parameter values.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the spline block at the given parameter values (array of size nDep).
+        """
+        return self._block_evaluation(self.nDep, bspy._spline_evaluation.evaluate, (uvw,))
+    
+    def jacobian(self, uvw):
+        """
+        Compute the value of the spline block's Jacobian at given parameter values.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the spline block's Jacobian at the given parameter values. The shape of the return value is (nDep, nInd).
+        """
+        jacobian = np.zeros((self.nDep, self.nInd), self.coefsDtype)
+        uvw = np.atleast_1d(uvw)
+        nDep = 0
+        for row in self.block:
+            for map, spline in row:
+                jacobian[nDep:nDep + spline.nDep, map] += spline.jacobian(uvw[map])
+            nDep += spline.nDep
+        return jacobian
+
+    def normal(self, uvw, normalize=True, indices=None):
+        """
+        Compute the normal of the spline block at given parameter values. The number of independent variables must be
+        one different than the number of dependent variables.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+        
+        normalize : `boolean`, optional
+            If True the returned normal will have unit length (the default). Otherwise, the normal's length will
+            be the area of the tangent space (for two independent variables, its the length of the cross product of tangent vectors).
+        
+        indices : `iterable`, optional
+            An iterable of normal indices to calculate. For example, `indices=(0, 3)` will return a vector of length 2
+            with the first and fourth values of the normal. If `None`, all normal values are returned (the default).
+
+        Returns
+        -------
+        normal : `numpy.array`
+            The normal vector of the spline block at the given parameter values.
+
+        See Also
+        --------
+        `normal_spline` : Compute a spline that evaluates to the normal of the given spline block (not normalized).
+
+        Notes
+        -----
+        Attentive readers will notice that the number of independent variables could be one more than the number of 
+        dependent variables (instead of one less, as is typical). In that case, the normal represents the null space of 
+        the matrix formed by the tangents of the spline. If the null space is greater than one dimension, the normal will be zero.
+        """
+        return bspy._spline_evaluation.normal(self, uvw, normalize, indices)
+
+    def normal_spline(self, indices=None):
+        """
+        Compute a spline that evaluates to the normal of the given spline block. The length of the normal
+        is the area of the tangent space (for two independent variables, its the length of the cross product of tangent vectors).
+        The number of independent variables must be one different than the number of dependent variables.
+        Find all the contour curves of a block of splines whose `nInd` is one larger than its `nDep`.
+
+        Parameters
+        ----------
+        indices : `iterable`, optional
+            An iterable of normal indices to calculate. For example, `indices=(0, 3)` will make the returned spline compute a vector of length 2
+            with the first and fourth values of the normal. If `None`, all normal values are returned (the default).
+
+        Returns
+        -------
+        spline : `Spline`
+            The spline that evaluates to the normal of the given spline block.
+
+        See Also
+        --------
+        `normal` : Compute the normal of the spline block at given parameter values.
+
+        Notes
+        -----
+        Attentive readers will notice that the number of independent variables could be one more than the number of 
+        dependent variables (instead of one less, as is typical). In that case, the normal represents the null space of 
+        the matrix formed by the tangents of the spline block. If the null space is greater than one dimension, the normal will be zero.
+        """
+        return bspy._spline_operations.normal_spline(self, indices)
+    
+    def range_bounds(self):
+        """
+        Return the range of a spline block as lower and upper bounds on each of the
+        dependent variables.
+        """
+        return self._block_evaluation((self.nDep, 2), bspy._spline_evaluation.range_bounds, [])
+    
+    def reparametrize(self, newDomain):
+        """
+        Reparametrize a spline block to match new domain bounds. The number of knots and coefficients remain unchanged.
+
+        Parameters
+        ----------
+        newDomain : array-like
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
+            returned from `domain`). If a bound pair is `None` then the original bound (and knots) are left unchanged. 
+            For example, `[[0.0, 1.0], None]` will reparametrize the first independent variable and leave the second unchanged)
+
+        Returns
+        -------
+        block : `SplineBlock`
+            Reparametrized spline block.
+
+        See Also
+        --------
+        `domain` : Return the domain of a spline block.
+        """
+        return self._block_operation(bspy._spline_domain.reparametrize, (newDomain,))
+
+    def split(self, minContinuity = 0, breaks = None):
+        """
+        Split a spline block into separate pieces.
+
+        Parameters
+        ----------
+        minContinuity : `int`, optional
+            The minimum expected continuity of each spline block piece. The default is zero, for C0 continuity.
+
+        breaks : `iterable` of length `nInd` or `None`, optional
+            An iterable that specifies the breaks at which to separate the spline block. 
+            len(breaks[ind]) == 0 if there the spline block isn't separated for the `ind` independent variable. 
+            If breaks is `None` (the default), the spline block will only be separated at discontinuities.
+
+        Returns
+        -------
+        splineBlockArray : array of `SplineBlock`
+            A array of spline blocks with nInd dimensions containing the spline block pieces. 
+        """
+        if minContinuity < 0: raise ValueError("minContinuity must be >= 0")
+        if self.nInd < 1: return self
+
+        # Step 1: Determine all the breaks.
+        breakList = [set() for i in range(self.nInd)]
+        if breaks is not None:
+            if len(breaks) != self.nInd: raise ValueError("Invalid breaks")
+            for breakSet, knots, domain in zip(breakList, breaks, self.domain()):
+                for knot in knots:
+                    if knot < domain[0] or knot > domain[1]: raise ValueError("Break outside of domain")
+                    if domain[0] < knot < domain[1]:
+                        breakSet.add(knot)
+
+        for row in self.block:
+            for map, spline in row:
+                for i, order, knots in zip(range(spline.nInd), spline.order, spline.knots):
+                    unique, counts = np.unique(knots[order:], return_counts=True) # Skip left end
+                    for knot, count in zip(unique, counts):
+                        if count > order - 1 - minContinuity:
+                            breakList[map[i]].add(knot)
+
+        # Step 2: Determine the size and shape of the splineBlockArray and allocate it.
+        size = 1
+        shape = []
+        for i, breakSet in enumerate(breakList):
+            count = len(breakSet)
+            shape.insert(0, count) # We build the transpose due to indexing arithmetic
+            size *= count
+            breakList[i] = sorted(breakSet)
+        splineBlockArray = np.empty(size, object)
+
+        # Step 3: Split up the spline block.
+        domain = self.domain().copy()
+        for i in range(size):
+            index = i
+            for j, knots in enumerate(breakList):
+                count = len(knots)
+                ix = index % count
+                index = index // count
+                if domain[j, 1] != knots[ix]:
+                    if ix == 0:
+                        domain[j, 0] = self._domain[j, 0]
+                    else:
+                        domain[j, 0] = domain[j, 1]
+                    domain[j, 1] = knots[ix]
+
+            splineBlockArray[i] = self.trim(domain)
+        
+        # Step 4: Reshape and transpose splineBlockArray
+        return splineBlockArray.reshape(shape).T
+
+    def trim(self, newDomain):
+        """
+        Trim the domain of a spline block.
+
+        Parameters
+        ----------
+        newDomain : array-like
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
+            returned from `domain`). If a bound is None or nan then the original bound (and knots) are left unchanged.
+
+        Returns
+        -------
+        block : `SplineBlock`
+            Trimmed spline block.
+        """
+        return self._block_operation(bspy._spline_domain.trim, (newDomain,))
+    
+    def zeros(self, epsilon=None, initialScale=None):
+        """
+        Find the roots of a block of splines (nInd must match nDep).
+
+        Parameters
+        ----------
+        epsilon : `float`, optional
+            Tolerance for root precision. The root will be within epsilon of the actual root. 
+            The default is the machine epsilon.
+
+        initialScale : array-like, optional
+            The initial scale of each dependent variable (as opposed to the current scale of 
+            the spline block, which may have been normalized). The default is an array of ones (size nDep).
+
+        Returns
+        -------
+        roots : `iterable`
+            An iterable containing the roots of the block of splines. If the block is 
+            zero over an interval, that root will appear as a tuple of the interval. 
+            For curves (nInd == 1), the roots are ordered.
+        
+        See Also
+        --------
+        `contours` : Find all the contour curves of a spline block whose `nInd` is one larger than its `nDep`.
+
+        Notes
+        -----
+        Implements a variation of the projected-polyhedron technique from Sherbrooke, Evan C., and Nicholas M. Patrikalakis. 
+        "Computation of the solutions of nonlinear polynomial systems." Computer Aided Geometric Design 10, no. 5 (1993): 379-405.
+        """
+        return bspy._spline_intersection.zeros_using_projected_polyhedron(self, epsilon, initialScale)

bspy/viewer.py

@@ -144,20 +144,26 @@ class Viewer(tk.Tk):
             solid = spline
             if solid.dimension != 3:
                 return
-            if name is None:
-                name = "Solid"
-            iid = self.treeview.insert('', 'end', text=name, open=False)
+            if name is not None:
+                solid.metadata["Name"] = name
+            elif "Name" not in solid.metadata:
+                solid.metadata["Name"] = f"Solid({solid.dimension}, {solid.containsInfinity})"
+            iid = self.treeview.insert('', 'end', text=solid.metadata["Name"], open=False)
             self.splineList[iid] = solid
             self.solidList.append(solid)
             if draw:
                 self.treeview.selection_add(iid)
             for i, boundary in enumerate(solid.boundaries):
-                self.list(boundary, f"{name} boundary {i+1}", fillColor, lineColor, options, False, iid)
+                if "Name" not in boundary.manifold.metadata:
+                    boundary.manifold.metadata["Name"] = f"Boundary {i}"
+                self.list(boundary, None, fillColor, lineColor, options, False, iid)
         elif isinstance(spline, Boundary):
             boundary = spline
             if isinstance(boundary.manifold, Hyperplane):
                 uvMin = boundary.domain.bounds[:,0]
                 uvMax = boundary.domain.bounds[:,1]
+                if (uvMax - uvMin).min() < 1.0e-8:
+                    return
                 xyzMinMin = boundary.manifold.evaluate(uvMin)
                 xyzMinMax = boundary.manifold.evaluate((uvMin[0], uvMax[1]))
                 xyzMaxMin = boundary.manifold.evaluate((uvMax[0], uvMin[1]))
@@ -165,15 +171,20 @@ class Viewer(tk.Tk):
                 spline = Spline(2, 3, (2, 2), (2, 2), 
                     np.array((uvMin, uvMin, uvMax, uvMax), np.float32).T,
                     np.array(((xyzMinMin, xyzMaxMin), (xyzMinMax, xyzMaxMax)), np.float32).T)
+                spline.metadata = boundary.manifold.metadata # Ensure the spline representing the hyperplane shares the same metadata
             elif isinstance(boundary.manifold, Spline):
                 spline = boundary.manifold
-            if not hasattr(spline, "cache"):
-                spline.cache = {}
-            spline.cache["trim"] = self.frame.tessellate2DSolid(boundary.domain)
+            tesselation = self.frame.tessellate2DSolid(boundary.domain)
+            if tesselation is not None:
+                if not hasattr(spline, "cache"):
+                    spline.cache = {}
+                spline.cache["trim"] = tesselation
             self.list(spline, name, fillColor, lineColor, options, draw, parentIID)
         else:
-            if "Name" not in spline.metadata:
-                spline.metadata["Name"] = f"Spline({spline.nInd}, {spline.nDep})" if name is None else name
+            if name is not None:
+                spline.metadata["Name"] = name
+            elif "Name" not in spline.metadata:
+                spline.metadata["Name"] = f"Spline({spline.nInd}, {spline.nDep})"
             if fillColor is not None:
                 spline.metadata["fillColor"] = fillColor
             if lineColor is not None:
@@ -210,7 +221,7 @@ class Viewer(tk.Tk):
                 if isinstance(spline, Spline):
                     self.list(spline)
                 else:
-                    self.list_solid(spline)
+                    self.list(spline)
     
     def erase_all(self):
         """Stop drawing all splines. Splines remain in the treeview."""
@@ -223,8 +234,7 @@ class Viewer(tk.Tk):
         """Remove splines from the treeview."""
         for item in self.treeview.selection():
             spline = self.splineList.pop(item)
-            self.splineDrawList.remove(spline)
-        self.treeview.delete(*self.treeview.selection())
+            self.treeview.delete(item)
         self.update()
 
     def empty(self):
@@ -263,7 +273,7 @@ class Viewer(tk.Tk):
         for item in self.treeview.selection():
             spline = self.splineList[item]
             if isinstance(spline, Spline):
-                coefs = spline.cache["coefs32"].T[:3]
+                coefs = spline.cache["xyzCoefs32"].T
                 coefsAxis = tuple(range(1, spline.nInd + 1))
                 if gotOne:
                     splineMin = np.minimum(splineMin, coefs.min(axis=coefsAxis))
@@ -276,7 +286,7 @@ class Viewer(tk.Tk):
             elif isinstance(spline, Solid):
                 for subitem in self.treeview.get_children(item):
                     spline = self.splineList[subitem]
-                    coefs = spline.cache["coefs32"].T[:3]
+                    coefs = spline.cache["xyzCoefs32"].T
                     coefsAxis = tuple(range(1, spline.nInd + 1))
                     if gotOne:
                         splineMin = np.minimum(splineMin, coefs.min(axis=coefsAxis))
@@ -426,7 +436,7 @@ class Viewer(tk.Tk):
         fillColor : `numpy.array`
             Array of four floats (r, g, b, a) in the range [0, 1].
         """
-        return spline.metadata["fillColor"]
+        return np.array(spline.metadata["fillColor"], np.float32)
 
     @staticmethod
     def set_fill_color(spline, r, g=None, b=None, a=None):
@@ -467,7 +477,7 @@ class Viewer(tk.Tk):
         lineColor : `numpy.array`
             Array of four floats (r, g, b, a) in the range [0, 1].
         """
-        return spline.metadata["lineColor"]
+        return np.array(spline.metadata["lineColor"], np.float32)
 
     @staticmethod
     def set_line_color(spline, r, g=None, b=None, a=None):

{bspy-4.1.dist-info → bspy-4.3.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 4.1
+Version: 4.3
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
 Author-email: ericbrec@msn.com
 License: MIT
 Project-URL: Bug Tracker, http://github.com/ericbrec/BSpy/issues
-Keywords: opengl,bspline,B-spline,nub,tkinter
+Keywords: bspline,B-spline,nub,solid,solid modeling,geometry,csg,opengl,tkinter
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Environment :: Console
@@ -34,14 +34,22 @@ Library for manipulating and rendering B-spline curves, surfaces, and multidimen
 
 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. 
+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 can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics. 
+Spline 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.
+There are methods to evaluate spline values, derivatives, normals, integrals, continuity, 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, split, 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. 
+Splines can be saved and loaded in json format.
 
 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 [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. Solids can be saved and loaded in json format.
+
+The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to process an array-like collection of splines that represent a system of equations. There are highly-optimized methods to compute the contours and zeros of a spline block, as well as a variety of methods to manipulate and evaluate a spline block and its derivatives.
+
+The [BSpyConvert](https://pypi.org/project/BSpyConvert/) package converts BSpy splines and solid models to and from [OpenCascade (OCCT)](https://dev.opencascade.org/) equivalents and a variety of geometry and CAD file formats, including STEP, IGES, and STL.
 
 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 

bspy-4.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+bspy/__init__.py,sha256=LnJx7iHah7A4vud9y64LR61rBtYnuhV4Wno9O2IEK1I,1499
+bspy/_spline_domain.py,sha256=bQQsJlKstIYdbEKIW7vr-7nTKat8y9thYc7jxzZHNFQ,33238
+bspy/_spline_evaluation.py,sha256=WIv0tLZNLy0uHNj9YwR7vbputgT2Mn5QDXZzlD6ousk,9638
+bspy/_spline_fitting.py,sha256=CEkmUQalXTT5N5ZOJpFF4Y2DI-ARlZap9IaCJ_Zg2Ws,50762
+bspy/_spline_intersection.py,sha256=8FPTh4IDtzkRpieNtlnw8VhLabPzY4E_LWDaGxHIMTM,66973
+bspy/_spline_operations.py,sha256=8yJGp4iVVvQ1zcUHAKgNq2TMIjDUhacf5XSoHp2jmVo,42799
+bspy/hyperplane.py,sha256=gnVZ7rjisGpzHfm1moItyzq8mO7HguzzpY4dpFwyDiw,24840
+bspy/manifold.py,sha256=vjgyz0M1mkgenUnTIbX7NFg1fUCgXtStr6ofF4oSLgg,14470
+bspy/solid.py,sha256=ufNs5JV0jQ1A13pUY61N0pcW6Ep-DZmXUau7GHHcKk4,36992
+bspy/spline.py,sha256=1USitAm1FIQg5JuWa1xLrVQQ2cWRGfP4VhQnS8XOKc8,101377
+bspy/splineOpenGLFrame.py,sha256=N8elVJrt24_utOSoTaM5Ue5De2M4DxrquyB7o2lLLD4,96256
+bspy/spline_block.py,sha256=O8MzfBEygVdAx57DoJMwzjkw349BQqht7_RVu8MO0Fg,20127
+bspy/viewer.py,sha256=_iQCyEpsBFPBLLuHq7tc43IPVvlcqxdp0Hig0uvpQns,34349
+bspy-4.3.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-4.3.dist-info/METADATA,sha256=lV6eciVqRf3FqWslbTD5OWb3gMD6-gv6WB-hkSRadPM,7044
+bspy-4.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+bspy-4.3.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-4.3.dist-info/RECORD,,

{bspy-4.1.dist-info → bspy-4.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bspy-4.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-bspy/__init__.py,sha256=q8XOJK3FsbHybfy2CSPufY5Z5SQJNxK_tH-d9zXR5vY,1308
-bspy/_spline_domain.py,sha256=kklvRrSeEEUUQ48yXvCCDzHMRPd4_BHICxAsOhyxhjk,30178
-bspy/_spline_evaluation.py,sha256=3cWD3sL4odnZ4w1DBQFmUnPg2PuPpSfaGfNcBl8ZrW0,7079
-bspy/_spline_fitting.py,sha256=hFhPyL39d87IGZiAs8teFhYZHxPN1EvzQYxHcDTeBLw,45318
-bspy/_spline_intersection.py,sha256=EV19Qt-kccr5K17aB1EETJXENdz-_UJlYTKWjK-ueJU,58324
-bspy/_spline_operations.py,sha256=y98zl-r31xsZzD6X0VYbuEPUabg3UNC_ERCbkXZRZXU,42530
-bspy/hyperplane.py,sha256=gRConjCEdMAjP8UXA7kaYU--NQHr1tYiVHtmZzLNnqY,24639
-bspy/manifold.py,sha256=29KkZXvv759-aywGd7Ek4Egm-DCBNDTEfusW_Az1kC4,14244
-bspy/solid.py,sha256=qbHofcdNbMTaoCCfKfxloYiEqZDsxfOIJD3MwZguEJ8,36444
-bspy/spline.py,sha256=747e_kChnGnN2Y93EcP9XymDrf2T4NFFweFB_YghEvw,94776
-bspy/splineOpenGLFrame.py,sha256=ezPUyDr9QKF0KU7H6XjHL-HhN23ffC8KbxGhGgGJhQ0,95843
-bspy/viewer.py,sha256=HdtjAj5CZnv4VKcfS8MhT-ciPEPRVNUTp-02TW1NQSU,33717
-bspy-4.1.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-4.1.dist-info/METADATA,sha256=Fe5wy39gSJOVk7Z3Ruz1Utm3oYZQlPyyJJMYGu6YvP4,6152
-bspy-4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bspy-4.1.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-4.1.dist-info/RECORD,,