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

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)) 
     
@@ -105,9 +113,9 @@ def confine(self, range_bounds):
     intersections.sort(key=lambda intersection: intersection[0])
 
     # Remove repeat points at start and end.
-    if intersections[1][0] - intersections[0][0] < epsilon:
+    while intersections[1][0] - intersections[0][0] < epsilon:
         del intersections[1]
-    if intersections[-1][0] - intersections[-2][0] < epsilon:
+    while intersections[-1][0] - intersections[-2][0] < epsilon:
         del intersections[-2]
 
     # Insert order-1 knots at each intersection point.
@@ -116,9 +124,9 @@ def confine(self, range_bounds):
         if unique[ix] == knot:
             count = (order - 1) - counts[ix]
             if count > 0:
-                spline = spline.insert_knots(([knot] * count,))
+                spline = spline.insert_knots(((knot, count),))
         else:
-            spline = spline.insert_knots(([knot] * (order - 1),))
+            spline = spline.insert_knots(((knot, order - 1),))
 
     # Go through the boundary points, assigning boundary coefficients, interpolating between boundary points, 
     # and removing knots and coefficients where the curve stalls.
@@ -630,79 +638,90 @@ def multiplyAndConvolve(self, other, indMap = None, productType = 'S'):
 
     return type(self)(nInd, nDep, order, nCoef, knots, coefs, self.metadata)
 
-# Return a matrix of booleans whose [i,j] value indicates if self's partial wrt variable i depends on variable j. 
-def _cross_correlation_matrix(self):
-    ccm = np.empty((self.nInd, self.nInd), bool)
-    for i in range(self.nInd - 1):
-        tangent = self.differentiate(i)
-        totalCoefs = tangent.coefs.size // tangent.nDep
-        ccm[i, i] = True
-        for j in range(i + 1, self.nInd):
-            coefs = np.moveaxis(tangent.coefs, (0, j + 1), (-1, -2))
-            coefs = coefs.reshape(totalCoefs // tangent.nCoef[j], tangent.nCoef[j], tangent.nDep)
-            match = True
-            for row in coefs:
-                first = row[0]
-                for point in row[1:]:
-                    match = np.allclose(point, first)
-                    if not match:
-                        break
-                if not match:
-                    break
-            ccm[i, j] = ccm[j, i] = not match
-    ccm[-1, -1] = True
-    return ccm
-
 def normal_spline(self, indices=None):
-    if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be one less than the number of dependent variables.")
+    if abs(self.nInd - self.nDep) != 1: raise ValueError("The number of independent variables must be different than the number of dependent variables.")
 
-    # Construct order and knots for generalized cross product of the tangent space.
+    # Construct order, nCoef, knots, and sample values for generalized cross product of the tangent space.
     newOrder = []
     newKnots = []
     uvwValues = []
     nCoefs = []
     totalCoefs = [1]
-    ccm = _cross_correlation_matrix(self)
-    for i, (order, knots) in enumerate(zip(self.order, self.knots)):
-        # First, calculate the order of the normal for this independent variable.
+    for nInd in range(self.nInd):
+        knots = None
+        counts = None
+        maxOrder = 0
+        maxMap = []
+        # First, collect the order, knots, and number of relevant columns for this independent variable.
+        for row in self.block:
+            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
+                        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:
+                                counts[ix] = max(counts[ix], count + maxOrder - order)
+                            else:
+                                knots = np.insert(knots, ix, knot)
+                                counts = np.insert(counts, ix, count + maxOrder - order)
+                    else:
+                        knots = k
+                        counts = c
+                        maxOrder = order
+                        maxMap = map
+                  
+                    break
+
+        # 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.
-        newOrd = 0
         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.  
-            for j in range(self.nInd):
-                newOrd += order - 1 if ccm[i, j] else 0
+            # so long as that tangent contains the independent variable.
+            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).
-            for index in range(self.nInd) if indices is None else indices:
+            order = 0
+            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 != i else 1
+                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 j in range(self.nInd):
-                    ord += order - 1 if ccm[i, j] and index != j else 0
-                newOrd = max(newOrd, ord)
-        newOrder.append(newOrd)
-        uniqueKnots, counts = np.unique(knots[order - 1:self.nCoef[i] + 1], return_counts=True)
-        counts += newOrd - order + 1 # Because we're multiplying all the tangents, the knot elevation is one more
-        counts[0] = newOrd # But not at the endpoints, which are full order as usual
-        counts[-1] = newOrd # But not at the endpoints, which are full order as usual
-        newKnots.append(np.repeat(uniqueKnots, counts))
+                for ind in maxMap:
+                    ord += maxOrder - 1 if index != ind else 0
+                order = max(order, ord)
+        
+        # Now, record the order of this independent variable and adjust the knot counts.
+        newOrder.append(order)
+        counts += order - maxOrder + 1 # Because we're multiplying all the tangents, the knot elevation is one more
+        counts[0] = order # But not at the endpoints, which are full order as usual
+        counts[-1] = order # But not at the endpoints, which are full order as usual
+        newKnots.append(np.repeat(knots, counts))
+        
         # Also calculate the total number of coefficients, capturing how it progressively increases, and
         # using that calculation to span uvw from the starting knot to the end for each variable.
         nCoef = len(newKnots[-1]) - newOrder[-1]
         totalCoefs.append(totalCoefs[-1] * nCoef)
-        knotAverages = bspy.Spline(1, 0, [newOrd], [nCoef], [newKnots[-1]], []).greville()
+        knotAverages = bspy.Spline(1, 0, [order], [nCoef], [newKnots[-1]], []).greville()
         for iKnot in range(1, len(knotAverages) - 1):
             if knotAverages[iKnot] == knotAverages[iKnot + 1]:
                 knotAverages[iKnot] = 0.5 * (knotAverages[iKnot - 1] + knotAverages[iKnot])
                 knotAverages[iKnot + 1] = 0.5 * (knotAverages[iKnot + 1] + knotAverages[iKnot + 2])
         uvwValues.append(knotAverages)
         nCoefs.append(nCoef)
+    
+    # Construct data points for normal.
     points = []
-    ijk = [0 for order in self.order]
+    ijk = [0] * self.nInd
     for i in range(totalCoefs[-1]):
         uvw = [uvwValues[j][k] for j, k in enumerate(ijk)]
         points.append(self.normal(uvw, False, indices))
@@ -716,7 +735,7 @@ def normal_spline(self, indices=None):
     nCoefs.reverse()
     points = np.reshape(points, [nDep] + nCoefs)
     points = np.transpose(points, [0] + list(range(self.nInd, 0, -1)))
-    return bspy.Spline.least_squares(uvwValues, points, order = newOrder, knots = newKnots, metadata = self.metadata)
+    return bspy.Spline.least_squares(uvwValues, points, order = newOrder, knots = newKnots)
 
 def rotate(self, vector, angle):
     vector = np.atleast_1d(vector)

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
     -----
@@ -25,14 +28,15 @@ class Hyperplane(Manifold):
     Thus the dimension of the domain is one less than that of the range.
     """
 
-    maxAlignment = 0.99 # 1 - 1/10^2
-    """ If a shift of 1 in the normal direction of one manifold yields a shift of 10 in the tangent plane intersection, the manifolds are parallel."""
+    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):
-        self._normal = np.atleast_1d(np.array(normal))
-        self._point = np.atleast_1d(np.array(point))
-        self._tangentSpace = np.atleast_1d(np.array(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)
@@ -172,7 +176,7 @@ class Hyperplane(Manifold):
         -------
         point : `numpy.array`
         """
-        return np.dot(self._tangentSpace, domainPoint) + self._point
+        return np.dot(self._tangentSpace, np.atleast_1d(domainPoint)) + self._point
 
     def flip_normal(self):
         """
@@ -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,10 +5,15 @@ 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.01
-    """If two points are within 0.01 of each each other, they are coincident."""
+    minSeparation = 0.0001
+    """If two points are within minSeparation of each each other, they are coincident."""
 
     Crossing = namedtuple('Crossing', ('left','right'))
     Coincidence = namedtuple('Coincidence', ('left', 'right', 'alignment', 'transform', 'inverse', 'translation'))
@@ -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
 
@@ -113,7 +117,7 @@ class Solid:
         if boundary.manifold.range_dimension() != self.dimension: raise ValueError("Dimensions don't match")
         self.boundaries.append(boundary)
         if self.bounds is None:
-            self.bounds = boundary.bounds
+            self.bounds = boundary.bounds.copy()
         elif boundary.bounds is None:
             raise ValueError("Mix of infinite and bounded boundaries")
         else:
@@ -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:
@@ -509,25 +513,28 @@ class Solid:
                         slice.add_boundary(Boundary(right, domainSlice))
 
                 elif isinstance(intersection, Manifold.Coincidence):
-                    # First, intersect domain coincidence with the domain boundary.
-                    coincidence = left.intersection(boundary.domain)
-                    # Next, invert the domain coincidence (which will remove it) if this is a twin or if the normals point in opposite directions.
+                    # Intersect domain coincidence with the boundary's domain.
+                    left = left.intersection(boundary.domain)
+                    # Invert the domain coincidence (which will remove it) if this is a twin or if the normals point in opposite directions.
+                    #invertCoincidence = trimTwin and (isTwin or intersection.alignment < 0.0)
                     invertCoincidence = (trimTwin and isTwin) or intersection.alignment < 0.0
+                    # Create the coincidence to hold the trimmed and transformed domain coincidence (left).
+                    coincidence = Solid(left.dimension, left.containsInfinity)
                     if invertCoincidence:
                         coincidence.containsInfinity = not coincidence.containsInfinity
                     # Next, transform the domain coincidence from the boundary to the given manifold.
                     # Create copies of the manifolds and boundaries, since we are changing them.
-                    for i in range(len(coincidence.boundaries)):
-                        domainManifold = coincidence.boundaries[i].manifold
+                    for coincidenceBoundary in left.boundaries:
+                        coincidenceManifold = coincidenceBoundary.manifold
                         if invertCoincidence:
-                            domainManifold = domainManifold.flip_normal()
+                            coincidenceManifold = coincidenceManifold.flip_normal()
                         if isTwin:
-                            domainManifold = domainManifold.translate(-intersection.translation)
-                            domainManifold = domainManifold.transform(intersection.inverse, intersection.transform.T)
+                            coincidenceManifold = coincidenceManifold.translate(-intersection.translation)
+                            coincidenceManifold = coincidenceManifold.transform(intersection.inverse, intersection.transform.T)
                         else:
-                            domainManifold = domainManifold.transform(intersection.transform, intersection.inverse.T)
-                            domainManifold = domainManifold.translate(intersection.translation)
-                        coincidence.boundaries[i] = Boundary(domainManifold, coincidence.boundaries[i].domain)
+                            coincidenceManifold = coincidenceManifold.transform(intersection.transform, intersection.inverse.T)
+                            coincidenceManifold = coincidenceManifold.translate(intersection.translation)
+                        coincidence.add_boundary(Boundary(coincidenceManifold, coincidenceBoundary.domain))
                     # Finally, add the domain coincidence to the list of coincidences.
                     coincidences.append((invertCoincidence, coincidence))