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

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

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

bspy-4.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+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,,

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

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

bspy/bspyApp.py

@@ -1,426 +0,0 @@
-import numpy as np
-import tkinter as tk
-from tkinter.colorchooser import askcolor
-from tkinter import filedialog
-import queue, threading
-from bspy import SplineOpenGLFrame
-from bspy import Spline, DrawableSpline
-
-class _BitCheckbutton(tk.Checkbutton):
-    """A tkinter `CheckButton` that gets/sets its variable based on a given `bitmask`."""
-    def __init__(self, parent, bitMask, **kw):
-        self.bitMask = bitMask
-        self.variable = kw.get("variable")
-        self.command = kw.get("command")
-        self.var = tk.IntVar()
-        self.var.set(1 if self.variable.get() & self.bitMask else 0)
-        kw["variable"] = self.var
-        kw["onvalue"] = 1
-        kw["offvalue"] = 0
-        kw["command"] = self.Command
-        tk.Checkbutton.__init__(self, parent, **kw)
-    
-    def Command(self):
-        """
-        Handles when the checkbutton is pushed, updating the variable based on the 
-        bitmask and then calling the checkbutton command.
-        """
-        if self.var.get() == 1:
-            self.variable.set(self.variable.get() | self.bitMask)
-        else:
-            self.variable.set(self.variable.get() & ~self.bitMask)
-        self.command(self.variable.get())
-
-    def Update(self):
-        """Updates checkbutton state."""
-        self.var.set(1 if self.variable.get() & self.bitMask else 0)
-
-class bspyApp(tk.Tk):
-    """
-    A tkinter app (`tkinter.Tk`) that hosts a `SplineOpenGLFrame`, a listbox full of 
-    splines, and a set of controls to adjust and view the selected splines.
-
-    See Also
-    --------
-    `bspyGraphics` : A graphics engine to display splines. It launches a `bspyApp` and issues commands to the app.
-
-    Examples
-    --------
-    Creates a bspyApp, show some splines, and launches the app (blocks on the main loop).
-    >>> app = bspyApp()
-    >>> app.show(spline1)
-    >>> app.show(spline2)
-    >>> app.show(spline3)
-    >>> app.mainloop()
-    """
-
-    def __init__(self, *args, SplineOpenGLFrame=SplineOpenGLFrame, workQueue=None, **kw):
-        tk.Tk.__init__(self, *args, **kw)
-        self.title('bspy')
-        self.geometry('600x500')
-
-        # Controls on the left
-        controls = tk.Frame(self)
-        controls.pack(side=tk.LEFT, fill=tk.Y)
-
-        tk.Button(controls, text='Adjust', command=self._Adjust).pack(side=tk.BOTTOM, fill=tk.X)
-        #tk.Button(controls, text='Empty', command=self.empty).pack(side=tk.BOTTOM, fill=tk.X)
-        tk.Button(controls, text='Erase', command=self.erase_all).pack(side=tk.BOTTOM, fill=tk.X)
-        tk.Button(controls, text='Save', command=self.save_splines).pack(side=tk.BOTTOM, fill=tk.X)
-        tk.Button(controls, text='Load', command=self.load_splines).pack(side=tk.BOTTOM, fill=tk.X)
-
-        self.listBox = tk.Listbox(controls, selectmode=tk.MULTIPLE)
-        self.listBox.pack(side=tk.LEFT, fill=tk.Y)
-        self.listBox.bind('<<ListboxSelect>>', self._ListSelectionChanged)
-
-        verticalScroll = tk.Scrollbar(controls, orient=tk.VERTICAL)
-        verticalScroll.pack(side=tk.LEFT, fill=tk.Y)
-        self.listBox.configure(yscrollcommand=verticalScroll.set)
-        verticalScroll.config(command=self.listBox.yview)
-
-        # Controls on the right
-        controls = tk.Frame(self)
-        controls.pack(side=tk.RIGHT, fill=tk.BOTH, expand=tk.YES)
-
-        self.frame = SplineOpenGLFrame(controls, draw_func=self._DrawSplines)
-        self.frame.pack(side=tk.TOP, fill=tk.BOTH, expand=tk.YES)
-
-        buttons = tk.Frame(controls)
-        buttons.pack(side=tk.BOTTOM)
-        tk.Button(buttons, text='Reset View', command=self.frame.Reset).pack(side=tk.LEFT)
-        self.frameMode = tk.IntVar()
-        tk.Radiobutton(buttons, text='Rotate', variable=self.frameMode, value=SplineOpenGLFrame.ROTATE, command=self._ChangeFrameMode).pack(side=tk.LEFT)
-        tk.Radiobutton(buttons, text='Pan', variable=self.frameMode, value=SplineOpenGLFrame.PAN, command=self._ChangeFrameMode).pack(side=tk.LEFT)
-        tk.Radiobutton(buttons, text='Fly', variable=self.frameMode, value=SplineOpenGLFrame.FLY, command=self._ChangeFrameMode).pack(side=tk.LEFT)
-        self.frameMode.set(SplineOpenGLFrame.ROTATE)
-        self.scale = tk.Scale(buttons, orient=tk.HORIZONTAL, from_=0, to=1, resolution=0.1, showvalue=0, command=self.frame.SetScale)
-        self.scale.pack(side=tk.LEFT)
-        self.scale.set(0.5)
-
-        self.splineList = []
-        self.splineDrawList = []
-        self.splineRadius = 0.0
-        self.adjust = None
-        self.workQueue = workQueue
-        if self.workQueue is not None:
-            self.work = {
-                "show" : self.show,
-                "draw" : self.draw,
-                "erase_all" : self.erase_all,
-                "empty" : self.empty,
-                "set_background_color" : self.set_background_color,
-                "update" : self.update
-            }
-            self.after(1000, self._check_for_work)
-    
-    def _check_for_work(self):
-        """Check queue for calls to make."""
-        while not self.workQueue.empty():
-            try:
-                work = self.workQueue.get_nowait()
-            except queue.Empty:
-                break
-            else:
-                if work[0] in self.work:
-                    self.work[work[0]](*work[1])
-        self.after(200, self._check_for_work)
-
-    def list(self, spline, name = None):
-        """List a `Spline` in the listbox. Can be called before 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)
-
-    def show(self, spline, name = None):
-        """Show a `Spline` in the listbox (calls the list method, kept for compatibility). Can be called before app is running."""
-        self.list(spline, name)
-        
-    def draw(self, spline, name = None):
-        """Add a `Spline` to the listbox and draw it. Can be called before the app is running."""
-        self.list(spline, name)
-        self.listBox.selection_set(self.listBox.size() - 1)
-        self.update()
-
-    def save_splines(self):
-        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.splineDrawList[0].save(fileName, *self.splineDrawList[1:])
-
-    def load_splines(self):
-        fileName = filedialog.askopenfilename(title="Load splines", 
-            defaultextension=".json", filetypes=(('Json files', '*.json'),('All files', '*.*')))
-        if fileName:
-            splines = DrawableSpline.load(fileName)
-            for spline in splines:
-                self.list(spline)
-    
-    def erase_all(self):
-        """Stop drawing all splines. Splines remain in the listbox."""
-        self.listBox.selection_clear(0, self.listBox.size() - 1)
-        self.splineRadius = 0.0
-        self.frame.ResetView()
-        self.update()
-
-    def empty(self):
-        """Stop drawing all splines and remove them from the listbox."""
-        self.splineList = []
-        self.listBox.delete(0, self.listBox.size() - 1)
-        self.splineRadius = 0.0
-        self.frame.ResetView()
-        self.update()
-
-    def set_background_color(self, r, g=None, b=None, a=None):
-        """
-        Set the background color.
-
-        Parameters
-        ----------
-        r : `float`, `int` or array-like of floats or ints
-            The red value [0, 1] as a float, [0, 255] as an int, or the rgb or rgba value as floats or ints (default).
-        
-        g: `float` or `int`
-            The green value [0, 1] as a float or [0, 255] as an int.
-        
-        b: `float` or `int`
-            The blue value [0, 1] as a float or [0, 255] as an int.
-        
-        a: `float`, `int`, or None
-            The alpha value [0, 1] as a float or [0, 255] as an int. If `None` then alpha is set to 1.
-        """
-        self.frame.SetBackgroundColor(r, g, b, a)
-        self.frame.Update()
-
-    def update(self):
-        """Update the spline draw list, set the default view, reset the bounds, and refresh the frame."""
-        self.splineDrawList = []
-        gotOne = False
-        for item in self.listBox.curselection():
-            spline = self.splineList[item]
-            coefsAxis = tuple(range(1,spline.nInd + 1))
-            if gotOne:
-                splineMin = np.minimum(splineMin, spline.coefs[:3].min(axis=coefsAxis))
-                splineMax = np.maximum(splineMax, spline.coefs[:3].max(axis=coefsAxis))
-            else:
-                splineMin = spline.coefs[:3].min(axis=coefsAxis)
-                splineMax = spline.coefs[:3].max(axis=coefsAxis)
-                gotOne = True
-            self.splineDrawList.append(spline)
-
-        if gotOne:
-            newRadius = 0.5 * np.max(splineMax - splineMin)
-            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.splineDrawList: 
-                self.bits.set(self.splineDrawList[0].get_options())
-                animate = self.splineDrawList[0].get_animate()
-            else:
-                self.bits.set(0)
-                animate = None
-            for button in self.checkButtons.winfo_children():
-                button.Update()
-            self.animate.set(next(key for key, value in self.animateOptions.items() if value == animate))
-
-        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()
-    
-    def _ChangeFrameMode(self):
-        """Handle when the view mode has changed."""
-        self.frame.SetMode(self.frameMode.get())
-
-    def _Adjust(self):
-        """Handle when the Adjust button is pressed."""
-        if self.adjust is None:
-            self.adjust = tk.Toplevel()
-            self.adjust.title("Adjust")
-            self.adjust.bind('<Destroy>', self._AdjustDestroy)
-
-            self.checkButtons = tk.LabelFrame(self.adjust, text="Decoration")
-            self.checkButtons.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)
-
-            self.bits = tk.IntVar()
-            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)
-            _BitCheckbutton(self.checkButtons, DrawableSpline.BOUNDARY, text="Boundary", anchor=tk.W, variable=self.bits, command=self._ChangeOptions).pack(side=tk.TOP, fill=tk.X)
-            _BitCheckbutton(self.checkButtons, DrawableSpline.ISOPARMS, text="Isoparms", anchor=tk.W, variable=self.bits, command=self._ChangeOptions).pack(side=tk.TOP, fill=tk.X)
-            _BitCheckbutton(self.checkButtons, DrawableSpline.HULL, text="Hull", anchor=tk.W, variable=self.bits, command=self._ChangeOptions).pack(side=tk.TOP, fill=tk.X)
-
-            buttons = tk.LabelFrame(self.adjust, text="Options")
-            buttons.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)
-            tk.Button(buttons, text='Fill color', command=self._FillColorChange).pack(side=tk.TOP, fill=tk.X)
-            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.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))
-            tk.OptionMenu(buttons, self.animate, *self.animateOptions.keys(), command=self._ChangeAnimate).pack(side=tk.TOP, fill=tk.X)
-            tk.Button(buttons, text='Dismiss', command=self.adjust.withdraw).pack(side=tk.TOP, fill=tk.X)
-
-            self.adjust.update()
-            self.adjust.resizable(False, False)
-        else:
-            self.adjust.deiconify()
-
-        if self.winfo_x() + self.winfo_width() + 205 <= self.winfo_screenwidth():
-            self.adjust.geometry("{width}x{height}+{x}+{y}".format(width=205, height=self.adjust.winfo_height(), x=self.winfo_x() + self.winfo_width(), y=self.winfo_y()))
-        else:
-            self.adjust.geometry("{width}x{height}+{x}+{y}".format(width=205, height=self.adjust.winfo_height(), x=self.winfo_screenwidth() - 205, y=self.winfo_y()))
-
-    def _AdjustDestroy(self, event):
-        """Handle when the adjust dialog is destroyed."""
-        self.adjust = None
-        self.checkButtons = None
-    
-    def _ChangeOptions(self, options):
-        """Handle when the spline options are changed."""
-        for spline in self.splineDrawList:
-            spline.set_options(options)
-        self.frame.Update()
-    
-    def _ChangeAnimate(self, value):
-        """Handle when the spline animation is changed."""
-        nInd = self.animateOptions[value]
-        animating = False
-        for spline in self.splineDrawList:
-            if nInd is None or nInd < spline.nInd:
-                spline.set_animate(nInd)
-                animating = True
-        self.frame.SetAnimating(animating)
-        self.frame.Update()
-
-    def _FillColorChange(self):
-        """Handle when the fill color changed."""
-        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.splineDrawList:
-                    spline.set_fill_color(newColor[0])
-                self.frame.Update()
-
-    def _LineColorChange(self):
-        """Handle when the line color changed."""
-        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.splineDrawList:
-                    spline.set_line_color(newColor[0])
-                self.frame.Update()
-    
-class bspyGraphics:
-    """
-    A graphics engine to display splines. It launches a `bspyApp` and issues commands to the app.
-
-    Parameters
-    ----------
-    variableDictionary : `dict`
-        A dictionary of variable names, typically `locals()`, used to assign names to splines.
-
-    See Also
-    --------
-    `bspyApp` : A tkinter app (`tkinter.Tk`) that hosts a `SplineOpenGLFrame`, a listbox full of 
-        splines, and a set of controls to adjust and view the selected splines.
-
-    Examples
-    --------
-    Launch a bspyApp and tell it to draw some splines.
-    >>> graphics = bspyGraphics(locals())
-    >>> graphics.draw(spline1)
-    >>> graphics.draw(spline2)
-    >>> graphics.draw(spline3)
-    """
-
-    def __init__(self, variableDictionary):
-        self.workQueue = queue.Queue()
-        self.appThread = threading.Thread(target=self._app_thread)
-        self.appThread.start()
-        self.variableDictionary = variableDictionary
-            
-    def _app_thread(self):
-        app = bspyApp(workQueue=self.workQueue)
-        app.mainloop()        
-
-    def list(self, spline, name = None):
-        """List a `Spline` in the listbox."""
-        if name is not None:
-            spline.metadata["Name"] = name
-        elif "Name" not in spline.metadata:
-            for name, value in self.variableDictionary.items():
-                if value is spline:
-                    spline.metadata["Name"] = name
-                    break
-        self.workQueue.put(("show", (spline,)))
-
-    def show(self, spline, name = None):
-        """Show a `Spline` in the listbox (calls list method, kept for compatibility)."""
-        self.list(spline, name)
-
-    def draw(self, spline, name = None):
-        """Add a `Spline` to the listbox and draw it."""
-        if name is not None:
-            spline.metadata["Name"] = name
-        elif "Name" not in spline.metadata:
-            for name, value in self.variableDictionary.items():
-                if value is spline:
-                    spline.metadata["Name"] = name
-                    break
-        self.workQueue.put(("draw", (spline,)))
-
-    def erase_all(self):
-        """Stop drawing all splines. Splines remain in the listbox."""
-        self.workQueue.put(("erase_all", ()))
-
-    def empty(self):
-        """Stop drawing all splines and remove them from the listbox."""
-        self.workQueue.put(("empty", ()))
-
-    def set_background_color(self, r, g=None, b=None, a=None):
-        """
-        Set the background color.
-
-        Parameters
-        ----------
-        r : `float`, `int` or array-like of floats or ints
-            The red value [0, 1] as a float, [0, 255] as an int, or the rgb or rgba value as floats or ints (default).
-        
-        g: `float` or `int`
-            The green value [0, 1] as a float or [0, 255] as an int.
-        
-        b: `float` or `int`
-            The blue value [0, 1] as a float or [0, 255] as an int.
-        
-        a: `float`, `int`, or None
-            The alpha value [0, 1] as a float or [0, 255] as an int. If `None` then alpha is set to 1.
-        """
-        self.workQueue.put(("set_background_color", (r, g, b, a)))
-
-    def update(self):
-        """Update the spline draw list and refresh the frame."""
-        self.workQueue.put(("update", ()))