bspy 1.5.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

bspy/spline.py

@@ -6,14 +6,6 @@ import bspy._spline_intersection
 import bspy._spline_fitting
 import bspy._spline_operations
 
-def _isIterable(object):
-    result = True
-    try:
-        iterator = iter(object)
-    except TypeError:
-        result = False
-    return result
-
 class Spline:
     """
     A class to model, represent, and process piecewise polynomial tensor product
@@ -84,8 +76,8 @@ class Spline:
         self.accuracy = accuracy
         self.metadata = dict(metadata)
 
-    def __call__(self, uvw):
-        return self.evaluate(uvw)
+    def __call__(self, *uvw, **kwargs):
+        return self.evaluate(*uvw, **kwargs)
 
     def __repr__(self):
         return f"Spline({self.nInd}, {self.nDep}, {self.order}, " + \
@@ -94,81 +86,60 @@ class Spline:
 
     def __add__(self, other):
         if isinstance(other, Spline):
-            return self.add(other)
-        elif _isIterable(other):
-            return self.translate(other)
+            return self.add(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
         else:
-            return NotImplemented
+            return self.translate(other)
 
     def __radd__(self, other):
         if isinstance(other, Spline):
-            return other.add(self)
-        elif _isIterable(other):
-            return self.translate(other)
+            return other.add(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
         else:
-            return NotImplemented
+            return self.translate(other)
 
     def __matmul__(self, other):
-        if _isIterable(other):
-            if not isinstance(other, np.ndarray):
-                other = np.array(other)
-            if len(other.shape) == 2:
+        if isinstance(other, Spline):
+            return self.multiply(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'D')
+        else:
+            other = np.atleast_1d(other)
+            if len(other.shape) > 1:
                 return self.transform(other.T)
             else:
                 return self.dot(other)
-        else:
-            return NotImplemented
 
     def __rmatmul__(self, other):
-        if _isIterable(other):
-            if not isinstance(other, np.ndarray):
-                other = np.array(other)
-            if len(other.shape) == 2:
+        if isinstance(other, Spline):
+            return other.multiply(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'D')
+        else:
+            other = np.atleast_1d(other)
+            if len(other.shape) > 1:
                 return self.transform(other)
             else:
                 return self.dot(other)
-        else:
-            return NotImplemented
 
     def __mul__(self, other):
         if isinstance(other, Spline):
-            if self.nDep == 1 or other.nDep == 1:
-                return self.multiply(other, None, 'S')
-            else:
-                return self.multiply(other, None, 'D')
-        elif np.isscalar(other) or _isIterable(other):
-            return self.scale(other)
+            return self.multiply(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'S')
         else:
-            return NotImplemented
+            return self.scale(other)
 
     def __rmul__(self, other):
         if isinstance(other, Spline):
-            if self.nDep == 1 or other.nDep == 1:
-                return other.multiply(self, None, 'S')
-            else:
-                return other.multiply(self, None, 'D')
-            return other.multiply(self)
-        elif np.isscalar(other) or _isIterable(other):
-            return self.scale(other)
+            return other.multiply(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'S')
         else:
-            return NotImplemented
+            return self.scale(other)
 
     def __sub__(self, other):
         if isinstance(other, Spline):
-            return self.subtract(other)
-        elif _isIterable(other):
-            return self.translate(-np.array(other))
+            return self.subtract(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
         else:
-            return NotImplemented
+            return self.translate(-np.atleast_1d(other))
 
     def __rsub__(self, other):
         if isinstance(other, Spline):
-            return other.subtract(self)
-        elif _isIterable(other):
+            return other.subtract(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
+        else:
             spline = self.scale(-1.0)
             return spline.translate(other)
-        else:
-            return NotImplemented
 
     def add(self, other, indMap = None):
         """
@@ -201,10 +172,12 @@ class Spline:
 
         Notes
         -----
+        Equivalent to spline1 + spline2 with indMap = range(min(spline1.nInd, spline2.nInd)).
+        
         Uses `common_basis` to ensure mapped variables share the same order and knots. 
         """
         if indMap is not None:
-            indMap = [mapping if _isIterable(mapping) else (mapping, mapping) for mapping in indMap]
+            indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return bspy._spline_operations.add(self, other, indMap)
 
     def blossom(self, uvw):
@@ -274,6 +247,33 @@ class Spline:
         """
         return bspy._spline_evaluation.bspline_values(knot, knots, splineOrder, u, derivativeOrder, taylorCoefs)
 
+    @staticmethod
+    def circular_arc(radius, angle, tolerance = None):
+        """
+        Create a 2D circular arc for a given radius and angle accurate to within a given tolerance.
+
+        Parameters
+        ----------
+        radius : `float`
+            The radius of the circular arc.
+
+        angle : `float`
+            The angle of the circular arc measured in degrees starting at the x-axis rotating counterclockwise.
+
+        tolerance : `float`, optional
+            The maximum allowed error in the circular arc (default is machine epsilon).
+
+        Returns
+        -------
+        spline : `Spline`
+            A spline curve for the circular arc (domain from 0 to 1).
+
+        See Also
+        --------
+        `section` : Fit a planar section to the list of 4-tuples of data.
+        `revolve` : Rotate the spline to create a surface of revolution.
+        """
+        return bspy._spline_fitting.circular_arc(radius, angle, tolerance)
 
     def clamp(self, left, right):
         """
@@ -477,7 +477,7 @@ class Spline:
             The type of product to perform on the dependent variables (default is 'S').
                 'C' is for a cross product, self x other (nDep must be 2 or 3).
                 'D' is for a dot product (nDep must match).
-                'S' is for a scalar product (nDep must be 1 for one of the splines).
+                'S' is for a scalar product (nDep must match or be 1 for one of the splines).
         
         Returns
         -------
@@ -495,7 +495,7 @@ class Spline:
         Computer Aided Geometric Design 11, no. 6 (1994): 597-620.
         """
         if indMap is not None:
-            indMap = [(*(mapping if _isIterable(mapping) else (mapping, mapping)), True) for mapping in indMap]
+            indMap = [(mapping, mapping, True) if np.isscalar(mapping) else (*mapping, True) for mapping in indMap]
         return bspy._spline_operations.multiplyAndConvolve(self, other, indMap, productType)
 
     def copy(self, metadata={}):
@@ -534,7 +534,28 @@ class Spline:
         """
         return bspy._spline_operations.cross(self, vector)
 
-    def derivative(self, with_respect_to, uvw):
+    def curvature(self, uvw):
+        """
+        Compute the curvature of a univariate spline.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : scalar
+            The value of the curvature at the given point on the curve.
+        
+        Notes
+        -----
+        Computes the curvature of the graph of the function if nDep == 1.  If nDep == 1 or 2,
+        then the curvature is computed as a signed quantity.
+        """
+        return bspy._spline_evaluation.curvature(self, uvw)
+
+    def derivative(self, with_respect_to, *uvw, **kwargs):
         """
         Compute the derivative of the spline at given parameter values.
 
@@ -544,13 +565,18 @@ class Spline:
             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).
+        *uvw : `iterable` or iterable of iterables
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values), or 
+            an iterable of iterables of length `nInd` that specifies values for each independent variable (numpy ufunc style).
+
+        **kwargs:
+            For other keyword-only arguments, see the `ufunc docs <https://numpy.org/doc/stable/reference/ufuncs.html#ufuncs-kwargs>`_.
 
         Returns
         -------
         value : `numpy.array`
-            The value of the derivative of the spline at the given parameter values.
+            The value of the derivative of the spline at the given parameter values (array of size nDep). If multiple points are 
+            passed (numpy ufunc style), then multiple arrays are returned, one for each dependent variable.
 
         See Also
         --------
@@ -566,7 +592,13 @@ class Spline:
         evaluated, then the dot product of those B-splines with the vector of
         B-spline coefficients is computed.
         """
-        return bspy._spline_evaluation.derivative(self, with_respect_to, uvw)
+        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+            def vectorized(*uvwInstance):
+                return tuple(bspy._spline_evaluation.derivative(self, with_respect_to, uvwInstance))
+            uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
+            return uFunc(*uvw, **kwargs)
+        else:
+            return bspy._spline_evaluation.derivative(self, with_respect_to, *uvw)
 
     def differentiate(self, with_respect_to = 0):
         """
@@ -623,6 +655,10 @@ class Spline:
         See Also
         --------
         `multiply` : Multiply two splines (cross, dot, or scalar product).
+
+        Notes
+        -----
+        Equivalent to spline @ vector.
         """
         return bspy._spline_operations.dot(self, vector)
 
@@ -685,19 +721,24 @@ class Spline:
         """
         return bspy._spline_domain.elevate_and_insert_knots(self, m, newKnots)
 
-    def evaluate(self, uvw):
+    def evaluate(self, *uvw, **kwargs):
         """
         Compute the value of the spline at given parameter values.
 
         Parameters
         ----------
-        uvw : `iterable`
-            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+        *uvw : `iterable` or iterable of iterables
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values), or 
+            an iterable of iterables of length `nInd` that specifies values for each independent variable (numpy ufunc style).
+
+        **kwargs:
+            For other keyword-only arguments, see the `ufunc docs <https://numpy.org/doc/stable/reference/ufuncs.html#ufuncs-kwargs>`_.
 
         Returns
         -------
         value : `numpy.array`
-            The value of the spline at the given parameter values.
+            The value of the spline at the given parameter values (array of size nDep). If multiple points are 
+            passed (numpy ufunc style), then multiple arrays are returned, one for each dependent variable.
 
         See Also
         --------
@@ -705,12 +746,20 @@ class Spline:
 
         Notes
         -----
+        Equivalent to spline(*uvw, **kwargs).
+
         The evaluate method uses the de Boor recurrence relations for a B-spline
         series to evaluate a spline.  The non-zero B-splines are
         evaluated, then the dot product of those B-splines with the vector of
         B-spline coefficients is computed.
         """
-        return bspy._spline_evaluation.evaluate(self, uvw)
+        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+            def vectorized(*uvwInstance):
+                return tuple(bspy._spline_evaluation.evaluate(self, uvwInstance))
+            uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
+            return uFunc(*uvw, **kwargs)
+        else:
+            return bspy._spline_evaluation.evaluate(self, *uvw)
 
     def extrapolate(self, newDomain, continuityOrder):
         """
@@ -773,6 +822,31 @@ class Spline:
         """
         return bspy._spline_domain.fold(self, foldedInd)
     
+    def graph(self):
+        """
+        Generate the spline which is the graph of the given spline.
+        
+        Parameters
+        ----------
+        
+        Returns
+        -------
+        Given a spline with n independent variables and m dependent variables, generate a new
+        spline with n independent variables which has n + m dependent variables, the first n of
+        which are just the independent variables themselves.  For example, given a scalar
+        valued function f of two variables u and v, return the spline of two variables whose
+        three dependent variables are (u, v, f(u,v)).
+        
+        See Also
+        --------
+        `add` : Add two splines together
+
+        Notes
+        -----
+        Makes use of matrix spline multiply and tensor product addition for splines.
+        """
+        return bspy._spline_operations.graph(self)
+    
     def insert_knots(self, newKnots):
         """
         Insert new knots into a spline.
@@ -893,9 +967,9 @@ class Spline:
         if not(self.nDep == other.nDep): raise ValueError("The number of dependent variables for both splines much match.")
         freeParameters = self.nInd + other.nInd - self.nDep
         if freeParameters == 0:
-            return (self - other).zeros()
+            return self.subtract(other).zeros()
         elif freeParameters == 1:
-            return (self - other).contours()
+            return self.subtract(other).contours()
         else:
             return NotImplemented
 
@@ -1061,7 +1135,7 @@ class Spline:
             The type of product to perform on the dependent variables (default is 'S').
                 'C' is for a cross product, self x other (nDep must be 2 or 3).
                 'D' is for a dot product (nDep must match).
-                'S' is for a scalar product (nDep must be 1 for one of the splines).
+                'S' is for a scalar product (nDep must match or be 1 for one of the splines).
         
         Returns
         -------
@@ -1076,11 +1150,13 @@ class Spline:
 
         Notes
         -----
+        Equivalent to spline1 * spline2 with indMap = range(min(spline1.nInd, spline2.nInd)) and productType = 'S'.
+        
         Taken in part from Lee, E. T. Y. "Computing a chain of blossoms, with application to products of splines." 
         Computer Aided Geometric Design 11, no. 6 (1994): 597-620.
         """
         if indMap is not None:
-            indMap = [(*(mapping if _isIterable(mapping) else (mapping, mapping)), False) for mapping in indMap]
+            indMap = [(mapping, mapping, False) if np.isscalar(mapping) else (*mapping, False) for mapping in indMap]
         return bspy._spline_operations.multiplyAndConvolve(self, other, indMap, productType)
 
     def normal(self, uvw, normalize=True, indices=None):
@@ -1156,49 +1232,60 @@ class Spline:
         """
         return bspy._spline_evaluation.range_bounds(self)
 
-    def remove_knots(self, oldKnots=((),), maxRemovalsPerKnot=0, tolerance=None):
+    def remove_knot(self, iKnot):
         """
-        Remove interior knots from a spline.
-
+        Remove a single knot from a univariate spline.
+        
         Parameters
         ----------
-        oldKnots : `iterable` of length `nInd`, optional
-            An iterable that specifies the knots that can be removed from each independent variable's interior knots. 
-            len(newKnots[ind]) == 0 if all interior knots can be removed for the `ind` independent variable (the default). 
-            Knots that don't appear in the independent variable's interior knots are ignored.
+        iKnot : integer
+            index of the knot to remove from the spline
+        
+        Returns
+        -------
+        spline : `Spline`
+            New spline with the specified knot removed
+        residual : array-like
+            A vector containing the least squares residuals for each dependent variable
         
-        maxRemovalsPerKnot : `int`, optional
-            A non-zero count of the largest number of times a knot can be removed. For example, one means that 
-            only one instance of each knot can be removed. (Zero means each knot can be removed completely, 
-            which is the default.)
+        See Also
+        --------
+        `remove_knots`
         
-        tolerance : `float` or `None`, optional
-            The maximum residual error permitted after removing a knot. Knots will not be removed if the 
-            resulting residual error is above this threshold. Default is `None`, meaning all specified knots 
-            will be removed up to `maxRemovalsPerKnot`.
+        Notes
+        -----
+        Solves a simple least squares problem
+        """
+        return bspy._spline_domain.remove_knot(self, iKnot)
+    
+    def remove_knots(self, tolerance = 1.0e-14):
+        """
+        Remove interior knots from a spline.
+
+        Parameters
+        ----------
+        tolerance : `float`, optional
+            The maximum pointwise relative error permitted after removing all the knots. Knots will be
+            removed until removal of the next knot would put the pointwise error above the threshold.
+            The default is 1.0e-14 which is relative to the size of each of the dependent variables.
 
         Returns
         -------
         spline : `Spline`
             A spline with the knots removed.
-        
-        totalRemoved : `int`
-            The total number of knots removed.
-        
-        residualError : `float`
-            The residual error relative to the old spline. (The returned spline's accuracy is also adjusted accordingly.)
 
         See Also
         --------
         `insert_knots` : Insert new knots into a spline.
+        `remove_knot` : Remove an indicated knot from a spline.
         `trim` : Trim the domain of a spline.
 
         Notes
         -----
-        Implements a variation of the algorithms from Tiller, Wayne. "Knot-removal algorithms for NURBS curves and surfaces." Computer-Aided Design 24, no. 8 (1992): 445-453.
+        Calls `remove_knot` repeatedly until no longer possible.
         """
-        return bspy._spline_domain.remove_knots(self, oldKnots, maxRemovalsPerKnot, tolerance)
-
+        return bspy._spline_domain.remove_knots(self, tolerance)
+    
     def reparametrize(self, newDomain):
         """
         Reparametrize a spline to match new domain bounds. The spline's number of knots and its coefficients remain unchanged.
@@ -1241,9 +1328,46 @@ class Spline:
         """
         return bspy._spline_domain.reverse(self, variable)
 
+    def revolve(self, angle):
+        """
+        Rotate the spline to create a surface of revolution (nDep must equal 2, 
+        first dimension provides the radius for x and y, second dimension provides the z).
+
+        Parameters
+        ----------
+        angle : `float`
+            The angle of the circular arc measured in degrees starting at the x-axis rotating counterclockwise.
+
+        Returns
+        -------
+        spline : `Spline`
+            Surface of revolution (first independent variable sweeps the arc from 0 to 1).
+
+        See Also
+        --------
+        `circular_arc` : Create a 2D circular arc for a given radius and angle accurate to within a given tolerance.
+        """
+        return bspy._spline_fitting.revolve(self, angle)
+
     @staticmethod
     def ruled_surface(spline1, spline2):
-       return bspy._spline_fitting.ruled_surface(spline1, spline2)
+        """
+        Create a ruled surface between two splines.
+
+        Parameters
+        ----------
+        spline1 : `Spline`
+            The first spline (must have the same nInd and nDep as the second spline).
+
+        spline2 : `Spline`
+            The second spline (must have the same nInd and nDep as the first spline).
+        
+        Returns
+        -------
+        spline : `Spline`
+            Ruled surface between spline1 and spline2.
+        """
+        return bspy._spline_fitting.ruled_surface(spline1, spline2)
     
     def save(self, fileName):
         """
@@ -1288,6 +1412,10 @@ class Spline:
         `multiply` : Multiply two splines (cross, dot, or scalar product).
         `transform` : Transform a spline by the given matrix.
         `translate` : Translate a spline by the given translation vector.
+
+        Notes
+        -----
+        Equivalent to spline * multiplier.
         """
         return bspy._spline_operations.scale(self, multiplier)
     
@@ -1316,6 +1444,10 @@ class Spline:
         consecutive data points without passing through an intermediate inflection point (i.e. a point which
         has zero curvature and at which the sign of the curvature changes), then this method will fail
         with an error.
+
+        See Also
+        --------
+        `circular_arc` : Create a 2D circular arc for a given radius and angle accurate to within a given tolerance.
         """
         return bspy._spline_fitting.section(xytk)
 
@@ -1350,10 +1482,12 @@ class Spline:
 
         Notes
         -----
+        Equivalent to spline1 - spline2 with indMap = range(min(spline1.nInd, spline2.nInd)).
+        
         Uses `common_basis` to ensure mapped variables share the same order and knots. 
         """
         if indMap is not None:
-            indMap = [mapping if _isIterable(mapping) else (mapping, mapping) for mapping in indMap]
+            indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return self.add(other.scale(-1.0), indMap)
 
     def transform(self, matrix, maxSingularValue=None):
@@ -1378,6 +1512,10 @@ class Spline:
         --------
         `scale` : Scale a spline by the given scalar or scale vector.
         `translate` : Translate a spline by the given translation vector.
+
+        Notes
+        -----
+        Equivalent to spline @ matrix.
         """
         return bspy._spline_operations.transform(self, matrix, maxSingularValue)
 
@@ -1399,6 +1537,10 @@ class Spline:
         --------
         `scale` : Scale a spline by the given scalar or scale vector.
         `transform` : Transform a spline by the given matrix.
+        
+        Notes
+        -----
+        Equivalent to spline + translationVector.
         """
         return bspy._spline_operations.translate(self, translationVector)
 

{bspy-1.5.0.dist-info → bspy-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 1.5.0
+Version: 2.1.0
 Summary: Library for manipulating and rendering non-uniform b-splines
 Home-page: http://github.com/ericbrec/bspy
 Author: Eric Brechner
@@ -33,8 +33,9 @@ Requires-Dist: pyopengltk
 Library for manipulating and rendering b-spline curves, surfaces, and multidimensional manifolds with non-uniform knots in each dimension.
 
 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. Other methods add, subtract, multiply, and linearly transform splines, as well as confine spline curves to a given range. 
-There are methods to evaluate spline values, derivatives, integrals, normals, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+scalar and vector functions of single and multiple variables. It also has methods to create circular arcs, ruled surfaces, and surfaces of revolution. 
+Other methods add, subtract, multiply, and linearly transform 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, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. 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.

bspy-2.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bspy/__init__.py,sha256=XRBelbYtbhB6AWKh8DTsWVMDIteVxUm7Cf_S1fkqeEs,851
+bspy/_spline_domain.py,sha256=XDctoM5Gd9KF5OhMb2eaZ6oAk4MSecCTdDqc9qX6BRE,28333
+bspy/_spline_evaluation.py,sha256=1aCf4Op5zQNv-_wW2IOR13MieuYPVJrN1cJCBiI8AaY,7534
+bspy/_spline_fitting.py,sha256=oPaP0kcaBUQK3T6eHPFys9rpfhkWccr8TQDPQi7Egb8,25993
+bspy/_spline_intersection.py,sha256=gWs22hfIKqD6YZaeFWJO_3t0ohCNzVvxdiWJqVNlJMI,40934
+bspy/_spline_operations.py,sha256=yWzOH0new78rE_movBVX2k-ais7It8t7wml6naCgcH4,42420
+bspy/bspyApp.py,sha256=UxmNp_IGaG7gMVexUmA7YfuwX5iuMBr7ibW3DRan8R8,14524
+bspy/drawableSpline.py,sha256=Ha7wh__aRTpGTr3cEDG49SeAyRrKtfMUQYkEZ3w9OJw,17004
+bspy/spline.py,sha256=sfiYGRCP1h8rgnlHHaIYckVZ56-mRGnGpq4KdUC9qYs,69575
+bspy/splineOpenGLFrame.py,sha256=77rikAbAood76cf5w1Idj7wciTwPV-Bn-yGSuRFvlJM,60616
+bspy-2.1.0.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-2.1.0.dist-info/METADATA,sha256=V1uTS820oScmbcDcIsJgYpGz_i6iVQShCGDWZAfceWM,3963
+bspy-2.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+bspy-2.1.0.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-2.1.0.dist-info/RECORD,,

{bspy-1.5.0.dist-info → bspy-2.1.0.dist-info}/WHEEL

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

bspy-1.5.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-bspy/__init__.py,sha256=XRBelbYtbhB6AWKh8DTsWVMDIteVxUm7Cf_S1fkqeEs,851
-bspy/_spline_domain.py,sha256=Fr7j6jTMAO22kL5ddVhfUdtbWHGDnpJ0q6s7HUGQ8GY,31078
-bspy/_spline_evaluation.py,sha256=6QqV59jHM-uJwtKaRxbBCRsJNqSNsHSibnloNCcnqfc,7059
-bspy/_spline_fitting.py,sha256=Q8IORwt-O8wCobmwupUMer5XcL66bn-b_kmxaXkJcAY,25303
-bspy/_spline_intersection.py,sha256=gWs22hfIKqD6YZaeFWJO_3t0ohCNzVvxdiWJqVNlJMI,40934
-bspy/_spline_operations.py,sha256=tmI8c6pN9MHzJBATGCVaXitmM4VjbGy1E0cD3-DgUzc,40879
-bspy/bspyApp.py,sha256=UxmNp_IGaG7gMVexUmA7YfuwX5iuMBr7ibW3DRan8R8,14524
-bspy/drawableSpline.py,sha256=Ha7wh__aRTpGTr3cEDG49SeAyRrKtfMUQYkEZ3w9OJw,17004
-bspy/spline.py,sha256=qGu_ST93T1tSVxmYGLOegIQrOAz901X0VaggWwXQ-WA,64031
-bspy/splineOpenGLFrame.py,sha256=77rikAbAood76cf5w1Idj7wciTwPV-Bn-yGSuRFvlJM,60616
-bspy-1.5.0.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-1.5.0.dist-info/METADATA,sha256=SSeypwrd437pW4rS68JaCTs29hksspplZ5by-Y8ziZU,3853
-bspy-1.5.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-bspy-1.5.0.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-1.5.0.dist-info/RECORD,,