bspy 4.0__py3-none-any.whl → 4.2__py3-none-any.whl

bspy/spline.py

@@ -2,12 +2,14 @@ import numpy as np
 from os import path
 import json
 from bspy.manifold import Manifold
+import bspy.spline_block
 import bspy._spline_domain
 import bspy._spline_evaluation
 import bspy._spline_intersection
 import bspy._spline_fitting
 import bspy._spline_operations
 
+@Manifold.register
 class Spline(Manifold):
     """
     A class to model, represent, and process piecewise polynomial tensor product
@@ -123,6 +125,9 @@ class Spline(Manifold):
         else:
             return self.scale(other)
 
+    def __neg__(self):
+        return self.scale(-1.0)
+    
     def __sub__(self, other):
         if isinstance(other, Spline):
             return self.subtract(other, [(ix, ix) for ix in range(min(self.nInd, other.nInd))])
@@ -313,6 +318,71 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.common_basis(splines, indMap)
 
+    def complete_slice(self, slice, solid):
+        """
+        Add any missing inherent (implicit) boundaries of this spline's domain to the given slice of the 
+        given solid that are needed to make the slice valid and complete.
+
+        Parameters
+        ----------
+        slice : `solid.Solid`
+            The slice of the given solid formed by the spline. The slice may be incomplete, missing some of the 
+            spline's inherent domain boundaries. Its dimension must match `self.domain_dimension()`.
+
+        solid : `solid.Solid`
+            The solid being sliced by the manifold. Its dimension must match `self.range_dimension()`.
+
+        See Also
+        --------
+        `solid.Solid.slice` : slice the solid by a manifold.
+        `domain` : Return the domain of a spline.
+
+        Notes
+        -----
+        A spline's inherent domain is determined by its knot array for each dimension. This method only works for 
+        nInd of 1 or 2.
+        """
+        if self.domain_dimension() != slice.dimension: raise ValueError("Spline domain dimension must match slice dimension")
+        if self.range_dimension() != solid.dimension: raise ValueError("Spline range dimension must match solid dimension")
+        if slice.dimension != 1 and slice.dimension != 2: raise ValueError("Only works for nInd = 1 or 2")
+        return bspy._spline_intersection.complete_slice(self, slice, solid)
+
+    @staticmethod
+    def composition(splines, tolerance = 1.0e-6):
+        """
+        Construct a spline approximation to a composition of splines sequence.
+
+        Parameters
+        ----------
+        splines : `array-like`
+            An array of splines.  The splines should have the property that the number
+            of independent variables of the ith spline should be the same as the number
+            of dependent variables of the (i+1)st spline.  The number of dependent
+            variables of the first spline is arbitrary, as is the number of independent
+            variables of the last one.  Moreover, the range of the ith spline should be
+            a subset of the domain of the (i-1)st spline.  The interpretation of the
+            sequence is s_0(s_1(... s_(n-1)(u)))).
+        
+        tolerance : `scalar`
+            The maximum 2-norm of the difference between the given function and the
+            spline fit.  Defaults to 1.0e-6.
+        
+        Returns
+        -------
+        spline : `Spline`
+            The spline which approximates the given composition.
+
+        Notes
+        -----
+        This currently defaults to a cubic spline.  Depending on user experience, this
+        may change in the future.
+
+        See also
+        --------
+        `fit` : Fit a given function to a specified tolerance.
+        """
+        return bspy._spline_fitting.composition(splines, tolerance)
+
     @staticmethod
     def cone(radius1, radius2, height, tolerance = None):
         """
@@ -379,6 +449,24 @@ class Spline(Manifold):
         """
         return bspy._spline_operations.confine(self, range_bounds)
 
+    def continuity(self):
+        """
+        Return the smoothness of the spline in each of its independent variables.
+
+        Returns
+        -------
+        `smoothness` : `iterable`
+            An array of length nInd containing the number of times the function is continuously
+            in each of the independent variables of the input spline.
+
+        Notes
+        -----
+        The value -1 is returned if the spline is discontinuous in that variable.  The degree of the spline
+        is returned if the spline contains no interior knots even though the spline is an analytic function
+        of that variable.
+        """
+        return bspy._spline_evaluation.continuity(self)
+
     @staticmethod
     def contour(F, knownXValues, dF = None, epsilon = None, metadata = {}):
         """
@@ -388,8 +476,8 @@ class Spline(Manifold):
 
         Parameters
         ----------
-        F : function or `Spline`
-            A function or spline that takes an array-like argument of length `n` and returns an 
+        F : function, `Spline`, or `SplineBlock`
+            A function, spline, or spline block that takes an array-like argument of length `n` and returns an 
             array-like result of length `n - 1`.
 
         knownXValues : `iterable` of array-like
@@ -398,11 +486,12 @@ class Spline(Manifold):
             All x values must be length `n` and be listed in the order they appear on the contour.  
             `F(x)` for all known x values must be a zero vector of length `n-1`.
 
-        dF : `iterable` or `None`, optional
-            An `iterable` of the `n` functions representing the `n` first derivatives of `F`. 
+        dF : function, `iterable`, or `None`, optional
+            A function that returns the Jacobian of F as an array with shape (n - 1, n). 
+            Can also be an `iterable` of `n` functions that return the `n` first derivatives of `F`. 
             If `dF` is `None` (the default), the first derivatives will be computed for you. 
-            If `F` is not a spline, computing the first derivatives involves multiple calls to `F` 
-            and can be numerically unstable. 
+            If `F` is not a spline or spline block, computing the first derivatives involves 
+            multiple calls to `F` and can be numerically unstable. 
 
         epsilon : `float`, optional
             Tolerance for contour precision. Evaluating `F` with contour values will be within epsilon 
@@ -425,7 +514,7 @@ class Spline(Manifold):
         Notes
         -----
         The returned spline has constant parametric speed (the length of its derivative is constant). 
-        If `F` is a `Spline`, then the range of the returned contour is confined to the domain of `F`. 
+        If `F` is a `Spline` or a `SplineBlock`, then the range of the returned contour is confined to the domain of `F`. 
         Implements the algorithm described in section 7 of Grandine, Thomas A. 
         "Applications of contouring." Siam Review 42, no. 2 (2000): 297-316.
         """
@@ -453,7 +542,7 @@ class Spline(Manifold):
         The algorithm used to to find all intersection curves is from Grandine, Thomas A., and Frederick W. Klein IV. 
         "A new approach to the surface intersection problem." Computer Aided Geometric Design 14, no. 2 (1997): 111-134.
         """
-        return bspy._spline_intersection.contours(self)
+        return bspy._spline_intersection.contours(bspy.spline_block.SplineBlock(self))
 
     def contract(self, uvw):
         """
@@ -518,21 +607,16 @@ class Spline(Manifold):
             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={}):
+    def copy(self):
         """
         Create a copy of a spline.
-
-        Parameters
-        ----------
-        metadata : `dict`, optional
-            A dictionary of ancillary data to store with the spline. Default is {}.
         
         Returns
         -------
         spline : `Spline`
             The spline copy.
         """
-        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, self.coefs, metadata)
+        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, self.coefs, self.metadata)
 
     def cross(self, vector):
         """
@@ -556,7 +640,7 @@ class Spline(Manifold):
 
     def curvature(self, uvw):
         """
-        Compute the curvature of a univariate spline.
+        Compute the curvature of a univariate or bivariate spline.
 
         Parameters
         ----------
@@ -566,7 +650,8 @@ class Spline(Manifold):
         Returns
         -------
         value : scalar
-            The value of the curvature at the given point on the curve.
+            The value of the curvature at the given point on the curve or surface.  If called on a surface,
+            the value will represent the Gaussian curvature of the surface at the given point.
         
         Notes
         -----
@@ -693,7 +778,7 @@ class Spline(Manifold):
         Returns
         -------
         bounds : `numpy.array`
-            nInd x 2 array of the upper and lower bounds on each of the independent variables.
+            nInd x 2 array of the lower and upper bounds on each of the independent variables.
 
         See Also
         --------
@@ -702,6 +787,17 @@ class Spline(Manifold):
         """
         return bspy._spline_evaluation.domain(self)
 
+    def domain_dimension(self):
+        """
+        Return the domain dimension of a spline (nInd).
+
+        Returns
+        -------
+        dimension : `int`
+            The dimension of the spline's domain (nInd)
+        """
+        return self.nInd
+
     def dot(self, vector):
         """
         Dot product a spline by the given vector.
@@ -839,7 +935,7 @@ class Spline(Manifold):
         Parameters
         ----------
         newDomain : array-like
-            nInd x 2 array of the new upper and lower bounds on each of the independent variables (same form as 
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
             returned from `domain`). If a bound is None or nan then the original bound (and knots) are left unchanged.
 
         continuityOrder : `int`
@@ -859,6 +955,63 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.extrapolate(self, newDomain, continuityOrder)
 
+    @staticmethod
+    def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
+        """
+        Fit the function f with a spline to a given tolerance.
+
+        Parameters
+        ----------
+        domain - `array-like`
+            An nInd x 2 array which specifies the rectangular domain (in nInd dimensions)
+            over which the function f is defined.  The approximating spline which is the
+            output will be defined over the same rectangular domain
+        
+        f : Python function
+            The function to approximate.  It is a vector-valued function of nDep
+            components in nInd variables.
+        
+        order : `array-like`
+            An optional integer array of length nInd which specifies the polynomial
+            order to use in each of the independent variables.  It will default to order
+            4 (degree 3) if None is specified (the default)
+        
+        knots : `array-like`
+            The initial knot sequence to use, if given
+        
+        tolerance : `scalar`
+            The maximum 2-norm of the difference between the given function and the
+            spline fit.  Defaults to 1.0e-4.
+        
+        Returns
+        -------
+        spline : `Spline`
+            A spline which approximates the given function to within the specified
+            tolerance.
+        
+        See Also
+        --------
+        `least_squares` : Fit a least squares approximation to given data.
+        """
+        return bspy._spline_fitting.fit(domain, f, order, knots, tolerance)
+    
+    def flip_normal(self):
+        """
+        Flip the direction of the normal.
+
+        Returns
+        -------
+        spline : `Spline`
+            The spline with flipped normal. The spline retains the same tangent space.
+
+        See Also
+        --------
+        `solid.Solid.complement` : Return the complement of the solid: whatever was inside is outside and vice-versa.
+        """
+        spline = self.copy()
+        spline.metadata["flipNormal"] = not self.metadata.get("flipNormal", False)
+        return spline
+
     def fold(self, foldedInd):
         """
         Fold the coefficients of a spline's indicated independent variables into the coefficients of the remaining independent variables, retaining the 
@@ -937,6 +1090,42 @@ class Spline(Manifold):
         """
         return bspy._spline_fitting.four_sided_patch(bottom, right, top, left, surfParam)
 
+    @staticmethod
+    def from_dict(dictionary):
+        """
+        Create a `Spline` from data in a `dict`.
+
+        Parameters
+        ----------
+        dictionary : `dict`
+            The `dict` containing `Spline` data.
+
+        Returns
+        -------
+        spline : `Spline`
+
+        See Also
+        --------
+        `to_dict` : Return a `dict` with `Spline` data.
+        """
+        return Spline(dictionary["nInd"], dictionary["nDep"], dictionary["order"], dictionary["nCoef"],
+                [np.array(knots) for knots in dictionary["knots"]], np.array(dictionary["coefs"]), dictionary["metadata"])
+
+    def full_domain(self):
+        """
+        Return a solid that represents the full domain of the spline.
+
+        Returns
+        -------
+        domain : `Solid`
+            The full (untrimmed) domain of the spline.
+
+        See Also
+        --------
+        `Boundary` : A portion of the boundary of a solid.
+        """
+        return bspy._spline_intersection.full_domain(self)
+    
     def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
         """
         Determine a geodesic between two points on a surface
@@ -1039,48 +1228,46 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.insert_knots(self, newKnots)
 
-    def integral(self, with_respect_to, uvw1, uvw2, returnSpline = False):
+    def integral(self, integrand = None, domain = None):
         """
-        Compute the derivative of the spline at given parameter values.
+        Compute the integral of a function composed with a spline.  In particular, compute the
+        nInd-dimensional integral over the specified domain of the quantity f(x_0, x_1, ..., x_{nDep - 1})dA,
+        where x_i is the (i+1)-th dependent variable, and dA is the multivariate measure of the spline mapping.
 
         Parameters
         ----------
-        with_respect_to : `iterable`
-            An iterable of length `nInd` that specifies the integer order of integral for each independent variable.
-            A zero-order integral just evaluates the spline normally.
-        
-        uvw1 : `iterable`
-            An iterable of length `nInd` that specifies the lower limit of each independent variable (the parameter values).
+        integrand : Python function, optional
+            A Python function which takes an array-like object of length nDep as input and returns a
+            scalar.  If None is specified for integrand, then the function which returns a constant value
+            of one is used.  This computes the volume measure of the spline itself (arc length, surface area,
+            volume, etc.) depending on the dimensionality of the spline itself.
+    
+        domain : array-like
+            nInd x 2 array of the lower and upper limits of integration for the spline on each of the
+            independent variables.  If domain is None, then the actual domain of the spline is used.
         
-        uvw2 : `iterable`
-            An iterable of length `nInd` that specifies the upper limit of each independent variable (the parameter values).
-
-        returnSpline : `boolean`, optional
-            A boolean flag that if true returns the integrated spline along with the value of its integral. Default is false.
- 
         Returns
         -------
-        value : `numpy.ndarray`
-            The value of the integral of the spline at the given parameter limits.
-
-        spline : `Spline`
-            The integrated spline, which is only returned if `returnSpline` is `True`.
-
+        integral_value : `float`
+            The computed value of the specified integral
+        
         See Also
         --------
-        `integrate` : Integrate a spline with respect to one of its independent variables, returning the resulting spline.
-        `evaluate` : Compute the value of the spline at a given parameter value.
-        `differentiate` : Differentiate a spline with respect to one of its independent variables, returning the resulting spline.
-        `derivative` : Compute the derivative of the spline at a given parameter value.
+        `integrate` : Integrate a spline with respect to one of its independent variables, returning
+                      the resulting spline.
 
         Notes
         -----
-        The integral method uses the integrate method to integrate the spline `with_respect_to` times for each independent variable.
-        Then the method returns that integrated spline's value at `uw2` minus its value at `uw1` (optionally along with the spline).
-        The method doesn't calculate the integral directly because the number of operations required is nearly the same as constructing
-        the integrated spline.
+        This function is very useful for computing mass properties of splines.  If the integrand function
+        returns one, then the volume measure of the spline itself is computed (arc length, surface area,
+        volume, etc.).  If the integrand function returns one of the dependent variable values, then the
+        integral will be the first moment of the spline with respect to that variable, making it possible
+        to compute centroids and center of mass.  The integrand function should be smooth, but is otherwise
+        unrestricted.
+
+        Attempts to compute the integral to two digits less than machine precision.
         """
-        return bspy._spline_evaluation.integral(self, with_respect_to, uvw1, uvw2, returnSpline)
+        return bspy._spline_evaluation.composed_integral(self, integrand, domain)
 
     def integrate(self, with_respect_to = 0):
         """
@@ -1089,7 +1276,7 @@ class Spline(Manifold):
         Parameters
         ----------
         with_respect_to : integer, optional
-            The number of the independent variable to integrate. Default is zero.
+            The index of the independent variable to integrate. Default is zero.
 
         Returns
         -------
@@ -1137,12 +1324,13 @@ class Spline(Manifold):
         --------
         `zeros` : Find the roots of a spline (nInd must match nDep).
         `contours` : Find all the contour curves of a spline.
+        `solid.Solid.slice` : slice the solid by a manifold.
 
         Notes
         -----
         Uses `zeros` to find all intersection points and `contours` to find all the intersection curves.
         """
-        if not(self.nDep == other.nDep): raise ValueError("The number of dependent variables for both splines much match.")
+        if not(self.range_dimension() == other.range_dimension()): raise ValueError("The number of dependent variables for both splines much match.")
         return bspy._spline_intersection.intersect(self, other)
 
     def jacobian(self, uvw):
@@ -1343,9 +1531,8 @@ class Spline(Manifold):
         if isinstance(splineData, dict):
             splineData = [splineData]
         for splineDict in splineData:
-            splines.append(Spline(splineDict["nInd"], splineDict["nDep"], splineDict["order"], splineDict["nCoef"],
-                [np.array(knots) for knots in splineDict["knots"]], np.array(splineDict["coefs"]), splineDict["metadata"]))
-        return splines        
+            splines.append(Spline.from_dict(splineDict))
+        return splines
 
     def multiply(self, other, indMap = None, productType = 'S'):
         """
@@ -1457,7 +1644,7 @@ class Spline(Manifold):
         dependent variables (instead of one less, as is typical). In that case, the normal represents the null space of 
         the matrix formed by the tangents of the spline. If the null space is greater than one dimension, the normal will be zero.
         """
-        return bspy._spline_operations.normal_spline(self, indices)
+        return bspy._spline_operations.normal_spline(bspy.spline_block.SplineBlock(self), indices)
 
     @staticmethod
     def point(point):
@@ -1487,10 +1674,21 @@ class Spline(Manifold):
     def range_bounds(self):
         """
         Return the range of a spline as lower and upper bounds on each of the
-        dependent variables
+        dependent variables.
         """
         return bspy._spline_evaluation.range_bounds(self)
 
+    def range_dimension(self):
+        """
+        Return the range dimension of a spline (nDep).
+
+        Returns
+        -------
+        dimension : `int`
+            The dimension of the spline's range (nDep)
+        """
+        return self.nDep
+
     def remove_knot(self, iKnot, nLeft = 0, nRight = 0):
         """
         Remove a single knot from a univariate spline.
@@ -1573,7 +1771,7 @@ class Spline(Manifold):
         Parameters
         ----------
         newDomain : array-like
-            nInd x 2 array of the new upper and lower bounds on each of the independent variables (same form as 
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
             returned from `domain`). If a bound pair is `None` then the original bound (and knots) are left unchanged. 
             For example, `[[0.0, 1.0], None]` will reparametrize the first independent variable and leave the second unchanged)
 
@@ -1610,7 +1808,7 @@ class Spline(Manifold):
 
     def revolve(self, angle):
         """
-        Rotate the spline to create a surface of revolution (nDep must equal 2, 
+        Revolve the spline to create a surface of revolution (nDep must equal 2, 
         first dimension provides the radius for x and y, second dimension provides the z).
 
         Parameters
@@ -1698,15 +1896,7 @@ class Spline(Manifold):
                 if isinstance(obj, np.ndarray):
                     return obj.tolist()
                 if isinstance(obj, Spline):
-                    return {
-                        "nInd" : obj.nInd,
-                        "nDep" : obj.nDep,
-                        "order" : obj.order,
-                        "nCoef" : obj.nCoef,
-                        "knots" : obj.knots,
-                        "coefs" : obj.coefs,
-                        "metadata" : obj.metadata
-                    }
+                    return obj.to_dict()
                 return super().default(obj)
 
         with open(fileName, 'w', encoding='utf-8') as file:
@@ -1851,6 +2041,31 @@ class Spline(Manifold):
         `multiply` : Multiply two splines together.
         """
         return bspy._spline_fitting.sphere(radius, tolerance)
+
+    def split(self, minContinuity = 0, breaks = None):
+        """
+        Split a spline into separate spline pieces.
+
+        Parameters
+        ----------
+        minContinuity : `int`, optional
+            The minimum expected continuity of each spline piece. The default is zero, for C0 continuity.
+
+        breaks : `iterable` of length `nInd` or `None`, optional
+            An iterable that specifies the breaks at which to separate the spline. 
+            len(breaks[ind]) == 0 if there the spline isn't separated for the `ind` independent variable. 
+            If breaks is `None` (the default), the spline will only be separated at discontinuities.
+
+        Returns
+        -------
+        splineArray : array of `Spline`
+            A array of splines with nInd dimensions containing the spline pieces. 
+
+        See Also
+        --------
+        `join` : Join a list of splines together into a single spline.
+        """
+        return bspy._spline_domain.split(self, minContinuity, breaks)
     
     def subtract(self, other, indMap = None):
         """
@@ -1891,6 +2106,37 @@ class Spline(Manifold):
             indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return self.add(other.scale(-1.0), indMap)
 
+    def tangent_space(self, uvw):
+        """
+        Return the tangent space of the spline. (Same as Jacobian.)
+
+        Parameters
+        ----------
+        uvw : array-like
+            The value at which to evaluate the tangent space.
+
+        Returns
+        -------
+        tangentSpace : `numpy.array`
+            The nDep x nInd matrix of tangent vectors (tangents are the columns).
+        """
+        return bspy._spline_evaluation.jacobian(self, uvw)
+
+    def to_dict(self):
+        """
+        Return a `dict` with `Spline` data.
+
+        Returns
+        -------
+        dictionary : `dict`
+
+        See Also
+        --------
+        `from_dict` : Create a `Spline` from a data in a `dict`.
+        """
+        return {"type" : "Spline", "nInd" : self.nInd, "nDep" : self.nDep, "order" : self.order, "nCoef" : self.nCoef,
+            "knots" : self.knots, "coefs" : self.coefs, "metadata" : self.metadata}
+
     @staticmethod
     def torus(innerRadius, outerRadius, tolerance = None):
         """
@@ -1929,7 +2175,7 @@ class Spline(Manifold):
         """
         return bspy._spline_fitting.torus(innerRadius, outerRadius, tolerance)
     
-    def transform(self, matrix):
+    def transform(self, matrix, matrixInverseTranspose = None):
         """
         Transform a spline by the given matrix.
 
@@ -1938,6 +2184,9 @@ class Spline(Manifold):
         matrix : array-like
             An array of size `newNDep`x`nDep` that specifies the transform matrix.
 
+        matrixInverseTranspose : `numpy.array`, optional
+            The inverse transpose of matrix (not used for splines).
+
         Returns
         -------
         spline : `Spline`
@@ -2012,7 +2261,7 @@ class Spline(Manifold):
         Parameters
         ----------
         newDomain : array-like
-            nInd x 2 array of the new upper and lower bounds on each of the independent variables (same form as 
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
             returned from `domain`). If a bound is None or nan then the original bound (and knots) are left unchanged.
 
         Returns
@@ -2027,6 +2276,31 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.trim(self, newDomain)
 
+    def trimmed_range_bounds(self, domainBounds):
+        """
+        Return the trimmed range bounds for the spline.
+
+        Parameters
+        ----------
+        domainBounds : array-like
+            An array with shape (nInd, 2) of lower and upper and lower bounds on each independent variable.
+
+        Returns
+        -------
+        trimmedSpline : `Spline`
+            A spline trimmed to the given domain bounds.
+        
+        rangeBounds : `np.array`
+            The range of the trimmed spline given as lower and upper bounds on each dependent variable.
+
+        See Also
+        --------
+        `trim` : Trim the domain of a spline.
+        `range_bounds` : Return the range of a spline as lower and upper bounds on each of the
+            dependent variables.
+        """
+        return bspy._spline_domain.trimmed_range_bounds(self, domainBounds)
+
     def unfold(self, foldedInd, coefficientlessSpline):
         """
         Unfold the coefficients of an original spline's indicated independent variables back into the spline, using the 
@@ -2064,7 +2338,7 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.unfold(self, foldedInd, coefficientlessSpline)
 
-    def zeros(self, epsilon=None):
+    def zeros(self, epsilon=None, initialScale=None):
         """
         Find the roots of a spline (nInd must match nDep).
 
@@ -2074,6 +2348,10 @@ class Spline(Manifold):
             Tolerance for root precision. The root will be within epsilon of the actual root. 
             The default is the machine epsilon.
 
+        initialScale : array-like, optional
+            The initial scale of each dependent variable (as opposed to the current scale of 
+            the spline, which may have been normalized). The default is an array of ones (size nDep).
+
         Returns
         -------
         roots : `iterable`
@@ -2084,7 +2362,7 @@ class Spline(Manifold):
         See Also
         --------
         `intersect` : Intersect two splines.
-        `contour` : Fit a spline to the contour defined by `F(x) = 0`.
+        `contours` : Find all the contour curves of a spline whose `nInd` is one larger than its `nDep`.
 
         Notes
         -----
@@ -2097,4 +2375,5 @@ class Spline(Manifold):
         if self.nInd <= 1:
             return bspy._spline_intersection.zeros_using_interval_newton(self)
         else:
-            return bspy._spline_intersection.zeros_using_projected_polyhedron(self, epsilon)
+            return bspy._spline_intersection.zeros_using_projected_polyhedron(bspy.spline_block.SplineBlock(self), epsilon, initialScale)
+