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

bspy/_spline_operations.py

@@ -17,7 +17,7 @@ def add(self, other, indMap = None):
     otherMapped = []
     otherToSelf = {}
     if indMap is not None:
-        (self, other) = self.common_basis((other,), indMap)
+        (self, other) = bspy.Spline.common_basis((self, other), indMap)
         for map in indMap:
             selfMapped.append(map[0])
             otherMapped.append(map[1])
@@ -57,7 +57,7 @@ def add(self, other, indMap = None):
     # Reverse the permutation.
     coefs = coefs.transpose(np.argsort(permutation)) 
     
-    return type(self)(nInd, self.nDep, order, nCoef, knots, coefs, self.accuracy + other.accuracy, self.metadata)
+    return type(self)(nInd, self.nDep, order, nCoef, knots, coefs, self.metadata)
 
 def confine(self, range_bounds):
     if self.nInd != 1: raise ValueError("Confine only works on curves (nInd == 1)")
@@ -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.
@@ -194,7 +200,7 @@ def contract(self, uvw):
         else:
             ix += 1
     
-    return type(self)(nInd, self.nDep, order, nCoef, knots, coefs, self.accuracy, self.metadata)
+    return type(self)(nInd, self.nDep, order, nCoef, knots, coefs, self.metadata)
 
 def cross(self, vector):
     if isinstance(vector, bspy.Spline):
@@ -206,14 +212,14 @@ def cross(self, vector):
         coefs[0] = vector[2] * self.coefs[1] - vector[1] * self.coefs[2]
         coefs[1] = vector[0] * self.coefs[2] - vector[2] * self.coefs[0]
         coefs[2] = vector[1] * self.coefs[0] - vector[0] * self.coefs[1]
-        return type(self)(self.nInd, 3, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
+        return type(self)(self.nInd, 3, self.order, self.nCoef, self.knots, coefs, self.metadata)
     else:
         if not(self.nDep == 2): raise ValueError("Invalid nDep")
         if not(len(vector) == self.nDep): raise ValueError("Invalid vector")
 
         coefs = np.empty((1, *self.coefs.shape[1:]), self.coefs.dtype)
         coefs[0] = vector[1] * self.coefs[0] - vector[0] * self.coefs[1]
-        return type(self)(self.nInd, 3, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
+        return type(self)(self.nInd, 3, self.order, self.nCoef, self.knots, coefs, self.metadata)
 
 def differentiate(self, with_respect_to = 0):
     if not(0 <= with_respect_to < self.nInd): raise ValueError("Invalid with_respect_to")
@@ -237,7 +243,7 @@ def differentiate(self, with_respect_to = 0):
         alpha =  degree / (dKnots[i+degree] - dKnots[i])
         newCoefs[i] = alpha * (newCoefs[i] - oldCoefs[i])
     
-    return type(self)(self.nInd, self.nDep, order, nCoef, knots, newCoefs.swapaxes(0, with_respect_to + 1), self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, order, nCoef, knots, newCoefs.swapaxes(0, with_respect_to + 1), self.metadata)
 
 def dot(self, vector):
     if isinstance(vector, bspy.Spline):
@@ -250,24 +256,24 @@ def dot(self, vector):
             coefs += vector[i] * self.coefs[i]
         if len(coefs.shape) == len(self.coefs.shape) - 1:
             coefs = coefs.reshape(1, *coefs.shape)
-        return type(self)(self.nInd, 1, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
+        return type(self)(self.nInd, 1, self.order, self.nCoef, self.knots, coefs, self.metadata)
 
 def graph(self):
     self = self.clamp(range(self.nInd), range(self.nInd))
     coefs = np.insert(self.coefs, self.nInd * (0,), 0.0, axis = 0)
     for nInd in range(self.nInd):
         dep = np.swapaxes(coefs, nInd + 1, 1)[nInd] # Returns a view, so changes to dep make changes to coefs
-        for i, knotAvg in enumerate(self.greville(nInd)):
-            dep[i] = knotAvg
-    return type(self)(self.nInd, self.nInd + self.nDep, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
+        for i, knotAverage in enumerate(self.greville(nInd)):
+            dep[i] = knotAverage
+    return type(self)(self.nInd, self.nInd + self.nDep, self.order, self.nCoef, self.knots, coefs, self.metadata)
 
 def greville(self, ind = 0):
     if ind < 0 or ind >= self.nInd:  raise ValueError("Invalid independent variable")
     myKnots = self.knots[ind]
-    knotAvgs = 0
+    knotAverages = 0
     for ix in range(1, self.order[ind]):
-        knotAvgs = knotAvgs + myKnots[ix : ix + self.nCoef[ind]]
-    return knotAvgs / (self.order[ind] - 1)
+        knotAverages = knotAverages + myKnots[ix : ix + self.nCoef[ind]]
+    return knotAverages / (self.order[ind] - 1)
 
 def integrate(self, with_respect_to = 0):
     if not(0 <= with_respect_to < self.nInd): raise ValueError("Invalid with_respect_to")
@@ -295,7 +301,7 @@ def integrate(self, with_respect_to = 0):
     for i in range(1, nCoef[with_respect_to]):
         newCoefs[i] = newCoefs[i - 1] + ((iKnots[degree + i] - iKnots[i]) / degree) * oldCoefs[i - 1]
 
-    return type(self)(self.nInd, self.nDep, order, nCoef, knots, newCoefs.swapaxes(0, with_respect_to + 1), self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, order, nCoef, knots, newCoefs.swapaxes(0, with_respect_to + 1), self.metadata)
 
 def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
     if not(productType == 'C' or productType == 'D' or productType == 'S'): raise ValueError("productType must be 'C', 'D' or 'S'")
@@ -631,7 +637,7 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
             # Now move combined independent variable back to its original axis.
             coefs = np.moveaxis(newCoefs[:nCoef[ind1]], 0, ind1 + 1)
 
-    return type(self)(nInd, nDep, order, nCoef, knots, coefs, self.accuracy + other.accuracy, self.metadata)
+    return type(self)(nInd, nDep, order, nCoef, knots, coefs, self.metadata)
 
 # Return a matrix of booleans whose [i,j] value indicates if self's partial wrt variable i depends on variable j. 
 def _cross_correlation_matrix(self):
@@ -653,23 +659,20 @@ def _cross_correlation_matrix(self):
                 if not match:
                     break
             ccm[i, j] = ccm[j, i] = not match
-
     ccm[-1, -1] = True
     return ccm
 
 def normal_spline(self, indices=None):
-    if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be one different than the number of dependent variables.")
+    if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be one less than the number of dependent variables.")
 
     # Construct order and knots for generalized cross product of the tangent space.
     newOrder = []
     newKnots = []
-    startUvw = []
-    endUvw = []
-    deltaUvw = []
+    uvwValues = []
+    nCoefs = []
     totalCoefs = [1]
-    rank = min(self.nInd, self.nDep)
     ccm = _cross_correlation_matrix(self)
-    for i, order, knots in zip(range(self.nInd), self.order, self.knots):
+    for i, (order, knots) in enumerate(zip(self.order, self.knots)):
         # First, calculate the order of the normal for this independent variable.
         # Note that the total order will be one less than usual, because one of 
         # the tangents is the derivative with respect to that independent variable.
@@ -700,56 +703,67 @@ def normal_spline(self, indices=None):
         # using that calculation to span uvw from the starting knot to the end for each variable.
         nCoef = len(newKnots[-1]) - newOrder[-1]
         totalCoefs.append(totalCoefs[-1] * nCoef)
-        startUvw.append(uniqueKnots[0])
-        endUvw.append(uniqueKnots[-1])
-        deltaUvw.append((uniqueKnots[-1] - uniqueKnots[0]) / (nCoef - 1))
-    
+        uvwValues.append(bspy.Spline(1, 0, [newOrd], [nCoef], [newKnots[-1]], []).greville())
+        nCoefs.append(nCoef)
     points = []
-    uvw = [*startUvw]
+    ijk = [0 for order in self.order]
     for i in range(totalCoefs[-1]):
-        points.append((*uvw, *self.normal(uvw, False, indices)))
-        for j, nCoef, start, end, delta in zip(range(self.nInd), totalCoefs[:-1], startUvw, endUvw, deltaUvw):
+        uvw = [uvwValues[j][k] for j, k in enumerate(ijk)]
+        points.append(self.normal(uvw, False, indices))
+        for j, nCoef in enumerate(totalCoefs[:-1]):
             if (i + 1) % nCoef == 0:
-                uvw[j] = min(uvw[j] + delta, end)
+                ijk[j] += 1
                 if j > 0:
-                    uvw[j - 1] = previousStart
-            previousStart = start
-    
+                    ijk[j - 1] = 0
+    points = np.array(points).T
     nDep = max(self.nInd, self.nDep) if indices is None else len(indices)
-    return bspy.Spline.least_squares(self.nInd, nDep, newOrder, points, newKnots, 0, self.metadata)
+    nCoefs.reverse()
+    points = np.reshape(points, [nDep] + nCoefs)
+    points = np.transpose(points, [0] + list(range(self.nInd, 0, -1)))
+    return bspy.Spline.least_squares(uvwValues, points, order = newOrder, knots = newKnots, metadata = self.metadata)
+#    return bspy.Spline.least_squares(self.nInd, nDep, newOrder, points, newKnots, 0, self.metadata)
+
+def rotate(self, vector, angle):
+    vector = np.atleast_1d(vector)
+    vector = vector / np.linalg.norm(vector)
+    if len(vector) != 3:  raise ValueError("Rotation vector must have 3 components")
+    if self.nDep != 3:  raise ValueError("Spline must have exactly 3 dependent variables")
+    radians = np.pi * angle / 180.0
+    cost = np.cos(radians)
+    sint = np.sin(radians)
+    kMat = np.array([[0.0, -vector[2], vector[1]],
+                     [vector[2], 0.0, -vector[0]],
+                     [-vector[1], vector[0], 0.0]])
+    rotMat = np.identity(3) + sint * kMat + (1.0 - cost) * kMat @ kMat
+    return list(rotMat) @ self
 
 def scale(self, multiplier):
     if isinstance(multiplier, bspy.Spline):
         return self.multiply(multiplier, [(ix, ix) for ix in range(min(self.nInd, multiplier.nInd))], 'S')
     else:
         if np.isscalar(multiplier):
-            accuracy = abs(multiplier) * self.accuracy
             nDep = self.nDep
             coefs = multiplier * self.coefs
         elif len(multiplier) == self.nDep:
-            accuracy = np.linalg.norm(multiplier) * self.accuracy
             nDep = self.nDep
             coefs = np.array(self.coefs)
             for i in range(nDep):
                 coefs[i] *= multiplier[i]
         elif self.nDep == 1:
-            accuracy = np.linalg.norm(multiplier) * self.accuracy
             nDep = len(multiplier)
             coefs = np.empty((nDep, *self.coefs.shape[1:]), self.coefs.dtype)
             for i in range(nDep):
                 coefs[i] = multiplier[i] * self.coefs[0]
         else:
             raise ValueError("Invalid multiplier")
-        return type(self)(self.nInd, nDep, self.order, self.nCoef, self.knots, coefs, accuracy, self.metadata)
+        return type(self)(self.nInd, nDep, self.order, self.nCoef, self.knots, coefs, self.metadata)
 
-def transform(self, matrix, maxSingularValue=None):
+def transform(self, matrix):
     if not(matrix.ndim == 2 and matrix.shape[1] == self.nDep): raise ValueError("Invalid matrix")
 
-    if maxSingularValue is None:
-        maxSingularValue = np.linalg.svd(matrix, compute_uv=False)[0]
     swapped = np.swapaxes(self.coefs, 0, -2)
     newCoefs = np.swapaxes(matrix @ swapped, 0, -2)
-    return type(self)(self.nInd, matrix.shape[0], self.order, self.nCoef, self.knots, newCoefs, maxSingularValue * self.accuracy, self.metadata)
+    return type(self)(self.nInd, matrix.shape[0], self.order, self.nCoef, self.knots, newCoefs, self.metadata)
 
 def translate(self, translationVector):
     translationVector = np.atleast_1d(translationVector)
@@ -758,4 +772,4 @@ def translate(self, translationVector):
     coefs = np.array(self.coefs)
     for i in range(self.nDep):
         coefs[i] += translationVector[i]
-    return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
+    return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, coefs, self.metadata)

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,32 +139,25 @@ 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", 
             defaultextension=".json", filetypes=(('Json files', '*.json'),('All files', '*.*')))
         if fileName:
             splines = DrawableSpline.load(fileName)
-            if isinstance(splines, Spline):
-                self.list(splines)
-            else:
-                for spline in splines:
-                    self.list(spline)
+            for spline in splines:
+                self.list(spline)
     
     def erase_all(self):
         """Stop drawing all splines. Splines remain in the listbox."""
@@ -203,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]
@@ -215,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
@@ -243,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()
@@ -262,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)
@@ -277,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))
@@ -302,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()
     
@@ -310,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
@@ -319,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/drawableSpline.py

@@ -91,11 +91,6 @@ class DrawableSpline(Spline):
     coefs : array-like
         A list of the B-spline coefficients of the spline.
     
-    accuracy : `float`
-        Each spline function is presumed to be an approximation of something else. 
-        The `accuracy` stores the infinity norm error of the difference between 
-        the given spline function and that something else.
-
     metadata : `dict`
         A dictionary of ancillary data to store with the spline
 
@@ -135,7 +130,6 @@ class DrawableSpline(Spline):
             self.nCoef = spline.nCoef
             self.knots = spline.knots
             self.coefs = spline.coefs
-            self.accuracy = spline.accuracy
             self.metadata = spline.metadata
         else:
             Spline.__init__(self, *args, **kwargs)
@@ -151,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]))
@@ -204,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()
@@ -221,11 +219,11 @@ 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.")
         
-        drawable = DrawableSpline(spline.nInd, nDep, spline.order, spline.nCoef, knotList, coefs, spline.accuracy)
+        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)