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

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

@@ -13,47 +13,55 @@ def _shiftPolynomial(polynomial, delta):
 
 def add(self, other, indMap = None):
     if not(self.nDep == other.nDep): raise ValueError("self and other must have same nDep")
-    selfMapped = []
-    otherMapped = []
+    selfMapped = set()
     otherToSelf = {}
     if indMap is not None:
         (self, other) = bspy.Spline.common_basis((self, other), indMap)
         for map in indMap:
-            selfMapped.append(map[0])
-            otherMapped.append(map[1])
+            selfMapped.add(map[0])
             otherToSelf[map[1]] = map[0]
 
     # Construct new spline parameters.
-    # We index backwards because we're adding transposed coefficients (see below). 
     nInd = self.nInd
     order = [*self.order]
     nCoef = [*self.nCoef]
     knots = list(self.knots)
-    permutation = [] # Used to transpose coefs to match other.coefs.T.
-    for i in range(self.nInd - 1, -1, -1):
-        if i not in selfMapped:
-            permutation.append(i + 1) # Add 1 to account for dependent variables.
-    for i in range(other.nInd - 1, -1, -1):
-        if i not in otherMapped:
-            order.append(other.order[other.nInd - 1 - i])
-            nCoef.append(other.nCoef[other.nInd - 1 - i])
-            knots.append(other.knots[other.nInd - 1 - i])
-            permutation.append(self.nInd + i + 1) # Add 1 to account for dependent variables.
+    for i in range(other.nInd):
+        if i not in otherToSelf:
+            order.append(other.order[i])
+            nCoef.append(other.nCoef[i])
+            knots.append(other.knots[i])
             nInd += 1
-        else:
-            permutation.append(otherToSelf[i] + 1) # Add 1 to account for dependent variables.
-    permutation.append(0) # Account for dependent variables.
-    permutation = np.array(permutation)
+
+    # Build coefs array.
     coefs = np.zeros((self.nDep, *nCoef), self.coefs.dtype)
 
-    # Build coefs array by transposing the changing coefficients to the end, including the dependent variables.
-    # First, add in self.coefs.
+    # Add in self.coefs (you need to transpose coefs for the addition to work properly).
     coefs = coefs.T
     coefs += self.coefs.T
-    # Permutation for other.coefs.T accounts for coefs being transposed by subtracting permutation from ndim - 1.
-    coefs = coefs.transpose((coefs.ndim - 1) - permutation)
-    # Add in other.coefs. 
+    coefs = coefs.T
+
+    # Construct permutation of coefs to transpose coefs to match other.coefs.
+    otherUnmappedCount = 0
+    permutation = [0] # Account for dependent variables
+    for i in range(other.nInd):
+        if i in otherToSelf:
+            permutation.append(otherToSelf[i] + 1) # Add 1 to account for dependent variables.
+        else:
+            permutation.append(self.nInd + otherUnmappedCount + 1) # Add 1 to account for dependent variables.
+            otherUnmappedCount += 1
+    for i in range(self.nInd):
+        if i not in selfMapped:
+            permutation.append(i + 1) # Add 1 to account for dependent variables.
+
+    # Permute coefs to match other.coefs
+    coefs = coefs.transpose(permutation)
+
+    # Add in other.coefs (you need to transpose coefs for the addition to work properly).
+    coefs = coefs.T
     coefs += other.coefs.T
+    coefs = coefs.T
+
     # Reverse the permutation.
     coefs = coefs.transpose(np.argsort(permutation)) 
     
@@ -63,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
@@ -80,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
@@ -104,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.
@@ -131,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,)
@@ -643,21 +664,20 @@ def normal_spline(self, indices=None):
         knots = None
         counts = None
         maxOrder = 0
-        startInd = 0
-        endInd = 0
+        maxMap = []
         # First, collect the order, knots, and number of relevant columns for this independent variable.
         for row in self.block:
-            rowInd = 0
-            for spline in row:
-                if rowInd <= nInd < rowInd + spline.nInd:
-                    ind = nInd - rowInd
+            for map, spline in row:
+                if nInd in map:
+                    ind = map.index(nInd)
                     order = spline.order[ind]
                     k, c = np.unique(spline.knots[ind][order-1:spline.nCoef[ind]+1], return_counts=True)
                     if knots:
                         if maxOrder < order:
                             counts += order - maxOrder
                             maxOrder = order
-                        endInd = max(endInd, rowInd + spline.nInd)
+                        if len(maxMap) < len(map):
+                            maxMap = map
                         for knot, count in zip(k[1:-1], c[1:-1]):
                             ix = np.searchsorted(knots, knot)
                             if knots[ix] == knot:
@@ -669,30 +689,27 @@ def normal_spline(self, indices=None):
                         knots = k
                         counts = c
                         maxOrder = order
-                        startInd = rowInd
-                        endInd = rowInd + spline.nInd
-                    
+                        maxMap = map
+                  
                     break
 
-                rowInd += spline.nInd
-
         # Next, calculate the order of the normal for this independent variable.
         # Note that the total order will be one less than usual, because one of 
         # the tangents is the derivative with respect to that independent variable.
         if self.nInd < self.nDep:
             # If this normal involves all tangents, simply add the degree of each,
             # so long as that tangent contains the independent variable.
-            order = (maxOrder - 1) * (endInd - startInd)
+            order = (maxOrder - 1) * len(maxMap)
         else:
             # If this normal doesn't involve all tangents, find the max order of
             # each returned combination (as defined by the indices).
             order = 0
-            for index in range(startInd, endInd) if indices is None else indices:
+            for index in maxMap if indices is None else indices:
                 # The order will be one larger if this independent variable's tangent is excluded by the index.
                 ord = 0 if index != nInd else 1
                 # Add the degree of each tangent, so long as that tangent contains the 
                 # independent variable and is not excluded by the index.  
-                for ind in range(startInd, endInd):
+                for ind in maxMap:
                     ord += maxOrder - 1 if index != ind else 0
                 order = max(order, ord)
         

bspy/hyperplane.py

@@ -18,6 +18,9 @@ class Hyperplane(Manifold):
     
     tangentSpace : array-like
         A array of tangents that are linearly independent and orthogonal to the normal.
+
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the hyperplane. Default is {}.
     
     Notes
     -----
@@ -28,11 +31,12 @@ class Hyperplane(Manifold):
     maxAlignment = 0.9999 # 1 - 1/10^4
     """ If the absolute value of the dot product of two unit normals is greater than maxAlignment, the manifolds are parallel."""
 
-    def __init__(self, normal, point, tangentSpace):
+    def __init__(self, normal, point, tangentSpace, metadata = {}):
         self._normal = np.atleast_1d(normal)
         self._point = np.atleast_1d(point)
         self._tangentSpace = np.atleast_1d(tangentSpace)
         if not np.allclose(self._tangentSpace.T @ self._normal, 0.0): raise ValueError("normal must be orthogonal to tangent space")
+        self.metadata = dict(metadata)
 
     def __repr__(self):
         return "Hyperplane({0}, {1}, {2})".format(self._normal, self._point, self._tangentSpace)
@@ -207,7 +211,7 @@ class Hyperplane(Manifold):
         --------
         `to_dict` : Return a `dict` with `Hyperplane` data.
         """
-        return Hyperplane(dictionary["normal"], dictionary["point"], dictionary["tangentSpace"])
+        return Hyperplane(dictionary["normal"], dictionary["point"], dictionary["tangentSpace"], dictionary.get("metadata", {}))
 
     def full_domain(self):
         """
@@ -455,7 +459,7 @@ class Hyperplane(Manifold):
         --------
         `from_dict` : Create a `Hyperplane` from a data in a `dict`.
         """
-        return {"type" : "Hyperplane", "normal" : self._normal, "point" : self._point, "tangentSpace" : self._tangentSpace}
+        return {"type" : "Hyperplane", "normal" : self._normal, "point" : self._point, "tangentSpace" : self._tangentSpace, "metadata" : self.metadata}
 
     def transform(self, matrix, matrixInverseTranspose = None):
         """

bspy/manifold.py

@@ -5,6 +5,11 @@ class Manifold:
     """
     A manifold is an abstract base class for differentiable functions with
     normals and tangent spaces whose range is one dimension higher than their domain.
+
+    Parameters
+    ----------
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the manifold. Default is {}.
     """
 
     minSeparation = 0.0001
@@ -17,8 +22,8 @@ class Manifold:
     factory = {}
     """Factory dictionary for creating manifolds."""
 
-    def __init__(self):
-        pass
+    def __init__(self, metadata = {}):
+        self.metadata = dict(metadata)
 
     def cached_intersect(self, other, cache = None):
         """
@@ -322,7 +327,7 @@ class Manifold:
         --------
         `from_dict` : Create a `Manifold` from a data in a `dict`.
         """
-        return None
+        return {"metadata" : self.metadata}
 
     def transform(self, matrix, matrixInverseTranspose = None):
         """

bspy/solid.py

@@ -59,6 +59,9 @@ class Solid:
     
     containsInfinity : `bool`
         Indicates whether or not the solid contains infinity.
+
+    metadata : `dict`, optional
+        A dictionary of ancillary data to store with the solid. Default is {}.
     
     See also
     --------
@@ -70,10 +73,11 @@ class Solid:
 
     Solids can be of zero dimension, typically acting as the domain of boundary endpoints. Zero-dimension solids have no boundaries, they only contain infinity or not.
     """
-    def __init__(self, dimension, containsInfinity):
+    def __init__(self, dimension, containsInfinity, metadata = {}):
         assert dimension >= 0
         self.dimension = dimension
         self.containsInfinity = containsInfinity
+        self.metadata = dict(metadata)
         self.boundaries = []
         self.bounds = None
 
@@ -356,7 +360,7 @@ class Solid:
         `save` : Save a solids and/or manifolds in json format to the specified filename (full path).
         """
         def from_dict(dictionary):
-            solid = Solid(dictionary["dimension"], dictionary["containsInfinity"])
+            solid = Solid(dictionary["dimension"], dictionary["containsInfinity"], dictionary.get("metadata", {}))
             for boundary in dictionary["boundaries"]:
                 manifold = boundary["manifold"]
                 solid.add_boundary(Boundary(Manifold.factory[manifold.get("type", "Spline")].from_dict(manifold), from_dict(boundary["domain"])))
@@ -428,7 +432,7 @@ class Solid:
                 if isinstance(obj, Boundary):
                     return {"type" : "Boundary", "manifold" : obj.manifold, "domain" : obj.domain}
                 if isinstance(obj, Solid):
-                    return {"type" : "Solid", "dimension" : obj.dimension, "containsInfinity" : obj.containsInfinity, "boundaries" : obj.boundaries}
+                    return {"type" : "Solid", "dimension" : obj.dimension, "containsInfinity" : obj.containsInfinity, "boundaries" : obj.boundaries, "metadata" : obj.metadata}
                 return super().default(obj)
 
         with open(fileName, 'w', encoding='utf-8') as file:
@@ -749,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