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

bspy/drawableSpline.py

@@ -1,585 +0,0 @@
-import numpy as np
-from OpenGL.GL import *
-from bspy import Spline
-
-def _set_color(r, g=None, b=None, a=None):
-    """
-    Return an array with the specified 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.
-
-    Returns
-    -------
-    color : `numpy.array`
-        The specified color as an array of 4 float32 values between 0 and 1.
-    """
-    if isinstance(r, (int, np.integer)):
-        red = float(r) / 255.0
-        green = red
-        blue = red
-        alpha = 1.0
-    elif np.isscalar(r):
-        red = r
-        green = red
-        blue = red
-        alpha = 1.0
-    elif isinstance(r[0], (int, np.integer)):
-        red = float(r[0]) / 255.0
-        green = float(r[1]) / 255.0
-        blue = float(r[2]) / 255.0
-        alpha = float(r[3]) / 255.0 if len(r) >= 4 else 1.0
-    else:
-        red = r[0]
-        green = r[1]
-        blue = r[2]
-        alpha = r[3] if len(r) >= 4 else 1.0
-
-    if isinstance(g, (int, np.integer)):
-        green = float(g) / 255.0
-    elif np.isscalar(g):
-        green = g
-
-    if isinstance(b, (int, np.integer)):
-        blue = float(b) / 255.0
-    elif np.isscalar(b):
-        blue = b
-
-    if isinstance(a, (int, np.integer)):
-        alpha = float(a) / 255.0
-    elif np.isscalar(a):
-        alpha = a
-    
-    return np.array((red, green, blue, alpha), np.float32)
-
-class DrawableSpline(Spline):
-    """
-    A `Spline` that can be drawn within a `SplineOpenGLFrame`.
-
-    Parameters
-    ----------
-    spline or nInd : `Spline` or `int`
-        An existing spline that needs to become drawable (using `DrawableSpline.make_drawable`), or the number of independent variables of the new spline. 
-        If it is an existing spline, the remaining parameters are optional and ignored.
-
-    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 function in that variable
-
-    nCoef : `tuple`
-        A tuple of length nInd where each integer entry represents the
-        dimension (i.e. number of B-spline coefficients) of the function
-        space in that variable
-
-    knots : `list`
-        A list of the lists of the knots of the spline in each independent variable
-
-    coefs : array-like
-        A list of the B-spline coefficients of the spline.
-    
-    metadata : `dict`
-        A dictionary of ancillary data to store with the spline
-
-    See Also
-    --------
-    `bspy.spline` : A class to model, represent, and process piecewise polynomial tensor product
-        functions (spline functions) as linear combinations of B-splines.
-    
-    `make_drawable` : Convert a `Spline` into a `DrawableSpline` that can be drawn in a `SplineOpenGLFrame`. Converts 
-        1D splines into 3D curves, 2D splines into surfaces (y-axis hold amplitude), and 3D splines into solids.
-    """
-
-    maxOrder = 9
-    """Maximum order for drawable splines."""
-    maxCoefficients = 120
-    """Maximum number of coefficients for drawable splines."""
-    maxKnots = maxCoefficients + maxOrder
-    """Maximum number of knots for drawable splines."""
-    _maxFloats = 4 + 2 * maxKnots + 4 * maxCoefficients * maxCoefficients
-    """Maximum total number of floats for drawable splines."""
-
-    HULL = (1 << 0)
-    """Option to draw the convex hull of the spline (the coefficients). Off by default."""
-    SHADED = (1 << 1)
-    """Option to draw the spline shaded (only useful for nInd >= 2). On by default."""
-    BOUNDARY = (1 << 2)
-    """Option to draw the boundary of the spline in the line color (only useful for nInd >= 2). On by default."""
-    ISOPARMS = (1 << 3)
-    """Option to draw the lines of constant knot values of the spline in the line color (only useful for nInd >= 2). Off by default."""
-
-    def __init__(self, *args, **kwargs):
-        if isinstance(args[0], Spline):
-            spline = DrawableSpline.make_drawable(args[0])
-            self.nInd = spline.nInd
-            self.nDep = spline.nDep
-            self.order = spline.order
-            self.nCoef = spline.nCoef
-            self.knots = spline.knots
-            self.coefs = spline.coefs
-            self.metadata = spline.metadata
-        else:
-            Spline.__init__(self, *args, **kwargs)
-            if self.nInd > 3: raise ValueError("nInd must be no more than 3")
-            if self.nDep < 3: raise ValueError("nDep must be at least 3")
-            if self.coefs.dtype != np.float32: raise ValueError("Must use 32-bit floats")
-            for knotArray in self.knots:
-                if knotArray.dtype != np.float32: raise ValueError("Must use 32-bit floats")
-            floatCount = 0
-            coefficientCount = 1
-            for i in range(self.nInd):
-                if self.order[i] > self.maxOrder: raise ValueError(f"order larger than {self.maxOrder}")
-                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")
-            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]))
-
-    @staticmethod
-    def make_drawable(spline):
-        """
-        Convert a `Spline` into a `DrawableSpline` that can be drawn in a `SplineOpenGLFrame`. Converts 
-        1D splines into 3D curves, 2D splines into surfaces (y-axis hold amplitude), and 3D splines into solids.
-
-        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 drawable spline will share the original spline's metadata (metadata changes are shared).
-        """
-        if isinstance(spline, DrawableSpline):
-            return spline
-        if not(isinstance(spline, Spline)): raise ValueError("Invalid spline")
-        if spline.nInd > 3: raise ValueError("Spline must have no more than 3 independent variables")
-        if spline.nDep > 6: raise ValueError("Spline must have no more than 6 dependent variables")
-
-        nDep = 3
-        if spline.nInd >= 2 and spline.nDep > 3:
-            nDep = 4 if spline.nDep == 4 else 6 # No nDep of 5
-        
-        knotList = [knots.astype(np.float32, copy=False) for knots in spline.knots]
-        coefs = np.zeros((nDep, *spline.nCoef), np.float32)
-        if spline.nInd == 1:
-            if spline.nDep == 1:
-                spline = spline.graph()
-                coefs[0] = spline.coefs[0]
-                coefs[1] = spline.coefs[1]
-            else:
-                coefs[:min(spline.nDep, 3)] = spline.coefs[:min(spline.nDep, 3)]
-        elif spline.nInd == 2:
-            if spline.nDep == 1:
-                spline = spline.graph()
-                coefs[0] = spline.coefs[0]
-                coefs[1] = spline.coefs[2]
-                coefs[2] = spline.coefs[1]
-            else:
-                coefs[:spline.nDep] = spline.coefs
-                # For dimensions above three, rescale dependent variables to [0, 1].
-                for i in range(3, spline.nDep):
-                    minCoef = coefs[i].min()
-                    rangeCoef = coefs[i].max() - minCoef
-                    if rangeCoef > 1.0e-8:
-                        coefs[i] = (coefs[i] - minCoef) / rangeCoef
-                    else:
-                        coefs[i] = max(0.0, min(1.0, minCoef))
-        elif spline.nInd == 3:
-            if spline.nDep == 1:
-                spline = spline.graph()
-                coefs[0] = spline.coefs[0]
-                coefs[1] = spline.coefs[3]
-                coefs[2] = spline.coefs[1]
-                coefs[3] = spline.coefs[2]
-            else:
-                coefs[:spline.nDep] = spline.coefs
-                # For dimensions above three, rescale dependent variables to [0, 1].
-                for i in range(3, spline.nDep):
-                    minCoef = coefs[i].min()
-                    rangeCoef = coefs[i].max() - minCoef
-                    if rangeCoef > 1.0e-8:
-                        coefs[i] = (coefs[i] - minCoef) / rangeCoef
-                    else:
-                        coefs[i] = max(0.0, min(1.0, minCoef))
-        else:
-            raise ValueError("Can't convert to drawable spline.")
-        
-        drawable = DrawableSpline(spline.nInd, nDep, spline.order, spline.nCoef, knotList, coefs)
-        drawable.metadata = spline.metadata # Make the original spline share its metadata with its drawable spline
-        if not "fillColor" in drawable.metadata:
-            drawable.metadata["fillColor"] = np.array((0.0, 1.0, 0.0, 1.0), np.float32)
-        if not "lineColor" in drawable.metadata:
-            drawable.metadata["lineColor"] = np.array((0.0, 0.0, 0.0, 1.0) if drawable.nInd > 1 else (1.0, 1.0, 1.0, 1.0), np.float32)
-        if not "options" in drawable.metadata:
-            drawable.metadata["options"] = drawable.SHADED | drawable.BOUNDARY
-        if not "animate" in drawable.metadata:
-            drawable.metadata["animate"] = None
-        return drawable
-
-    def _DrawPoints(self, frame, drawCoefficients):
-        """
-        Draw spline points for an nInd == 0 or order == 1 spline within a `SplineOpenGLFrame`. The frame will call this method for you.
-        """
-        glColor4fv(self.get_line_color())
-        glBegin(GL_POINTS)
-        if self.nInd == 0:
-            glVertex3fv(drawCoefficients)
-        else:
-            for point in drawCoefficients:
-                glVertex3fv(point)
-        glEnd()
-
-    def _DrawCurve(self, frame, drawCoefficients):
-        """
-        Draw a spline curve (nInd == 1) within a `SplineOpenGLFrame`. The frame will call this method for you.
-        """
-        if self.get_options() & self.HULL:
-            glColor3f(0.0, 0.0, 1.0)
-            glBegin(GL_LINE_STRIP)
-            for point in drawCoefficients:
-                glVertex3f(point[0], point[1], point[2])
-            glEnd()
-
-        program = frame.curveProgram
-        glUseProgram(program.curveProgram)
-        glUniform4fv(program.uCurveLineColor, 1, self.get_line_color())
-        glBindBuffer(GL_TEXTURE_BUFFER, frame.splineDataBuffer)
-        offset = 0
-        size = 4 * 2
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((self.order[0], self.nCoef[0]), np.float32))
-        offset += size
-        size = 4 * len(self.knots[0])
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, self.knots[0])
-        offset += size
-        size = 3 * 4 * self.nCoef[0]
-        drawCoefficients = drawCoefficients[..., :3]
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients)
-        glEnableVertexAttribArray(program.aCurveParameters)
-        if frame.tessellationEnabled:
-            glPatchParameteri(GL_PATCH_VERTICES, 1)
-            glDrawArraysInstanced(GL_PATCHES, 0, 1, self.nCoef[0] - self.order[0] + 1)
-        else:
-            glDrawArraysInstanced(GL_POINTS, 0, 1, self.nCoef[0] - self.order[0] + 1)
-            glFlush() # Old graphics card
-        glDisableVertexAttribArray(program.aCurveParameters)
-        glUseProgram(0)
-
-    @staticmethod
-    def _ConvertRGBToHSV(r, g, b, a):
-        # Taken from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
-        K = 0.0
-        if g < b:
-            tmp = g
-            g = b
-            b = tmp
-            K = -1.0
-        if r < g:
-            tmp = r
-            r = g
-            g = tmp
-            K = -2.0 / 6.0 - K
-        chroma = r - min(g, b)
-        return np.array((abs(K + (g - b) / (6.0 * chroma + 1e-20)), chroma / (r + 1e-20), r, a), np.float32)
-    
-    def _DrawSurface(self, frame, drawCoefficients):
-        """
-        Draw a spline surface (nInd == 2) within a `SplineOpenGLFrame`. The frame will call this method for you.
-        """
-        if self.get_options() & self.HULL:
-            glColor3f(0.0, 0.0, 1.0)
-            for pointList in drawCoefficients:
-                glBegin(GL_LINE_STRIP)
-                for point in pointList:
-                    glVertex3f(point[0], point[1], point[2])
-                glEnd()
-
-        fillColor = self.get_fill_color()
-        if self.nDep == 3:
-            program = frame.surface3Program
-        elif self.nDep == 4:
-            program = frame.surface4Program
-            fillColor = self._ConvertRGBToHSV(fillColor[0], fillColor[1], fillColor[2], fillColor[3])
-        elif self.nDep == 6:
-            program = frame.surface6Program
-        else:
-            raise ValueError("Can't draw surface.")
-        
-        useBlending = fillColor[3] < 1.0
-        if useBlending:
-            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-            glEnable( GL_BLEND )
-            glDisable( GL_DEPTH_TEST )
-
-        glUseProgram(program.surfaceProgram)
-        glUniform4fv(program.uSurfaceFillColor, 1, fillColor)
-        glUniform4fv(program.uSurfaceLineColor, 1, self.get_line_color())
-        glUniform1i(program.uSurfaceOptions, self.get_options())
-        glBindBuffer(GL_TEXTURE_BUFFER, frame.splineDataBuffer)
-        offset = 0
-        size = 4 * 4
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((self.order[0], self.order[1], self.nCoef[0], self.nCoef[1]), np.float32))
-        offset += size
-        size = 4 * len(self.knots[0])
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, self.knots[0])
-        offset += size
-        size = 4 * len(self.knots[1])
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, self.knots[1])
-        offset += size
-        size = self.nDep * 4 * self.nCoef[0] * self.nCoef[1]
-        glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients)
-        glEnableVertexAttribArray(program.aSurfaceParameters)
-        if frame.tessellationEnabled:
-            glPatchParameteri(GL_PATCH_VERTICES, 1)
-            glDrawArraysInstanced(GL_PATCHES, 0, 1, (self.nCoef[0] - self.order[0] + 1) * (self.nCoef[1] - self.order[1] + 1))
-        else:
-            glDrawArraysInstanced(GL_POINTS, 0, 1, (self.nCoef[0] - self.order[0] + 1) * (self.nCoef[1] - self.order[1] + 1))
-            glFlush() # Old graphics card
-        glDisableVertexAttribArray(program.aSurfaceParameters)
-        glUseProgram(0)
-        if useBlending:
-            glDisable( GL_BLEND )
-            glEnable( GL_DEPTH_TEST )
-    
-    def _DrawSolid(self, frame, drawCoefficients):
-        """
-        Draw a spline solid (nInd == 3) within a `SplineOpenGLFrame`. The frame will call this method for you.
-        """
-        if self.get_options() & self.HULL:
-            glColor3f(0.0, 0.0, 1.0)
-            for pointSet in drawCoefficients:
-                for pointList in pointSet:
-                    glBegin(GL_LINE_STRIP)
-                    for point in pointList:
-                        glVertex3f(point[0], point[1], point[2])
-                    glEnd()
-
-        fillColor = self.get_fill_color().copy()
-        lineColor = self.get_line_color().copy()
-        if self.nDep == 3:
-            program = frame.surface3Program
-        elif self.nDep == 4:
-            program = frame.surface4Program
-            fillColor = self._ConvertRGBToHSV(fillColor[0], fillColor[1], fillColor[2], fillColor[3])
-        elif self.nDep == 6:
-            program = frame.surface6Program
-        else:
-            raise ValueError("Can't draw surface.")
-        fillColor[3] *= 0.5
-        lineColor[3] *= 0.5
-
-        def _DrawBoundarySurface(axis, index):
-            fullSlice = slice(None)
-            if axis == 0:
-                i1 = 1
-                i2 = 2
-                coefSlice = (fullSlice, fullSlice, index, fullSlice)
-            elif axis == 1:
-                i1 = 0
-                i2 = 2
-                coefSlice = (fullSlice, index, fullSlice, fullSlice)
-            else:
-                i1 = 0
-                i2 = 1
-                coefSlice = (index, fullSlice, fullSlice, fullSlice)
-
-            glBindBuffer(GL_TEXTURE_BUFFER, frame.splineDataBuffer)
-            offset = 0
-            size = 4 * 4
-            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, np.array((self.order[i1], self.order[i2], self.nCoef[i1], self.nCoef[i2]), np.float32))
-            offset += size
-            size = 4 * len(self.knots[i1])
-            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, self.knots[i1])
-            offset += size
-            size = 4 * len(self.knots[i2])
-            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, self.knots[i2])
-            offset += size
-            size = self.nDep * 4 * self.nCoef[i1] * self.nCoef[i2]
-            glBufferSubData(GL_TEXTURE_BUFFER, offset, size, drawCoefficients[coefSlice])
-            glEnableVertexAttribArray(program.aSurfaceParameters)
-            if frame.tessellationEnabled:
-                glPatchParameteri(GL_PATCH_VERTICES, 1)
-                glDrawArraysInstanced(GL_PATCHES, 0, 1, (self.nCoef[i1] - self.order[i1] + 1) * (self.nCoef[i2] - self.order[i2] + 1))
-            else:
-                glDrawArraysInstanced(GL_POINTS, 0, 1, (self.nCoef[i1] - self.order[i1] + 1) * (self.nCoef[i2] - self.order[i2] + 1))
-                glFlush() # Old graphics card
-            glDisableVertexAttribArray(program.aSurfaceParameters)
-
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-        glEnable( GL_BLEND )
-        glDisable( GL_DEPTH_TEST )
-        glUseProgram(program.surfaceProgram)
-        glUniform4fv(program.uSurfaceFillColor, 1, fillColor)
-        glUniform4fv(program.uSurfaceLineColor, 1, lineColor)
-        glUniform1i(program.uSurfaceOptions, self.get_options())
-
-        _DrawBoundarySurface(0, 0)
-        _DrawBoundarySurface(0, -1)
-        _DrawBoundarySurface(1, 0)
-        _DrawBoundarySurface(1, -1)
-        _DrawBoundarySurface(2, 0)
-        _DrawBoundarySurface(2, -1)
-
-        glUseProgram(0)
-        glDisable( GL_BLEND )
-        glEnable( GL_DEPTH_TEST )
-
-    def _Draw(self, frame, transform):
-        """
-        Draw a spline  within a `SplineOpenGLFrame`. The frame will call this method for you.
-        """
-        # Contract spline if it's animating.
-        nInd = self.get_animate()
-        if nInd is not None:
-            uvw = self.nInd * [None]
-            u1 = self.knots[nInd][self.order[nInd] - 1]
-            u2 = self.knots[nInd][self.nCoef[nInd]]
-            # Contraction value is set to cycle every 10 seconds (10000 ms).
-            uvw[nInd] = u1 + 0.49999 * (u2 - u1) * (1.0 - np.cos(2.0 * np.pi * frame.frameCount * frame.MsPerFrame / 10000))
-            self = self.contract(uvw)
-
-        # Transform coefs by view transform.
-        coefs = self.coefs.T
-        drawCoefficients = np.empty(coefs.shape, np.float32)
-        drawCoefficients[..., :3] = coefs[..., :3] @ transform[:3,:3] + transform[3,:3]
-        drawCoefficients[..., 3:] = coefs[..., 3:]
-
-        # Draw spline.
-        if self.nInd == 0 or self.order[0] == 1:
-            self._DrawPoints(frame, drawCoefficients)
-        elif self.nInd == 1:
-            self._DrawCurve(frame, drawCoefficients)
-        elif self.nInd == 2:
-            self._DrawSurface(frame, drawCoefficients)
-        elif self.nInd == 3:
-            self._DrawSolid(frame, drawCoefficients)
-    
-    def get_fill_color(self):
-        """
-        Gets the fill color of the spline (only useful for nInd >= 2).
-
-        Returns
-        -------
-        fillColor : `numpy.array`
-            Array of four floats (r, g, b, a) in the range [0, 1].
-        """
-        return self.metadata["fillColor"]
-
-    def set_fill_color(self, r, g=None, b=None, a=None):
-        """
-        Set the fill color of the spline (only useful for nInd >= 2).
-
-        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.metadata["fillColor"] = _set_color(r, g, b, a)
-    
-    def get_line_color(self):
-        """
-        Gets the line color of the spline.
-
-        Returns
-        -------
-        lineColor : `numpy.array`
-            Array of four floats (r, g, b, a) in the range [0, 1].
-        """
-        return self.metadata["lineColor"]
-
-    def set_line_color(self, r, g=None, b=None, a=None):
-        """
-        Set the line color of the spline.
-
-        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.metadata["lineColor"] = _set_color(r, g, b, a)
-    
-    def get_options(self):
-        """
-        Gets the draw options for the spline.
-
-        Returns
-        -------
-        options : `int` bitwise or (`|`) of zero or more of the following values:
-            * `DrawableSpline.HULL` Draw the convex hull of the spline (the coefficients). Off by default.
-            * `DrawableSpline.SHADED` Draw the spline shaded (only useful for nInd >= 2). On by default.
-            * `DrawableSpline.BOUNDARY` Draw the boundary of the spline in the line color (only useful for nInd >= 2). On by default.
-            * `DrawableSpline.ISOPARMS` Draw the lines of constant knot values of the spline in the line color (only useful for nInd >= 2). Off by default.
-        """
-        return self.metadata["options"]
-
-    def set_options(self, options):
-        """
-        Set the draw options for the spline.
-
-        Parameters
-        ----------
-        options : `int` bitwise or (`|`) of zero or more of the following values:
-            * `DrawableSpline.HULL` Draw the convex hull of the spline (the coefficients). Off by default.
-            * `DrawableSpline.SHADED` Draw the spline shaded (only useful for nInd >= 2). On by default.
-            * `DrawableSpline.BOUNDARY` Draw the boundary of the spline in the line color (only useful for nInd >= 2). On by default.
-            * `DrawableSpline.ISOPARMS` Draw the lines of constant knot values of the spline in the line color (only useful for nInd >= 2). Off by default.
-        """
-        self.metadata["options"] = options
-    
-    def get_animate(self):
-        """
-        Get the independent variable that is animated (None if there is none).
-
-        Returns
-        -------
-        animate : `int` or `None`
-            The index of the independent variable that is animated (None is there is none).
-        """
-        return self.metadata["animate"]
-
-    def set_animate(self, animate):
-        """
-        Set the independent variable that is animated (None if there is none).
-
-        Parameters
-        ----------
-        animate : `int` or `None`
-            The index of the independent variable that is animated (None is there is none).
-        """
-        self.metadata["animate"] = animate

bspy-3.0.1.dist-info/RECORD

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