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

bspy/_spline_domain.py

@@ -330,6 +330,7 @@ def insert_knots(self, newKnotList):
                     continue
 
             # Check if knot and its total multiplicity is valid.
+            knot = knots.dtype.type(knot) # Cast to correct type
             if knot < knots[degree] or knot > knots[-order]:
                 raise ValueError(f"Knot insertion outside domain: {knot}")
             position = np.searchsorted(knots, knot, 'right')
@@ -499,7 +500,7 @@ def remove_knots(self, tolerance, nLeft = 0, nRight = 0):
         foldedIndices = list(filter(lambda x: x != id, indIndex))
         currentFold, foldedBasis = currentSpline.fold(foldedIndices)
         while True:
-            bestError = np.finfo(scaleDep[0].dtype).max
+            bestError = np.finfo(self.coefs.dtype).max
             bestSpline = currentFold
             ix = currentFold.order[0]
             while ix < currentFold.nCoef[0]:

bspy/_spline_evaluation.py

@@ -5,7 +5,7 @@ def bspline_values(knot, knots, splineOrder, u, derivativeOrder = 0, taylorCoefs
     basis = np.zeros(splineOrder, knots.dtype)
     if knot is None:
         knot = np.searchsorted(knots, u, side = 'right')
-        knot = min(knot, len(knots) - splineOrder)
+        knot = min(max(knot, splineOrder), len(knots) - splineOrder)
     if derivativeOrder >= splineOrder:
         return knot, basis
     basis[-1] = 1.0

bspy/_spline_fitting.py

@@ -1,6 +1,7 @@
 import numpy as np
 import scipy as sp
 import bspy.spline
+import bspy.spline_block
 import math
 
 def circular_arc(radius, angle, tolerance = None):
@@ -12,14 +13,33 @@ def circular_arc(radius, angle, tolerance = None):
     return bspy.Spline.section([(radius * np.cos(u * angle * np.pi / 180), radius * np.sin(u * angle * np.pi / 180), 90 + u * angle, 1.0 / radius) for u in np.linspace(0.0, 1.0, samples)])
 
 def composition(splines, tolerance):
+    # Collect domains and check range bounds
+    domains = [None]
+    domain = None
+    for i, spline in enumerate(splines):
+        if domain is not None:
+            if len(domain) != spline.nDep:
+                raise ValueError(f"Domain dimension of spline {i-1} does not match range dimension of spline {i}")
+            rangeBounds = spline.range_bounds()
+            for ix in range(spline.nDep):
+                if rangeBounds[ix][0] < domain[ix][0] or rangeBounds[ix][1] > domain[ix][1]:
+                    raise ValueError(f"Range of spline {i} exceeds domain of spline {i-1}")
+            domains.append(domain)
+        domain = spline.domain()
+
     # Define the callback function
     def composition_of_splines(u):
-        for f in splines[::-1]:
-            u = f(u)
+        for spline, domain in zip(splines[::-1], domains[::-1]):
+            u = spline(u)
+            if domain is not None:
+                # We've already checked that the range of spline is within the domain
+                # of its successor, but numerics may cause the spline value to slightly 
+                # exceed its range, so we clip the spline value accordingly.
+                u = np.clip(u, domain[:, 0], domain[:, 1])
         return u
     
     # Approximate this composition
-    return bspy.Spline.fit(splines[-1].domain(), composition_of_splines, tolerance = tolerance)
+    return bspy.Spline.fit(domain, composition_of_splines, tolerance = tolerance)
 
 def cone(radius1, radius2, height, tolerance = None):
     if tolerance is None:
@@ -366,9 +386,10 @@ def fit(domain, f, order = None, knots = None, tolerance = 1.0e-4):
         indices = nInd * [0]
         iLast = nInd
         while iLast >= 0:
+            # 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(uValue)
+                fDictionary[uValue] = f(np.array(uValue))
             fValues.append(fDictionary[uValue])
             iLast = nInd - 1
             while iLast >= 0:
@@ -518,7 +539,7 @@ def four_sided_patch(bottom, right, top, left, surfParam = 0.5):
     
     return (1.0 - surfParam) * coons + surfParam * laplace
 
-def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
+def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-5):
     # Check validity of input
     if self.nInd != 2:  raise ValueError("Surface must have two independent variables")
     if len(uvStart) != 2:  raise ValueError("uvStart must have two components")
@@ -616,7 +637,7 @@ def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
     initialGuess = line(uvStart, uvEnd).elevate([2])
 
     # Solve the ODE and return the geodesic
-    solution = initialGuess.solve_ode(1, 1, geodesicCallback, 1.0e-5, (self, uvDomain))
+    solution = initialGuess.solve_ode(1, 1, geodesicCallback, tolerance, (self, uvDomain))
     return solution
 
 def least_squares(uValues, dataPoints, order = None, knots = None, compression = 0.0,
@@ -878,7 +899,7 @@ def section(xytk):
     # Join the pieces together and return
     return bspy.Spline.join(mySections)
 
-def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
+def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = (), includeEstimate = False):
     # Ensure that the ODE is properly formulated
 
     if nLeft < 0:  raise ValueError("Invalid number of left hand boundary conditions")
@@ -970,7 +991,7 @@ def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
                 residuals = np.append(residuals, np.zeros((nLeft * nDep,)))
                 collocationMatrix[bandWidth, 0 : nLeft * nDep] = 1.0
                 for iPoint, t in enumerate(collocationPoints[iFirstPoint : iNextPoint]):
-                    uData = np.array([workingSpline.derivative([i], t) for i in range(nOrder)]).T
+                    uData = np.array([workingSpline.derivative([i], t) for i in range(nOrder + 1 if includeEstimate else nOrder)]).T
                     F, F_u = FAndF_u(t, uData, *args)
                     residuals = np.append(residuals, workingSpline.derivative([nOrder], t) - continuation * F)
                     ix = None

bspy/_spline_intersection.py

@@ -958,6 +958,8 @@ def intersect(self, other):
             zeros = spline.zeros()
             # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
             for zero in zeros:
+                if isinstance(zero, tuple) and zero[1] - zero[0] < Manifold.minSeparation:
+                    zero = 0.5 * (zero[0] + zero[1])
                 if isinstance(zero, tuple):
                     # Intersection is an interval, so create a Manifold.Coincidence.
                     planeBounds = (projection @ (self((zero[0],)) - other._point), projection @ (self((zero[1],)) - other._point))
@@ -1019,6 +1021,8 @@ def intersect(self, other):
             zeros = block.zeros()
             # Convert each intersection point into a Manifold.Crossing and each intersection interval into a Manifold.Coincidence.
             for zero in zeros:
+                if isinstance(zero, tuple) and zero[1] - zero[0] < Manifold.minSeparation:
+                    zero = 0.5 * (zero[0] + zero[1])
                 if isinstance(zero, tuple):
                     # Intersection is an interval, so create a Manifold.Coincidence.
 
@@ -1135,14 +1139,14 @@ def complete_slice(self, slice, solid):
             newBoundary.touched = False
 
         # Define function for adding slice points to full domain boundaries.
-        def process_domain_point(boundary, domainPoint):
+        def process_domain_point(boundary, domainPoint, adjustment):
             point = boundary.manifold.evaluate(domainPoint)
             # See if and where point touches full domain.
             for newBoundary in fullDomain.boundaries:
                 vector = point - newBoundary.manifold._point
                 if abs(np.dot(newBoundary.manifold._normal, vector)) < Manifold.minSeparation:
-                    # Add the point onto the new boundary.
-                    normal = np.sign(newBoundary.manifold._tangentSpace.T @ boundary.manifold.normal(domainPoint))
+                    # Add the point onto the new boundary (adjust normal evaluation point to move away from boundary).
+                    normal = np.sign(newBoundary.manifold._tangentSpace.T @ boundary.manifold.normal(domainPoint + adjustment))
                     newBoundary.domain.add_boundary(Boundary(Hyperplane(normal, newBoundary.manifold._tangentSpace.T @ vector, 0.0), Solid(0, True)))
                     newBoundary.touched = True
                     break
@@ -1151,9 +1155,9 @@ def complete_slice(self, slice, solid):
         for boundary in slice.boundaries:
             domainBoundaries = boundary.domain.boundaries
             domainBoundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), boundary.manifold.normal(0.0)))
-            process_domain_point(boundary, domainBoundaries[0].manifold._point)
+            process_domain_point(boundary, domainBoundaries[0].manifold._point, Manifold.minSeparation)
             if len(domainBoundaries) > 1:
-                process_domain_point(boundary, domainBoundaries[-1].manifold._point)
+                process_domain_point(boundary, domainBoundaries[-1].manifold._point, -Manifold.minSeparation)
         
         # For touched boundaries, remove domain bounds that aren't needed and then add boundary to slice.
         boundaryWasTouched = False
@@ -1161,7 +1165,6 @@ def complete_slice(self, slice, solid):
             if newBoundary.touched:
                 boundaryWasTouched = True
                 domainBoundaries = newBoundary.domain.boundaries
-                assert len(domainBoundaries) > 2
                 domainBoundaries.sort(key=lambda boundary: (boundary.manifold.evaluate(0.0), boundary.manifold.normal(0.0)))
                 # Ensure domain endpoints don't overlap and their normals are consistent.
                 if abs(domainBoundaries[0].manifold._point - domainBoundaries[1].manifold._point) < Manifold.minSeparation or \

bspy/_spline_milling.py

@@ -0,0 +1,233 @@
+import numpy as np
+import bspy.spline
+import bspy.spline_block
+
+def line_of_curvature(self, uvStart, is_max, tolerance = 1.0e-3):
+    if self.nInd != 2:  raise ValueError("Surface must have two independent variables")
+    if len(uvStart) != 2:  raise ValueError("uvStart must have two components")
+    uvDomain = self.domain()
+    if uvStart[0] < uvDomain[0, 0] or uvStart[0] > uvDomain[0, 1] or \
+       uvStart[1] < uvDomain[1, 0] or uvStart[1] > uvDomain[1, 1]:
+        raise ValueError("uvStart is outside domain of the surface")
+    is_max = bool(is_max) # Ensure is_max is a boolean for XNOR operation
+    
+    # Define the callback function for the ODE solver
+    def curvatureLineCallback(t, u):
+        # Evaluate the surface information needed.
+        uv = np.maximum(uvDomain[:, 0], np.minimum(uvDomain[:, 1], u[:, 0]))
+        su = self.derivative((1, 0), uv)
+        sv = self.derivative((0, 1), uv)
+        suu = self.derivative((2, 0), uv)
+        suv = self.derivative((1, 1), uv)
+        svv = self.derivative((0, 2), uv)
+        suuu = self.derivative((3, 0), uv)
+        suuv = self.derivative((2, 1), uv)
+        suvv = self.derivative((1, 2), uv)
+        svvv = self.derivative((0, 3), uv)
+        normal = self.normal(uv)
+
+        # Calculate curvature matrix and its derivatives.
+        sU = np.concatenate((su, sv)).reshape(2, -1)
+        sUu = np.concatenate((suu, suv)).reshape(2, -1)
+        sUv = np.concatenate((suv, svv)).reshape(2, -1)
+        sUU = np.concatenate((suu, suv, suv, svv)).reshape(2, 2, -1)
+        sUUu = np.concatenate((suuu, suuv, suuv, suvv)).reshape(2, 2, -1)
+        sUUv = np.concatenate((suuv, suvv, suvv, svvv)).reshape(2, 2, -1)
+        fffI = np.linalg.inv(sU @ sU.T) # Inverse of first fundamental form
+        k = fffI @ (sUU @ normal) # Curvature matrix
+        ku = fffI @ (sUUu @ normal - (sUu @ sU.T + sU @ sUu.T) @ k - sUU @ (sU.T @ k[:, 0]))
+        kv = fffI @ (sUUv @ normal - (sUv @ sU.T + sU @ sUv.T) @ k - sUU @ (sU.T @ k[:, 1]))
+
+        # Determine principle curvatures and directions, and assign new direction.
+        curvatures, directions = np.linalg.eig(k)
+        curvatureDelta = curvatures[1] - curvatures[0]
+        if abs(curvatureDelta) < tolerance:
+            # If we're at an umbilic, use the last direction (jacobian is zero at umbilic).
+            direction = u[:, 1]
+            jacobian = np.zeros((2,2,1), self.coefs.dtype)
+        else:
+            # Otherwise, compute the lhs inverse for the jacobian.
+            directionsInverse = np.linalg.inv(directions)
+            eigenIndex = 0 if bool(curvatures[0] > curvatures[1]) == is_max else 1
+            direction = directions[:, eigenIndex]
+            B = np.zeros((2, 2), self.coefs.dtype)
+            B[0, 1 - eigenIndex] = np.dot(directions[:, 1], direction) / curvatureDelta
+            B[1, 1 - eigenIndex] = -np.dot(directions[:, 0], direction) / curvatureDelta
+            lhsInv =  directions @ B @ directionsInverse
+
+            # Adjust the direction for consistency.
+            if np.dot(direction, u[:, 1]) < -tolerance:
+                direction *= -1
+
+            # Compute the jacobian for the direction.
+            jacobian = np.empty((2,2,1), self.coefs.dtype)
+            jacobian[:,0,0] = lhsInv @ ku @ direction
+            jacobian[:,1,0] = lhsInv @ kv @ direction
+
+        return direction, jacobian
+
+    # Generate the initial guess for the line of curvature.
+    uvStart = np.atleast_1d(uvStart)
+    direction = 0.5 * (uvDomain[:,0] + uvDomain[:,1]) - uvStart # Initial guess toward center
+    distanceFromCenter = np.linalg.norm(direction)
+    if distanceFromCenter < 10 * tolerance:
+        # If we're at the center, just point to the far corner.
+        direction = np.array((1.0, 1.0)) / np.sqrt(2)
+    else:
+        direction /= distanceFromCenter
+
+    # Compute line of curvature direction at start.
+    direction, jacobian = curvatureLineCallback(0.0, np.array(((uvStart[0], direction[0]), (uvStart[1], direction[1]))))
+
+    # Calculate distance to the boundary in that direction.
+    if direction[0] < -tolerance:
+        uBoundaryDistance = (uvDomain[0, 0] - uvStart[0]) / direction[0]
+    elif direction[0] > tolerance:
+        uBoundaryDistance = (uvDomain[0, 1] - uvStart[0]) / direction[0]
+    else:
+        uBoundaryDistance = np.inf
+    if direction[1] < -tolerance:
+        vBoundaryDistance = (uvDomain[1, 0] - uvStart[1]) / direction[1]
+    elif direction[1] > tolerance:
+        vBoundaryDistance = (uvDomain[1, 1] - uvStart[1]) / direction[1]
+    else:
+        vBoundaryDistance = np.inf
+    boundaryDistance = min(uBoundaryDistance, vBoundaryDistance)
+
+    # Construct the initial guess from start point to boundary.
+    initialGuess = bspy.spline.Spline.line(uvStart, uvStart + boundaryDistance * direction).elevate([2])
+
+    # Solve the ODE and return the line of curvature confined to the surface's domain.
+    solution = initialGuess.solve_ode(1, 0, curvatureLineCallback, tolerance, includeEstimate = True)
+    return solution.confine(uvDomain)
+
+def offset(self, edgeRadius, bitRadius=None, angle=np.pi / 2.2, path=None, subtract=False, removeCusps=False, tolerance = 1.0e-4):
+    if self.nDep < 2 or self.nDep > 3 or self.nDep - self.nInd != 1: raise ValueError("The offset is only defined for 2D curves and 3D surfaces with well-defined normals.")
+    if edgeRadius < 0:
+        raise ValueError("edgeRadius must be >= 0")
+    elif edgeRadius == 0:
+        return self
+    if bitRadius is None:
+        bitRadius = edgeRadius
+    elif bitRadius < edgeRadius:
+        raise ValueError("bitRadius must be >= edgeRadius")
+    if angle < 0 or angle >= np.pi / 2: raise ValueError("angle must in the range [0, pi/2)")
+    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")
+
+    # Determine geometry of drill bit.
+    if subtract:
+        edgeRadius *= -1
+        bitRadius *= -1
+    w = bitRadius - edgeRadius
+    h = w * np.tan(angle)
+    bottom = np.sin(angle)
+    bottomRadius = edgeRadius + h / bottom
+
+    # 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)
+    elif self.nDep == 2: # General offset curve
+        def drillBit(u):
+            xy = self(u)
+            normal = self.normal(u)
+            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]
+            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)
+            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
+    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
+    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))
+
+    # Fit new spline to offset by drill bit.
+    offset = bspy.spline.Spline.fit(self.domain(), drillBit, newOrder, newKnots, tolerance)
+
+    # Remove cusps as required (only applies to offset curves).
+    if removeCusps and self.nInd == 1:
+        # 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:
+                start = knot
+            if not flipped and start is not None:
+                cusps.append((start, previousKnot))
+                start = None
+            previousKnot = knot
+
+        # Remove the cusps by intersecting the offset segments before and after each cusp.
+        segmentList = []
+        for cusp in cusps:
+            domain = offset.domain()
+            before = offset.trim(((domain[0][0], cusp[0]),))
+            after = -offset.trim(((cusp[1], domain[0][1]),))
+            if path is not None:
+                # Project before and after onto a 2D plane defined by the offset tangent 
+                # and the surface normal at the start of the cusp.
+                # 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))
+                before = before.transform(projection)
+                after = after.transform(projection)
+            block = bspy.spline_block.SplineBlock([[before, after]])
+            intersections = block.zeros()
+            for intersection in intersections:
+                segmentList.append(offset.trim(((domain[0][0], intersection[0]),)))
+                offset = offset.trim(((intersection[1], domain[0][1]),))
+        segmentList.append(offset)
+        offset = bspy.spline.Spline.join(segmentList)
+    
+    return offset

bspy/_spline_operations.py

@@ -71,16 +71,20 @@ def confine(self, range_bounds):
     if self.nInd != 1: raise ValueError("Confine only works on curves (nInd == 1)")
     if len(range_bounds) != self.nDep: raise ValueError("len(range_bounds) must equal nDep")
     spline = self.clamp((0,), (0,))
+    if spline is self:
+        spline = self.copy()
     order = spline.order[0]
     degree = order - 1
     domain = spline.domain()
+    dtype = spline.knots[0].dtype
     unique, counts = np.unique(spline.knots[0], return_counts=True)
     machineEpsilon = np.finfo(self.coefs.dtype).eps
     epsilon = np.sqrt(machineEpsilon)
     intersections = [] # List of tuples (u, boundaryPoint, headingOutside)
 
     def addIntersection(u, headedOutside = False):
-        boundaryPoint = spline(np.atleast_1d(u))
+        u = dtype.type(u) # Cast to spline domain type
+        boundaryPoint = spline(u)
         for i in range(spline.nDep):
             if boundaryPoint[i] < range_bounds[i][0]:
                 headedOutside = True if boundaryPoint[i] < range_bounds[i][0] - epsilon else headedOutside
@@ -88,18 +92,18 @@ def confine(self, range_bounds):
             if boundaryPoint[i] > range_bounds[i][1]:
                 headedOutside = True if boundaryPoint[i] > range_bounds[i][1] + epsilon else headedOutside
                 boundaryPoint[i] = range_bounds[i][1]
-        intersections.append((u, boundaryPoint, headedOutside))
+        intersections.append([u, boundaryPoint, headedOutside])
 
     def intersectBoundary(i, j):
         zeros = type(spline)(1, 1, spline.order, spline.nCoef, spline.knots, (spline.coefs[i] - range_bounds[i][j],)).zeros()
         for zero in zeros:
             if isinstance(zero, tuple):
-                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), np.atleast_1d(zero[0]))[i] > epsilon
+                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), zero[0])[i] > 0
                 addIntersection(zero[0], headedOutside)
-                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), np.atleast_1d(zero[1]))[i] > epsilon
+                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), zero[1])[i] > 0
                 addIntersection(zero[1], headedOutside)
             else:
-                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), np.atleast_1d(zero))[i] > epsilon
+                headedOutside = (-1 if j == 0 else 1) * spline.derivative((1,), zero)[i] > 0
                 addIntersection(zero, headedOutside)
 
     addIntersection(domain[0][0]) # Confine starting point
@@ -112,21 +116,22 @@ def confine(self, range_bounds):
     # Put the intersection points in order.
     intersections.sort(key=lambda intersection: intersection[0])
 
-    # Remove repeat points at start and end.
-    while intersections[1][0] - intersections[0][0] < epsilon:
-        del intersections[1]
-    while intersections[-1][0] - intersections[-2][0] < epsilon:
-        del intersections[-2]
-
-    # Insert order-1 knots at each intersection point.
-    for (knot, boundaryPoint, headedOutside) in intersections:
-        ix = np.searchsorted(unique, knot)
-        if unique[ix] == knot:
-            count = (order - 1) - counts[ix]
-            if count > 0:
-                spline = spline.insert_knots(((knot, count),))
+    # Insert order-1 (degree) knots at each intersection point.
+    previousKnot, previousBoundaryPoint, previousHeadedOutside = intersections[0]
+    previousIx = 0
+    for i, (knot, boundaryPoint, headedOutside) in enumerate(intersections[1:]):
+        if knot - previousKnot < epsilon:
+            intersections[previousIx][2] = headedOutside # Keep last headed outside
         else:
-            spline = spline.insert_knots(((knot, order - 1),))
+            ix = np.searchsorted(unique, knot)
+            if unique[ix] == knot:
+                count = degree - counts[ix]
+                if count > 0:
+                    spline = spline.insert_knots((((knot, count),),))
+            else:
+                spline = spline.insert_knots((((knot, degree),),))
+            previousKnot = knot
+            previousIx = i
 
     # Go through the boundary points, assigning boundary coefficients, interpolating between boundary points, 
     # and removing knots and coefficients where the curve stalls.
@@ -139,29 +144,37 @@ def confine(self, range_bounds):
     knotAdjustment = 0.0
     for knot, boundaryPoint, headedOutside in intersections[1:]:
         knot += knotAdjustment
-        ix = np.searchsorted(knots, knot, 'right') - order
-        ix = min(ix, nCoef - 1)
-        coefs[:, ix] = boundaryPoint # Assign boundary coefficients
-        if previousHeadedOutside and np.linalg.norm(boundaryPoint - previousBoundaryPoint) < epsilon:
-            # Curve has stalled, so remove intervening knots and coefficients, and adjust knot values.
-            nCoef -= ix - previousIx
-            knots = np.delete(knots, slice(previousIx + 1, ix + 1))
-            knots[previousIx + 1:] -= knot - previousKnot
-            knotAdjustment -= knot - previousKnot
-            coefs = np.delete(coefs, slice(previousIx, ix), axis=1)
-            previousHeadedOutside = headedOutside # The previous knot is unchanged, but inherits the new headedOutside value
-        else:
-            if previousHeadedOutside:
-                # If we were outside, linearly interpolate between the previous and current boundary points.
-                slope = (boundaryPoint - previousBoundaryPoint) / (knot - previousKnot)
-                for i in range(previousIx + 1, ix):
-                    coefs[:, i] = coefs[:, i - 1] + ((knots[i + degree] - knots[i]) / degree) * slope
-
-            # Update previous knot
-            previousKnot = knot
-            previousBoundaryPoint = boundaryPoint
-            previousHeadedOutside = headedOutside
-            previousIx = ix
+        if knot - previousKnot >= epsilon:
+            ix = np.searchsorted(knots, knot, 'right') - order
+            ix = min(ix, nCoef - 1)
+            coefs[:, ix] = boundaryPoint # Assign boundary coefficients
+            if previousHeadedOutside and np.linalg.norm(boundaryPoint - previousBoundaryPoint) < epsilon:
+                # Curve has stalled, so remove intervening knots and coefficients, and adjust knot values.
+                nCoef -= ix - previousIx
+                knots = np.delete(knots, slice(previousIx + 1, ix + 1))
+                knots[previousIx + 1:] -= knot - previousKnot
+                knotAdjustment -= knot - previousKnot
+                coefs = np.delete(coefs, slice(previousIx, ix), axis=1)
+                previousHeadedOutside = headedOutside # The previous knot is unchanged, but inherits the new headedOutside value
+            else:
+                if previousHeadedOutside:
+                    # If we were outside, linearly interpolate between the previous and current boundary points.
+                    slope = (boundaryPoint - previousBoundaryPoint) / (knot - previousKnot)
+                    for i in range(previousIx + 1, ix):
+                        coefs[:, i] = coefs[:, i - 1] + ((knots[i + degree] - knots[i]) / degree) * slope
+
+                # Update previous knot
+                previousKnot = knot
+                previousBoundaryPoint = boundaryPoint
+                previousHeadedOutside = headedOutside
+                previousIx = ix
+        elif previousKnot != knot and knot == domain[0][1] and np.linalg.norm(boundaryPoint - previousBoundaryPoint) < epsilon:
+            # Curve stalled at the end. Remove the last knot and its associated coefficients.
+            # Keep the last knot if the previous and last knot are the same.
+            nCoef -= degree
+            knots = knots[:-degree]
+            knots[-1] = previousKnot
+            coefs = coefs[:,:-degree]
     
     spline.nCoef = (nCoef,)
     spline.knots = (knots,)

bspy/solid.py

@@ -753,7 +753,7 @@ class Solid:
 
                 # Calculate Integral(f) * first cofactor. Note that quad returns a tuple: (integral, error bound).
                 returnValue = 0.0
-                firstCofactor = boundary.manifold.normal(evalPoint, False, (0,))
+                firstCofactor = boundary.manifold.normal(evalPoint, False, (0,))[0]
                 if abs(x0 - point[0]) > epsabs and abs(firstCofactor) > epsabs:
                     returnValue = integrate.quad(fHat, x0, point[0], epsabs=epsabs, epsrel=epsrel, *quadArgs)[0] * firstCofactor
                 return returnValue

bspy/spline.py

@@ -5,8 +5,9 @@ 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_intersection
+import bspy._spline_milling
 import bspy._spline_operations
 
 @Manifold.register
@@ -59,8 +60,8 @@ class Spline(Manifold):
         self.knots = tuple(np.array(kk) for kk in knots)
         for knots, order, nCoef in zip(self.knots, self.order, self.nCoef):
             for i in range(nCoef):
-                if not(knots[i] <= knots[i + 1] and knots[i] < knots[i + order]):
-                       raise ValueError("Improperly ordered knot sequence")
+                if not(knots[i] <= knots[i + 1] and knots[i + order] - knots[i] > 0):
+                       raise ValueError("Improper knot order or multiplicity")
         totalCoefs = 1
         for nCoef in self.nCoef:
             totalCoefs *= nCoef
@@ -974,15 +975,15 @@ class Spline(Manifold):
             resulting spline function will have nInd + number of independent variables
             in the splines returned independent variables and nDep dependent variables.
         
-        order : `array-like`
+        order : `array-like`, optional
             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`
+        knots : `array-like`, optional
             The initial knot sequence to use, if given
         
-        tolerance : `scalar`
+        tolerance : `scalar`, optional
             The maximum 2-norm of the difference between the given function and the
             spline fit.  Defaults to 1.0e-4.
         
@@ -1129,7 +1130,7 @@ class Spline(Manifold):
         """
         return bspy._spline_intersection.full_domain(self)
     
-    def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-6):
+    def geodesic(self, uvStart, uvEnd, tolerance = 1.0e-5):
         """
         Determine a geodesic between two points on a surface
 
@@ -1141,9 +1142,9 @@ class Spline(Manifold):
         uvEnd : `array-like`
             The parameter values for the surface at the other end of the desired geodesic.
         
-        tolerance : scalar
+        tolerance : scalar, optional
             The maximum error in parameter space to which the geodesic should get computed.
-            Defaults to 1.0e-6.
+            Defaults to 1.0e-5.
 
         Returns
         -------
@@ -1499,6 +1500,36 @@ class Spline(Manifold):
         """
         return bspy._spline_fitting.line(startPoint, endPoint)
     
+    def line_of_curvature(self, uvStart, is_max = True, tolerance = 1.0e-3):
+        """
+        Determine a line of curvature along a surface
+
+        Parameters
+        ----------
+        uvStart : `array-like`
+            The parameter values for the surface at one end of the desired line of curvature.
+        
+        is_max : `bool`, optional
+            Boolean value indicating that the line of curvature should be the maximal curvature line. 
+            If False, the minimal curvature line is returned. Defaults to True.
+        
+        tolerance : scalar, optional
+            The maximum error in parameter space to which the geodesic should get computed.
+            Defaults to 1.0e-3.
+
+        Returns
+        -------
+        spline : `Spline`
+            A spline curve whose range is in the domain of the given surface.  The range of the
+            curve is the locus of points whose image under the surface map form the line of curvature
+            starting at the given point.
+        
+        See Also
+        --------
+        `solve_ode` : Solve an ordinary differential equation using spline collocation.
+        """
+        return bspy._spline_milling.line_of_curvature(self, uvStart, is_max, tolerance)
+    
     @staticmethod
     def load(fileName):
         """
@@ -1653,6 +1684,61 @@ class Spline(Manifold):
         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(bspy.spline_block.SplineBlock(self), indices)
+    
+    def offset(self, edgeRadius, bitRadius=None, angle=np.pi / 2.2, path=None, subtract=False, removeCusps=False, tolerance = 1.0e-4):
+        """
+        Compute the offset of a spline to a given tolerance.
+
+        Parameters
+        ----------
+        edgeRadius : scalar
+            The radius of offset. If a bit radius is specified, the edge radius is the
+            smaller radius of the cutting edge of the drill bit, whereas bit radius specifies 
+            half of the full width of the drill bit.
+
+        bitRadius : scalar, optional
+            The radius of the drill bit (half its full width). For a ball nose cutter (the default), 
+            the bit radius is the same as the edge radius. For an end mill,
+            the bit radius is larger (typically much larger) than the edge radius.
+
+        angle : scalar, optional
+            The angle at which the drill bit transitions from the edge radius to the 
+            flatter bottom of the drill bit. The angle must be in the range [0, pi/2). 
+            Defaults to pi / 2.2.
+
+        path : `Spline`, optional
+            The path along self that the drill bit should contact. 
+            If specified, the path must be a 2D curve in the domain of self, self must be a 3D surface,  
+            and the offset returned is a 3D curve providing the 3D position of the drill bit, 
+            rather than the full offset surface. Defaults to None.
+
+        subtract : boolean, optional
+            Flag indicating if the drill bit should be subtracted from the spline instead of added. 
+            Subtracting the drill bit returns the tool path that cuts out the spline. Defaults to False.
+
+        removeCusps : boolean, optional
+            Flag indicating if cusps and their associated self-intersections should be removed from the 
+            offset. Only applicable to offset curves and paths along offset surfaces. Defaults to False.
+    
+        tolerance : `scalar`, optional
+            The maximum 2-norm of the difference between the offset and the
+            spline fit. Defaults to 1.0e-4.
+        
+        Returns
+        -------
+        offset : `Spline`
+            The spline that represents the offset.
+        
+        See Also
+        --------
+        `fit` : Fit the function f with a spline to a given tolerance.
+
+        Notes
+        -----
+        The offset is only defined for 2D curves and 3D surfaces with well-defined normals. 
+        The bottom of the drill bit is tangent to its lowest y value.
+        """
+        return bspy._spline_milling.offset(self, edgeRadius, bitRadius, angle, path, subtract, removeCusps, tolerance)
 
     @staticmethod
     def point(point):
@@ -1971,7 +2057,7 @@ class Spline(Manifold):
         """
         return bspy._spline_fitting.section(xytk)
     
-    def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = ()):
+    def solve_ode(self, nLeft, nRight, FAndF_u, tolerance = 1.0e-6, args = (), includeEstimate = False):
         """
         Numerically solve an ordinary differential equation with boundary conditions.
 
@@ -1994,26 +2080,31 @@ class Spline(Manifold):
         FAndF_u : Python function
             FAndF_u must have exactly this calling sequence:  FAndF_u(t, uData, *args).  t is a scalar set
             to the desired value of the independent variable of the ODE.  uData will be a numpy matrix of shape
-            (self.nDep, nOrder) whose columns are (u, ... , u^(nOrder - 1).  It must return a numpy
+            (self.nDep, nOrder) whose columns are u, ... , u^(nOrder - 1).  It must return a numpy
             vector of length self.nDep and a numpy array whose shape is (self.nDep, self.nDep, nOrder).
             The first output vector is the value of the forcing function F at (t, uData).  The numpy
             array is the array of partial derivatives with respect to all the numbers in uData.  Thus, if
             this array is called jacobian, then jacobian[:, i, j] is the gradient of the forcing function with
             respect to uData[i, j].
         
-        tolerance : scalar
-            The relative error to which the ODE should get solved.
+        tolerance : scalar, optional
+            The relative error to which the ODE should get solved. Default is 1.0e-6.
         
-        args : tuple
+        args : tuple, optional
             Additional arguments to pass to the user-defined function FAndF_u.  For example, if FAndF_u has the
-            FAndF_u(t, uData, a, b, c), then args must be a tuple of length 3.
+            FAndF_u(t, uData, a, b, c), then args must be a tuple of length 3. Default is ().
+        
+        includeEstimate : bool, optional
+            If `includeEstimate` is True, the uData passed to `FAndF_u` will be a numpy matrix of shape
+            (self.nDep, nOrder + 1) whose columns are u, ... , u^(nOrder). The last column will be the most
+            recent estimate of u^(nOrder)(t). Default is False.
 
         Notes
         =====
         This method uses B-splines as finite elements.  The ODE itself is discretized using
         collocation.
         """
-        return bspy._spline_fitting.solve_ode(self, nLeft, nRight, FAndF_u, tolerance, args)
+        return bspy._spline_fitting.solve_ode(self, nLeft, nRight, FAndF_u, tolerance, args, includeEstimate)
 
     @staticmethod
     def sphere(radius, tolerance = None):

{bspy-4.3.dist-info → bspy-4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: bspy
-Version: 4.3
+Version: 4.4
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -28,14 +28,13 @@ Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: PyOpenGL
 Requires-Dist: pyopengltk
+Dynamic: license-file
 
 # BSpy
 Library for manipulating and rendering B-spline curves, surfaces, and multidimensional manifolds with non-uniform knots in each dimension.
 
-The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
-
-The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for scalar and vector functions of single and multiple variables. It also can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics. 
-Spline has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
+The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for scalar and vector functions of single and multiple variables. It also can fit splines to functions, to solutions for ordinary differential equations (ODEs), geodesics, offsets, and lines of curvature. 
+Spline has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, four-sided patches, and compositions of splines. 
 Other methods add, subtract, and multiply splines, as well as confine spline curves to a given range. 
 There are methods to evaluate spline values, derivatives, normals, integrals, continuity, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions. 
 In addition, there are methods to manipulate the domain of splines, including trim, join, split, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. 
@@ -43,16 +42,18 @@ There are methods to manipulate the range of splines, including dot product, cro
 Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines. 
 Splines can be saved and loaded in json format.
 
-The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.
-
-The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.
-
 The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to process an array-like collection of splines that represent a system of equations. There are highly-optimized methods to compute the contours and zeros of a spline block, as well as a variety of methods to manipulate and evaluate a spline block and its derivatives.
 
 The [BSpyConvert](https://pypi.org/project/BSpyConvert/) package converts BSpy splines and solid models to and from [OpenCascade (OCCT)](https://dev.opencascade.org/) equivalents and a variety of geometry and CAD file formats, including STEP, IGES, and STL.
 
+The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.
+
+The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
+
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.
+
 The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
-[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Spline surfaces with more 
+[OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves, surfaces, and solids. Spline surfaces with more 
 than 3 dependent variables will have their added dimensions rendered as colors (up to 6 dependent variables are supported). Only tested on Windows systems.
 
 The [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) class is a 
@@ -60,7 +61,7 @@ The [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) class is a
 [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html), 
 a tree view full of solids and splines, and a set of controls to adjust and view the selected solids and splines. Only tested on Windows systems.
 
-The [Graphics](https://ericbrec.github.io/BSpy/bspy/viewer.html#Graphics) class is a graphics engine to display splines.
+The [Graphics](https://ericbrec.github.io/BSpy/bspy/viewer.html#Graphics) class is a graphics engine to display solids and splines.
 It launches a [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) and issues commands to the viewer for use 
 in [jupyter](https://jupyter.org/) notebooks and other scripting environments. Only tested on Windows systems.
 

bspy-4.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+bspy/__init__.py,sha256=LnJx7iHah7A4vud9y64LR61rBtYnuhV4Wno9O2IEK1I,1499
+bspy/_spline_domain.py,sha256=pAoauqMJrY80k6bhnMJKnPWY_p_zx1k4daP3krsAN8M,33303
+bspy/_spline_evaluation.py,sha256=aQ9w4N5MQDol7_OQ6HLljMtCbGVuS5iCAlM7Sg2q8B4,9656
+bspy/_spline_fitting.py,sha256=TH2fwHu_wsRSvFIXngfWxOAHKex0ilP0Xi8ThXYQ0dI,52002
+bspy/_spline_intersection.py,sha256=CErinlW8co_kaamM9Wb1TFrbB6EmjlUh1exYlcXkrpQ,67349
+bspy/_spline_milling.py,sha256=OzhYi3eNPcL0INk7k_ryNwlt8SUniWL10ULxgE_nKHI,11435
+bspy/_spline_operations.py,sha256=O2AsfJb0PvaNbM2Rp3_AbNXKo8X6X6RJDwDclqOwT7o,43564
+bspy/hyperplane.py,sha256=gnVZ7rjisGpzHfm1moItyzq8mO7HguzzpY4dpFwyDiw,24840
+bspy/manifold.py,sha256=vjgyz0M1mkgenUnTIbX7NFg1fUCgXtStr6ofF4oSLgg,14470
+bspy/solid.py,sha256=tsO7fcGj-x3SWH2fBSkeu-Hx5vX0KMFOt1baH-OYNgQ,36995
+bspy/spline.py,sha256=vSscV6FRXjFp1FnhS1IoyFiy2pRFgr8-kZyKXw8weJU,105842
+bspy/splineOpenGLFrame.py,sha256=N8elVJrt24_utOSoTaM5Ue5De2M4DxrquyB7o2lLLD4,96256
+bspy/spline_block.py,sha256=O8MzfBEygVdAx57DoJMwzjkw349BQqht7_RVu8MO0Fg,20127
+bspy/viewer.py,sha256=_iQCyEpsBFPBLLuHq7tc43IPVvlcqxdp0Hig0uvpQns,34349
+bspy-4.4.dist-info/licenses/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-4.4.dist-info/METADATA,sha256=8Y8G0jkCCuFdmJVb9CZgPJ5kuwaQivu89loQ6kyqlbc,7138
+bspy-4.4.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+bspy-4.4.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-4.4.dist-info/RECORD,,

{bspy-4.3.dist-info → bspy-4.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bspy-4.3.dist-info/RECORD

@@ -1,18 +0,0 @@
-bspy/__init__.py,sha256=LnJx7iHah7A4vud9y64LR61rBtYnuhV4Wno9O2IEK1I,1499
-bspy/_spline_domain.py,sha256=bQQsJlKstIYdbEKIW7vr-7nTKat8y9thYc7jxzZHNFQ,33238
-bspy/_spline_evaluation.py,sha256=WIv0tLZNLy0uHNj9YwR7vbputgT2Mn5QDXZzlD6ousk,9638
-bspy/_spline_fitting.py,sha256=CEkmUQalXTT5N5ZOJpFF4Y2DI-ARlZap9IaCJ_Zg2Ws,50762
-bspy/_spline_intersection.py,sha256=8FPTh4IDtzkRpieNtlnw8VhLabPzY4E_LWDaGxHIMTM,66973
-bspy/_spline_operations.py,sha256=8yJGp4iVVvQ1zcUHAKgNq2TMIjDUhacf5XSoHp2jmVo,42799
-bspy/hyperplane.py,sha256=gnVZ7rjisGpzHfm1moItyzq8mO7HguzzpY4dpFwyDiw,24840
-bspy/manifold.py,sha256=vjgyz0M1mkgenUnTIbX7NFg1fUCgXtStr6ofF4oSLgg,14470
-bspy/solid.py,sha256=ufNs5JV0jQ1A13pUY61N0pcW6Ep-DZmXUau7GHHcKk4,36992
-bspy/spline.py,sha256=1USitAm1FIQg5JuWa1xLrVQQ2cWRGfP4VhQnS8XOKc8,101377
-bspy/splineOpenGLFrame.py,sha256=N8elVJrt24_utOSoTaM5Ue5De2M4DxrquyB7o2lLLD4,96256
-bspy/spline_block.py,sha256=O8MzfBEygVdAx57DoJMwzjkw349BQqht7_RVu8MO0Fg,20127
-bspy/viewer.py,sha256=_iQCyEpsBFPBLLuHq7tc43IPVvlcqxdp0Hig0uvpQns,34349
-bspy-4.3.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-4.3.dist-info/METADATA,sha256=lV6eciVqRf3FqWslbTD5OWb3gMD6-gv6WB-hkSRadPM,7044
-bspy-4.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-bspy-4.3.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-4.3.dist-info/RECORD,,