topologicpy 0.4.57__tar.gz → 0.4.59__tar.gz

{topologicpy-0.4.57/src/topologicpy.egg-info → topologicpy-0.4.59}/PKG-INFO

@@ -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 → topologicpy-0.4.59}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "topologicpy"
-version = "0.4.57"
+version = "0.4.59"
 authors = [
   { name="Wassim Jabi", email="wassim.jabi@gmail.com" },
 ]

{topologicpy-0.4.57 → topologicpy-0.4.59}/src/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-0.4.57 → topologicpy-0.4.59}/src/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-0.4.57 → topologicpy-0.4.59}/src/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-0.4.57 → topologicpy-0.4.59}/src/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-0.4.57 → topologicpy-0.4.59}/src/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-0.4.57 → topologicpy-0.4.59}/src/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 → topologicpy-0.4.59/src/topologicpy.egg-info}/PKG-INFO

@@ -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