bspy 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

bspy/_spline_intersection.py

@@ -67,12 +67,15 @@ def zeros_using_interval_newton(self):
         adjustedLeftStep = min(leftNewtonStep, rightNewtonStep) - 0.5 * epsilon
         adjustedRightStep = max(leftNewtonStep, rightNewtonStep) + 0.5 * epsilon
         if derivativeBounds[0] * derivativeBounds[1] >= 0.0:    # Refine interval
-           projectedLeftStep = max(0.0, adjustedLeftStep)
-           projectedRightStep = min(1.0, adjustedRightStep)
-           if projectedLeftStep <= projectedRightStep:
-               trimmedSpline = mySpline.trim(((projectedLeftStep, projectedRightStep),))
-               myZeros = refine(trimmedSpline, intervalSize, functionMax)
-           else:
+            projectedLeftStep = max(0.0, adjustedLeftStep)
+            projectedRightStep = min(1.0, adjustedRightStep)
+            if projectedLeftStep <= projectedRightStep:
+                if projectedRightStep - projectedLeftStep <= epsilon:
+                    myZeros = [0.5 * (projectedLeftStep + projectedRightStep)]
+                else:
+                    trimmedSpline = mySpline.trim(((projectedLeftStep, projectedRightStep),))
+                    myZeros = refine(trimmedSpline, intervalSize, functionMax)
+            else:
                return []
         else:                           # . . . or split as needed
             myZeros = []
@@ -206,7 +209,16 @@ def _refine_projected_polyhedron(interval):
     machineEpsilon = np.finfo(interval.spline.coefs.dtype).eps
     root = None
     intervals = []
-    scale = np.abs(interval.spline.range_bounds()).max()
+    scale = 0.0
+    # Go through each nDep of the spline, checking bounds.
+    for coefs in interval.spline.coefs:
+        coefsMin = coefs.min()
+        coefsMax = coefs.max()
+        if coefsMax < -evaluationEpsilon or coefsMin > evaluationEpsilon:
+            # No roots in this interval.
+            return root, intervals
+        scale = max(scale, abs(coefsMin), abs(coefsMax))
+    
     if scale < epsilon:
         # Return the bounds of the interval within which the spline is zero.
         root = (interval.intercept, interval.slope + interval.intercept)
@@ -349,9 +361,24 @@ def contours(self):
     Point = namedtuple('Point', ('d', 'det', 'onBoundary', 'uvw'))
     epsilon = np.sqrt(np.finfo(self.coefs.dtype).eps)
     evaluationEpsilon = np.sqrt(epsilon)
+
+    # Go through each nDep of the spline, checking bounds.
+    for coefs in self.coefs:
+        coefsMin = coefs.min()
+        coefsMax = coefs.max()
+        if coefsMax < -evaluationEpsilon or coefsMin > evaluationEpsilon:
+            # No contours for this spline.
+            return []
+
+    # Record self's original domain and then reparametrize self's domain to [0, 1]^nInd.
+    domain = self.domain().T
+    self = self.reparametrize(((0.0, 1.0),) * self.nInd)
+    
+    # Construct self's tangents and normal.
     tangents = []
     for nInd in range(self.nInd):
         tangents.append(self.differentiate(nInd))
+    normal = self.normal_spline((0, 1)) # We only need the first two indices
 
     theta = np.sqrt(2) # Arbitrary starting value for theta (picked one in [0, pi/2] unlikely to be a stationary point)
     # Try different theta values until no border or turning points are degenerate.
@@ -363,7 +390,6 @@ def contours(self):
         abort = False
 
         # Construct the turning point determinant.
-        normal = self.normal_spline((0, 1)) # We only need the first two indices
         turningPointDeterminant = normal.dot((cosTheta, sinTheta))
 
         # Find intersections with u and v boundaries.
@@ -478,6 +504,20 @@ def contours(self):
     # (3) Take all the points found in Step (1) and Step (2) and order them by distance in the theta direction from the origin.
     points.sort()
 
+    # Extra step not in the paper: Add a panel between two consecutive turning points to uniquely determine contours between them.
+    if len(points) > 1:
+        i = 0
+        previousPoint = points[i]
+        while i < len(points) - 1:
+            i += 1
+            point = points[i]
+            if not previousPoint.onBoundary and not point.onBoundary and point.d - previousPoint.d > epsilon:
+                # We have two consecutive turning points on separate panels.
+                # Insert a panel in between them, with the uvw value of None, since there is no zero associated.
+                points.insert(i, Point(0.5 * (previousPoint.d + point.d), 0.0, False, None))
+                i += 1
+            previousPoint = point
+
     # (4) Initialize an ordered list of contours. No contours will be on the list at first.
     currentContourPoints = [] # Holds contours currently being identified
     contourPoints = [] # Hold contours already identified
@@ -523,29 +563,34 @@ def contours(self):
             # the list. Go back to Step (5).
             # First, construct panel, whose zeros lie along the panel boundary, u * cosTheta + v * sinTheta - d = 0.
             panel.coefs[self.nDep] -= point.d
-            # Split panel below and above the known zero point.
-            # This avoids extra computation and the high-zero at the known zero point.
-            panelPoints = [point.uvw]
-            # To split the panel, we need to determine the offset from the point.
-            # Since the objective function (self) is zero and its derivative is zero at the point,
-            # we use second derivatives to determine when the objective function will likely grow 
-            # evaluationEpsilon above zero again.
-            wrt = [0] * self.nInd
-            wrt[0] = 2
-            selfUU = self.derivative(wrt, point.uvw)
-            wrt[0] = 1
-            wrt[1] = 1
-            selfUV = self.derivative(wrt, point.uvw)
-            wrt[0] = 0
-            wrt[1] = 2
-            selfVV = self.derivative(wrt, point.uvw)
-            offset = np.sqrt(2.0 * evaluationEpsilon / \
-                np.linalg.norm(selfUU * sinTheta * sinTheta - 2.0 * selfUV * sinTheta * cosTheta + selfVV * cosTheta * cosTheta))
-            # Now, we can find the zeros of the split panel, checking to ensure each panel is within bounds first.
-            if point.uvw[0] + sinTheta * offset < 1.0 - epsilon and epsilon < point.uvw[1] - cosTheta * offset:
-                panelPoints += panel.trim(((point.uvw[0] + sinTheta * offset, 1.0), (0.0, point.uvw[1] - cosTheta * offset)) + ((None, None),) * (self.nInd - 2)).zeros()
-            if epsilon < point.uvw[0] - sinTheta * offset and point.uvw[1] + cosTheta * offset < 1.0 - epsilon:
-                panelPoints += panel.trim(((0.0, point.uvw[0] - sinTheta * offset), (point.uvw[1] + cosTheta * offset, 1.0)) + ((None, None),) * (self.nInd - 2)).zeros()
+
+            if point.uvw is None:
+                # For an inserted panel between two consecutive turning points, just find zeros along the panel.
+                panelPoints = panel.zeros()
+            else:
+                # Split panel below and above the known zero point.
+                # This avoids extra computation and the high-zero at the known zero point.
+                panelPoints = [point.uvw]
+                # To split the panel, we need to determine the offset from the point.
+                # Since the objective function (self) is zero and its derivative is zero at the point,
+                # we use second derivatives to determine when the objective function will likely grow 
+                # evaluationEpsilon above zero again.
+                wrt = [0] * self.nInd
+                wrt[0] = 2
+                selfUU = self.derivative(wrt, point.uvw)
+                wrt[0] = 1
+                wrt[1] = 1
+                selfUV = self.derivative(wrt, point.uvw)
+                wrt[0] = 0
+                wrt[1] = 2
+                selfVV = self.derivative(wrt, point.uvw)
+                offset = np.sqrt(2.0 * evaluationEpsilon / \
+                    np.linalg.norm(selfUU * sinTheta * sinTheta - 2.0 * selfUV * sinTheta * cosTheta + selfVV * cosTheta * cosTheta))
+                # Now, we can find the zeros of the split panel, checking to ensure each panel is within bounds first.
+                if point.uvw[0] + sinTheta * offset < 1.0 - epsilon and epsilon < point.uvw[1] - cosTheta * offset:
+                    panelPoints += panel.trim(((point.uvw[0] + sinTheta * offset, 1.0), (0.0, point.uvw[1] - cosTheta * offset)) + ((None, None),) * (self.nInd - 2)).zeros()
+                if epsilon < point.uvw[0] - sinTheta * offset and point.uvw[1] + cosTheta * offset < 1.0 - epsilon:
+                    panelPoints += panel.trim(((0.0, point.uvw[0] - sinTheta * offset), (point.uvw[1] + cosTheta * offset, 1.0)) + ((None, None),) * (self.nInd - 2)).zeros()
             # Sort zero points by their position along the panel boundary (using vector orthogonal to its normal).
             panelPoints.sort(key=lambda uvw: uvw[1] * cosTheta - uvw[0] * sinTheta)
             # Add d back to prepare for next turning point.
@@ -553,7 +598,7 @@ def contours(self):
             # Go through panel points, adding them to existing contours, creating new ones, or closing old ones.
             adjustment = 0 # Adjust index after a contour point is added or removed.
             for i, uvw in zip(range(len(panelPoints)), panelPoints):
-                if np.allclose(point.uvw, uvw):
+                if point.uvw is not None and np.allclose(point.uvw, uvw):
                     if point.det > 0.0:
                         # Insert the turning point twice (second one appears before the first one in the points list).
                         currentContourPoints.insert(i, [True, point.uvw]) # True indicates end point
@@ -576,6 +621,9 @@ def contours(self):
     # Now we just need to create splines for those contours using the Spline.contour method.
     splineContours = []
     for points in contourPoints:
-        splineContours.append(bspy.spline.Spline.contour(self, points[1:])) # Skip endPoint boolean at start of points list
+        contour = bspy.spline.Spline.contour(self, points[1:]) # Skip endPoint boolean at start of points list
+        # Transform the contour to self's original domain.
+        contour.coefs = (contour.coefs.T * (domain[1] - domain[0]) + domain[0]).T
+        splineContours.append(contour)
     
     return splineContours

bspy/_spline_operations.py

@@ -573,10 +573,10 @@ def normal_spline(self, indices=None):
                     ord += order - 1 if ccm[i, j] and index != j else 0
                 newOrd = max(newOrd, ord)
         newOrder.append(newOrd)
-        uniqueKnots, counts = np.unique(knots, return_counts=True)
+        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] -= 1 # But not at the endpoints, which get reduced by one when taking the derivative
-        counts[-1] -= 1 # But not at the endpoints, which get reduced by one when taking the derivative
+        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))
         # 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.

bspy/spline.py

@@ -457,6 +457,22 @@ class Spline:
             indMap = [(*(mapping if _isIterable(mapping) else (mapping, mapping)), True) for mapping in indMap]
         return bspy._spline_operations.multiplyAndConvolve(self, other, indMap, productType)
 
+    def copy(self, metadata={}):
+        """
+        Create a copy of a spline.
+
+        Parameters
+        ----------
+        metadata : `dict`, optional
+            A dictionary of ancillary data to store with the spline. Default is {}.
+        
+        Returns
+        -------
+        spline : `Spline`
+            The spline copy.
+        """
+        return type(self)(self.nInd, self.nDep, self.order, self.nCoef, self.knots, self.coefs, self.accuracy, metadata)
+
     def cross(self, vector):
         """
         Cross product a spline with `nDep` of 2 or 3 by the given vector.
@@ -898,6 +914,30 @@ class Spline:
 
     @staticmethod
     def load(fileName, splineType=None):
+        """
+        Load a spline from the specified filename (full path).
+
+        Parameters
+        ----------
+        fileName : `string`
+            The full path to the file containing the spline. Can be a relative path.
+        
+        splineType : `type`, optional
+            The class type that should be created. It must be an instance of Spline (the default).
+        
+        Returns
+        -------
+        spline : `Spline`
+            The loaded spline.
+
+        See Also
+        --------
+        `save` : Save a spline to the specified filename (full path).
+
+        Notes
+        -----
+        Uses numpy's load function.
+        """
         kw = np.load(fileName)
         order = kw["order"]
         nInd = len(order)
@@ -1094,6 +1134,22 @@ class Spline:
         return bspy._spline_domain.reparametrize(self, newDomain)
 
     def save(self, fileName):
+        """
+        Save a spline to the specified filename (full path).
+
+        Parameters
+        ----------
+        fileName : `string`
+            The full path to the file containing the spline. Can be a relative path.
+        
+        See Also
+        --------
+        `load` : Load a spline from the specified filename (full path).
+
+        Notes
+        -----
+        Uses numpy's savez function. Accuracy and metadata are not saved.
+        """
         kw = {}
         kw["order"] = order=np.array(self.order, np.int32)
         for i in range(len(self.knots)):

{bspy-1.2.1.dist-info → bspy-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 1.2.1
+Version: 1.2.3
 Summary: Library for manipulating and rendering non-uniform b-splines
 Home-page: http://github.com/ericbrec/bspy
 Author: Eric Brechner

{bspy-1.2.1.dist-info → bspy-1.2.3.dist-info}/RECORD

@@ -2,14 +2,14 @@ bspy/__init__.py,sha256=XRBelbYtbhB6AWKh8DTsWVMDIteVxUm7Cf_S1fkqeEs,851
 bspy/_spline_domain.py,sha256=29_Mp0bn9_8z4ltu__DG9_NZuCiSuol0tRgAeIuzXZI,27826
 bspy/_spline_evaluation.py,sha256=i0qPy6UNe1MeoCOxF5LjTtloP6HUnxtxPHseAUAlmJU,6376
 bspy/_spline_fitting.py,sha256=NKNUfHfHYkQLlK_4i5oF7MIS59wrCqVKkPXHDcDGwIc,20552
-bspy/_spline_intersection.py,sha256=-KrbgKY4Nqnz7PAQg53kjwKEjHIALrMJI5F8QgbgW8g,30801
-bspy/_spline_operations.py,sha256=mkp1FeFNRDRyWln6-9Z0GBHZUB9FnXYwjpJWYHccs5U,35722
+bspy/_spline_intersection.py,sha256=olDQpLohlF6DhNshMY0kriitlypXHNVXPcMcY3NUnGs,33110
+bspy/_spline_operations.py,sha256=8VIVLGgYln7lLplgVBpnMVHMWbjigvir-LHE8tusZ-A,35715
 bspy/bspyApp.py,sha256=UxmNp_IGaG7gMVexUmA7YfuwX5iuMBr7ibW3DRan8R8,14524
 bspy/drawableSpline.py,sha256=Ha7wh__aRTpGTr3cEDG49SeAyRrKtfMUQYkEZ3w9OJw,17004
-bspy/spline.py,sha256=Rs-YcOF4MU_Y46AboT2OH24XNIMXRMG21GCFtu0Sco0,57454
+bspy/spline.py,sha256=WIPhSQu09laxQdtjpp4XDO8RscYRin4hF8ERVHLeE1o,59087
 bspy/splineOpenGLFrame.py,sha256=77rikAbAood76cf5w1Idj7wciTwPV-Bn-yGSuRFvlJM,60616
-bspy-1.2.1.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-1.2.1.dist-info/METADATA,sha256=kYsWQUqTFTBZKz6Tq6Re9Fu0QvXaOKqr-vUl4OLrxDw,3777
-bspy-1.2.1.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
-bspy-1.2.1.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-1.2.1.dist-info/RECORD,,
+bspy-1.2.3.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-1.2.3.dist-info/METADATA,sha256=uEuJAnmqnP85Zs8qInKp4JzRYPo_GTp7OJ08bisn9No,3777
+bspy-1.2.3.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+bspy-1.2.3.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-1.2.3.dist-info/RECORD,,

{bspy-1.2.1.dist-info → bspy-1.2.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.0)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-any