bspy 2.0.0__tar.gz → 2.1.0__tar.gz

{bspy-2.0.0 → bspy-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 2.0.0
+Version: 2.1.0
 Summary: Library for manipulating and rendering non-uniform b-splines
 Home-page: http://github.com/ericbrec/bspy
 Author: Eric Brechner
@@ -35,7 +35,7 @@ Library for manipulating and rendering b-spline curves, surfaces, and multidimen
 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 circular arcs, ruled surfaces, and surfaces of revolution. 
 Other methods add, subtract, multiply, and linearly transform splines, as well as confine spline curves to a given range. 
-There are methods to evaluate spline values, derivatives, integrals, normals, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+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, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
 
 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.

{bspy-2.0.0 → bspy-2.1.0}/README.md

@@ -4,7 +4,7 @@ Library for manipulating and rendering b-spline curves, surfaces, and multidimen
 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 circular arcs, ruled surfaces, and surfaces of revolution. 
 Other methods add, subtract, multiply, and linearly transform splines, as well as confine spline curves to a given range. 
-There are methods to evaluate spline values, derivatives, integrals, normals, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+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, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
 
 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.

{bspy-2.0.0 → bspy-2.1.0}/bspy/_spline_domain.py

@@ -51,7 +51,7 @@ def common_basis(self, splines, indMap):
     alignedSplines = []
     for i, spline in enumerate(splines):
         m = spline.nInd * [0]
-        newKnots = [[] for ix in range(spline.nInd)]
+        newKnots = [[] for ix in spline.order]
         for (map, order, multiplicities) in zip(indMap, orders, knots):
             ind = map[i]
             m[ind] = order - spline.order[ind]

{bspy-2.0.0 → bspy-2.1.0}/bspy/_spline_evaluation.py

@@ -56,6 +56,21 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
             b += 1
     return basis
 
+def curvature(self, uv):
+    if self.nInd == 1:
+        if self.nDep == 1:
+            self = self.graph()
+        fp = self.derivative([1], uv)
+        fpp = self.derivative([2], uv)
+        fpdotfp = fp @ fp
+        fpdotfpp = fp @ fpp
+        denom = fpdotfp ** 1.5
+        if self.nDep == 2:
+            numer = fp[0] * fpp[1] - fp[1] * fpp[0]
+        else:
+            numer = np.sqrt((fpp @ fpp) * fpdotfp - fpdotfpp ** 2)
+        return numer / denom 
+
 def derivative(self, with_respect_to, uvw):
     # Make work for scalar valued functions
     uvw = np.atleast_1d(uvw)

{bspy-2.0.0 → bspy-2.1.0}/bspy/_spline_fitting.py

@@ -2,7 +2,9 @@ import numpy as np
 import bspy.spline
 import math
 
-def circular_arc(radius, angle, tolerance):
+def circular_arc(radius, angle, tolerance = None):
+    if tolerance is None:
+        tolerance = np.finfo(float).eps
     if radius < 0.0 or angle < 0.0 or tolerance < 0.0: raise ValueError("The radius, angle, and tolerance must be positive.")
 
     samples = int(max(np.ceil(((1.1536e-5 * radius / tolerance)**(1/8)) * angle / 90), 2.0)) + 1
@@ -418,7 +420,7 @@ def revolve(self, angle):
     maxRadius = max(abs(self.coefs[0].min()), self.coefs[0].max())
     arc = ((1.0 / maxRadius, 0.0),
             (0.0, 1.0 / maxRadius),
-            (0.0, 0.0)) @ bspy.Spline.circular_arc(maxRadius, angle, np.finfo(self.coefs.dtype).eps) + (0.0, 0.0, 1.0)
+            (0.0, 0.0)) @ bspy.Spline.circular_arc(maxRadius, angle) + (0.0, 0.0, 1.0)
     radiusHeight = ((1.0, 0.0),
             (1.0, 0.0),
             (0.0, 1.0)) @ self

{bspy-2.0.0 → bspy-2.1.0}/bspy/_spline_operations.py

@@ -252,6 +252,20 @@ def dot(self, vector):
             coefs = coefs.reshape(1, *coefs.shape)
         return type(self)(self.nInd, 1, self.order, self.nCoef, self.knots, coefs, self.accuracy, self.metadata)
 
+def graph(self):
+    splineDomain = self.domain()
+    uvwSplines = [bspy.Spline(1, 1, [2], [2], [[uLow, uLow, uHigh, uHigh]],
+                              [[uLow, uHigh]]) for uLow, uHigh in splineDomain]
+    graphSpline = uvwSplines[0]
+    for nextSpline in uvwSplines[1:]:
+        graphMat = list(np.block([[np.identity(graphSpline.nInd)], [0.0]]))
+        nextMat = list(np.block([[np.zeros((graphSpline.nInd, 1))], [1.0]]))
+        graphSpline = (graphMat @ graphSpline).add(nextMat @ nextSpline)
+    graphMat = list(np.block([[np.identity(graphSpline.nInd)], [np.zeros((self.nDep, graphSpline.nInd))]]))
+    selfMat = list(np.block([[np.zeros((graphSpline.nInd, self.nDep))], [np.identity(self.nDep)]]))
+    finalGraph = graphMat @ graphSpline + selfMat @ self
+    return finalGraph
+
 def integrate(self, with_respect_to = 0):
     if not(0 <= with_respect_to < self.nInd): raise ValueError("Invalid with_respect_to")
 
@@ -732,10 +746,12 @@ def transform(self, matrix, maxSingularValue=None):
 
     if maxSingularValue is None:
         maxSingularValue = np.linalg.svd(matrix, compute_uv=False)[0]
-
-    return type(self)(self.nInd, matrix.shape[0], self.order, self.nCoef, self.knots, matrix @ self.coefs, maxSingularValue * self.accuracy, self.metadata)
+    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)
 
 def translate(self, translationVector):
+    translationVector = np.atleast_1d(translationVector)
     if not(len(translationVector) == self.nDep): raise ValueError("Invalid translationVector")
 
     coefs = np.array(self.coefs)

{bspy-2.0.0 → bspy-2.1.0}/bspy/spline.py

@@ -6,14 +6,6 @@ import bspy._spline_intersection
 import bspy._spline_fitting
 import bspy._spline_operations
 
-def _isIterable(object):
-    result = True
-    try:
-        iterator = iter(object)
-    except TypeError:
-        result = False
-    return result
-
 class Spline:
     """
     A class to model, represent, and process piecewise polynomial tensor product
@@ -84,8 +76,8 @@ class Spline:
         self.accuracy = accuracy
         self.metadata = dict(metadata)
 
-    def __call__(self, uvw):
-        return self.evaluate(uvw)
+    def __call__(self, *uvw, **kwargs):
+        return self.evaluate(*uvw, **kwargs)
 
     def __repr__(self):
         return f"Spline({self.nInd}, {self.nDep}, {self.order}, " + \
@@ -95,77 +87,59 @@ class Spline:
     def __add__(self, other):
         if isinstance(other, Spline):
             return self.add(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
-        elif _isIterable(other):
-            return self.translate(other)
         else:
-            return NotImplemented
+            return self.translate(other)
 
     def __radd__(self, other):
         if isinstance(other, Spline):
             return other.add(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
-        elif _isIterable(other):
-            return self.translate(other)
         else:
-            return NotImplemented
+            return self.translate(other)
 
     def __matmul__(self, other):
         if isinstance(other, Spline):
             return self.multiply(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'D')
-        elif _isIterable(other):
-            if not isinstance(other, np.ndarray):
-                other = np.array(other)
-            if len(other.shape) == 2:
+        else:
+            other = np.atleast_1d(other)
+            if len(other.shape) > 1:
                 return self.transform(other.T)
             else:
                 return self.dot(other)
-        else:
-            return NotImplemented
 
     def __rmatmul__(self, other):
         if isinstance(other, Spline):
             return other.multiply(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'D')
-        elif _isIterable(other):
-            if not isinstance(other, np.ndarray):
-                other = np.array(other)
-            if len(other.shape) == 2:
+        else:
+            other = np.atleast_1d(other)
+            if len(other.shape) > 1:
                 return self.transform(other)
             else:
                 return self.dot(other)
-        else:
-            return NotImplemented
 
     def __mul__(self, other):
         if isinstance(other, Spline):
             return self.multiply(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'S')
-        elif np.isscalar(other) or _isIterable(other):
-            return self.scale(other)
         else:
-            return NotImplemented
+            return self.scale(other)
 
     def __rmul__(self, other):
         if isinstance(other, Spline):
             return other.multiply(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))], 'S')
-        elif np.isscalar(other) or _isIterable(other):
-            return self.scale(other)
         else:
-            return NotImplemented
+            return self.scale(other)
 
     def __sub__(self, other):
         if isinstance(other, Spline):
             return self.subtract(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
-        elif _isIterable(other):
-            return self.translate(-np.array(other))
         else:
-            return NotImplemented
+            return self.translate(-np.atleast_1d(other))
 
     def __rsub__(self, other):
         if isinstance(other, Spline):
             return other.subtract(self, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
-        elif _isIterable(other):
+        else:
             spline = self.scale(-1.0)
             return spline.translate(other)
-        else:
-            return NotImplemented
 
     def add(self, other, indMap = None):
         """
@@ -203,7 +177,7 @@ class Spline:
         Uses `common_basis` to ensure mapped variables share the same order and knots. 
         """
         if indMap is not None:
-            indMap = [mapping if _isIterable(mapping) else (mapping, mapping) for mapping in indMap]
+            indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return bspy._spline_operations.add(self, other, indMap)
 
     def blossom(self, uvw):
@@ -274,7 +248,7 @@ class Spline:
         return bspy._spline_evaluation.bspline_values(knot, knots, splineOrder, u, derivativeOrder, taylorCoefs)
 
     @staticmethod
-    def circular_arc(radius, angle, tolerance):
+    def circular_arc(radius, angle, tolerance = None):
         """
         Create a 2D circular arc for a given radius and angle accurate to within a given tolerance.
 
@@ -286,8 +260,8 @@ class Spline:
         angle : `float`
             The angle of the circular arc measured in degrees starting at the x-axis rotating counterclockwise.
 
-        tolerance : `float`
-            The maximum allowed error in the circular arc.
+        tolerance : `float`, optional
+            The maximum allowed error in the circular arc (default is machine epsilon).
 
         Returns
         -------
@@ -521,7 +495,7 @@ class Spline:
         Computer Aided Geometric Design 11, no. 6 (1994): 597-620.
         """
         if indMap is not None:
-            indMap = [(*(mapping if _isIterable(mapping) else (mapping, mapping)), True) for mapping in indMap]
+            indMap = [(mapping, mapping, True) if np.isscalar(mapping) else (*mapping, True) for mapping in indMap]
         return bspy._spline_operations.multiplyAndConvolve(self, other, indMap, productType)
 
     def copy(self, metadata={}):
@@ -560,7 +534,28 @@ class Spline:
         """
         return bspy._spline_operations.cross(self, vector)
 
-    def derivative(self, with_respect_to, uvw):
+    def curvature(self, uvw):
+        """
+        Compute the curvature of a univariate spline.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : scalar
+            The value of the curvature at the given point on the curve.
+        
+        Notes
+        -----
+        Computes the curvature of the graph of the function if nDep == 1.  If nDep == 1 or 2,
+        then the curvature is computed as a signed quantity.
+        """
+        return bspy._spline_evaluation.curvature(self, uvw)
+
+    def derivative(self, with_respect_to, *uvw, **kwargs):
         """
         Compute the derivative of the spline at given parameter values.
 
@@ -570,13 +565,18 @@ class Spline:
             An iterable of length `nInd` that specifies the integer order of derivative for each independent variable.
             A zero-order derivative just evaluates the spline normally.
         
-        uvw : `iterable`
-            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+        *uvw : `iterable` or iterable of iterables
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values), or 
+            an iterable of iterables of length `nInd` that specifies values for each independent variable (numpy ufunc style).
+
+        **kwargs:
+            For other keyword-only arguments, see the `ufunc docs <https://numpy.org/doc/stable/reference/ufuncs.html#ufuncs-kwargs>`_.
 
         Returns
         -------
         value : `numpy.array`
-            The value of the derivative of the spline at the given parameter values.
+            The value of the derivative of the spline at the given parameter values (array of size nDep). If multiple points are 
+            passed (numpy ufunc style), then multiple arrays are returned, one for each dependent variable.
 
         See Also
         --------
@@ -592,7 +592,13 @@ class Spline:
         evaluated, then the dot product of those B-splines with the vector of
         B-spline coefficients is computed.
         """
-        return bspy._spline_evaluation.derivative(self, with_respect_to, uvw)
+        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+            def vectorized(*uvwInstance):
+                return tuple(bspy._spline_evaluation.derivative(self, with_respect_to, uvwInstance))
+            uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
+            return uFunc(*uvw, **kwargs)
+        else:
+            return bspy._spline_evaluation.derivative(self, with_respect_to, *uvw)
 
     def differentiate(self, with_respect_to = 0):
         """
@@ -715,19 +721,24 @@ class Spline:
         """
         return bspy._spline_domain.elevate_and_insert_knots(self, m, newKnots)
 
-    def evaluate(self, uvw):
+    def evaluate(self, *uvw, **kwargs):
         """
         Compute the value of the spline at given parameter values.
 
         Parameters
         ----------
-        uvw : `iterable`
-            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+        *uvw : `iterable` or iterable of iterables
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values), or 
+            an iterable of iterables of length `nInd` that specifies values for each independent variable (numpy ufunc style).
+
+        **kwargs:
+            For other keyword-only arguments, see the `ufunc docs <https://numpy.org/doc/stable/reference/ufuncs.html#ufuncs-kwargs>`_.
 
         Returns
         -------
         value : `numpy.array`
-            The value of the spline at the given parameter values.
+            The value of the spline at the given parameter values (array of size nDep). If multiple points are 
+            passed (numpy ufunc style), then multiple arrays are returned, one for each dependent variable.
 
         See Also
         --------
@@ -735,12 +746,20 @@ class Spline:
 
         Notes
         -----
+        Equivalent to spline(*uvw, **kwargs).
+
         The evaluate method uses the de Boor recurrence relations for a B-spline
         series to evaluate a spline.  The non-zero B-splines are
         evaluated, then the dot product of those B-splines with the vector of
         B-spline coefficients is computed.
         """
-        return bspy._spline_evaluation.evaluate(self, uvw)
+        if len(uvw) > 1 or (not np.isscalar(uvw[0]) and len(uvw[0]) > self.nInd):
+            def vectorized(*uvwInstance):
+                return tuple(bspy._spline_evaluation.evaluate(self, uvwInstance))
+            uFunc = np.frompyfunc(vectorized, self.nInd, self.nDep)
+            return uFunc(*uvw, **kwargs)
+        else:
+            return bspy._spline_evaluation.evaluate(self, *uvw)
 
     def extrapolate(self, newDomain, continuityOrder):
         """
@@ -803,6 +822,31 @@ class Spline:
         """
         return bspy._spline_domain.fold(self, foldedInd)
     
+    def graph(self):
+        """
+        Generate the spline which is the graph of the given spline.
+        
+        Parameters
+        ----------
+        
+        Returns
+        -------
+        Given a spline with n independent variables and m dependent variables, generate a new
+        spline with n independent variables which has n + m dependent variables, the first n of
+        which are just the independent variables themselves.  For example, given a scalar
+        valued function f of two variables u and v, return the spline of two variables whose
+        three dependent variables are (u, v, f(u,v)).
+        
+        See Also
+        --------
+        `add` : Add two splines together
+
+        Notes
+        -----
+        Makes use of matrix spline multiply and tensor product addition for splines.
+        """
+        return bspy._spline_operations.graph(self)
+    
     def insert_knots(self, newKnots):
         """
         Insert new knots into a spline.
@@ -1112,7 +1156,7 @@ class Spline:
         Computer Aided Geometric Design 11, no. 6 (1994): 597-620.
         """
         if indMap is not None:
-            indMap = [(*(mapping if _isIterable(mapping) else (mapping, mapping)), False) for mapping in indMap]
+            indMap = [(mapping, mapping, False) if np.isscalar(mapping) else (*mapping, False) for mapping in indMap]
         return bspy._spline_operations.multiplyAndConvolve(self, other, indMap, productType)
 
     def normal(self, uvw, normalize=True, indices=None):
@@ -1443,7 +1487,7 @@ class Spline:
         Uses `common_basis` to ensure mapped variables share the same order and knots. 
         """
         if indMap is not None:
-            indMap = [mapping if _isIterable(mapping) else (mapping, mapping) for mapping in indMap]
+            indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return self.add(other.scale(-1.0), indMap)
 
     def transform(self, matrix, maxSingularValue=None):

{bspy-2.0.0 → bspy-2.1.0}/bspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 2.0.0
+Version: 2.1.0
 Summary: Library for manipulating and rendering non-uniform b-splines
 Home-page: http://github.com/ericbrec/bspy
 Author: Eric Brechner
@@ -35,7 +35,7 @@ Library for manipulating and rendering b-spline curves, surfaces, and multidimen
 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 circular arcs, ruled surfaces, and surfaces of revolution. 
 Other methods add, subtract, multiply, and linearly transform splines, as well as confine spline curves to a given range. 
-There are methods to evaluate spline values, derivatives, integrals, normals, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+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, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
 
 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.

{bspy-2.0.0 → bspy-2.1.0}/setup.cfg

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

{bspy-2.0.0 → bspy-2.1.0}/tests/test_bspy.py

@@ -700,6 +700,14 @@ def test_cross():
             maxError = max(maxError, np.sqrt(xyz @ xyz))
     assert maxError <= np.sqrt(np.finfo(float).eps)
 
+def test_curvature():
+    testCurve = bspy.Spline.section([[1.0, 0.0, 90.0, 1.0], [0.0, 1.0, 180.0, 2.0]])
+    assert abs(testCurve.curvature(0.0) - 1.0) < 2.0e-15
+    assert abs(testCurve.curvature(1.0) - 2.0) < 2.0e-15
+    testCurve = testCurve @ [0, 1]
+    testVals = [testCurve.curvature(u) for u in np.linspace(0.0, 1.0, 101)]
+    return
+
 def test_derivative():
     maxError = 0.0
     myDerivative = myCurve.differentiate()
@@ -821,6 +829,16 @@ def test_fold_unfold():
                     maxError = max(maxError, abs(unfolded.coefs[i, j, k, l] - spline.coefs[i, j, k, l]))
     assert maxError <= np.finfo(float).eps
 
+def test_graph():
+    simpleFunc = bspy.Spline(2, 1, [3, 4], [4, 5], [[0.0, 0, 0, 0.4, 1, 1, 1],
+                             [0.0, 0, 0, 0, 0.6, 1, 1, 1, 1]], [[1.0, 2, 3, 4, 2, 3, 4, 5,
+                              3, 4, 5, 6, 4, 5, 6, 7, 5, 6, 7, 8]])
+    graphFunc = simpleFunc.graph()
+    uvfPoint = graphFunc([0.27, 0.83])
+    assert abs(uvfPoint[0] - 0.27) <= 4.0 * np.finfo(float).eps
+    assert abs(uvfPoint[1] - 0.83) <= 4.0 * np.finfo(float).eps
+    assert abs(uvfPoint[2] - simpleFunc([0.27, 0.83])[0]) <= 4.0 * np.finfo(float).eps
+
 def test_insert_knots():
     maxError = 0.0
     newCurve = myCurve.insert_knots([[.2, .3]])
@@ -1167,6 +1185,14 @@ def test_transform():
         [xTest, yTest] = transformedCurve.evaluate([u])
         maxError = max(maxError, (xTest - (2.0 * x + 3.0 * y)) ** 2 + (yTest - (-1.0 * x - 4.0 * y)) ** 2)
     assert maxError <= np.finfo(float).eps
+    shape234 = bspy.Spline(2, 2, [3, 4], [3, 4], [[0.0, 0, 0, 1, 1, 1], [0.0, 0, 0, 0, 1, 1, 1, 1]],
+                           [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+                            [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]])
+    shape334 = [[2, 0], [0, 0.5], [1, 1]] @ shape234
+    assert shape334.coefs[0,1,0] == 8
+    assert shape334.coefs[0,2,1] == 18
+    assert shape334.coefs[1,0,2] == 11
+    assert shape334.coefs[2,2,3] == 42
 
 def test_translate():
     maxError = 0.0