bspy 4.4__tar.gz → 4.4.1__tar.gz

{bspy-4.4 → bspy-4.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bspy
-Version: 4.4
+Version: 4.4.1
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner

{bspy-4.4 → bspy-4.4.1}/bspy/_spline_domain.py

@@ -1,6 +1,34 @@
 import numpy as np
+import bspy
 from bspy.manifold import Manifold
 
+def arc_length_map(self, tolerance):
+    if self.nInd != 1:  raise ValueError("Spline doesn't have exactly one independent variable")
+
+    # Compute the length of the spline
+    curveLength = self.integral()
+    domain = self.domain()[0]
+    guess = bspy.Spline.line([0.0], [1.0])
+    guess = guess.elevate([4])
+
+    # Solve the ODE
+    def arcLengthF(t, uData):
+        uValue = (1.0 - uData[0][0]) * domain[0] + uData[0][0] * domain[1]
+        uValue = np.clip(uValue, domain[0], domain[1])
+        d1 = self.derivative([1], [uValue])
+        d2 = self.derivative([2], [uValue])
+        speed = np.sqrt(d1 @ d1)
+        d1d2 = d1 @ d2
+        return np.array([curveLength / speed]), np.array([-curveLength * d1d2 / speed ** 3]).reshape((1, 1, 1))
+    arcLengthMap = guess.solve_ode(1, 0, arcLengthF, tolerance)
+
+    # Adjust range to match domain
+
+    arcLengthMap *= (domain[1] - domain[0]) / arcLengthMap(1.0)[0]
+    arcLengthMap += domain[0]
+    arcLengthMap.coefs[0][-1] = domain[1]
+    return arcLengthMap
+
 def clamp(self, left, right):
     bounds = [[None, None] for i in range(self.nInd)]
 
@@ -404,12 +432,11 @@ def join(splineList):
         splDomain = spl.domain()[0]
         start2 = spl(splDomain[0])
         end2 = spl(splDomain[1])
-        gaps = [np.linalg.norm(vecDiff) for vecDiff in [start1 - start2, start1 - end2, end1 - start2, end1 - end2]]
-        minDist = min(*gaps)
-        if minDist == gaps[0] or minDist == gaps[1]:
-            workingSpline = workingSpline.reverse()
-        if minDist == gaps[1] or minDist == gaps[3]:
+        ixMin = np.argmin([np.linalg.norm(vecDiff) for vecDiff in [end1 - start2, end1 - end2, start1 - start2, start1 - end2]])
+        if ixMin == 1 or ixMin == 3:
             spl = spl.reverse()
+        if ixMin == 2 or ixMin == 3:
+            workingSpline = workingSpline.reverse()
         maxOrder = max(workingSpline.order[0], spl.order[0])
         workingSpline = workingSpline.elevate([maxOrder - workingSpline.order[0]])
         spl = spl.elevate([maxOrder - spl.order[0]])
@@ -610,6 +637,8 @@ def trim(self, newDomain):
             if multiplicity > 0:
                 newKnots.append((bounds[0], multiplicity))
                 noChange = False
+            if bounds[0] != knots[order - 1]:
+                noChange = False
 
         if not np.isnan(bounds[1]):
             if not(knots[order - 1] <= bounds[1] <= knots[-order]): raise ValueError("Invalid newDomain")
@@ -627,6 +656,8 @@ def trim(self, newDomain):
             if multiplicity > 0:
                 newKnots.append((bounds[1], multiplicity))
                 noChange = False
+            if bounds[1] != knots[-order]:
+                noChange = False
 
         newKnotsList.append(newKnots)
     

{bspy-4.4 → bspy-4.4.1}/bspy/_spline_fitting.py

@@ -339,6 +339,7 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
     nInd = len(domain)
     midPoint = f(0.5 * (domain.T[0] + domain.T[1]))
     if not type(midPoint) is bspy.Spline:
+        midPoint = np.array(midPoint).flatten()
         nDep = len(midPoint)
 
     # Make sure order and knots conform to this
@@ -389,7 +390,10 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
             # Create a tuple for the u value (must be a tuple to use it as a dictionary key)
             uValue = tuple([uvw[i][indices[i]] for i in range(nInd)])
             if not uValue in fDictionary:
-                fDictionary[uValue] = f(np.array(uValue))
+                newValue = f(np.array(uValue))
+                if not type(newValue) is bspy.Spline:
+                    newValue = np.array(newValue).flatten()
+                fDictionary[uValue] = newValue
             fValues.append(fDictionary[uValue])
             iLast = nInd - 1
             while iLast >= 0:
@@ -1067,7 +1071,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = (), inclu
 
     # Is it time to give up?
 
-        if (not done or continuation < 1.0) and n > 1000:
+        if (not done or continuation < 1.0) and n > 10000:
             raise RuntimeError("Can't find solution with given initial guess")
 
     # Estimate the error

{bspy-4.4 → bspy-4.4.1}/bspy/_spline_intersection.py

@@ -174,7 +174,6 @@ def _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInter
         for p1 in hull[1:]:
             yDelta = p0[1] - p1[1]
             if p0[1] * p1[1] <= 0.0 and yDelta != 0.0:
-                yDelta = p0[1] - p1[1]
                 alpha = p0[1] / yDelta
                 xNew = p0[0] * (1.0 - alpha) + p1[0] * alpha
                 if sign * yDelta > 0.0:
@@ -255,14 +254,13 @@ def _refine_projected_polyhedron(interval):
 
         # Compute the coefficients for f(x) = x for the independent variable and its knots.
         xData = spline.greville(ind)
-        
+        if len(xData) == 1:
+            xData = spline.domain()[ind]
+
         # Loop through each dependent variable in this row to refine the interval containing the root for this independent variable.
-        for yData, ySplineBounds, yBounds in zip(coefs, spline.range_bounds(),
-                                                 interval.bounds[nDep:nDep + spline.nDep]):
+        for yData, ySplineBounds, yBounds in zip(coefs, spline.range_bounds(), interval.bounds[nDep:nDep + spline.nDep]):
             # Compute the 2D convex hull of the knot coefficients and the spline's coefficients
             lowerHull, upperHull = _convex_hull_2D(xData, yData.ravel(), yBounds, yBounds - ySplineBounds)
-            if lowerHull is None or upperHull is None:
-                return roots, intervals
             
             # Intersect the convex hull with the xInterval along the x axis (the knot coefficients axis).
             xInterval = _intersect_convex_hull_with_x_interval(lowerHull, upperHull, epsilon, xInterval)
@@ -943,7 +941,8 @@ def contours(self):
 
 def intersect(self, other):
     intersections = []
-    nDep = self.nInd # The dimension of the intersection's range
+    # Compute the number of degrees of freedom of the intersection.
+    dof = self.nInd + other.domain_dimension() - self.nDep
 
     # Spline-Hyperplane intersection.
     if isinstance(other, Hyperplane):
@@ -953,7 +952,7 @@ def intersect(self, other):
         spline = self.dot(other._normal) - np.atleast_1d(np.dot(other._normal, other._point))
 
         # Curve-Line intersection.
-        if nDep == 1:
+        if dof == 0:
             # Find the intersection points and intervals.
             zeros = spline.zeros()
             # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
@@ -974,10 +973,10 @@ def intersect(self, other):
                         intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[1] + epsilon, 0.0), Hyperplane(1.0, planeBounds[1], 0.0)))
 
                     # Now, create the coincidence.
-                    left = Solid(nDep, False)
+                    left = Solid(1, False)
                     left.add_boundary(Boundary(Hyperplane(-1.0, zero[0], 0.0), Solid(0, True)))
                     left.add_boundary(Boundary(Hyperplane(1.0, zero[1], 0.0), Solid(0, True)))
-                    right = Solid(nDep, False)
+                    right = Solid(1, False)
                     if planeBounds[0] > planeBounds[1]:
                         planeBounds = (planeBounds[1], planeBounds[0])
                     right.add_boundary(Boundary(Hyperplane(-1.0, planeBounds[0], 0.0), Solid(0, True)))
@@ -992,7 +991,7 @@ def intersect(self, other):
                     intersections.append(Manifold.Crossing(Hyperplane(1.0, zero, 0.0), Hyperplane(1.0, projection @ (self((zero,)) - other._point), 0.0)))
 
         # Surface-Plane intersection.
-        elif nDep == 2:
+        elif dof == 1:
             # Find the intersection contours, which are returned as splines.
             contours = spline.contours()
             # Convert each contour into a Manifold.Crossing.
@@ -1015,8 +1014,8 @@ def intersect(self, other):
         # Construct a spline block that represents the intersection.
         block = bspy.spline_block.SplineBlock([[self, -other]])
 
-        # Curve-Curve intersection.
-        if nDep == 1:
+        # Zero degrees of freedom, typically a Curve-Curve intersection.
+        if dof == 0:
             # Find the intersection points and intervals.
             zeros = block.zeros()
             # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
@@ -1041,10 +1040,10 @@ def intersect(self, other):
                         intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[1][0], 0.0), Hyperplane(1.0, zero[1][1] + epsilon, 0.0)))
 
                     # Now, create the coincidence.
-                    left = Solid(nDep, False)
+                    left = Solid(self.nInd, False)
                     left.add_boundary(Boundary(Hyperplane(-1.0, zero[0][0], 0.0), Solid(0, True)))
                     left.add_boundary(Boundary(Hyperplane(1.0, zero[1][0], 0.0), Solid(0, True)))
-                    right = Solid(nDep, False)
+                    right = Solid(other.nInd, False)
                     right.add_boundary(Boundary(Hyperplane(-1.0, zero[0][1], 0.0), Solid(0, True)))
                     right.add_boundary(Boundary(Hyperplane(1.0, zero[1][1], 0.0), Solid(0, True)))
                     alignment = np.dot(self.normal(zero[0][0]), other.normal(zero[0][1])) # Use the first zeros, since B-splines are closed on the left
@@ -1054,10 +1053,10 @@ def intersect(self, other):
                     intersections.append(Manifold.Coincidence(left, right, alignment, np.atleast_2d(transform), np.atleast_2d(1.0 / transform), np.atleast_1d(translation)))
                 else:
                     # Intersection is a point, so create a Manifold.Crossing.
-                    intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[:nDep], 0.0), Hyperplane(1.0, zero[nDep:], 0.0)))
+                    intersections.append(Manifold.Crossing(Hyperplane(1.0, zero[:self.nInd], 0.0), Hyperplane(1.0, zero[self.nInd:], 0.0)))
         
-        # Surface-Surface intersection.
-        elif nDep == 2:
+        # One degree of freedom, typically a Surface-Surface intersection.
+        elif dof == 1:
             if "Name" in self.metadata and "Name" in other.metadata:
                 logging.info(f"intersect:{self.metadata['Name']}:{other.metadata['Name']}")
             # Find the intersection contours, which are returned as splines.
@@ -1075,32 +1074,34 @@ def intersect(self, other):
                 # Convert each contour into a Manifold.Crossing, swapping the manifolds back.
                 for contour in contours:
                     # Swap left and right, compared to not swapped.
-                    left = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[nDep:], contour.metadata)
-                    right = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[:nDep], contour.metadata)
+                    left = bspy.Spline(contour.nInd, self.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[other.nInd:], contour.metadata)
+                    right = bspy.Spline(contour.nInd, other.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[:other.nInd], contour.metadata)
                     intersections.append(Manifold.Crossing(left, right))
             else:
                 # Convert each contour into a Manifold.Crossing.
                 for contour in contours:
-                    left = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[:nDep], contour.metadata)
-                    right = bspy.Spline(contour.nInd, nDep, contour.order, contour.nCoef, contour.knots, contour.coefs[nDep:], contour.metadata)
+                    left = bspy.Spline(contour.nInd, self.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[:self.nInd], contour.metadata)
+                    right = bspy.Spline(contour.nInd, other.nInd, contour.order, contour.nCoef, contour.knots, contour.coefs[self.nInd:], contour.metadata)
                     intersections.append(Manifold.Crossing(left, right))
         else:
             return NotImplemented
     else:
         return NotImplemented
 
-    # Ensure the normals point outwards for both Manifolds in each crossing intersection.
-    # Note that evaluating left and right at 0.5 is always valid because either they are points or curves with [0.0, 1.0] domains.
-    domainPoint = np.atleast_1d(0.5)
-    for i, intersection in enumerate(intersections):
-        if isinstance(intersection, Manifold.Crossing):
-            left = intersection.left
-            right = intersection.right
-            if np.dot(self.tangent_space(left.evaluate(domainPoint)) @ left.normal(domainPoint), other.normal(right.evaluate(domainPoint))) < 0.0:
-                left = left.flip_normal()
-            if np.dot(other.tangent_space(right.evaluate(domainPoint)) @ right.normal(domainPoint), self.normal(left.evaluate(domainPoint))) < 0.0:
-                right = right.flip_normal()
-            intersections[i] = Manifold.Crossing(left, right)
+    # If self and other have normals, ensure they are pointing in the correct direction.
+    if self.nInd + 1 == self.nDep and other.domain_dimension() + 1 == self.nDep:
+        # Ensure the normals point outwards for both Manifolds in each crossing intersection.
+        # Note that evaluating left and right at 0.5 is always valid because either they are points or curves with [0.0, 1.0] domains.
+        domainPoint = np.atleast_1d(0.5)
+        for i, intersection in enumerate(intersections):
+            if isinstance(intersection, Manifold.Crossing):
+                left = intersection.left
+                right = intersection.right
+                if np.dot(self.tangent_space(left.evaluate(domainPoint)) @ left.normal(domainPoint), other.normal(right.evaluate(domainPoint))) < 0.0:
+                    left = left.flip_normal()
+                if np.dot(other.tangent_space(right.evaluate(domainPoint)) @ right.normal(domainPoint), self.normal(left.evaluate(domainPoint))) < 0.0:
+                    right = right.flip_normal()
+                intersections[i] = Manifold.Crossing(left, right)
 
     return intersections
 

{bspy-4.4 → bspy-4.4.1}/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,79 +181,79 @@ 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
+                tangent = self.jacobian(path(knot)) @ path.derivative((1,), knot)
+            else:
+                tangent = self.derivative((1,), knot)
             flipped = np.dot(tangent, offset.derivative((1,), knot)) < 0
             if flipped and start is None:
                 start = 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-4.4 → bspy-4.4.1}/bspy/spline.py

@@ -185,6 +185,25 @@ class Spline(Manifold):
             indMap = [(mapping, mapping) if np.isscalar(mapping) else mapping for mapping in indMap]
         return bspy._spline_operations.add(self, other, indMap)
 
+    def arc_length_map(self, tolerance = 1.0e-6):
+        """
+        Determine a mapping s -> u such that any curve parametrized arbitrarily can be composed with the
+        computed mapping to get the curve parametrized by arc length.  Specifically, given a curve x with
+        points on the curve given by x(u), determine a mapping u such that the composite curve x o u is
+        parametrized by arc length, i.e. x can be thought of as x(u(s)) for an arc length parameter s.
+
+        Parameters
+        ----------
+        tolerance : the accuracy to which the arc length map should be computed
+
+        Returns
+        -------
+        spline : Spline
+            The spline mapping from R1 -> R1 which approximates the arc length map to within the specified
+            tolerance.
+        """
+        return bspy._spline_domain.arc_length_map(self, tolerance)
+    
     @staticmethod
     def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs = False):
         """
@@ -547,13 +566,13 @@ class Spline(Manifold):
 
     def contract(self, uvw):
         """
-        Contract a spline by assigning a fixed value to one or more of its independent variables.
+        Contract a spline, reducing its number of independent variables, by assigning a fixed value to one or more of its independent variables.
 
         Parameters
         ----------
         uvw : `iterable`
             An iterable of length `nInd` that specifies the values of each independent variable to contract.
-            A value of `None` for an independent variable indicates that variable should remain unchanged.
+            A value of `None` for an independent variable retains that independent variable in the contacted spline.
 
         Returns
         -------

{bspy-4.4 → bspy-4.4.1}/bspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bspy
-Version: 4.4
+Version: 4.4.1
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner

{bspy-4.4 → bspy-4.4.1}/setup.cfg

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