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

bspy/spline.py

@@ -8,6 +8,7 @@ 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
@@ -313,6 +314,35 @@ 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 cone(radius1, radius2, height, tolerance = None):
         """
@@ -518,21 +548,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):
         """
@@ -693,7 +718,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 +727,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 +875,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 +895,23 @@ class Spline(Manifold):
         """
         return bspy._spline_domain.extrapolate(self, newDomain, continuityOrder)
 
+    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 +990,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 a 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
@@ -1137,12 +1226,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 +1433,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'):
         """
@@ -1487,10 +1576,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 +1673,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 +1710,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 +1798,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:
@@ -1891,6 +1983,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.
+
+        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.tangent_space(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 +2052,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 +2061,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 +2138,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 +2153,29 @@ 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, rangeBounds : `Spline`, `np.array`
+            A spline trimmed to the given domain bounds, and 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