bspy 1.2.2__tar.gz → 1.2.4__tar.gz

{bspy-1.2.2 → bspy-1.2.4}/PKG-INFO

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

{bspy-1.2.2 → bspy-1.2.4}/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 = []
@@ -215,8 +218,9 @@ def _refine_projected_polyhedron(interval):
             # No roots in this interval.
             return root, intervals
         scale = max(scale, abs(coefsMin), abs(coefsMax))
-    
-    if scale < epsilon:
+    newScale = scale * interval.scale
+
+    if newScale < evaluationEpsilon:
         # Return the bounds of the interval within which the spline is zero.
         root = (interval.intercept, interval.slope + interval.intercept)
     else:
@@ -262,7 +266,6 @@ def _refine_projected_polyhedron(interval):
                 domain.append(xInterval)
         
         if domain is not None:
-            newScale = scale * interval.scale
             domain = np.array(domain).T
             width = domain[1] - domain[0]
             newSlope = np.multiply(width, interval.slope)
@@ -270,10 +273,9 @@ def _refine_projected_polyhedron(interval):
             # one iteration past being less than sqrt(machineEpsilon) or simply less than epsilon.
             if interval.atMachineEpsilon or newSlope.max() < epsilon:
                 newIntercept = np.multiply(domain[0], interval.slope) + interval.intercept
-                root = newIntercept + 0.5 * newSlope
                 # Double-check that we're at an actual zero (avoids boundary case).
-                if newScale * np.linalg.norm(spline(0.5 * (domain[0] + domain[1]))) >= evaluationEpsilon:
-                    root = None
+                if newScale * np.linalg.norm(spline(0.5 * (domain[0] + domain[1]))) < evaluationEpsilon:
+                    root = (newIntercept, newIntercept + newSlope)
             else:
                 # Split domain in dimensions that aren't decreasing in width sufficiently.
                 domains = [domain]
@@ -296,7 +298,10 @@ def _refine_projected_polyhedron(interval):
                     newIntercept = np.multiply(domain[0], interval.slope) + interval.intercept
                     for i, w in zip(range(spline.nInd), width):
                         if w < machineEpsilon:
-                            domain[1, i] = domain[0, i] + machineEpsilon
+                            if domain[0, i] > machineEpsilon:
+                                domain[0, i] = domain[1, i] - machineEpsilon
+                            else:
+                                domain[1, i] = domain[0, i] + machineEpsilon
                     newDomain = [None if s < epsilon else (0.0, 1.0) for s in newSlope]
                     intervals.append(Interval(spline.trim(domain.T).reparametrize(newDomain), newScale, newSlope, newIntercept, epsilon, np.dot(newSlope, newSlope) < machineEpsilon))
   
@@ -330,25 +335,48 @@ def zeros_using_projected_polyhedron(self, epsilon=None):
                 nextIntervals += newIntervals
         intervals = nextIntervals
             
-    # Check for duplicate roots. We test for a distance between roots of 2*epsilon to account for a left vs. right sided limit.
-    i = 0
-    rootCount = len(roots)
-    while i < rootCount:
-        root = roots[i]
-        j = i + 1
-        while j < rootCount:
-            if np.linalg.norm(root - roots[j]) < 2.0 * epsilon:
-                # For a duplicate root, return the average value.
-                roots[i] = 0.5 * (root + roots[j])
-                roots.pop(j)
-                rootCount -= 1
-            else:
-                j += 1
-        i += 1
+    # Connect intervals of zeros that overlap.
+    gotOverlap = True
+    while gotOverlap:
+        gotOverlap = False
+        i = 0
+        rootCount = len(roots)
+        while i < rootCount:
+            iRoot = roots[i]
+            root = (iRoot[0].copy(), iRoot[1].copy()) # Temporary storage for expanded interval
+            j = i + 1
+            # Check for overlap with other intervals.
+            while j < rootCount:
+                jRoot = roots[j]
+                overlapped = True
+                for d in range(self.nInd):
+                    if iRoot[0][d] < jRoot[1][d] + epsilon and jRoot[0][d] < iRoot[1][d] + epsilon:
+                        root[0][d] = min(iRoot[0][d], jRoot[0][d])
+                        root[1][d] = max(iRoot[1][d], jRoot[1][d])
+                    else:
+                        overlapped = False
+                        break
+                if overlapped:
+                    # For an overlapped interval, expand original interval and toss overlapping interval.
+                    iRoot[0][:] = root[0]
+                    iRoot[1][:] = root[1]
+                    roots.pop(j)
+                    rootCount -= 1
+                    gotOverlap = True
+                else:
+                    j += 1
+            i += 1
+    
+    # Collapse intervals to points as appropriate.
+    for i in range(len(roots)):
+        iRoot = roots[i]
+        # If interval is small, just return a single value (not an interval).
+        if True: # Skip small interval test, since it's typically a shallow point, not a flat section. np.linalg.norm(iRoot[1] - iRoot[0]) < 2.0 * epsilon:
+            roots[i] = 0.5 * (iRoot[0] + iRoot[1])
 
     # Sort roots if there's only one dimension.
     if self.nInd == 1:
-        roots.sort(key=lambda root: root[0] if type(root) is tuple else root)
+        roots.sort(key=lambda root: root[0] if isinstance(root, tuple) else root)
 
     return roots
 
@@ -367,9 +395,15 @@ def contours(self):
             # 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.
@@ -381,7 +415,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.
@@ -496,6 +529,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
@@ -541,29 +588,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.
@@ -571,7 +623,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
@@ -594,6 +646,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-1.2.2 → bspy-1.2.4}/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-1.2.2 → bspy-1.2.4}/bspy.egg-info/PKG-INFO

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

{bspy-1.2.2 → bspy-1.2.4}/setup.cfg

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

{bspy-1.2.2 → bspy-1.2.4}/tests/test_bspy.py

@@ -592,7 +592,7 @@ def test_blossom():
         maxError = max(maxError, np.linalg.norm(myCurve.coefs[:,i] - coef))
     assert maxError <= np.finfo(float).eps
 
-def test_contour():
+def test_contours():
     maxError = 0.0
     F = lambda x: (x[0] - x[2], x[1] - x[3], x[0]*x[0] + x[1]*x[1]/9.0 - 1.0 + x[2]*x[2] + x[3]*x[3]/9.0 - 1.0)
     spline = bspy.Spline.contour(F, ((1.0, 0.0, 1.0, 0.0), (0.0, 3.0, 0.0, 3.0)))
@@ -601,6 +601,41 @@ def test_contour():
         maxError = max(maxError, np.linalg.norm(F(x)))
     assert maxError <= 0.05
 
+    maxError = 0.0
+    order = 3
+    knots = [0.0] * order + [1.0] * order
+    nCoef = len(knots) - order
+    spline = bspy.Spline(2, 1, (order, order), (nCoef, nCoef), (knots, knots), \
+        (((1.0, 0.0, 1.0), (0.0, -5.0, 0.0), (1.0, 0.0, 1.0)),))
+    contours = spline.contours()
+    for contour in contours:
+        for t in np.linspace(0.0, 1.0, 11):
+            uvw = contour((t,))
+            maxError = max(maxError, np.linalg.norm(spline(uvw)))
+    assert maxError <= 0.05
+
+    return # Comment this line to run the following lengthy test
+
+    maxError = 0.0
+    F = lambda u , v : (u ** 2 + (v - 3/4) ** 2 - 1/25) * \
+        ((u - 2/5) ** 2 + (v - 3/5) ** 2 - 1/25) * \
+        (u ** 2 + (v - 3/2) ** 2 - 25/16) * \
+        ((u - 1) ** 2 + (v - 3/10) ** 2 - 1/25)
+    order = 9
+    knots = [0.0] * order + [1.0] * order
+    nCoef = order
+    points = []
+    for u in np.linspace(0.0, 1.0, nCoef):
+        for v in np.linspace(0.0, 1.0, nCoef):
+            points.append((u, v, F(u, v)))
+    spline = bspy.Spline.least_squares(2, 1, (order, order), points, (knots, knots))
+    contours = spline.contours()
+    for contour in contours:
+        for t in np.linspace(0.0, 1.0, 11):
+            uvw = contour((t,))
+            maxError = max(maxError, np.linalg.norm(spline(uvw)))
+    assert maxError <= 0.05
+
 def test_contract():
     maxError = 0.0
     contracted = mySurface.contract([.25, None])
@@ -804,32 +839,14 @@ def test_integral():
     assert maxError <= np.finfo(float).eps
 
 def test_intersect():
+
+    return # Comment this line to run the following additional really lengthy test
+
     maxError = 0.0
     F = lambda u , v : (u ** 2 + (v - 3/4) ** 2 - 1/25) * \
         ((u - 2/5) ** 2 + (v - 3/5) ** 2 - 1/25) * \
         (u ** 2 + (v - 3/2) ** 2 - 25/16) * \
         ((u - 1) ** 2 + (v - 3/10) ** 2 - 1/25)
-
-    order = 9
-    knots = [0.0] * order + [1.0] * order
-    nCoef = order
-    points = []
-    for u in np.linspace(0.0, 1.0, nCoef):
-        for v in np.linspace(0.0, 1.0, nCoef):
-            points.append((u, v, F(u, v)))
-    spline = bspy.Spline.least_squares(2, 1, (order, order), points, (knots, knots))
-
-    return # Comment this line to run the following lengthy test
-
-    contours = spline.contours()
-    for contour in contours:
-        for t in np.linspace(0.0, 1.0, 11):
-            uvw = contour((t,))
-            maxError = max(maxError, np.linalg.norm(spline(uvw)))
-    assert maxError <= np.finfo(float).eps ** 0.2
-
-    return # Comment this line to run the following additional really lengthy test
-
     order = 9
     knots = [0.0] * order + [1.0] * order
     nCoef = order
@@ -1060,10 +1077,15 @@ def test_zeros():
         assert expectedRootCount == len(roots)
         for root in roots:
             value = spline(root)
-            assert np.dot(value, value) < tolerance
+            assert np.dot(value, value) < np.sqrt(tolerance)
 
     tolerance = 1.0e-14
 
+    spline = bspy.Spline(1, 1, (3,), (3,), [[0., 0., 0., 1., 1., 1.]], [[-1.2, -0.2,  0.8]], 0.0, {})
+    expectedRoots = (0.6,)
+    roots = spline.zeros()
+    check_1D_roots(expectedRoots, roots, tolerance)
+
     spline = bspy.Spline(1, 1, (4,), (4,), ((0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0),), ((1.0, -2.0, -2.0, 1.0),))
     expectedRoots = (0.12732200375003502, 0.8726779962499649)
     roots = spline.zeros()