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

bspy/spline_block.py

@@ -8,29 +8,38 @@ import bspy._spline_operations
 
 class SplineBlock:
     """
-    A class to represent and process an array-like collection of splines. 
-    Spline blocks are useful for efficiently manipulating and solving systems of equations with splines.
+    A class to process an array-like collection of splines that represent a system of equations. 
 
     Parameters
     ----------
-    block : an array-like collection of splines (may be a list of lists)
-        Splines in the same row are treated as if they are added together. 
+    block : an array-like collection of rows of splines (a list of lists)
+        The block of splines represents a system of equations. Splines in the same row are treated as if they are added together. 
         Each row need not have the same number of splines, but all splines in a row must have the same 
         number of dependent variables (same nDep). Corresponding independent variables must have the same domain.
 
-        For example, if F is a spline with nInd = 3 and nDep = 2, G is a spline with nInd = 1 and nDep = 2, 
-        and h is a spline with nInd = 2 and nDep = 1, then [[F, G], [h]] is a valid block (total nDep is 3 
-        and max nInd is 4).
+        For example, say you wanted to represent the system: 
+        F(u, v, w) + G(u) = 0, h(u, v) = 0, where F and G are 2D vector functions and h is a scalar function. 
+        After fitting F, G, and h with splines, you'd form the following spline block: [[F, G], [h]].
+
+        You may optionally supply maps for independent variables to represent complex systems of equations. For example, 
+        say you wanted to represent a similar systems as before, but with a more complicated relationship between the 
+        independent variables: F(u, v, w) + G(v, s) = 0, h(u, t, w, s) = 0. 
+        First, you'd assign consecutive indices for each variable starting at zero. For example, (s, t, u, v, w) could be indexed as (0, 1, 2, 3, 4, 5). 
+        Then, you'd provide maps for each spline's independent variables to form the following spline block: 
+        [[([3, 4, 5], F), ([4, 0], G)], [([3, 1, 5, 0], h)]]. 
+        Notice how each spline from the first example is replaced by a (map, spline) tuple in the complex second example.
     """
 
+    @staticmethod
+    def _map_args(map, args):
+        return [arg[map] if isinstance(arg, np.ndarray) else [arg[index] for index in map] for arg in args]
+    
     def _block_evaluation(self, returnShape, splineFunction, args):
         value = np.zeros(returnShape, self.coefsDtype)
         nDep = 0
         for row in self.block:
-            nInd = 0
-            for spline in row:
-                value[nDep:nDep + spline.nDep] += splineFunction(spline, *[arg[nInd:nInd + spline.nInd] for arg in args])
-                nInd += spline.nInd
+            for map, spline in row:
+                value[nDep:nDep + spline.nDep] += splineFunction(spline, *SplineBlock._map_args(map, args))
             nDep += spline.nDep
         return value
     
@@ -38,49 +47,69 @@ class SplineBlock:
         newBlock = []
         for row in self.block:
             newRow = []
-            nInd = 0
-            for spline in row:
-                newRow.append(splineFunction(spline, *[arg[nInd:nInd + spline.nInd] for arg in args]))
-                nInd += spline.nInd
+            for map, spline in row:
+                newRow.append((map, splineFunction(spline, *SplineBlock._map_args(map, args))))
             newBlock.append(newRow)
         return SplineBlock(newBlock)
     
     def __init__(self, block):
         if isinstance(block, bspy.spline.Spline):
-            self.block = [[block]]
-        elif isinstance(block[0], bspy.spline.Spline):
-            self.block = [block]
-        else:
-            self.block = block
+            block = [[block]]
+        elif isinstance(block[0], bspy.spline.Spline) or (len(block) > 1 and isinstance(block[1], bspy.spline.Spline)):
+            block = [block]
+
+        self.block = []
         self.nInd = 0
         self.nDep = 0
         self.knotsDtype = None
         self.coefsDtype = None
         self.size = 0
-        self._domain = []
-        for row in self.block:
+        domain = {}
+        for row in block:
             rowInd = 0
             rowDep = 0
-            for spline in row:
+            indSet = set()
+            newRow = []
+            for entry in row:
+                if isinstance(entry, bspy.spline.Spline):
+                    spline = entry
+                    map = list(range(rowInd, rowInd + spline.nInd))
+                else:
+                    (map, spline) = entry
+                    map = list(map) # Convert to list and make a copy
+                rowInd += spline.nInd
                 if rowDep == 0:
                     rowDep = spline.nDep
-                    if self.nInd == 0:
+                    if self.nDep == 0:
                         self.knotsDtype = spline.knots[0].dtype
                         self.coefsDtype = spline.coefs.dtype
                 elif rowDep != spline.nDep:
                     raise ValueError("All splines in the same row must have the same nDep")
                 d = spline.domain()
-                for i in range(rowInd, rowInd + spline.nInd):
-                    ind = i - rowInd
-                    if i < self.nInd:
-                        if self._domain[i][0] != d[ind, 0] or self._domain[i][1] != d[ind, 1]:
+                for ind, i in enumerate(map):
+                    if i in indSet:
+                        raise ValueError(f"Multiple splines in the same row map to independent variable {i}")
+                    else:
+                        indSet.add(i)
+                    if i in domain:
+                        if domain[i][0] != d[ind, 0] or domain[i][1] != d[ind, 1]:
                             raise ValueError("Domains of independent variables must match")
                     else:
-                        self._domain.append(d[ind])
-                rowInd += spline.nInd
-            self.nInd = max(self.nInd, rowInd)
-            self.nDep += rowDep
-            self.size += len(row)
+                        domain[i] = d[ind]
+                newRow.append((map, spline))
+            
+            if rowDep > 0:
+                self.nDep += rowDep
+                self.size += len(row)
+                self.block.append(newRow)
+
+        self.nInd = len(domain)
+        self._domain = []
+        for i in range(self.nInd):
+            if i in domain:
+                self._domain.append(domain[i])
+            else:
+                raise ValueError(f"Block is missing independent variable {i}")
         self._domain = np.array(self._domain, self.knotsDtype)
 
     def __call__(self, uvw):
@@ -126,7 +155,26 @@ class SplineBlock:
         block : `SplineBlock`
             The contracted spline block.
         """
-        return self._block_operation(bspy._spline_operations.contract, (uvw,))
+        # First, remap the remaining independent variables (the ones not fixed by uvw).
+        remap = []
+        newIndex = 0
+        for value in uvw:
+            if value is None:
+                remap.append(newIndex)
+                newIndex += 1
+            else:
+                remap.append(None)
+
+        # Next, rebuild the block with contracted splines.
+        newBlock = []
+        for row in self.block:
+            newRow = []
+            for map, spline in row:
+                spline = spline.contract([uvw[index] for index in map])
+                map = [remap[ind] for ind in map if uvw[ind] is None]
+                newRow.append((map, spline))
+            newBlock.append(newRow)
+        return SplineBlock(newBlock)
 
     def derivative(self, with_respect_to, uvw):
         """
@@ -190,12 +238,11 @@ class SplineBlock:
             The value of the spline block's Jacobian at the given parameter values. The shape of the return value is (nDep, nInd).
         """
         jacobian = np.zeros((self.nDep, self.nInd), self.coefsDtype)
+        uvw = np.atleast_1d(uvw)
         nDep = 0
         for row in self.block:
-            nInd = 0
-            for spline in row:
-                jacobian[nDep:nDep + spline.nDep, nInd:nInd + spline.nInd] += spline.jacobian(uvw[nInd:nInd + spline.nInd])
-                nInd += spline.nInd
+            for map, spline in row:
+                jacobian[nDep:nDep + spline.nDep, map] += spline.jacobian(uvw[map])
             nDep += spline.nDep
         return jacobian
 
@@ -293,6 +340,76 @@ class SplineBlock:
         """
         return self._block_operation(bspy._spline_domain.reparametrize, (newDomain,))
 
+    def split(self, minContinuity = 0, breaks = None):
+        """
+        Split a spline block into separate pieces.
+
+        Parameters
+        ----------
+        minContinuity : `int`, optional
+            The minimum expected continuity of each spline block piece. The default is zero, for C0 continuity.
+
+        breaks : `iterable` of length `nInd` or `None`, optional
+            An iterable that specifies the breaks at which to separate the spline block. 
+            len(breaks[ind]) == 0 if there the spline block isn't separated for the `ind` independent variable. 
+            If breaks is `None` (the default), the spline block will only be separated at discontinuities.
+
+        Returns
+        -------
+        splineBlockArray : array of `SplineBlock`
+            A array of spline blocks with nInd dimensions containing the spline block pieces. 
+        """
+        if minContinuity < 0: raise ValueError("minContinuity must be >= 0")
+        if self.nInd < 1: return self
+
+        # Step 1: Determine all the breaks.
+        breakList = [set() for i in range(self.nInd)]
+        if breaks is not None:
+            if len(breaks) != self.nInd: raise ValueError("Invalid breaks")
+            for breakSet, knots, domain in zip(breakList, breaks, self.domain()):
+                for knot in knots:
+                    if knot < domain[0] or knot > domain[1]: raise ValueError("Break outside of domain")
+                    if domain[0] < knot < domain[1]:
+                        breakSet.add(knot)
+
+        for row in self.block:
+            for map, spline in row:
+                for i, order, knots in zip(range(spline.nInd), spline.order, spline.knots):
+                    unique, counts = np.unique(knots[order:], return_counts=True) # Skip left end
+                    for knot, count in zip(unique, counts):
+                        if count > order - 1 - minContinuity:
+                            breakList[map[i]].add(knot)
+
+        # Step 2: Determine the size and shape of the splineBlockArray and allocate it.
+        size = 1
+        shape = []
+        for i, breakSet in enumerate(breakList):
+            count = len(breakSet)
+            shape.insert(0, count) # We build the transpose due to indexing arithmetic
+            size *= count
+            breakList[i] = sorted(breakSet)
+        splineBlockArray = np.empty(size, object)
+
+        # Step 3: Split up the spline block.
+        domain = self.domain().copy()
+        for i in range(size):
+            index = i
+            for j, knots in enumerate(breakList):
+                count = len(knots)
+                ix = index % count
+                index = index // count
+                if domain[j, 1] != knots[ix]:
+                    if ix == 0:
+                        domain[j, 0] = self._domain[j, 0]
+                    else:
+                        domain[j, 0] = domain[j, 1]
+                    domain[j, 1] = knots[ix]
+
+            splineBlockArray[i] = self.trim(domain)
+        
+        # Step 4: Reshape and transpose splineBlockArray
+        return splineBlockArray.reshape(shape).T
+
     def trim(self, newDomain):
         """
         Trim the domain of a spline block.

bspy/viewer.py

@@ -144,15 +144,19 @@ class Viewer(tk.Tk):
             solid = spline
             if solid.dimension != 3:
                 return
-            if name is None:
-                name = "Solid"
-            iid = self.treeview.insert('', 'end', text=name, open=False)
+            if name is not None:
+                solid.metadata["Name"] = name
+            elif "Name" not in solid.metadata:
+                solid.metadata["Name"] = f"Solid({solid.dimension}, {solid.containsInfinity})"
+            iid = self.treeview.insert('', 'end', text=solid.metadata["Name"], open=False)
             self.splineList[iid] = solid
             self.solidList.append(solid)
             if draw:
                 self.treeview.selection_add(iid)
             for i, boundary in enumerate(solid.boundaries):
-                self.list(boundary, f"Boundary {i}", fillColor, lineColor, options, False, iid)
+                if "Name" not in boundary.manifold.metadata:
+                    boundary.manifold.metadata["Name"] = f"Boundary {i}"
+                self.list(boundary, None, fillColor, lineColor, options, False, iid)
         elif isinstance(spline, Boundary):
             boundary = spline
             if isinstance(boundary.manifold, Hyperplane):
@@ -167,15 +171,20 @@ class Viewer(tk.Tk):
                 spline = Spline(2, 3, (2, 2), (2, 2), 
                     np.array((uvMin, uvMin, uvMax, uvMax), np.float32).T,
                     np.array(((xyzMinMin, xyzMaxMin), (xyzMinMax, xyzMaxMax)), np.float32).T)
+                spline.metadata = boundary.manifold.metadata # Ensure the spline representing the hyperplane shares the same metadata
             elif isinstance(boundary.manifold, Spline):
                 spline = boundary.manifold
-            if not hasattr(spline, "cache"):
-                spline.cache = {}
-            spline.cache["trim"] = self.frame.tessellate2DSolid(boundary.domain)
+            tesselation = self.frame.tessellate2DSolid(boundary.domain)
+            if tesselation is not None:
+                if not hasattr(spline, "cache"):
+                    spline.cache = {}
+                spline.cache["trim"] = tesselation
             self.list(spline, name, fillColor, lineColor, options, draw, parentIID)
         else:
-            if "Name" not in spline.metadata:
-                spline.metadata["Name"] = f"Spline({spline.nInd}, {spline.nDep})" if name is None else name
+            if name is not None:
+                spline.metadata["Name"] = name
+            elif "Name" not in spline.metadata:
+                spline.metadata["Name"] = f"Spline({spline.nInd}, {spline.nDep})"
             if fillColor is not None:
                 spline.metadata["fillColor"] = fillColor
             if lineColor is not None:
@@ -264,7 +273,7 @@ class Viewer(tk.Tk):
         for item in self.treeview.selection():
             spline = self.splineList[item]
             if isinstance(spline, Spline):
-                coefs = spline.cache["coefs32"].T[:3]
+                coefs = spline.cache["xyzCoefs32"].T
                 coefsAxis = tuple(range(1, spline.nInd + 1))
                 if gotOne:
                     splineMin = np.minimum(splineMin, coefs.min(axis=coefsAxis))
@@ -277,7 +286,7 @@ class Viewer(tk.Tk):
             elif isinstance(spline, Solid):
                 for subitem in self.treeview.get_children(item):
                     spline = self.splineList[subitem]
-                    coefs = spline.cache["coefs32"].T[:3]
+                    coefs = spline.cache["xyzCoefs32"].T
                     coefsAxis = tuple(range(1, spline.nInd + 1))
                     if gotOne:
                         splineMin = np.minimum(splineMin, coefs.min(axis=coefsAxis))

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 4.2
+Version: 4.3
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
 Author-email: ericbrec@msn.com
 License: MIT
 Project-URL: Bug Tracker, http://github.com/ericbrec/BSpy/issues
-Keywords: opengl,bspline,B-spline,nub,tkinter
+Keywords: bspline,B-spline,nub,solid,solid modeling,geometry,csg,opengl,tkinter
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Environment :: Console
@@ -47,7 +47,9 @@ The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has
 
 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 represent and process an array-like collection of splines, including ones to compute the contours and zeros of a spline block, as well as a variety of methods to evaluate a spline block and its derivatives. Spline blocks are useful for efficiently manipulating and solving systems of equations with splines.
+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 [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 

bspy-4.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+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,,

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

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

bspy-4.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-bspy/__init__.py,sha256=ruWkrHgrjGFeB2uATnCNY-J9hpgK5R6vsXrtshBIFDk,1476
-bspy/_spline_domain.py,sha256=xbXOlRxFSwbM55dNiy6RpSOJsgHc1xD3hgACBxYiifk,33647
-bspy/_spline_evaluation.py,sha256=MQmF6hhxHXBEOWCSTGZOTmecP5uOn7VrI9Aj8NUCSb8,9622
-bspy/_spline_fitting.py,sha256=EbM_FI-QW5PjZKbpAF4r4dP8DZOLn8QX3dYvG9zzuFo,50753
-bspy/_spline_intersection.py,sha256=cFciLdc1wTFZuKixfWoOlN8PJhQHWt_nN6N9Wt4EMhw,65438
-bspy/_spline_operations.py,sha256=KNkWSg27jFjoewsaNqMfNLrMAD4MUQJvCkXOfQbEHmI,43088
-bspy/hyperplane.py,sha256=wngJw_9x358gf_S1O3sPqodnUx7HHdJunAp4ceOq7Fw,24605
-bspy/manifold.py,sha256=Ecrm7LjcfttOJ617mKMXdJSWqVxt2eToNvpq5skLliA,14255
-bspy/solid.py,sha256=E8iAcIFV5r_SrzcY_5UB0hKitE-bcrI0-dPzXcvD6iw,36763
-bspy/spline.py,sha256=Bt1WDF69ZYO--rz9Myclb26f0fDnr62q1NWYTxcwFvw,100398
-bspy/splineOpenGLFrame.py,sha256=ezPUyDr9QKF0KU7H6XjHL-HhN23ffC8KbxGhGgGJhQ0,95843
-bspy/spline_block.py,sha256=gfoK_-QVqQCrv9acDCkQf-deHZntjOw1VgyPWAxDWcU,14656
-bspy/viewer.py,sha256=S0yij3LwHIll0ZA-bZevpkNFYSzs41a5xb8EgpHTW_M,33760
-bspy-4.2.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-4.2.dist-info/METADATA,sha256=a7T__b4_Kyf9wKg7ba8_s_51FdKB-XgaQg0zLfLWGI8,6792
-bspy-4.2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-bspy-4.2.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-4.2.dist-info/RECORD,,