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

bspy/spline.py

@@ -35,16 +35,11 @@ class Spline:
     coefs : array-like
         A list of the B-spline coefficients of the spline.
     
-    accuracy : `float`, optional
-        Each spline is presumed to be an approximation of something else. 
-        The `accuracy` stores the infinity norm error of the difference between 
-        the given spline and that something else. Default is zero.
-
     metadata : `dict`, optional
         A dictionary of ancillary data to store with the spline. Default is {}.
     """
     
-    def __init__(self, nInd, nDep, order, nCoef, knots, coefs, accuracy = 0.0, metadata = {}):
+    def __init__(self, nInd, nDep, order, nCoef, knots, coefs, metadata = {}):
         if not(nInd >= 0): raise ValueError("nInd < 0")
         self.nInd = int(nInd)
         if not(nDep >= 0): raise ValueError("nDep < 0")
@@ -74,7 +69,6 @@ class Spline:
                 self.coefs = self.coefs.reshape((*self.nCoef[::-1], self.nDep)).T
             else:
                 self.coefs = np.array([c.T for c in self.coefs]).reshape((self.nDep, *self.nCoef))
-        self.accuracy = accuracy
         self.metadata = dict(metadata)
 
     def __call__(self, *uvw, **kwargs):
@@ -82,8 +76,7 @@ class Spline:
 
     def __repr__(self):
         return f"Spline({self.nInd}, {self.nDep}, {self.order}, " + \
-               f"{self.nCoef}, {self.knots} {self.coefs}, {self.accuracy}, " + \
-               f"{self.metadata})"
+               f"{self.nCoef}, {self.knots} {self.coefs}, {self.metadata})"
 
     def __add__(self, other):
         if isinstance(other, Spline):
@@ -305,14 +298,15 @@ class Spline:
         """
         return bspy._spline_domain.clamp(self, left, right)
 
-    def common_basis(self, splines, indMap):
+    @staticmethod
+    def common_basis(splines, indMap = None):
         """
         Align a collection of splines to a common basis, elevating the order and adding knots as needed.
 
         Parameters
         ----------
         splines : `iterable`
-            The collection of N - 1 splines to align (N total splines, including self).
+            The collection of N splines to align.
 
         indMap : `iterable`
             The collection of independent variables to align. Since each spline can have multiple 
@@ -321,6 +315,7 @@ class Spline:
             The domains of mapped independent variables must match. 
             An independent variable can map to no more than one other independent variable.
             If all the splines are curves (1 independent variable), then `indMap` is ((0, 0, .. 0),).
+            If indMap is None (the default), then it is set to [N * [i] for i in range(nInd)]
 
         Returns
         -------
@@ -335,7 +330,47 @@ class Spline:
         -----
         Uses `elevate_and_insert_knots` to ensure mapped variables share the same order and knots. 
         """
-        return bspy._spline_domain.common_basis(self, splines, indMap)
+        return bspy._spline_domain.common_basis(splines, indMap)
+
+    @staticmethod
+    def cone(radius1, radius2, height, tolerance = None):
+        """
+        Construct a cone of the two given radii and height.
+
+        Parameters
+        ----------
+        radius1 : scalar
+            The desired radius of the cone at the bottom
+        
+        radius2 : scalar
+            The desired radius of the cone at the top
+        
+        height : scalar
+            The desired height of the cone
+
+        tolerance : scalar, optional
+            The desired absolute tolerance to which the cylinder should be constructed.  Defaults
+            to 1.0e-12 if tolerance == None.
+
+        Returns
+        -------
+        spline : `Spline`
+            A bi-quartic spline approximation to a cone of the specified radii and height,
+            accurate to the given tolerance.
+        
+        Notes
+        -----
+        The resulting mapping is defined over the unit square.  The first independent variable
+        corresponds to the radial position on the cone, while the second independent variable
+        is the location along the height.
+    
+        See Also
+        --------
+        `circular_arc` : Create a 2D circular arc for a given radius and angle accurate to within
+                         a given tolerance.
+        `ruled_surface` : Construct a ruled surface between two curves.
+        """
+        return bspy._spline_fitting.cone(radius1, radius2, height, tolerance)
 
     def confine(self, range_bounds):
         """
@@ -390,8 +425,7 @@ class Spline:
 
         epsilon : `float`, optional
             Tolerance for contour precision. Evaluating `F` with contour values will be within epsilon 
-            of zero. The default is square root of machine epsilon. The actual accuracy of the contour 
-            is returned as `spline.accuracy`.
+            of zero. The default is square root of machine epsilon.
             
         metadata : `dict`, optional
             A dictionary of ancillary data to store with the spline. Default is {}.
@@ -517,7 +551,7 @@ class Spline:
         spline : `Spline`
             The spline copy.
         """
-        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, self.coefs, self.accuracy, metadata)
+        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, self.coefs, metadata)
 
     def cross(self, vector):
         """
@@ -560,6 +594,43 @@ class Spline:
         """
         return bspy._spline_evaluation.curvature(self, uvw)
 
+    @staticmethod
+    def cylinder(radius, height, tolerance = None):
+        """
+        Construct a cylinder of the given radius and height.
+
+        Parameters
+        ----------
+        radius : scalar
+            The desired radius of the cylinder
+        
+        height : scalar
+            The desired height of the cylinder
+
+        tolerance : scalar, optional
+            The desired absolute tolerance to which the cylinder should be constructed.  Defaults
+            to 1.0e-12 if tolerance == None.
+
+        Returns
+        -------
+        spline : `Spline`
+            A bi-quartic spline approximation to a cylinder of the specified radius and height,
+            accurate to the given tolerance.
+        
+        Notes
+        -----
+        The resulting mapping is defined over the unit square.  The first independent variable
+        corresponds to the radial position on the cylinder, while the second independent variable
+        is the location along the height.
+    
+        See Also
+        --------
+        `circular_arc` : Create a 2D circular arc for a given radius and angle accurate to within
+                         a given tolerance.
+        `ruled_surface` : Construct a ruled surface between two curves.
+        """
+        return bspy._spline_fitting.cylinder(radius, height, tolerance)
+
     def derivative(self, with_respect_to, *uvw, **kwargs):
         """
         Compute the derivative of the spline at given parameter values.
@@ -597,11 +668,18 @@ class Spline:
         evaluated, then the dot product of those B-splines with the vector of
         B-spline coefficients is computed.
         """
-        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+        if len(uvw) == 0 and self.nInd == 0:
+            return np.zeros(self.nDep, self.coefs.dtype)
+        elif np.isscalar(uvw[0]):
+            return bspy._spline_evaluation.derivative(self, with_respect_to, uvw)
+        elif len(uvw) > 1 or 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)
+            if self.nDep > 1:
+                return tuple([a.astype(self.coefs.dtype, copy=False) for a in uFunc(*uvw, **kwargs)])
+            else:
+                return np.array([x[0] for x in uFunc(*uvw, **kwargs)], self.coefs.dtype)
         else:
             return bspy._spline_evaluation.derivative(self, with_respect_to, *uvw)
 
@@ -760,11 +838,16 @@ class Spline:
         """
         if len(uvw) == 0 and self.nInd == 0:
             return self.coefs
-        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+        elif np.isscalar(uvw[0]):
+            return bspy._spline_evaluation.evaluate(self, uvw)
+        elif len(uvw) > 1 or 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)
+            if self.nDep > 1:
+                return tuple([a.astype(self.coefs.dtype, copy=False) for a in uFunc(*uvw, **kwargs)])
+            else:
+                return np.array([x[0] for x in uFunc(*uvw, **kwargs)], self.coefs.dtype)
         else:
             return bspy._spline_evaluation.evaluate(self, *uvw)
 
@@ -1091,41 +1174,72 @@ class Spline:
         return bspy._spline_domain.join(splineList)
        
     @staticmethod
-    def least_squares(nInd, nDep, order, dataPoints, knots = None, compression = 0, metadata = {}):
+    def least_squares(uValues, dataPoints, order = None, knots = None, compression = 0.0,
+                      tolerance = None, fixEnds = False, metadata = {}):
         """
         Fit a spline to an array of data points using the method of least squares.
 
         Parameters
         ----------
-        nInd : `int`
-            The number of independent variables of the spline.
+        uValues : `iterable` of array-like values
+            The values of the independent variables in each of the coordinate directions for
+            each of the data points.  It's either a simple array of length nU or it is an array
+            of length nInd of arrays with corresponding lengths nU, nV, . . ., nW, where each
+            length indicates the number of data points in that independent variable.  For each
+            independent variable, the values must be ordered, i.e. uValue[i] <= uValue[i+1].  The
+            corresponding point in dataPoints will be an array of length nDep which represents the
+            desired function values at that point.  If the values in uValues are repeated, then
+            the corresponding data in dataPoints represents a derivative value.  Examples:
+            
+            If uValues == [0.0, 1.0, 1.0, 2.0, 3.0, 3.0, 3.0], then nInd == 1 and dataPoints
+            contains
+            [f(0.0), f(1.0), f'(1.0), f(2.0), f(3.0), f'(3.0), f''(3.0)]
 
-        nDep : `int`
-            The number of dependent variables of the spline.
-        
-        order : `tuple`
-            A tuple of length nInd where each integer entry represents the
-            polynomial order of the spline in that variable. When in doubt,
-            use `[4] * nInd` (a cubic spline).
+            if uValues == [[0.0, 1.0, 1.0, 2.0], [0.0, 1.0, 2.0, 2.0, 3.0]], then nInd == 2 and
+            dataPoints contains
+            [[f(0,0), f(0,1), f(0,2), f_v(0,2), f(0,3)],
+             [f(1,0), f(1,1), f(1,2), f_v(1,2), f(1,3)],
+             [f_u(1,0), f_u(1,1), f_u(1,2), f_uv(1,2), f_u(1,3)],
+             [f(2,0), f(2,1), f(2,2), f_v(2,2), f(2,3)]]
 
         dataPoints : `iterable` of array-like values
-            A collection of data points. Each data point is an array of length `nInd + nDep`. 
-            The first `nInd` values designate the independent values for the point.
-            The next `nDep` values designate the dependent values for the point. 
-            The data points need not form a regular mesh nor be in any particular order.
-            In addition, each data point may instead have `nInd + nDep * (nInd + 1)` values, 
-            the first `nInd` being independent and the next `nInd + 1` sets of `nDep` values designating 
-            the dependent point and its first derivatives with respect to each independent variable.
+            A collection of data points.  The shape of this array mirrors the shape of
+            Spline.coefs, i.e. it has shape (nDep, nU, nV, . . . , nW).  The indices into this
+            array also index into uValues to retrieve the independent variable values.
+            For example, if nInd == 2 and nDep == 3, then the shape of dataPoints is (3, nU, nV)
+            and dataPoint[:,i,j] has independent variable values given by uValues[0,i] and
+            uValues[1,j].
+
+        order : `tuple`
+            A tuple of length nInd where each integer entry represents the
+            polynomial order of the spline in that variable.  If order == None, then
+            order == [4] * nInd is assumed.
 
         knots : `list`, optional
-            A list of the lists of the knots of the spline in each independent variable.
-            Default is `None`, in which case knots are chosen automatically.
+            A list of the lists of the knots of the spline in each independent variable.  The
+            length of knots should be nInd if it is specified, where each of the arrays specify
+            the knots of the spline to use in that independent variable.  All of the dataPoints
+            must lie within the domain specified by the knots.  If knots == None (the default),
+            then the knots are automatically determined.
+        
+        compression : scalar, optional
+            The desired compression of data used as a fraction of the number of data points, i.e
+            compression is a number between 0 and 1.  This fraction is used to determine the
+            total number of spline coefficients when knots are chosen automatically (it's if the
+            knots are specified). The actual compression will be slightly less because the number
+            of coefficients is rounded up. The default value is zero (interpolation, no compression).
+
+        tolerance : scalar, optional
+            If tolerance is specified, then a fit to tolerance is performed.  Using the given knots
+            as the initial set of knots, additional knots are inserted until the 2-norm of the
+            difference between each of the each given dataPoints and the vector given by the
+            spline is no larger than the specified tolerance.
         
-        compression : `int`, optional
-            The desired compression of data used as a percentage of the number of data points (0 - 99). 
-            This percentage is used to determine the total number of spline coefficients when 
-            knots are chosen automatically (it's ignored otherwise). The actual compression will be slightly less 
-            because the number of coefficients is rounded up. The default value is zero (interpolation, no compression).
+        fixEnds : Boolean, optional
+            if fixEnds is True, then all of the dataPoints which lie on any of the domain
+            boundaries of the spline become interpolation conditions, i.e. the spline will be
+            fit in such a way that those boundary points are exactly satisfied by the computed
+            spline.  Otherwise, least-squares fitting will be performed on all of the dataPoints.
 
         metadata : `dict`, optional
             A dictionary of ancillary data to store with the spline. Default is {}.
@@ -1137,12 +1251,10 @@ class Spline:
 
         Notes
         -----
-        Uses `numpy.linalg.lstsq` to compute the least squares solution. The returned spline.accuracy is computed 
-        from the sum of the residual across dependent variables and the system epsilon. 
-        The algorithm to choose knots automatically is from Piegl, Les A., and Wayne Tiller. 
-        "Surface approximation to scanned data." The visual computer 16 (2000): 386-395.
+        Uses `numpy.linalg.lstsq` to compute the least squares solution.
         """
-        return bspy._spline_fitting.least_squares(nInd, nDep, order, dataPoints, knots, compression, metadata)
+        return bspy._spline_fitting.least_squares(uValues, dataPoints, order, knots, compression,
+                                                  tolerance, fixEnds, metadata)
 
     @staticmethod
     def line(startPoint, endPoint):
@@ -1175,7 +1287,7 @@ class Spline:
     @staticmethod
     def load(fileName):
         """
-        Load spline(s) in json format from the specified filename (full path).
+        Load splines in json format from the specified filename (full path).
 
         Parameters
         ----------
@@ -1184,8 +1296,8 @@ class Spline:
         
         Returns
         -------
-        spline(s) : `Spline` or list of `Spline`
-            The loaded spline(s).
+        splines : list of `Spline`
+            The loaded splines.
 
         See Also
         --------
@@ -1200,7 +1312,7 @@ class Spline:
             for i in range(nInd):
                 knots.append(kw[f"knots{i}"])
             coefficients = kw["coefficients"]
-            return Spline(nInd, coefficients.shape[0], order, coefficients.shape[1:], knots, coefficients, metadata=dict(Path=path, Name=path.splitext(path.split(fileName)[1])[0]))
+            return [Spline(nInd, coefficients.shape[0], order, coefficients.shape[1:], knots, coefficients, metadata=dict(Path=path, Name=path.splitext(path.split(fileName)[1])[0]))]
         except:
             pass # Do nothing, an error is expected for json files
         
@@ -1208,15 +1320,13 @@ class Spline:
         with open(fileName, 'r', encoding='utf-8') as file:
             splineData = json.load(file)
 
+        splines = []
         if isinstance(splineData, dict):
-            return Spline(splineData["nInd"], splineData["nDep"], splineData["order"], splineData["nCoef"],
-                [np.array(knots) for knots in splineData["knots"]], np.array(splineData["coefs"]), splineData["accuracy"], splineData["metadata"])
-        else:
-            splines = []
-            for splineDict in splineData:
-                splines.append(Spline(splineDict["nInd"], splineDict["nDep"], splineDict["order"], splineDict["nCoef"],
-                    [np.array(knots) for knots in splineDict["knots"]], np.array(splineDict["coefs"]), splineDict["accuracy"], splineDict["metadata"]))
-            return splines        
+            splineData = [splineData]
+        for splineDict in splineData:
+            splines.append(Spline(splineDict["nInd"], splineDict["nDep"], splineDict["order"], splineDict["nCoef"],
+                [np.array(knots) for knots in splineDict["knots"]], np.array(splineDict["coefs"]), splineDict["metadata"]))
+        return splines        
 
     def multiply(self, other, indMap = None, productType = 'S'):
         """
@@ -1479,6 +1589,34 @@ class Spline:
         """
         return bspy._spline_fitting.revolve(self, angle)
 
+    def rotate(self, vector, angle):
+        """
+        Rotate a spline around a vector by the specified angle.
+
+        Parameters
+        ----------
+        vector : array-like
+            A vector of length three about which to rotate the spline
+        
+        angle : scalar
+            The number of degrees to rotate the spline around vector by
+        
+        Returns
+        -------
+        spline : `Spline`
+            The rotated spline
+        
+        See Also
+        --------
+        `transform` : Multiply a spline by a given matrix.
+
+        Notes
+        -----
+        Uses the well-known Rodrigues' rotation formula and mathematical operations
+        on splines.
+        """
+        return bspy._spline_operations.rotate(self, vector, angle)
+    
     @staticmethod
     def ruled_surface(spline1, spline2):
         """
@@ -1513,7 +1651,7 @@ class Spline:
         
         See Also
         --------
-        `load` : Load spline(s) in json format from the specified filename (full path).
+        `load` : Load splines in json format from the specified filename (full path).
         """
         class SplineEncoder(json.JSONEncoder):
             def default(self, obj):
@@ -1527,7 +1665,6 @@ class Spline:
                         "nCoef" : obj.nCoef,
                         "knots" : obj.knots,
                         "coefs" : obj.coefs,
-                        "accuracy" : obj.accuracy,
                         "metadata" : obj.metadata
                     }
                 return super().default(obj)
@@ -1708,7 +1845,7 @@ class Spline:
         """
         return bspy._spline_fitting.torus(innerRadius, outerRadius, tolerance)
     
-    def transform(self, matrix, maxSingularValue=None):
+    def transform(self, matrix):
         """
         Transform a spline by the given matrix.
 
@@ -1717,10 +1854,6 @@ class Spline:
         matrix : array-like
             An array of size `newNDep`x`nDep` that specifies the transform matrix.
 
-        maxSingularValue : `float`, optional
-            The largest singular value of `matrix`, used to update the accuracy of the spline. 
-            If no value is provided (default), the largest singular value is computed.
-
         Returns
         -------
         spline : `Spline`
@@ -1735,7 +1868,7 @@ class Spline:
         -----
         Equivalent to spline @ matrix.
         """
-        return bspy._spline_operations.transform(self, matrix, maxSingularValue)
+        return bspy._spline_operations.transform(self, matrix)
 
     def translate(self, translationVector):
         """
@@ -1855,7 +1988,7 @@ class Spline:
         ----------
         epsilon : `float`, optional
             Tolerance for root precision. The root will be within epsilon of the actual root. 
-            The default is the max of spline accuracy and machine epsilon.
+            The default is the machine epsilon.
 
         Returns
         -------

bspy/splineOpenGLFrame.py

@@ -2,13 +2,16 @@ import numpy as np
 import tkinter as tk
 from OpenGL.GL import *
 import OpenGL.GL.shaders as shaders
-from pyopengltk import OpenGLFrame
+try:
+    from pyopengltk import OpenGLFrame
+except ImportError:
+    from tkinter import Frame as OpenGLFrame
 from bspy import DrawableSpline
 from bspy.drawableSpline import _set_color
 
 class SplineOpenGLFrame(OpenGLFrame):
     """
-    A tkinter `OpenGLFrame` with shaders to display a `DrawableSpline` list. 
+    A tkinter `OpenGLFrame` with shaders to display a `DrawableSpline`.
     """
 
     ROTATE = 1
@@ -939,10 +942,10 @@ class SplineOpenGLFrame(OpenGLFrame):
         }
     """
  
-    def __init__(self, *args, eye=(0.0, 0.0, 3.0), center=(0.0, 0.0, 0.0), up=(0.0, 1.0, 0.0), **kw):
+    def __init__(self, *args, eye=(0.0, 0.0, 3.0), center=(0.0, 0.0, 0.0), up=(0.0, 1.0, 0.0), draw_func=None, **kw):
         OpenGLFrame.__init__(self, *args, **kw)
 
-        self.splineDrawList = []
+        self.draw_func = draw_func
         self.animating = False
         self.animate = 0 # Set to number of milliseconds before showing next frame (0 means no animation)
         self.frameCount = 0
@@ -994,12 +997,6 @@ class SplineOpenGLFrame(OpenGLFrame):
         self.backgroundColor = _set_color(r, g, b, a)
         if self.glInitialized:
             glClearColor(self.backgroundColor[0], self.backgroundColor[1], self.backgroundColor[2], self.backgroundColor[3])
-
-    def SetSplineList(self, list):
-        """
-        Set the `DrawableSpline` list which determines the splines to display.
-        """
-        self.splineDrawList = list
     
     def ResetView(self):
         """
@@ -1174,8 +1171,8 @@ class SplineOpenGLFrame(OpenGLFrame):
             (self.horizon[2], self.vertical[2], self.look[2], 0.0),
             (-np.dot(self.horizon, self.eye), -np.dot(self.vertical, self.eye), -np.dot(self.look, self.eye), 1.0)), np.float32)
 
-        for spline in self.splineDrawList:
-            spline._Draw(self, transform)
+        if self.draw_func is not None:
+            self.draw_func(self, transform)
 
         glFlush()
 
@@ -1192,7 +1189,10 @@ class SplineOpenGLFrame(OpenGLFrame):
         """
         Update the frame, typically after updating the spline list.
         """
-        self.tkExpose(None)
+        try:
+            self.tkExpose(None)
+        except AttributeError:
+            pass
 
     def Reset(self):
         """
@@ -1216,14 +1216,22 @@ class SplineOpenGLFrame(OpenGLFrame):
     
     def SetScale(self, scale):
         """
-        Set the flying speed scale.
+        Set anchor distance and/or flying speed (depending on mode).
 
         Parameters
         ----------
         scale : `float`
-            Speed scale between 0 and 1.
+            Scale between 0 and 1.
         """
-        self.speed = 0.033 * self.anchorDistance * (100.0 ** float(scale) - 1.0) / 99.0
+        if self.mode == self.FLY:
+            self.speed = 0.033 * self.anchorDistance * (100.0 ** float(scale) - 1.0) / 99.0
+        else:
+            defaultAnchorDistance = np.linalg.norm(self.defaultEye - self.defaultCenter)
+            self.anchorDistance = 2.0 * float(scale) * defaultAnchorDistance
+            self.anchorDistance = max(self.anchorDistance, 0.01)
+            self.speed = 0.033 * self.anchorDistance
+            self.eye = self.anchorPosition + self.anchorDistance * self.look
+            self.Update()
     
     def SetAnimating(self, animating):
         self.animating = animating

{bspy-2.2.2.dist-info → bspy-3.0.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 2.2.2
-Summary: Library for manipulating and rendering non-uniform b-splines
+Version: 3.0.1
+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
@@ -32,12 +32,12 @@ 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. It also has methods to create points, lines, circular arcs, spheres, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
-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, transpose, 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 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.
+[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Only tested on Windows systems.
 
 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 
@@ -48,14 +48,20 @@ Spline surfaces and solids with more than 3 dependent variables will have their
 The [bspyApp](https://ericbrec.github.io/BSpy/bspy/bspyApp.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.
+a listbox full of splines, and a set of controls to adjust and view the selected 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 
-in [jupyter](https://jupyter.org/) notebooks and other scripting environments.
+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")
 
 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

bspy-3.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+bspy/__init__.py,sha256=6COMVL3vEPGglirXvBWB9vadEMhj0tetOj7134im5wY,851
+bspy/_spline_domain.py,sha256=rES03UdvxB6yu_ccumcckLR0xX51C6Dv_-nK0wuTlGg,28689
+bspy/_spline_evaluation.py,sha256=rZLqruff8BT6MZdlfV5MBFzSnYuJgzgbpxk1W0mRHeI,7892
+bspy/_spline_fitting.py,sha256=P6rwnIdjjrC_tKqWgIIh5OHl48z04MJBT0QMh18Dvyk,31797
+bspy/_spline_intersection.py,sha256=ArdRkYMUc4JWRuj0CfhdGSWyBs_SBDnbvZtwb5Elo4U,40865
+bspy/_spline_operations.py,sha256=eHSRSd7ez6WrjtM-YlvKjn-LRcaRSObIdf9b8eV1chE,42898
+bspy/bspyApp.py,sha256=M7Uc3TL6GcuqwdWeTdQTH79yKdQ_eHD16ed3xWJipIg,18746
+bspy/drawableSpline.py,sha256=tM54Tk11qwGextRDCCkMn-NJUFp_XtlPkUK9X4Xxyyo,25076
+bspy/spline.py,sha256=clO9hxqrjImWDGW7dkDu_vqUGgLEKi5tYKlEVkM044A,84589
+bspy/splineOpenGLFrame.py,sha256=Fns8QjTiVX7jyolhwpty6RqoUE9RtPs8pHkDi1SlwFg,64643
+bspy-3.0.1.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-3.0.1.dist-info/METADATA,sha256=gEk1OHK15MToVxRcDTeB_4igZzkBo5O39_9pAODUKo8,4688
+bspy-3.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+bspy-3.0.1.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-3.0.1.dist-info/RECORD,,

bspy-2.2.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-bspy/__init__.py,sha256=XRBelbYtbhB6AWKh8DTsWVMDIteVxUm7Cf_S1fkqeEs,851
-bspy/_spline_domain.py,sha256=EF6f6y1aMSrDf65UoqQwmBOarTO79TO-hszZAFpxeJw,28821
-bspy/_spline_evaluation.py,sha256=1aCf4Op5zQNv-_wW2IOR13MieuYPVJrN1cJCBiI8AaY,7534
-bspy/_spline_fitting.py,sha256=IT89LPainTWoHtzBK6s2VnWiM1c76zzZLDJmsPFlSNA,31369
-bspy/_spline_intersection.py,sha256=gWs22hfIKqD6YZaeFWJO_3t0ohCNzVvxdiWJqVNlJMI,40934
-bspy/_spline_operations.py,sha256=javGKxiSPomhTruJU3ojJvGASoblZnjZG8MGQ3PrOHQ,42400
-bspy/bspyApp.py,sha256=Q_TAdKEtRgHzdbp9qj1xPq9oACQyRNnJXnGGvkiVQks,19051
-bspy/drawableSpline.py,sha256=lLWUjrgNROJ41wtl_XwAL-2RlKdMFo5SDsT5FopI3Xk,25131
-bspy/spline.py,sha256=RRJZRdsEE9_tSTTP980NnIUpmMYqMR4WGN2F4qZkHII,79308
-bspy/splineOpenGLFrame.py,sha256=h-XDC-KEcjiC8pNj9cqWBjZgVDiI6mOq1jljfk6fmV4,64194
-bspy-2.2.2.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-2.2.2.dist-info/METADATA,sha256=QQSRHSYTE03xFgwMLhrXguPDRpdqms-6Yy4n3wroKU4,4183
-bspy-2.2.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-bspy-2.2.2.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-2.2.2.dist-info/RECORD,,