bspy 4.4__py3-none-any.whl → 5.0.0__py3-none-any.whl

bspy/_spline_milling.py

@@ -1,6 +1,7 @@
 import numpy as np
 import bspy.spline
 import bspy.spline_block
+from collections import namedtuple
 
 def line_of_curvature(self, uvStart, is_max, tolerance = 1.0e-3):
     if self.nInd != 2:  raise ValueError("Surface must have two independent variables")
@@ -115,6 +116,60 @@ def offset(self, edgeRadius, bitRadius=None, angle=np.pi / 2.2, path=None, subtr
     if path is not None and (path.nInd != 1 or path.nDep != 2 or self.nInd != 2):
         raise ValueError("path must be a 2D curve and self must be a 3D surface")
 
+    # Compute new order, knots, and fillets for offset (ensure order is at least 4).
+    Fillet = namedtuple('Fillet', ('adjustment', 'isFillet'))
+    newOrder = []
+    newKnotList = []
+    newUniqueList = []
+    filletList = []
+    for order, knots in zip(self.order, self.knots):
+        min4Order = max(order, 4)
+        unique, counts = np.unique(knots, return_counts=True)
+        counts += min4Order - order # Ensure order is at least 4
+        newOrder.append(min4Order)
+        adjustment = 0
+        epsilon = np.finfo(unique.dtype).eps
+
+        # Add first knot.
+        newKnots = [unique[0]] * counts[0]
+        newUnique = [unique[0]]
+        fillets = [Fillet(adjustment, False)]
+
+        # Add internal knots, checking for C1 discontinuities needing fillets.
+        for knot, count in zip(unique[1:-1], counts[1:-1]):
+            knot += adjustment
+            newKnots += [knot] * count
+            newUnique.append(knot)
+            # Check for lack of C1 continuity (need for a fillet)
+            if count >= min4Order - 1:
+                fillets.append(Fillet(adjustment, True))
+                # Create parametric space for fillet.
+                adjustment += 1
+                knot += 1 + epsilon # Add additional adjustment and step slightly past discontinuity
+                newKnots += [knot] * (min4Order - 1)
+                newUnique.append(knot)
+            fillets.append(Fillet(adjustment, False))
+
+        # Add last knot.
+        newKnots += [unique[-1] + adjustment] * counts[-1]
+        newUnique.append(unique[-1] + adjustment)
+        fillets.append(Fillet(adjustment, False))
+
+        # Build fillet and knot lists.
+        newKnotList.append(np.array(newKnots, knots.dtype))
+        newUniqueList.append(np.array(newUnique, knots.dtype))
+        filletList.append(fillets)
+    
+    if path is not None:
+        min4Order = max(path.order[0], 4)
+        newOrder = [min4Order]
+        unique, counts = np.unique(path.knots[0], return_counts=True)
+        counts += min4Order - path.order[0] # Ensure order is at least 4
+        newKnotList = [np.repeat(unique, counts)]
+        domain = path.domain()
+    else:
+        domain = [(unique[0], unique[-1]) for unique in newUniqueList]
+
     # Determine geometry of drill bit.
     if subtract:
         edgeRadius *= -1
@@ -126,83 +181,83 @@ def offset(self, edgeRadius, bitRadius=None, angle=np.pi / 2.2, path=None, subtr
 
     # Define drill bit function.
     if abs(w) < tolerance and path is None: # Simple offset curve or surface
-        def drillBit(uv):
-            return self(uv) + edgeRadius * self.normal(uv)
+        def drillBit(normal):
+            return edgeRadius * normal
     elif self.nDep == 2: # General offset curve
-        def drillBit(u):
-            xy = self(u)
-            normal = self.normal(u)
+        def drillBit(normal):
             upward = np.sign(normal[1])
             if upward * normal[1] <= bottom:
-                xy[0] += edgeRadius * normal[0] + w * np.sign(normal[0])
-                xy[1] += edgeRadius * normal[1]
+                return np.array((edgeRadius * normal[0] + w * np.sign(normal[0]), edgeRadius * normal[1]))
             else:
-                xy[0] += bottomRadius * normal[0]
-                xy[1] += bottomRadius * normal[1] - upward * h
-            return xy
-    elif self.nDep == 3 and path is None: # General offset surface
-        def drillBit(uv):
-            xyz = self(uv)
-            normal = self.normal(uv)
+                return np.array((bottomRadius * normal[0], bottomRadius * normal[1] - upward * h))
+    elif self.nDep == 3: # General offset surface
+        def drillBit(normal):
             upward = np.sign(normal[1])
             if upward * normal[1] <= bottom:
                 norm = np.sqrt(normal[0] * normal[0] + normal[2] * normal[2])
-                xyz[0] += edgeRadius * normal[0] + w * normal[0] / norm
-                xyz[1] += edgeRadius * normal[1]
-                xyz[2] += edgeRadius * normal[2] + w * normal[2] / norm
+                return np.array((edgeRadius * normal[0] + w * normal[0] / norm, edgeRadius * normal[1], edgeRadius * normal[2] + w * normal[2] / norm))
             else:
-                xyz[0] += bottomRadius * normal[0]
-                xyz[1] += bottomRadius * normal[1] - upward * h
-                xyz[2] += bottomRadius * normal[2]
-            return xyz
-    elif self.nDep == 3: # General offset of a given path along a surface
-        surface = self
-        self = path # Redefine self to be the path (used below for fitting)
-        def drillBit(u):
-            uv = self(u)
-            xyz = surface(uv)
-            normal = surface.normal(uv)
-            upward = np.sign(normal[1])
-            if upward * normal[1] <= bottom:
-                norm = np.sqrt(normal[0] * normal[0] + normal[2] * normal[2])
-                xyz[0] += edgeRadius * normal[0] + w * normal[0] / norm
-                xyz[1] += edgeRadius * normal[1]
-                xyz[2] += edgeRadius * normal[2] + w * normal[2] / norm
-            else:
-                xyz[0] += bottomRadius * normal[0]
-                xyz[1] += bottomRadius * normal[1] - upward * h
-                xyz[2] += bottomRadius * normal[2]
-            return xyz
+                return np.array((bottomRadius * normal[0], bottomRadius * normal[1] - upward * h, bottomRadius * normal[2]))
     else: # Should never get here (exception raised earlier)
         raise ValueError("The offset is only defined for 2D curves and 3D surfaces with well-defined normals.")
 
-    # Compute new order and knots for offset (ensure order is at least 4).
-    newOrder = []
-    newKnots = []
-    for order, knots in zip(self.order, self.knots):
-        min4Order = max(order, 4)
-        unique, count = np.unique(knots, return_counts=True)
-        count += min4Order - order
-        newOrder.append(min4Order)
-        newKnots.append(np.repeat(unique, count))
+    # Define function to pass to fit.
+    def fitFunction(uv):
+        if path is not None:
+            uv = path(uv)
+        
+        # Compute adjusted spline uv values, accounting for fillets.
+        hasFillet = False
+        adjustedUV = uv.copy()
+        for (i, u), unique, fillets in zip(enumerate(uv), newUniqueList, filletList):
+            ix = np.searchsorted(unique, u, 'right') - 1
+            fillet = fillets[ix]
+            if fillet.isFillet:
+                hasFillet = True
+                adjustedUV[i] = unique[ix] - fillet.adjustment
+            else:
+                adjustedUV[i] -= fillet.adjustment
+        
+        # If we have fillets, compute the normal from their normal fan.
+        if hasFillet:
+            normal = np.zeros(self.nDep, self.coefs.dtype)
+            nudged = adjustedUV.copy()
+            for (i, u), unique, fillets in zip(enumerate(uv), newUniqueList, filletList):
+                ix = np.searchsorted(unique, u, 'right') - 1
+                fillet = fillets[ix]
+                if fillet.isFillet:
+                    epsilon = np.finfo(unique.dtype).eps
+                    alpha = u - unique[ix]
+                    np.copyto(nudged, adjustedUV)
+                    nudged[i] -= epsilon
+                    normal += (1 - alpha) * self.normal(nudged)
+                    nudged[i] += 2 * epsilon
+                    normal += alpha * self.normal(nudged)
+            normal = normal / np.linalg.norm(normal)
+        else:
+            normal = self.normal(adjustedUV)
+        
+        # Return the offset based on the normal.
+        return self(adjustedUV) + drillBit(normal)
 
     # Fit new spline to offset by drill bit.
-    offset = bspy.spline.Spline.fit(self.domain(), drillBit, newOrder, newKnots, tolerance)
+    offset = bspy.spline.Spline.fit(domain, fitFunction, newOrder, newKnotList, tolerance)
 
     # Remove cusps as required (only applies to offset curves).
-    if removeCusps and self.nInd == 1:
+    if removeCusps and (self.nInd == 1 or path is not None):
         # Find the cusps by checking for tangent direction reversal between the spline and offset.
         cusps = []
         previousKnot = None
         start = None
         for knot in np.unique(offset.knots[0][offset.order[0]:offset.nCoef[0]]):
-            tangent = self.derivative((1,), knot)
             if path is not None:
-                tangent = surface.jacobian(path(knot)) @ tangent
-            flipped = np.dot(tangent, offset.derivative((1,), knot)) < 0
-            if flipped and start is None:
+                tangent = self.jacobian(path(knot)) @ path.derivative((1,), knot)
+            else:
+                tangent = self.derivative((1,), knot)
+            negated = np.dot(tangent, offset.derivative((1,), knot)) < 0
+            if negated and start is None:
                 start = knot
-            if not flipped and start is not None:
+            if not negated and start is not None:
                 cusps.append((start, previousKnot))
                 start = None
             previousKnot = knot
@@ -219,7 +274,7 @@ def offset(self, edgeRadius, bitRadius=None, angle=np.pi / 2.2, path=None, subtr
                 # This is necessary to find the intersection point (2 equations, 2 unknowns).
                 tangent = offset.derivative((1,), cusp[0])
                 projection = np.concatenate((tangent / np.linalg.norm(tangent),
-                    surface.normal(path(cusp[0])))).reshape((2,3))
+                    self.normal(path(cusp[0])))).reshape((2,3))
                 before = before.transform(projection)
                 after = after.transform(projection)
             block = bspy.spline_block.SplineBlock([[before, after]])

bspy/hyperplane.py

@@ -41,19 +41,19 @@ class Hyperplane(Manifold):
     def __repr__(self):
         return "Hyperplane({0}, {1}, {2})".format(self._normal, self._point, self._tangentSpace)
 
-    def complete_slice(self, slice, solid):
+    def complete_cutout(self, cutout, solid):
         """
-        Add any missing inherent (implicit) boundaries of this manifold's domain to the given slice of the 
-        given solid that are needed to make the slice valid and complete.
+        Add any missing inherent (implicit) boundaries of this manifold's domain to the given cutout of the 
+        given solid that are needed to make the cutout valid and complete.
 
         Parameters
         ----------
-        slice : `Solid`
-            The slice of the given solid formed by the manifold. The slice may be incomplete, missing some of the 
+        cutout : `Solid`
+            The cutout of the given solid formed by the manifold. The cutout may be incomplete, missing some of the 
             manifold's inherent domain boundaries. Its dimension must match `self.domain_dimension()`.
 
         solid : `Solid`
-            The solid being sliced by the manifold. Its dimension must match `self.range_dimension()`.
+            The solid determining the cutout of the manifold. Its dimension must match `self.range_dimension()`.
 
         Parameters
         ----------
@@ -63,17 +63,17 @@ class Hyperplane(Manifold):
 
         See Also
         --------
-        `Solid.slice` : Slice the solid by a manifold.
+        `Solid.compute_cutout` : Compute the cutout portion of the manifold within the solid.
 
         Notes
         -----
         Since hyperplanes have no inherent domain boundaries, this operation only tests for 
         point containment for zero-dimension hyperplanes (points).
         """
-        assert self.domain_dimension() == slice.dimension
+        assert self.domain_dimension() == cutout.dimension
         assert self.range_dimension() == solid.dimension
-        if slice.dimension == 0:
-            slice.containsInfinity = solid.contains_point(self._point)
+        if cutout.dimension == 0:
+            cutout.containsInfinity = solid.contains_point(self._point)
 
     def copy(self):
         """
@@ -86,7 +86,7 @@ class Hyperplane(Manifold):
         return Hyperplane(self._normal, self._point, self._tangentSpace)
 
     @staticmethod
-    def create_axis_aligned(dimension, axis, offset, flipNormal=False):
+    def create_axis_aligned(dimension, axis, offset, negateNormal=False):
         """
         Create an axis-aligned hyperplane.
 
@@ -101,7 +101,7 @@ class Hyperplane(Manifold):
         offset : `float`
             The offset from zero along the axis of a point on the hyperplane. 
         
-        flipNormal : `bool`, optional
+        negateNormal : `bool`, optional
             A Boolean indicating that the normal should point toward in the negative direction along the axis. 
             Default is False, meaning the normal points in the positive direction along the axis.
 
@@ -112,7 +112,7 @@ class Hyperplane(Manifold):
         """
         assert dimension > 0
         diagonal = np.identity(dimension)
-        sign = -1.0 if flipNormal else 1.0
+        sign = -1.0 if negateNormal else 1.0
         normal = sign * diagonal[:,axis]
         point = offset * normal
         if dimension > 1:
@@ -178,21 +178,6 @@ class Hyperplane(Manifold):
         """
         return np.dot(self._tangentSpace, np.atleast_1d(domainPoint)) + self._point
 
-    def flip_normal(self):
-        """
-        Flip the direction of the normal.
-
-        Returns
-        -------
-        hyperplane : `Hyperplane`
-            The hyperplane with flipped normal. The hyperplane retains the same tangent space.
-
-        See Also
-        --------
-        `Solid.complement` : Return the complement of the solid: whatever was inside is outside and vice-versa.
-        """
-        return Hyperplane(-self._normal, self._point, self._tangentSpace)
-
     @staticmethod
     def from_dict(dictionary):
         """
@@ -244,14 +229,14 @@ class Hyperplane(Manifold):
             (Hyperplanes will have at most one intersection, but other types of manifolds can have several.)
             Each intersection records either a crossing or a coincident region.
 
-            For a crossing, intersection is a `Manifold.Crossing`: (left, right)
-            * left : `Manifold` in the manifold's domain where the manifold and the other cross.
-            * right : `Manifold` in the other's domain where the manifold and the other cross.
+            For a crossing, intersection is a `Manifold.Crossing`: (firstPart, secondPart)
+            * firstPart : `Manifold` in the manifold's domain where the manifold and the other cross.
+            * secondPart : `Manifold` in the other's domain where the manifold and the other cross.
             * Both intersection manifolds have the same domain and range (the crossing between the manifold and the other).
 
-            For a coincident region, intersection is a `Manifold.Coincidence`: (left, right, alignment, transform, inverse, translation)
-            * left : `Solid` in the manifold's domain within which the manifold and the other are coincident.
-            * right : `Solid` in the other's domain within which the manifold and the other are coincident.
+            For a coincident region, intersection is a `Manifold.Coincidence`: (firstPart, secondPart, alignment, transform, inverse, translation)
+            * firstPart : `Solid` in the manifold's domain within which the manifold and the other are coincident.
+            * secondPart : `Solid` in the other's domain within which the manifold and the other are coincident.
             * alignment : scalar value holding the normal alignment between the manifold and the other (the dot product of their unit normals).
             * transform : `numpy.array` holding the transform matrix from the manifold's domain to the other's domain.
             * inverse : `numpy.array` holding the inverse transform matrix from the other's domain to the boundary's domain.
@@ -260,7 +245,7 @@ class Hyperplane(Manifold):
 
         See Also
         --------
-        `Solid.slice` : slice the solid by a manifold.
+        `Solid.compute_cutout` : Compute the cutout portion of the manifold within the solid.
         `numpy.linalg.svd` : Compute the singular value decomposition of a matrix array.
 
         Notes
@@ -361,6 +346,21 @@ class Hyperplane(Manifold):
 
         return intersections
 
+    def negate_normal(self):
+        """
+        Negate the direction of the normal.
+
+        Returns
+        -------
+        hyperplane : `Hyperplane`
+            The hyperplane with negated normal. The hyperplane retains the same tangent space.
+
+        See Also
+        --------
+        `Solid.complement` : Return the complement of the solid: whatever was inside is outside and vice-versa.
+        """
+        return Hyperplane(-self._normal, self._point, self._tangentSpace)
+
     def normal(self, domainPoint, normalize=True, indices=None):
         """
         Return the normal.

bspy/manifold.py

@@ -15,8 +15,8 @@ class Manifold:
     minSeparation = 0.0001
     """If two points are within minSeparation of each each other, they are coincident."""
 
-    Crossing = namedtuple('Crossing', ('left','right'))
-    Coincidence = namedtuple('Coincidence', ('left', 'right', 'alignment', 'transform', 'inverse', 'translation'))
+    Crossing = namedtuple('Crossing', ('firstPart','secondPart'))
+    Coincidence = namedtuple('Coincidence', ('firstPart', 'secondPart', 'alignment', 'transform', 'inverse', 'translation'))
     """Return type for intersect."""
 
     factory = {}
@@ -43,14 +43,14 @@ class Manifold:
             A list of intersections between the two manifolds. 
             Each intersection records either a crossing or a coincident region.
 
-            For a crossing, intersection is a Manifold.Crossing: (left, right)
-            * left : `Manifold` in the manifold's domain where the manifold and the other cross.
-            * right : `Manifold` in the other's domain where the manifold and the other cross.
+            For a crossing, intersection is a Manifold.Crossing: (firstPart, secondPart)
+            * firstPart : `Manifold` in the manifold's domain where the manifold and the other cross.
+            * secondPart : `Manifold` in the other's domain where the manifold and the other cross.
             * Both intersection manifolds have the same domain and range (the crossing between the manifold and the other).
 
-            For a coincident region, intersection is Manifold.Coincidence: (left, right, alignment, transform, inverse, translation)
-            * left : `Solid` in the manifold's domain within which the manifold and the other are coincident.
-            * right : `Solid` in the other's domain within which the manifold and the other are coincident.
+            For a coincident region, intersection is Manifold.Coincidence: (firstPart, secondPart, alignment, transform, inverse, translation)
+            * firstPart : `Solid` in the manifold's domain within which the manifold and the other are coincident.
+            * secondPart : `Solid` in the other's domain within which the manifold and the other are coincident.
             * alignment : scalar value holding the normal alignment between the manifold and the other (the dot product of their unit normals).
             * transform : `numpy.array` holding the matrix transform from the boundary's domain to the other's domain.
             * inverse : `numpy.array` holding the matrix inverse transform from the other's domain to the boundary's domain.
@@ -63,7 +63,7 @@ class Manifold:
         See Also
         --------
         `intersect` : Intersect two manifolds.
-        `Solid.slice` : slice the solid by a manifold.
+        `Solid.compute_cutout` : Compute the cutout portion of the manifold within the solid.
 
         Notes
         -----
@@ -97,31 +97,31 @@ class Manifold:
         
         return intersections, isTwin
 
-    def complete_slice(self, slice, solid):
+    def complete_cutout(self, cutout, solid):
         """
-        Add any missing inherent (implicit) boundaries of this manifold's domain to the given slice of the 
-        given solid that are needed to make the slice valid and complete.
+        Add any missing inherent (implicit) boundaries of this manifold's domain to the given cutout of the 
+        given solid that are needed to make the cutout valid and complete.
 
         Parameters
         ----------
-        slice : `Solid`
-            The slice of the given solid formed by the manifold. The slice may be incomplete, missing some of the 
+        cutout : `Solid`
+            The cutout of the given solid formed by the manifold. The cutout may be incomplete, missing some of the 
             manifold's inherent domain boundaries. Its dimension must match `self.domain_dimension()`.
 
         solid : `Solid`
-            The solid being sliced by the manifold. Its dimension must match `self.range_dimension()`.
+            The solid determining the cutout of the manifold. Its dimension must match `self.range_dimension()`.
 
         See Also
         --------
-        `Solid.slice` : Slice the solid by a manifold.
+        `Solid.compute_cutout` : Compute the cutout portion of the manifold within the solid.
 
         Notes
         -----
         For manifolds without inherent domain boundaries (like hyperplanes), the operation does nothing.
         """
-        assert self.domain_dimension() == slice.dimension
+        assert self.domain_dimension() == cutout.dimension
         assert self.range_dimension() == solid.dimension
-
+    
     def copy(self):
         """
         Copy the manifold.
@@ -157,21 +157,6 @@ class Manifold:
         """
         return None
 
-    def flip_normal(self):
-        """
-        Flip the direction of the normal.
-
-        Returns
-        -------
-        manifold : `Manifold`
-            The manifold with flipped normal. The manifold retains the same tangent space.
-
-        See Also
-        --------
-        `Solid.complement` : Return the complement of the solid: whatever was inside is outside and vice-versa.
-        """
-        return None
-
     @staticmethod
     def from_dict(dictionary):
         """
@@ -222,14 +207,14 @@ class Manifold:
             A list of intersections between the two manifolds. 
             Each intersection records either a crossing or a coincident region.
 
-            For a crossing, intersection is a `Manifold.Crossing`: (left, right)
-            * left : `Manifold` in the manifold's domain where the manifold and the other cross.
-            * right : `Manifold` in the other's domain where the manifold and the other cross.
+            For a crossing, intersection is a `Manifold.Crossing`: (firstPart, secondPart)
+            * firstPart : `Manifold` in the manifold's domain where the manifold and the other cross.
+            * secondPart : `Manifold` in the other's domain where the manifold and the other cross.
             * Both intersection manifolds have the same domain and range (the crossing between the manifold and the other).
 
-            For a coincident region, intersection is a `Manifold.Coincidence`: (left, right, alignment, transform, inverse, translation)
-            * left : `Solid` in the manifold's domain within which the manifold and the other are coincident.
-            * right : `Solid` in the other's domain within which the manifold and the other are coincident.
+            For a coincident region, intersection is a `Manifold.Coincidence`: (firstPart, secondPart, alignment, transform, inverse, translation)
+            * firstPart : `Solid` in the manifold's domain within which the manifold and the other are coincident.
+            * secondPart : `Solid` in the other's domain within which the manifold and the other are coincident.
             * alignment : scalar value holding the normal alignment between the manifold and the other (the dot product of their unit normals).
             * transform : `numpy.array` holding the transform matrix from the manifold's domain to the other's domain.
             * inverse : `numpy.array` holding the inverse transform matrix from the other's domain to the boundary's domain.
@@ -239,7 +224,7 @@ class Manifold:
         See Also
         --------
         `cached_intersect` : Intersect two manifolds, caching the result for twins (same intersection but swapping self and other).
-        `Solid.slice` : slice the solid by a manifold.
+        `Solid.compute_cutout` : Compute the cutout portion of the manifold within the solid.
 
         Notes
         -----
@@ -247,6 +232,21 @@ class Manifold:
         """
         return NotImplemented
 
+    def negate_normal(self):
+        """
+        Negate the direction of the normal.
+
+        Returns
+        -------
+        manifold : `Manifold`
+            The manifold with negated normal. The manifold retains the same tangent space.
+
+        See Also
+        --------
+        `Solid.complement` : Return the complement of the solid: whatever was inside is outside and vice-versa.
+        """
+        return None
+
     def normal(self, domainPoint, normalize=True, indices=None):
         """
         Return the normal.