topologicpy 0.4.57__py3-none-any.whl → 0.4.59__py3-none-any.whl

topologicpy/CellComplex.py

@@ -46,7 +46,7 @@ class CellComplex(topologic.CellComplex):
                                  direction=direction, placement=placement, tolerance=tolerance)
     
     @staticmethod
-    def ByCells(cells: list, tolerance: float = 0.0001) -> topologic.CellComplex:
+    def ByCells(cells: list, tolerance: float = 0.0001, verbose: bool = True) -> topologic.CellComplex:
         """
         Creates a cellcomplex by merging the input cells.
 
@@ -67,14 +67,17 @@ class CellComplex(topologic.CellComplex):
         from topologicpy.Topology import Topology
 
         if not isinstance(cells, list):
-            print("CellComplex.ByCells - Error: The input cells parameter is not a valid list. Returning None.")
+            if verbose:
+                print("CellComplex.ByCells - Error: The input cells parameter is not a valid list. Returning None.")
             return None
         cells = [x for x in cells if isinstance(x, topologic.Cell)]
         if len(cells) < 1:
-            print("CellComplex.ByCells - Error: The input cells parameter does not contain any valid cells. Returning None.")
+            if verbose:
+                print("CellComplex.ByCells - Error: The input cells parameter does not contain any valid cells. Returning None.")
             return None
         elif len(cells) == 1:
-            print("CellComplex.ByCells - Warning: The input cells parameter contains only one valid cells. Returning object of type topologic.Cell instead of topologic.CellComplex.")
+            if verbose:
+                print("CellComplex.ByCells - Warning: The input cells parameter contains only one valid cells. Returning object of type topologic.Cell instead of topologic.CellComplex.")
             return cells[0]
         cellComplex = None
         try:
@@ -85,18 +88,22 @@ class CellComplex(topologic.CellComplex):
             cellComplex = Topology.Merge(topA, topB, tranDict=False, tolerance=tolerance)
         
         if not isinstance(cellComplex, topologic.CellComplex):
-            print("CellComplex.ByCells - Warning: Could not create a CellComplex. Returning object of type topologic.Cluster instead of topologic.CellComplex.")
+            if verbose:
+                print("CellComplex.ByCells - Warning: Could not create a CellComplex. Returning object of type topologic.Cluster instead of topologic.CellComplex.")
             return Cluster.ByTopologies(cells)
         else:
             temp_cells = CellComplex.Cells(cellComplex)
             if not isinstance(temp_cells, list):
-                print("CellComplex.ByCells - Error: The resulting object does not contain any cells. Returning None.")
+                if verbose:
+                    print("CellComplex.ByCells - Error: The resulting object does not contain any cells. Returning None.")
                 return None
             elif len(temp_cells) < 1:
-                print("CellComplex.ByCells - Error: Could not create a CellComplex. Returning None.")
+                if verbose:
+                    print("CellComplex.ByCells - Error: Could not create a CellComplex. Returning None.")
                 return None
             elif len(temp_cells) == 1:
-                print("CellComplex.ByCells - Warning: Resulting object contains only one cell. Returning object of type topologic.Cell instead of topologic.CellComplex.")
+                if verbose:
+                    print("CellComplex.ByCells - Warning: Resulting object contains only one cell. Returning object of type topologic.Cell instead of topologic.CellComplex.")
                 return(temp_cells[0])
         return cellComplex
     

topologicpy/Cluster.py

@@ -726,6 +726,74 @@ class Cluster(topologic.Cluster):
             t_clusters.append(cluster)
         return t_clusters
 
+    @staticmethod
+    def MergeCells(cells, tolerance=0.0001):
+        """
+        Creates a cluster that contains cellComplexes where it can create them plus any additional free cells.
+
+        Parameters
+        ----------
+        cells : list
+            The input list of cells.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic.Cluster
+            The created cluster with merged cells as possible.
+
+        """
+
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Topology import Topology
+
+        def find_cell_complexes(cells, adjacency_test, tolerance=0.0001):
+            cell_complexes = []
+            remaining_cells = set(cells)
+
+            def explore_complex(cell_complex, remaining, tolerance=0.0001):
+                new_cells = set()
+                for cell in remaining:
+                    if any(adjacency_test(cell, existing_cell, tolerance=tolerance) for existing_cell in cell_complex):
+                        new_cells.add(cell)
+                return new_cells
+
+            while remaining_cells:
+                current_cell = remaining_cells.pop()
+                current_complex = {current_cell}
+                current_complex.update(explore_complex(current_complex, remaining_cells, tolerance=tolerance))
+                cell_complexes.append(current_complex)
+                remaining_cells -= current_complex
+
+            return cell_complexes
+
+        # Example adjacency test function (replace this with your actual implementation)
+        def adjacency_test(cell1, cell2, tolerance=0.0001):
+            return isinstance(Topology.Merge(cell1, cell2, tolerance=tolerance), topologic.CellComplex)
+
+        if not isinstance(cells, list):
+            print("Cluster.MergeCells - Error: The input cells parameter is not a valid list of cells. Returning None.")
+            return None
+        #cells = [cell for cell in cells if isinstance(cell, topologic.Cell)]
+        if len(cells) < 1:
+            print("Cluster.MergeCells - Error: The input cells parameter does not contain any valid cells. Returning None.")
+            return None
+        
+        complexes = find_cell_complexes(cells, adjacency_test)
+        cellComplexes = []
+        cells = []
+        for aComplex in complexes:
+            aComplex = list(aComplex)
+            if len(aComplex) > 1:
+                cc = CellComplex.ByCells(aComplex, verbose=False)
+                if isinstance(cc, topologic.CellComplex):
+                    cellComplexes.append(cc)
+            elif len(aComplex) == 1:
+                if isinstance(aComplex[0], topologic.Cell):
+                    cells.append(aComplex[0])
+        return Cluster.ByTopologies(cellComplexes+cells)
+    
     @staticmethod
     def MysticRose(wire: topologic.Wire = None, origin: topologic.Vertex = None, radius: float = 0.5, sides: int = 16, perimeter: bool = True, direction: list = [0,0,1], placement:str = "center", tolerance: float = 0.0001) -> topologic.Cluster:
         """

topologicpy/Face.py

@@ -497,7 +497,7 @@ class Face(topologic.Face):
         return Face.ByVertices(vertices)
 
     @staticmethod
-    def ByWire(wire: topologic.Wire, tolerance: float=0.0001) -> topologic.Face:
+    def ByWire(wire: topologic.Wire, tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a face from the input closed wire.
 
@@ -505,8 +505,6 @@ class Face(topologic.Face):
         ----------
         wire : topologic.Wire
             The input wire.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -524,33 +522,32 @@ class Face(topologic.Face):
 
         def triangulateWire(wire):
             wire = Topology.RemoveCollinearEdges(wire)
-            vertices = Wire.Vertices(wire)
+            vertices = Topology.Vertices(wire)
             shell = Shell.Delaunay(vertices)
-            if isinstance(shell, topologic.Shell):
-                return Shell.Faces(shell)
+            if isinstance(shell, topologic.Topology):
+                return Topology.Faces(shell)
             else:
                 return []
         if not isinstance(wire, topologic.Wire):
             print("Face.ByWire - Error: The input wire parameter is not a valid topologic wire. Returning None.")
             return None
         if not Wire.IsClosed(wire):
-            print("Face.ByWire - Error: The input wire parameter is not a closed topologic wire. Attempting to close it.")
-            wire = Wire.Close(wire)
-            wire = Wire.Planarize(wire)
-            if not Wire.IsClosed(wire):
-                print("Face.ByWire - Error: Could not close the input wire parameter. Giving up and returning None.")
-                return None
+            print("Face.ByWire - Error: The input wire parameter is not a closed topologic wire. Returning None.")
+            return None
         
         edges = Wire.Edges(wire)
-        wire = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
+        wire = Topology.SelfMerge(Cluster.ByTopologies(edges))
         vertices = Wire.Vertices(wire)
-        try:
-            fList = topologic.Face.ByExternalBoundary(wire)
-        except:
-            if len(vertices) > 3:
-                fList = triangulateWire(wire)
-            else:
-                fList = []
+        fList = []
+        if isinstance(wire, topologic.Wire):
+            try:
+                fList = topologic.Face.ByExternalBoundary(wire)
+            except:
+                print("Face.ByWire - Warning: Could not create face by external boundary. Trying other methods.")
+                if len(vertices) > 3:
+                    fList = triangulateWire(wire)
+                else:
+                    fList = []
         
         if not isinstance(fList, list):
             fList = [fList]
@@ -573,7 +570,6 @@ class Face(topologic.Face):
         elif len(returnList) == 1:
             return returnList[0]
         else:
-            print("Face.ByWire - Warning: Forced to triangulate the face. Returning list of faces.")
             return returnList
 
     @staticmethod
@@ -1879,9 +1875,56 @@ class Face(topologic.Face):
             print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
             return None
         vertices = Topology.Vertices(face)
-        shell = Shell.Delaunay(vertices=vertices, face=face, tolerance=tolerance)
-        triangles = Topology.Faces(shell)
-        return triangles
+        if len(vertices) == 3: # Already a triangle
+            return [face]
+        #flatFace = Face.Flatten(face)
+        #if not isinstance(flatFace, topologic.Face):
+            #Topology.ExportToBREP(face, "C:/Users/sarwj/Downloads/troubleFace.brep")
+        #print("Tri 2", flatFace)
+
+        #world_origin = Vertex.ByCoordinates(0,0,0)
+        # Retrieve the needed transformations
+        #dictionary = Topology.Dictionary(flatFace)
+        #xTran = Dictionary.ValueAtKey(dictionary,"x")
+        #yTran = Dictionary.ValueAtKey(dictionary,"y")
+        #zTran = Dictionary.ValueAtKey(dictionary,"z")
+        #phi = Dictionary.ValueAtKey(dictionary,"phi")
+        #theta = Dictionary.ValueAtKey(dictionary,"theta")
+    
+        vertices = Topology.Vertices(face)
+        #print("Number of vertices:", len(vertices))
+        shell = Shell.Delaunay(vertices=vertices, face=face)
+        shell_faces = Topology.Faces(shell)
+        if not shell_faces:
+            return []
+        #for shell_face in shell_faces:
+            #c = Topology.Centroid(shell_face)
+            #if Face.IsInternal(face, c):
+                #faceTriangles.append(shell_face)
+
+        '''
+        for i in range(0,5,1):
+            try:
+                _ = topologic.FaceUtility.Triangulate(flatFace, float(i)*0.1, faceTriangles)
+                break
+            except:
+                continue
+        '''
+        if len(shell_faces) < 1:
+            return []
+        #finalFaces = []
+        #for f in faceTriangles:
+            #f = Topology.Rotate(f, origin=world_origin, x=0, y=1, z=0, degree=theta)
+            #f = Topology.Rotate(f, origin=world_origin, x=0, y=0, z=1, degree=phi)
+            #f = Topology.Translate(f, xTran, yTran, zTran)
+            #if Face.Angle(face, f) > 90:
+               # wire = Face.ExternalBoundary(f)
+                #wire = Wire.Invert(wire)
+               # f = topologic.Face.ByExternalBoundary(wire)
+               # finalFaces.append(f)
+            #else:
+                #finalFaces.append(f)
+        return shell_faces
 
     @staticmethod
     def TrimByWire(face: topologic.Face, wire: topologic.Wire, reverse: bool = False) -> topologic.Face:

topologicpy/Plotly.py

@@ -834,14 +834,13 @@ class Plotly:
                 all_triangles = []
                 for tp_face in tp_faces:
                     triangles = Face.Triangulate(tp_face, tolerance=tolerance)
-                    for tri in triangles:
-                        if faceLabelKey or faceGroupKey:
-                            d = Topology.Dictionary(tp_face)
-                            f_dictionaries.append(d)
-                            if d:
-                                _ = Topology.SetDictionary(tri, d)
-                        c = Topology.Centroid(tri)
-                        if Face.IsInternal(tp_face, c):
+                    if isinstance(triangles, list):
+                        for tri in triangles:
+                            if faceLabelKey or faceGroupKey:
+                                d = Topology.Dictionary(tp_face)
+                                f_dictionaries.append(d)
+                                if d:
+                                    _ = Topology.SetDictionary(tri, d)
                             all_triangles.append(tri)
                 if len(all_triangles) > 0:
                     f_cluster = Cluster.ByTopologies(all_triangles)

topologicpy/Shell.py

@@ -526,14 +526,15 @@ class Shell(Topology):
             tempTriangleVertices.append(vertices[simplex[2]])
             tempFace = Face.ByWire(Wire.ByVertices(tempTriangleVertices), tolerance=tolerance)
             tempCentroid = Topology.Centroid(tempFace)
-            if Face.IsInternal(flatFace, tempCentroid):
-                faces.append(tempFace)
+            faces.append(tempFace)
 
         shell = Shell.ByFaces(faces, tolerance=tolerance)
-        #if shell == None:
-            #print("Shell.Delaunay - WARNING: Could not create Shell. Returning a Cluster of Faces.")
-            #shell = Cluster.ByTopologies(faces)
+        if shell == None:
+            shell = Cluster.ByTopologies(faces)
+        
         if isinstance(face, topologic.Face):
+            edges = Topology.Edges(shell)
+            shell = Topology.Slice(flatFace, Cluster.ByTopologies(edges))
             # Get the internal boundaries of the face
             wires = Face.InternalBoundaries(flatFace)
             ibList = []

topologicpy/__init__.py

@@ -2,7 +2,7 @@ import sys
 import os, re
 from sys import platform
 
-__version__ = '0.4.57'
+__version__ = '0.4.59'
 __version_info__ = tuple([ int(num) for num in __version__.split('.')])
 
 if platform == 'win32':

{topologicpy-0.4.57.dist-info → topologicpy-0.4.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.57
+Version: 0.4.59
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 Project-URL: Homepage, https://github.com/wassimj/TopologicPy

{topologicpy-0.4.57.dist-info → topologicpy-0.4.59.dist-info}/RECORD

@@ -1,29 +1,29 @@
 topologicpy/Aperture.py,sha256=jNrvM_5dnVGF6yvSfJCF0L1QXtgGoSv5od6T5vR8LJE,2087
 topologicpy/Cell.py,sha256=CQonJvie6NPozdrd5CVHeWCSMVSgT055KLkdzm77uMY,81025
-topologicpy/CellComplex.py,sha256=eogmYhuhhndghZZ1j0HGcHbcAjS3P7gPf6EcsxOg3ts,36504
-topologicpy/Cluster.py,sha256=62rTLxyV10Df6M62rIUW7HOBz76EFfBWlmCP5bX9sjQ,39042
+topologicpy/CellComplex.py,sha256=2B-_o39bPDel0EZCOa0VSMrf83aEVjszLP5SLPVqQGU,36741
+topologicpy/Cluster.py,sha256=VRvv89Lww0eW2DyzP4ZVoW9mYTKrUCjid9qPyP0219o,41908
 topologicpy/Color.py,sha256=YRWPvyWjhIMUxG4cqWL-KBwmAtw07cFY6l_ftlex_3s,9741
 topologicpy/Context.py,sha256=j5TnPQlpK9NSGPnxy_7D_0Q7in-DyDQG_qNAlG_C0IM,2265
 topologicpy/DGL.py,sha256=8YxKxrEZ8V8OQOvQr8fO1nu45LiTfGWm_lJh770eP7w,136517
 topologicpy/Dictionary.py,sha256=rgXmYrDWhoaMsir3kg7mHv-dtZqWqvp9vDMqYp3MvPI,24067
 topologicpy/Edge.py,sha256=-xGhloh6FtbPNwMdlAMi1Eu11_uzIq3ZdYRalgk1Zjo,44367
 topologicpy/EnergyModel.py,sha256=a1fcI8ZAewyFWsoLv3Vu84FCEPXXp4ubOE2-O7FgnOc,50923
-topologicpy/Face.py,sha256=qxaLLHLR-mIQZFEzT776enieWhySU6SSc3nX2Rawg98,86054
+topologicpy/Face.py,sha256=MBQIjWcRScL_f2tkQ76ph7jTcbVJqm5_wt27eNkhsxQ,87751
 topologicpy/Graph.py,sha256=V1B0I25hNy5tUItiodv-3z9DRHkszLbT3wwyS4_tHp4,261732
 topologicpy/Grid.py,sha256=77WRTTqGxxIuUHorrH74JHeBS4E7v27ydzckIdu3K54,16661
 topologicpy/Helper.py,sha256=QKlt2nmpgFgmpgdKnb9aKd0G-_RNrCV6ED84QiW3E3s,12541
 topologicpy/Honeybee.py,sha256=rlYWSILN1vJGg6ElEe7iMJ597Jv_VN6WNXUOc6Emuwk,19234
 topologicpy/Matrix.py,sha256=GHd_o714eEWbTOhRM5X-fXcgsV5yYJJSj6xFdnkwC14,7625
 topologicpy/Neo4j.py,sha256=FWGGmr_1uBFHG8ADgTF9AmXVIQwiZol2s7nunwq73a4,18568
-topologicpy/Plotly.py,sha256=C1Gu-KX6gq9syAHQ-jg61fhu4uwbt839Nup1nrr6oGw,91917
+topologicpy/Plotly.py,sha256=pjFONUY1AYOgeGJBtsE8QlYOP6T8enpikOlWzqDqaHk,91885
 topologicpy/Polyskel.py,sha256=jz5k5H6p4QRWe3bbMnyYbP9Iji6EQ1wdk3qQvcnbg08,15156
-topologicpy/Shell.py,sha256=fyq_k1VsvZ5AYdDSXnggqNNTHggRXsqabVEpuabZ6Uo,80984
+topologicpy/Shell.py,sha256=GCLoOf8jyLRh3G-tuyGZsM-V5qvGhDyHLBbTsHmjjaw,80946
 topologicpy/Speckle.py,sha256=D6jk1uiHJeLHz478-hn8aWJCgbW9NFEkll84gRJbveA,14041
 topologicpy/Topology.py,sha256=5ljh5sLJ8O-hA1oPnidOS8WtR2nzlfQLDiXIf77vstU,284827
 topologicpy/Vector.py,sha256=AWBPEaoDqcVM_TullugMvYBQ71MQZ0RCEYPG1_yccRk,18357
 topologicpy/Vertex.py,sha256=FAAXsvV424Rwl6cgNPjBnzSLqhd1Ngk60w_zJut1X8k,54133
 topologicpy/Wire.py,sha256=GkWF4l0TbC1lwbgmQLsedQT2Ysg9l0PliFuNV63RLPs,128720
-topologicpy/__init__.py,sha256=BQovc3_o87dO7mtblnFZsaK98FheNxenNMf0oDosxF8,713
+topologicpy/__init__.py,sha256=fDYqriABru1p9DrrdlwBZU6rzfcxkti5oBdbF29iHj8,713
 topologicpy/bin/linux/topologic/__init__.py,sha256=XlFReDf3FWlYdM9uXtanYPIafgPb6GVTQczS_xJAXD0,60
 topologicpy/bin/linux/topologic/topologic.cpython-310-x86_64-linux-gnu.so,sha256=uvar01STZ8qu1c8fRmtYdVnK8evxBv305QScASXY9go,1852112
 topologicpy/bin/linux/topologic/topologic.cpython-311-x86_64-linux-gnu.so,sha256=42yjVWetFu_qn6-eZcDxgd_A8SQN_wHqkdw91txKt9U,1852112
@@ -67,8 +67,8 @@ topologicpy/bin/windows/topologic/topologic.cp310-win_amd64.pyd,sha256=F0sPLuMpD
 topologicpy/bin/windows/topologic/topologic.cp311-win_amd64.pyd,sha256=aBAJQj3OmJ58MOAF1ZIFybL_5fFK7FNR9hrIps6b6pc,1551872
 topologicpy/bin/windows/topologic/topologic.cp38-win_amd64.pyd,sha256=aLgNf54nbJmGc7Tdmkuy-V0m6B9zLxabIbpRwAy7cBA,1551360
 topologicpy/bin/windows/topologic/topologic.cp39-win_amd64.pyd,sha256=_8cp205hiRxkFHtzQQOweA4DhCPk8caH4kTVLWGQeVw,1411584
-topologicpy-0.4.57.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
-topologicpy-0.4.57.dist-info/METADATA,sha256=XfUWKgP1nEgvVRgEBU5EwJYho5QnCQzEXxGh-Z47ssg,6973
-topologicpy-0.4.57.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-topologicpy-0.4.57.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.4.57.dist-info/RECORD,,
+topologicpy-0.4.59.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
+topologicpy-0.4.59.dist-info/METADATA,sha256=SYsdzuK3qbgZWn-xpTcLkw5kWUPLXzS0K8bjUzKfnrs,6973
+topologicpy-0.4.59.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+topologicpy-0.4.59.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.4.59.dist-info/RECORD,,