bspy 4.1__tar.gz → 4.3__tar.gz

{bspy-4.1 → bspy-4.3}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 4.1
+Version: 4.3
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
 Author-email: ericbrec@msn.com
 License: MIT
 Project-URL: Bug Tracker, http://github.com/ericbrec/BSpy/issues
-Keywords: opengl,bspline,B-spline,nub,tkinter
+Keywords: bspline,B-spline,nub,solid,solid modeling,geometry,csg,opengl,tkinter
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Environment :: Console
@@ -34,14 +34,22 @@ Library for manipulating and rendering B-spline curves, surfaces, and multidimen
 
 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. 
+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 can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics. 
+Spline 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.
+There are methods to evaluate spline values, derivatives, normals, integrals, continuity, 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, split, 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. 
+Splines can be saved and loaded in json format.
 
 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 [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 [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. Solids can be saved and loaded in json format.
+
+The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to process an array-like collection of splines that represent a system of equations. There are highly-optimized methods to compute the contours and zeros of a spline block, as well as a variety of methods to manipulate and evaluate a spline block and its derivatives.
+
+The [BSpyConvert](https://pypi.org/project/BSpyConvert/) package converts BSpy splines and solid models to and from [OpenCascade (OCCT)](https://dev.opencascade.org/) equivalents and a variety of geometry and CAD file formats, including STEP, IGES, and STL.
 
 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 

{bspy-4.1 → bspy-4.3}/README.md

@@ -3,14 +3,22 @@ Library for manipulating and rendering B-spline curves, surfaces, and multidimen
 
 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. 
+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 can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics. 
+Spline 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.
+There are methods to evaluate spline values, derivatives, normals, integrals, continuity, 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, split, 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. 
+Splines can be saved and loaded in json format.
 
 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 [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 [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. Solids can be saved and loaded in json format.
+
+The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to process an array-like collection of splines that represent a system of equations. There are highly-optimized methods to compute the contours and zeros of a spline block, as well as a variety of methods to manipulate and evaluate a spline block and its derivatives.
+
+The [BSpyConvert](https://pypi.org/project/BSpyConvert/) package converts BSpy splines and solid models to and from [OpenCascade (OCCT)](https://dev.opencascade.org/) equivalents and a variety of geometry and CAD file formats, including STEP, IGES, and STL.
 
 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 

{bspy-4.1 → bspy-4.3}/bspy/__init__.py

@@ -12,6 +12,8 @@ Available subpackages
 `bspy.spline` : Provides the `Spline` subclass of `Manifold` that models, represents, and processes 
     piecewise polynomial tensor product functions (spline functions) as linear combinations of B-splines.
 
+`bspy.spline_block` : Provides the `SplineBlock` class that processes an array-like collection of splines which represent a system of equations.
+
 `bspy.splineOpenGLFrame` : Provides the `SplineOpenGLFrame` class, a tkinter `OpenGLFrame` with shaders to display splines.
 
 `bspy.viewer` : Provides the `Viewer` tkinter app (`tkinter.Tk`) that hosts a `SplineOpenGLFrame`, a listbox full of 
@@ -22,5 +24,6 @@ from bspy.solid import Solid, Boundary
 from bspy.manifold import Manifold
 from bspy.hyperplane import Hyperplane
 from bspy.spline import Spline
+from bspy.spline_block import SplineBlock
 from bspy.splineOpenGLFrame import SplineOpenGLFrame
 from bspy.viewer import Viewer, Graphics

{bspy-4.1 → bspy-4.3}/bspy/_spline_domain.py

@@ -310,26 +310,73 @@ def fold(self, foldedInd):
     coefficientlessSpline = type(self)(len(coefficientlessOrder), 0, coefficientlessOrder, coefficientlessNCoef, coefficientlessKnots, coefficientlessCoefs, self.metadata)
     return foldedSpline, coefficientlessSpline
 
-def insert_knots(self, newKnots):
-    if not(len(newKnots) == self.nInd): raise ValueError("Invalid newKnots")
-    knotsList = list(self.knots)
-    coefs = self.coefs
-    for ind, (order, knots) in enumerate(zip(self.order, self.knots)):
-        # We can't reference self.nCoef[ind] in this loop because we are expanding the knots and coefs arrays.
-        for knot in newKnots[ind]:
-            if knot < knots[order-1] or knot > knots[-order]:
-                raise ValueError(f"Knot insertion outside domain: {knot}")
-            if knot == knots[-order]:
-                position = len(knots) - order
+def insert_knots(self, newKnotList):
+    if not(len(newKnotList) == self.nInd): raise ValueError("Invalid newKnots")
+    knotsList = list(self.knots) # Create a new knot list
+    coefs = self.coefs # Set initial value for coefs to check later if it's changed
+
+    # Insert new knots into each independent variable.
+    for ind, (order, knots, newKnots) in enumerate(zip(self.order, self.knots, newKnotList)):
+        coefs = coefs.swapaxes(0, ind + 1) # Swap dependent and independent variable (swap back later)
+        degree = order - 1
+        for knot in newKnots:
+            # Determine new knot multiplicity.
+            if np.isscalar(knot):
+                multiplicity = 1
             else:
-                position = np.searchsorted(knots, knot, 'right')
-            coefs = coefs.swapaxes(0, ind + 1) # Swap dependent and independent variable (swap back later)
-            newCoefs = np.insert(coefs, position - 1, 0.0, axis=0)
-            for i in range(position - order + 1, position):
-                alpha = (knot - knots[i]) / (knots[i + order - 1] - knots[i])
-                newCoefs[i] = (1.0 - alpha) * coefs[i - 1] + alpha * coefs[i]
-            knotsList[ind] = knots = np.insert(knots, position, knot)
-            coefs = newCoefs.swapaxes(0, ind + 1)
+                multiplicity = knot[1]
+                knot = knot[0]
+                if multiplicity < 1:
+                    continue
+
+            # Check if knot and its total multiplicity is valid.
+            if knot < knots[degree] or knot > knots[-order]:
+                raise ValueError(f"Knot insertion outside domain: {knot}")
+            position = np.searchsorted(knots, knot, 'right')
+            oldMultiplicity = 0
+            for k in knots[position - 1::-1]:
+                if knot == k:
+                    oldMultiplicity += 1
+                else:
+                    break
+            if oldMultiplicity + multiplicity > order:
+                raise ValueError("Knot multiplicity > order")
+
+            # Initialize oldCoefs and expanded coefs array with multiplicity new coefficients, as well as some indices.
+            oldCoefs = coefs[position - order:position].copy()
+            lastKnotIndex = position - oldMultiplicity
+            firstCoefIndex = position - degree
+            coefs = np.insert(coefs, firstCoefIndex, oldCoefs[:multiplicity], axis=0)
+            # Compute inserted coefficients (multiplicity of them) and the degree - oldMultiplicity - 1 number of changed coefficients.
+            for j in range(multiplicity):
+                # Allocate new coefficients for the current multiplicity. 
+                size = degree - oldMultiplicity - j
+                if size < 1:
+                    # Full multiplicity knot, so use oldCoefs.
+                    coefs[firstCoefIndex + j] = oldCoefs[0]
+                else:
+                    # Otherwise, allocate space for newCoefs.
+                    newCoefs = np.empty((size, *coefs.shape[1:]), coefs.dtype)
+
+                    # Compute the new coefficients.
+                    for i, k in zip(range(size), range(lastKnotIndex - size, lastKnotIndex)):
+                        alpha = (knot - knots[k]) / (knots[k + degree - j] - knots[k])
+                        newCoefs[i] = (1.0 - alpha) * oldCoefs[i] + alpha * oldCoefs[i + 1]
+
+                    # Assign the ends of the new coefficients into their respective positions.
+                    coefs[firstCoefIndex + j] = newCoefs[0]
+                    if size > 1:
+                        coefs[lastKnotIndex + multiplicity - j - 2] = newCoefs[-1]
+                    oldCoefs = newCoefs
+            
+            # Assign remaining computed coefficients (the ones in the middle).
+            if size > 2:
+                coefs[firstCoefIndex + multiplicity:firstCoefIndex + multiplicity + size - 2] = newCoefs[1:-1]
+            
+            # Insert the inserted coefficients and inserted knots.
+            knotsList[ind] = knots = np.insert(knots, position, (knot,) * multiplicity)
+        
+        coefs = coefs.swapaxes(0, ind + 1) # Swap back
 
     if self.coefs is coefs:
         return self
@@ -535,10 +582,12 @@ def transpose(self, axes=None):
 def trim(self, newDomain):
     if not(len(newDomain) == self.nInd): raise ValueError("Invalid newDomain")
     if self.nInd < 1: return self
-    newDomain = np.array(newDomain, self.knots[0].dtype) # Force dtype and convert None to nan
+    newDomain = np.array(newDomain, self.knots[0].dtype, copy=True) # Force dtype and convert None to nan
+    epsilon = np.finfo(newDomain.dtype).eps
 
     # Step 1: Determine the knots to insert at the new domain bounds.
     newKnotsList = []
+    noChange = True
     for (order, knots, bounds) in zip(self.order, self.knots, newDomain):
         if not(len(bounds) == 2): raise ValueError("Invalid newDomain")
         unique, counts = np.unique(knots, return_counts=True)
@@ -548,28 +597,43 @@ def trim(self, newDomain):
         if not np.isnan(bounds[0]):
             if not(knots[order - 1] <= bounds[0] <= knots[-order]): raise ValueError("Invalid newDomain")
             leftBound = True
-            multiplicity = order
             i = np.searchsorted(unique, bounds[0])
-            if unique[i] == bounds[0]:
-                multiplicity -= counts[i]
-            newKnots += multiplicity * [bounds[0]]
+            if unique[i] - bounds[0] < epsilon:
+                bounds[0] = unique[i]
+                multiplicity = order - counts[i]
+            elif i > 0 and bounds[0] - unique[i - 1] < epsilon:
+                bounds[0] = unique[i - 1]
+                multiplicity = order - counts[i - 1]
+            else:
+                multiplicity = order
+            if multiplicity > 0:
+                newKnots.append((bounds[0], multiplicity))
+                noChange = False
 
         if not np.isnan(bounds[1]):
             if not(knots[order - 1] <= bounds[1] <= knots[-order]): raise ValueError("Invalid newDomain")
             if leftBound:
                 if not(bounds[0] < bounds[1]): raise ValueError("Invalid newDomain")
-            multiplicity = order
             i = np.searchsorted(unique, bounds[1])
-            if unique[i] == bounds[1]:
-                multiplicity -= counts[i]
-            newKnots += multiplicity * [bounds[1]]
+            if unique[i] - bounds[1] < epsilon:
+                bounds[1] = unique[i]
+                multiplicity = order - counts[i]
+            elif i > 0 and bounds[1] - unique[i - 1] < epsilon:
+                bounds[1] = unique[i - 1]
+                multiplicity = order - counts[i - i]
+            else:
+                multiplicity = order
+            if multiplicity > 0:
+                newKnots.append((bounds[1], multiplicity))
+                noChange = False
 
         newKnotsList.append(newKnots)
     
+    if noChange:
+        return self
+    
     # Step 2: Insert the knots.
     spline = self.insert_knots(newKnotsList)
-    if spline is self:
-        return spline
 
     # Step 3: Trim the knots and coefficients.
     knotsList = []

{bspy-4.1 → bspy-4.3}/bspy/_spline_evaluation.py

@@ -1,4 +1,5 @@
 import numpy as np
+import scipy as sp
 
 def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs = False):
     basis = np.zeros(splineOrder, knots.dtype)
@@ -25,10 +26,61 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
             b += 1
     return knot, basis
 
+def composed_integral(self, integrand = None, domain = None):
+    # Determine domain and check its validity
+    actualDomain = self.domain()
+    if domain is None:
+        domain = actualDomain
+    else:
+        for iInd in range(self.nInd):
+            if domain[iInd, 0] < actualDomain[iInd, 0] or \
+               domain[iInd, 1] > actualDomain[iInd, 1]:
+                raise ValueError("Can't integrate beyond the domain of the spline")
+
+    # Determine breakpoints for quadrature intervals; require functions to be analytic
+
+    uniqueKnots = []
+    for iInd in range(self.nInd):
+        iStart = np.searchsorted(self.knots[iInd], domain[iInd, 0], side = 'right')
+        iEnd = np.searchsorted(self.knots[iInd], domain[iInd, 1], side = 'right')
+        uniqueKnots.append(np.unique(np.insert(self.knots[iInd], [iStart, iEnd], domain[iInd])[iStart : iEnd + 2]))
+
+    # Set integrand function if none is given
+    if integrand is None:
+        integrand = lambda x : 1.0
+
+    # Set tolerance
+    tolerance = 1.0e-13 / self.nInd
+
+    # Establish the callback function
+    def composedIntegrand(u, nIndSoFar, uValues):
+        uValues[nIndSoFar] = u
+        nIndSoFar += 1
+        if self.nInd == nIndSoFar:
+            total = integrand(self(uValues)) * \
+                    np.prod(np.linalg.svd(self.jacobian(uValues), compute_uv = False))
+        else:
+            total = 0.0
+            for ix in range(len(uniqueKnots[nIndSoFar]) - 1):
+                value = sp.integrate.quad(composedIntegrand, uniqueKnots[nIndSoFar][ix],
+                                          uniqueKnots[nIndSoFar][ix + 1], (nIndSoFar, uValues),
+                                          epsabs = tolerance, epsrel = tolerance)
+                total += value[0]
+        return total    
+    
+    # Compute the value by calling the callback routine
+    total = composedIntegrand(0.0, -1, self.nInd * [0.0])
+    return total
+
+def continuity(self):
+    multiplicity = np.array([np.max(np.unique(knots, return_counts = True)[1][1 : -1]) for knots in self.knots])
+    continuity = self.order - multiplicity - 1
+    return continuity
+
 def curvature(self, uv):
+    if self.nDep == 1:
+        self = self.graph()
     if self.nInd == 1:
-        if self.nDep == 1:
-            self = self.graph()
         fp = self.derivative([1], uv)
         fpp = self.derivative([2], uv)
         fpDotFp = fp @ fp
@@ -38,7 +90,21 @@ def curvature(self, uv):
             numerator = fp[0] * fpp[1] - fp[1] * fpp[0]
         else:
             numerator = np.sqrt((fpp @ fpp) * fpDotFp - fpDotFpp ** 2)
-        return numerator / denom 
+        return numerator / denom
+    if self.nInd == 2:
+        su = self.derivative([1, 0], uv)
+        sv = self.derivative([0, 1], uv)
+        normal = self.normal(uv)
+        suu = self.derivative([2, 0], uv)
+        suv = self.derivative([1, 1], uv)
+        svv = self.derivative([0, 2], uv)
+        E = su @ su
+        F = su @ sv
+        G = sv @ sv
+        L = suu @ normal
+        M = suv @ normal
+        N = svv @ normal
+        return (L * N - M ** 2) / (E * G - F ** 2)
 
 def derivative(self, with_respect_to, uvw):
     # Make work for scalar valued functions
@@ -107,6 +173,8 @@ def greville(self, ind = 0):
         for ix in range(1, self.order[ind]):
             knotAverages = knotAverages + myKnots[ix : ix + self.nCoef[ind]]
         knotAverages /= (self.order[ind] - 1)
+    domain = self.domain()[ind]
+    knotAverages = np.minimum(domain[1], np.maximum(domain[0], knotAverages))
     return knotAverages
 
 def integral(self, with_respect_to, uvw1, uvw2, returnSpline = False):
@@ -150,8 +218,8 @@ def normal(self, uvw, normalize=True, 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.")
 
-    # Evaluate the tangents at the point.
-    tangentSpace = self.tangent_space(uvw)
+    # Evaluate the Jacobian at the point.
+    tangentSpace = self.jacobian(uvw)
     
     # Record the larger dimension and ensure it comes first.
     if self.nInd > self.nDep:
@@ -161,15 +229,15 @@ def normal(self, uvw, normalize=True, indices=None):
         nDep = self.nDep
     
     # Compute the normal using cofactors (determinants of subsets of the tangent space).
-    sign = -1 if self.metadata.get("flipNormal", False) else 1
+    sign = -1 if hasattr(self, "metadata") and self.metadata.get("flipNormal", False) else 1
+    dtype = self.coefs.dtype if hasattr(self, "coefs") else self.coefsDtype
     if indices is None:
         indices = range(nDep)
-        normal = np.empty(nDep, self.coefs.dtype)
+        normal = np.empty(nDep, dtype)
     else:
-        normal = np.empty(len(indices), self.coefs.dtype)
-    for i in indices:
-        normal[i] = sign * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
-        sign *= -1
+        normal = np.empty(len(indices), dtype)
+    for ix, i in enumerate(indices):
+        normal[ix] = sign * ((-1) ** i) * np.linalg.det(tangentSpace[[j for j in range(nDep) if i != j]])
     
     # Normalize the result as needed.
     if normalize:
@@ -180,13 +248,4 @@ def normal(self, uvw, normalize=True, indices=None):
 def range_bounds(self):
     # Assumes self.nDep is the first value in self.coefs.shape
     bounds = [[coefficient.min(), coefficient.max()] for coefficient in self.coefs]
-    return np.array(bounds, self.coefs.dtype)
-
-def tangent_space(self, uvw):
-    tangentSpace = np.empty((self.nDep, self.nInd), self.coefs.dtype)
-    wrt = [0] * self.nInd
-    for i in range(self.nInd):
-        wrt[i] = 1
-        tangentSpace[:, i] = self.derivative(wrt, uvw)
-        wrt[i] = 0
-    return tangentSpace
+    return np.array(bounds, self.coefs.dtype)