bspy 3.0.0__tar.gz → 3.0.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 3.0.0
+Version: 3.0.1
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -37,7 +37,7 @@ Other methods add, subtract, and multiply splines, as well as confine spline cur
 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,11 +48,11 @@ 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")
 

{bspy-3.0.0 → bspy-3.0.1}/README.md

@@ -7,7 +7,7 @@ Other methods add, subtract, and multiply splines, as well as confine spline cur
 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 
@@ -18,11 +18,11 @@ 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")
 

{bspy-3.0.0 → bspy-3.0.1}/bspy/_spline_operations.py

@@ -100,6 +100,15 @@ def confine(self, range_bounds):
     for i in range(spline.nDep):
         intersectBoundary(i, 0)
         intersectBoundary(i, 1)
+    
+    # Put the intersection points in order.
+    intersections.sort(key=lambda intersection: intersection[0])
+
+    # Remove repeat points at start and end.
+    if intersections[1][0] - intersections[0][0] < epsilon:
+        del intersections[1]
+    if intersections[-1][0] - intersections[-2][0] < epsilon:
+        del intersections[-2]
 
     # Insert order-1 knots at each intersection point.
     for (knot, boundaryPoint, headedOutside) in intersections:
@@ -110,9 +119,6 @@ def confine(self, range_bounds):
                 spline = spline.insert_knots(([knot] * count,))
         else:
             spline = spline.insert_knots(([knot] * (order - 1),))
-    
-    # Put the intersection points in order.
-    intersections.sort(key=lambda intersection: intersection[0])
 
     # Go through the boundary points, assigning boundary coefficients, interpolating between boundary points, 
     # and removing knots and coefficients where the curve stalls.

{bspy-3.0.0 → bspy-3.0.1}/bspy/bspyApp.py

@@ -82,7 +82,7 @@ class bspyApp(tk.Tk):
         controls = tk.Frame(self)
         controls.pack(side=tk.RIGHT, fill=tk.BOTH, expand=tk.YES)
 
-        self.frame = SplineOpenGLFrame(controls)
+        self.frame = SplineOpenGLFrame(controls, draw_func=self._DrawSplines)
         self.frame.pack(side=tk.TOP, fill=tk.BOTH, expand=tk.YES)
 
         buttons = tk.Frame(controls)
@@ -98,6 +98,7 @@ class bspyApp(tk.Tk):
         self.scale.set(0.5)
 
         self.splineList = []
+        self.splineDrawList = []
         self.splineRadius = 0.0
         self.adjust = None
         self.workQueue = workQueue
@@ -138,21 +139,17 @@ class bspyApp(tk.Tk):
         
     def draw(self, spline, name = None):
         """Add a `Spline` to the listbox and draw it. Can be called before the app is running."""
-        spline = DrawableSpline.make_drawable(spline)
-        if name is not None:
-            spline.metadata["Name"] = name
-        self.splineList.append(spline)
-        self.listBox.insert(tk.END, spline)
+        self.list(spline, name)
         self.listBox.selection_set(self.listBox.size() - 1)
         self.update()
 
     def save_splines(self):
-        if self.frame.splineDrawList:
-            initialName = self.frame.splineDrawList[0].metadata.get("Name", "spline") + ".json"
+        if self.splineDrawList:
+            initialName = self.splineDrawList[0].metadata.get("Name", "spline") + ".json"
             fileName = filedialog.asksaveasfilename(title="Save splines", initialfile=initialName,
                 defaultextension=".json", filetypes=(('Json files', '*.json'),('All files', '*.*')))
             if fileName:
-                self.frame.splineDrawList[0].save(fileName, *self.frame.splineDrawList[1:])
+                self.splineDrawList[0].save(fileName, *self.splineDrawList[1:])
 
     def load_splines(self):
         fileName = filedialog.askopenfilename(title="Load splines", 
@@ -200,7 +197,7 @@ class bspyApp(tk.Tk):
 
     def update(self):
         """Update the spline draw list, set the default view, reset the bounds, and refresh the frame."""
-        self.frame.splineDrawList = []
+        self.splineDrawList = []
         gotOne = False
         for item in self.listBox.curselection():
             spline = self.splineList[item]
@@ -212,25 +209,24 @@ class bspyApp(tk.Tk):
                 splineMin = spline.coefs[:3].min(axis=coefsAxis)
                 splineMax = spline.coefs[:3].max(axis=coefsAxis)
                 gotOne = True
-            self.frame.splineDrawList.append(spline)
+            self.splineDrawList.append(spline)
 
         if gotOne:
             newRadius = 0.5 * np.max(splineMax - splineMin)
-            if not np.isclose(newRadius, self.splineRadius):
-                self.splineRadius = newRadius
-                atDefaultEye = np.allclose(self.frame.eye, self.frame.defaultEye)
-                center = 0.5 * (splineMax + splineMin)
-                self.frame.SetDefaultView(center + (0.0, 0.0, 3.0 * newRadius), center, (0.0, 1.0, 0.0))
-                self.frame.ResetBounds()
-                if atDefaultEye:
-                    self.frame.ResetView()
+            self.splineRadius = newRadius
+            atDefaultEye = np.allclose(self.frame.eye, self.frame.defaultEye)
+            center = 0.5 * (splineMax + splineMin)
+            self.frame.SetDefaultView(center + (0.0, 0.0, 3.0 * newRadius), center, (0.0, 1.0, 0.0))
+            self.frame.ResetBounds()
+            if atDefaultEye:
+                self.frame.ResetView()
         else:
             self.splineRadius = 0.0
 
         if self.adjust is not None:
-            if self.frame.splineDrawList: 
-                self.bits.set(self.frame.splineDrawList[0].get_options())
-                animate = self.frame.splineDrawList[0].get_animate()
+            if self.splineDrawList: 
+                self.bits.set(self.splineDrawList[0].get_options())
+                animate = self.splineDrawList[0].get_animate()
             else:
                 self.bits.set(0)
                 animate = None
@@ -240,6 +236,10 @@ class bspyApp(tk.Tk):
 
         self.frame.Update()
 
+    def _DrawSplines(self, frame, transform):
+        for spline in self.splineDrawList:
+            spline._Draw(frame, transform)
+
     def _ListSelectionChanged(self, event):
         """Handle when the listbox selection has changed."""
         self.update()
@@ -259,8 +259,8 @@ class bspyApp(tk.Tk):
             self.checkButtons.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)
 
             self.bits = tk.IntVar()
-            if self.frame.splineDrawList:
-                self.bits.set(self.frame.splineDrawList[0].get_options())
+            if self.splineDrawList:
+                self.bits.set(self.splineDrawList[0].get_options())
             else:
                 self.bits.set(0)
             _BitCheckbutton(self.checkButtons, DrawableSpline.SHADED, text="Shaded", anchor=tk.W, variable=self.bits, command=self._ChangeOptions).pack(side=tk.TOP, fill=tk.X)
@@ -274,8 +274,8 @@ class bspyApp(tk.Tk):
             tk.Button(buttons, text='Line color', command=self._LineColorChange).pack(side=tk.TOP, fill=tk.X)
             self.animate = tk.StringVar()
             self.animateOptions = {"Animate: Off" : None, "Animate: u(0)" : 0, "Animate: v(1)" : 1, "Animate: w(2)" : 2}
-            if self.frame.splineDrawList:
-                animate = self.frame.splineDrawList[0].get_animate()
+            if self.splineDrawList:
+                animate = self.splineDrawList[0].get_animate()
             else:
                 animate = None
             self.animate.set(next(key for key, value in self.animateOptions.items() if value == animate))
@@ -299,7 +299,7 @@ class bspyApp(tk.Tk):
     
     def _ChangeOptions(self, options):
         """Handle when the spline options are changed."""
-        for spline in self.frame.splineDrawList:
+        for spline in self.splineDrawList:
             spline.set_options(options)
         self.frame.Update()
     
@@ -307,7 +307,7 @@ class bspyApp(tk.Tk):
         """Handle when the spline animation is changed."""
         nInd = self.animateOptions[value]
         animating = False
-        for spline in self.frame.splineDrawList:
+        for spline in self.splineDrawList:
             if nInd is None or nInd < spline.nInd:
                 spline.set_animate(nInd)
                 animating = True
@@ -316,21 +316,21 @@ class bspyApp(tk.Tk):
 
     def _FillColorChange(self):
         """Handle when the fill color changed."""
-        if self.frame.splineDrawList:
-            oldColor = 255.0 * self.frame.splineDrawList[0].get_fill_color()
+        if self.splineDrawList:
+            oldColor = 255.0 * self.splineDrawList[0].get_fill_color()
             newColor = askcolor(title="Set spline fill color", color="#%02x%02x%02x" % (int(oldColor[0]), int(oldColor[1]), int(oldColor[2])))
             if newColor[0] is not None:
-                for spline in self.frame.splineDrawList:
+                for spline in self.splineDrawList:
                     spline.set_fill_color(newColor[0])
                 self.frame.Update()
 
     def _LineColorChange(self):
         """Handle when the line color changed."""
-        if self.frame.splineDrawList:
-            oldColor = 255.0 * self.frame.splineDrawList[0].get_line_color()
+        if self.splineDrawList:
+            oldColor = 255.0 * self.splineDrawList[0].get_line_color()
             newColor = askcolor(title="Set spline line color", color="#%02x%02x%02x" % (int(oldColor[0]), int(oldColor[1]), int(oldColor[2])))
             if newColor[0] is not None:
-                for spline in self.frame.splineDrawList:
+                for spline in self.splineDrawList:
                     spline.set_line_color(newColor[0])
                 self.frame.Update()
     

{bspy-3.0.0 → bspy-3.0.1}/bspy/drawableSpline.py

@@ -145,10 +145,14 @@ class DrawableSpline(Spline):
                 floatCount += 2 + self.order[i] + self.nCoef[i]
                 coefficientCount *= self.nCoef[i]
             if not(floatCount + self.nDep * coefficientCount <= self._maxFloats): raise ValueError("Spline to large to draw")
-            self.metadata["fillColor"] = np.array((0.0, 1.0, 0.0, 1.0), np.float32)
-            self.metadata["lineColor"] = np.array((0.0, 0.0, 0.0, 1.0) if self.nInd > 1 else (1.0, 1.0, 1.0, 1.0), np.float32)
-            self.metadata["options"] = self.SHADED | self.BOUNDARY
-            self.metadata["animate"] = None
+            if not "fillColor" in self.metadata:
+                self.metadata["fillColor"] = np.array((0.0, 1.0, 0.0, 1.0), np.float32)
+            if not "lineColor" in self.metadata:
+                self.metadata["lineColor"] = np.array((0.0, 0.0, 0.0, 1.0) if self.nInd > 1 else (1.0, 1.0, 1.0, 1.0), np.float32)
+            if not "options" in self.metadata:
+                self.metadata["options"] = self.SHADED | self.BOUNDARY
+            if not "animate" in self.metadata:
+                self.metadata["animate"] = None
 
     def __str__(self):
         return self.metadata.get("Name", "[{0}, {1}]".format(self.coefs[0], self.coefs[1]))
@@ -198,7 +202,7 @@ class DrawableSpline(Spline):
                     if rangeCoef > 1.0e-8:
                         coefs[i] = (coefs[i] - minCoef) / rangeCoef
                     else:
-                        coefs[i] = 1.0
+                        coefs[i] = max(0.0, min(1.0, minCoef))
         elif spline.nInd == 3:
             if spline.nDep == 1:
                 spline = spline.graph()
@@ -215,7 +219,7 @@ class DrawableSpline(Spline):
                     if rangeCoef > 1.0e-8:
                         coefs[i] = (coefs[i] - minCoef) / rangeCoef
                     else:
-                        coefs[i] = 1.0
+                        coefs[i] = max(0.0, min(1.0, minCoef))
         else:
             raise ValueError("Can't convert to drawable spline.")
         

{bspy-3.0.0 → bspy-3.0.1}/bspy/spline.py

@@ -676,7 +676,10 @@ class Spline:
             def vectorized(*uvwInstance):
                 return tuple(bspy._spline_evaluation.derivative(self, with_respect_to, uvwInstance))
             uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
-            return tuple([a.astype(self.coefs.dtype, copy=False) for a in 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)
 
@@ -841,7 +844,10 @@ class Spline:
             def vectorized(*uvwInstance):
                 return tuple(bspy._spline_evaluation.evaluate(self, uvwInstance))
             uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
-            return tuple([a.astype(self.coefs.dtype, copy=False) for a in 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)
 

{bspy-3.0.0 → bspy-3.0.1}/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-3.0.0 → bspy-3.0.1}/bspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 3.0.0
+Version: 3.0.1
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -37,7 +37,7 @@ Other methods add, subtract, and multiply splines, as well as confine spline cur
 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,11 +48,11 @@ 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")
 

{bspy-3.0.0 → bspy-3.0.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bspy
-version = 3.0.0
+version = 3.0.1
 author = Eric Brechner
 author_email = ericbrec@msn.com
 description = Library for manipulating and rendering non-uniform B-splines