topologicpy 0.8.47__py3-none-any.whl → 0.8.48__py3-none-any.whl

topologicpy/CellComplex.py

@@ -193,6 +193,153 @@ class CellComplex():
         cells = Topology.Cells(cluster)
         return CellComplex.ByCells(cells, tolerance=tolerance)
 
+    @staticmethod
+    def ByDisjointedFaces(faces: list,
+                        minOffset: float = 0,
+                        maxOffset: float = 1.0,
+                        minCells: float = 2,
+                        maxCells: float = 10,
+                        maxAttempts: int = 100,
+                        patience: int = 5,
+                        transferDictionaries: bool = False,
+                        exclusive: bool = True,
+                        tolerance: float = 0.0001,
+                        silent: bool = False):
+        """
+        Creates a CellComplex from a list of disjointed faces. The algorithm expands the faces by an offset to find intersections before building cells.
+
+        Parameters
+        ----------
+        faces : list of topologic_core.Face
+            The linput ist of faces.
+        minOffset : float , optional
+            The minimum initial face offset to try. Default is 0.
+        maxOffset : float , optional
+            The final maximum face offset to try. Default is 1.0.
+        minCells : int , optional
+            The minimum number of cells to create. A CellComplex cannot have less than 2 cells. Default is 2.
+        maxCells : int , optional
+            The maximum number of cells to create. Default is 10.
+        maxAttempts : int , optional
+            The desired maximum number of attempts. Default is 100.
+        patience : int , optional
+            The desired number of attempts to wait with no change in the created number of cells. Default is 5.
+        transferDictionaries : bool , optional
+            If set to True, face dictionaries are inhertied. Default is False.
+        exclusive : bool , optional
+            Applies only if transferDictionaries is set to True. If set to True, only one source face contributes its dictionary to a target face. Default is True.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        topologic_core.CellComplex
+            The created CellComplex
+
+        """
+
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        def trim(cells, n):
+            volumes = [Cell.Volume(c) for c in cells]
+            return_cc = Helper.Sort(cells, volumes)
+            return_cc.reverse()
+            return return_cc[:n]
+
+        faces = [f for f in faces if Topology.IsInstance(f, "Face")]
+        if len(faces) == 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input list of faces does not contain any valid topologic faces. Returning None.")
+            return None
+        if len(faces) < 3:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input list of faces contains less than three topologic faces. Returning None.")
+            return None
+        if minOffset < 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minOffset parameter is less than 0. Returning None.")
+            return None
+        if minOffset > maxOffset:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minOffset parameter is greater than the input maxOffset parameter. Returning None.")
+            return None
+        if minCells < 2:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minCells parameter is less than 2. Returning None.")
+            return None
+        if minCells > maxCells:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input minCells parameter is greater than the input maxCells parameter. Returning None.")
+            return None
+        if maxAttempts <= 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input maxAttempts parameter is not greater than 0. Returning None.")
+            return None
+        if patience < 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input patience parameter is not greater than or equal to 0. Returning None.")
+            return None
+        if patience > maxAttempts:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: The input patience parameter is greater than the input maxAttempts parameter. Returning None.")
+            return None
+        cc = None
+        attempts = 0
+        increment = float(maxOffset) / float(maxAttempts)
+        cellComplexes = [] # List of all possible cellComplexes
+        patience_list = []
+        offset = minOffset
+        
+        while attempts < maxAttempts:
+            expanded_faces = [Face.ByOffset(f, offset=-offset) for f in faces]
+            try:
+                cc = CellComplex.ByFaces(expanded_faces, silent=True)
+                if Topology.IsInstance(cc, "cellComplex"):
+                    cells = Topology.Cells(cc)
+                    n_cells = len(cells)
+                    if minCells <= n_cells <= maxCells:
+                        cellComplexes.append(cc)
+                    elif n_cells > maxCells:
+                        cells = trim(cells, maxCells)
+                        try:
+                            new_cc = CellComplex.ByCells(cells)
+                            if Topology.IsInstance(new_cc, "CellComplex"):
+                                cellComplexes.append(new_cc)
+                        except:
+                            pass
+                    patience_list.append(n_cells)
+            except:
+                patience_list.append(0)
+            
+            if len(patience_list) >= patience:
+                if len(set(patience_list)) == 1 and not patience_list[0] == 0:
+                    if not silent:
+                        print("CellComplex.ByDisjointedFaces - Warning: Ran out of patience.")
+                    break
+                else:
+                    patience_list = []
+            attempts += 1
+            offset += increment
+
+        if len(cellComplexes) == 0:
+            if not silent:
+                print("CellComplex.ByDisjointedFaces - Error: Could not create a CellComplex. Consider revising the input parameters. Returning None.")
+            return None
+        n_cells = [len(Topology.Cells(c)) for c in cellComplexes] # Get the number of cells in each cellComplex
+        cellComplexes = Helper.Sort(cellComplexes, n_cells) # Sort the cellComplexes by their number of cells
+        for cc in cellComplexes:
+            cells = Topology.Cells(cc)
+        cc = cellComplexes[-1] # Choose the last cellComplex (the one with the most number of cells)
+        if transferDictionaries == True:
+            cc_faces = Topology.Faces(cc)
+            cc_faces = Topology.Inherit(targets=cc_faces, sources=faces, exclusive=exclusive, tolerance=tolerance, silent=silent)
+        return cc
+
     @staticmethod
     def ByFaces(faces: list, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Wire.py

@@ -870,6 +870,7 @@ class Wire():
                 edges.append(e)
             else:
                 if not silent:
+                    print("Wire.ByVertices - Warning: Degenerate edge. Skipping.")
                     curframe = inspect.currentframe()
                     calframe = inspect.getouterframes(curframe, 2)
                     print('caller name:', calframe[1][3])
@@ -885,6 +886,7 @@ class Wire():
                     curframe = inspect.currentframe()
                     calframe = inspect.getouterframes(curframe, 2)
                     print('caller name:', calframe[1][3])
+        
         if len(edges) < 1:
             if not silent:
                 print("Wire.ByVertices - Error: The number of edges is less than 1. Returning None.")
@@ -893,9 +895,21 @@ class Wire():
                 print('caller name:', calframe[1][3])
             return None
         elif len(edges) == 1:
+            if not silent:
+                print("Wire.ByVertices - Warning: The wire is made of only one edge.")
             wire = Wire.ByEdges(edges, orient=False, silent=silent)
         else:
             wire = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
+            if Topology.IsInstance(wire, "Edge"):
+                wire = Wire.ByEdges([wire], orient=False, silent=silent)
+        # Final Check
+        if not Topology.IsInstance(wire, "Wire"):
+            if not silent:
+                print("Wire.ByVertices - Error: Could not create a wire. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
         return wire
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.47'
+__version__ = '0.8.48'

{topologicpy-0.8.47.dist-info → topologicpy-0.8.48.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.47
+Version: 0.8.48
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.47.dist-info → topologicpy-0.8.48.dist-info}/RECORD

@@ -3,7 +3,7 @@ topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=JA4bb-9hgMfVZ_syzmSmTL3ueCq-0vMUGMPZxNcawAY,13023
 topologicpy/CSG.py,sha256=09la1-xzS9vr-WnV7tpJ0I-mkZ-XY0MRSd5iB50Nfgw,15556
 topologicpy/Cell.py,sha256=gldsBl3LnrvTRS4SnK9aAM8k_kS1aNovTjUNHxQRNKk,175319
-topologicpy/CellComplex.py,sha256=TOnMnhBX4eXypKjDdkyhNesEDc9yRetPSDUNIi2eqU0,60948
+topologicpy/CellComplex.py,sha256=1GS2X6feo3EoapNaOoV8fcbIHVjAHvWJKu39KQy0IlM,68066
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
@@ -28,11 +28,11 @@ topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
 topologicpy/Topology.py,sha256=x6NTJ8AFIeFq3emZRT7FA_6NgNd-aavd4i9ws704AAU,470541
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=0f6HouARKaCuxhdxsUEYi8T9giJycnWhQ8Cn70YILBA,84885
-topologicpy/Wire.py,sha256=u1q8SA5m5jtcoCTRd9cCizPo7nUOqpdtN9k_ju7QyWc,229757
+topologicpy/Wire.py,sha256=zqeTR9wou18OPJOB1lCAO2ZTd3q4ugL6IBxocImIDjs,230467
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=tn529OlBICnQHhkm_PSnCq9jyPIoFccHmsIrezWqemo,23
-topologicpy-0.8.47.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.47.dist-info/METADATA,sha256=FJ5bz-y-rgUKcMp5vKMPN6_lyG9158OcT-nPhOfrXxs,10535
-topologicpy-0.8.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.47.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.47.dist-info/RECORD,,
+topologicpy/version.py,sha256=rQU26Jir73SrvldR5URzF8LbyF1xpXWvqr62PHMFfvg,23
+topologicpy-0.8.48.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.48.dist-info/METADATA,sha256=V8Xh5XT8zuIn4oYFXkSngAurwDemSN4MiXzZ10jQvhk,10535
+topologicpy-0.8.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.48.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.48.dist-info/RECORD,,