topologicpy 0.4.55__tar.gz → 0.4.57__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.55
+Version: 0.4.57
 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.55 → topologicpy-0.4.57}/pyproject.toml

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

{topologicpy-0.4.55 → topologicpy-0.4.57}/src/topologicpy/Cell.py

@@ -93,8 +93,10 @@ class Cell(Topology):
             The created cell.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         if not isinstance(faces, list):
             print("Cell.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
@@ -103,15 +105,41 @@ class Cell(Topology):
         if len(faceList) < 1:
             print("Cell.ByFaces - Error: The input faces parameter does not contain valid faces. Returning None.")
             return None
+        # Try the default method
+        cell = topologic.Cell.ByFaces(faceList, tolerance)
+        if isinstance(cell, topologic.Cell):
+            return cell
+        
+        # Fuse all the vertices first and rebuild the faces
+        all_vertices = []
+        wires = []
+        for f in faceList:
+            w = Face.Wire(f)
+            wires.append(w)
+            all_vertices += Topology.Vertices(w)
+        all_vertices = Vertex.Fuse(all_vertices, tolerance=tolerance)
+        new_faces = []
+        for w in wires:
+            face_vertices = []
+            for v in Topology.Vertices(w):
+                index = Vertex.Index(v, all_vertices, tolerance=tolerance)
+                if not index == None:
+                    face_vertices.append(all_vertices[index])
+            new_w = Wire.ByVertices(face_vertices)
+            if isinstance(new_w, topologic.Wire):
+                new_f = Face.ByWire(new_w)
+                if isinstance(new_f, topologic.Face):
+                    new_faces.append(new_f)
+        faceList = new_faces
         planarizedList = []
         enlargedList = []
         if planarize:
             planarizedList = [Face.Planarize(f, tolerance=tolerance) for f in faceList]
             enlargedList = [Face.ByOffset(f, offset=-tolerance*10) for f in planarizedList]
             cell = topologic.Cell.ByFaces(enlargedList, tolerance)
-            faces = Topology.SubTopologies(cell, subTopologyType="face")
+            faceList = Topology.SubTopologies(cell, subTopologyType="face")
             finalFaces = []
-            for f in faces:
+            for f in faceList:
                 centroid = Topology.Centroid(f)
                 n = Face.Normal(f)
                 v = Topology.Translate(centroid, n[0]*0.01,n[1]*0.01,n[2]*0.01)
@@ -121,10 +149,22 @@ class Cell(Topology):
             for f in finalFaces:
                 vertices = Face.Vertices(f)
                 w = Wire.Cycles(Face.ExternalBoundary(f), maxVertices=len(vertices))[0]
-                finalFinalFaces.append(Face.ByWire(w, tolerance=tolerance))
-            return topologic.Cell.ByFaces(finalFinalFaces, tolerance)
+                f1 = Face.ByWire(w, tolerance=tolerance)
+                if isinstance(f1, topologic.Face):
+                    finalFinalFaces.append(f1)
+            cell = topologic.Cell.ByFaces(finalFinalFaces, tolerance)
+            if cell == None:
+                print("1. Cell.ByFaces - Error: The operation failed. Returning None.")
+                return None
+            else:
+                return cell
         else:
-            return topologic.Cell.ByFaces(faces, tolerance)
+            cell = topologic.Cell.ByFaces(faces, tolerance)
+            if cell == None:
+                print("2. Cell.ByFaces - Error: The operation failed. Returning None.")
+                return None
+            else:
+                return cell
 
     @staticmethod
     def ByShell(shell: topologic.Shell, planarize: bool = False, tolerance: float = 0.0001) -> topologic.Cell:
@@ -294,15 +334,25 @@ class Cell(Topology):
             The created cell.
 
         """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Shell import Shell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
 
         def cleanup(f):
-            flatFace = Face.Flatten(f, tolerance=tolerance)
+            origin = Topology.Centroid(f)
+            normal = Face.Normal(f)
+            flatFace = Topology.Flatten(f, origin=origin, direction=normal)
             world_origin = Vertex.ByCoordinates(0,0,0)
             # Retrieve the needed transformations
             dictionary = Topology.Dictionary(flatFace)
-            xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-            yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-            zTran = Dictionary.ValueAtKey(dictionary,"zTran")
+            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")
 
@@ -310,15 +360,6 @@ class Cell(Topology):
             f = Topology.Rotate(f, origin=world_origin, x=0, y=0, z=1, degree=phi)
             f = Topology.Translate(f, xTran, yTran, zTran)
             return f
-        
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
-        from topologicpy.Face import Face
-        from topologicpy.Shell import Shell
-        from topologicpy.Cluster import Cluster
-        from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
 
         if not isinstance(wires, list):
             print("Cell.ByWires - Error: The input wires parameter is not a valid list. Returning None.")
@@ -1437,8 +1478,40 @@ class Cell(Topology):
         prism = Topology.Rotate(prism, origin, 0, 1, 0, theta)
         prism = Topology.Rotate(prism, origin, 0, 0, 1, phi)
         return prism
+
+    @staticmethod
+    def RemoveCollinearEdges(cell: topologic.Cell, angTolerance: float = 0.1, tolerance: float = 0.0001) -> topologic.Wire:
+        """
+        Removes any collinear edges in the input cell.
+
+        Parameters
+        ----------
+        cell : topologic.Cell
+            The input cell.
+        angTolerance : float , optional
+            The desired angular tolerance. The default is 0.1.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic.Cell
+            The created cell without any collinear edges.
+
+        """
+        from topologicpy.Face import Face
+
+        if not isinstance(cell, topologic.Cell):
+            print("Cell.RemoveCollinearEdges - Error: The input cell parameter is not a valid cell. Returning None.")
+            return None
+        faces = Cell.Faces(cell)
+        clean_faces = []
+        for face in faces:
+            clean_faces.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance))
+        return Cell.ByFaces(clean_faces, tolerance=tolerance)
     
-    def Roof(face, degree: float = 45, angTolerance: float = 2.0 , tolerance: float = 0.001):
+    @staticmethod
+    def Roof(face, degree: float = 45, epsilon: float = 0.01 , tolerance: float = 0.001):
         """
             Creates a hipped roof through a straight skeleton. This method is contributed by 高熙鹏 xipeng gao <gaoxipeng1998@gmail.com>
             This algorithm depends on the polyskel code which is included in the library. Polyskel code is found at: https://github.com/Botffy/polyskel
@@ -1449,8 +1522,8 @@ class Cell(Topology):
             The input face.
         degree : float , optioal
             The desired angle in degrees of the roof. The default is 45.
-        angTolerance : float , optional
-            The desired angular tolerance. The default is 2. (This is set to a larger number as it was found to work better)
+        epsilon : float , optional
+            The desired epsilon (another form of tolerance for distance from plane). The default is 0.01. (This is set to a larger number as it was found to work better)
         tolerance : float , optional
             The desired tolerance. The default is 0.001. (This is set to a larger number as it was found to work better)
 
@@ -1464,7 +1537,7 @@ class Cell(Topology):
         from topologicpy.Cell import Cell
         from topologicpy.Topology import Topology
         
-        shell = Shell.Roof(face=face, degree=degree, angTolerance=angTolerance, tolerance=tolerance)
+        shell = Shell.Roof(face=face, degree=degree, epsilon=epsilon, tolerance=tolerance)
         faces = Topology.Faces(shell) + [face]
         cell = Cell.ByFaces(faces, tolerance=tolerance)
         if not cell:

{topologicpy-0.4.55 → topologicpy-0.4.57}/src/topologicpy/CellComplex.py

@@ -275,10 +275,10 @@ class CellComplex(topologic.CellComplex):
                 e3 = None
                 e4 = None
                 try:
-                    e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance)
+                    e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance, verbose=False)
                 except:
                     try:
-                        e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance)
+                        e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance, verbose=False)
                         f = Face.ByExternalBoundary(Wire.ByEdges([e1, e2, e4], tolerance=tolerance))
                         if triangulate == True:
                             if len(Topology.Vertices(face)) > 3:
@@ -291,10 +291,10 @@ class CellComplex(topologic.CellComplex):
                     except:
                         pass
                 try:
-                    e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance)
+                    e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance, verbose=False)
                 except:
                     try:
-                        e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance)
+                        e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance, verbose=False)
                         f = Face.ByWire(Wire.ByEdges([e1, e2, e3], tolerance=tolerance), tolerance=tolerance)
                         if triangulate == True:
                             if len(Topology.Vertices(face)) > 3:
@@ -308,7 +308,7 @@ class CellComplex(topologic.CellComplex):
                         pass
                 if e3 and e4:
                     if triangulate == True:
-                        e5 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.EndVertex(), tolerance=tolerance)
+                        e5 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.EndVertex(), tolerance=tolerance, verbose=False)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e5, e4], tolerance=tolerance), tolerance=tolerance))
                         faces.append(Face.ByWire(Wire.ByEdges([e2, e5, e3], tolerance=tolerance), tolerance=tolerance))
                     else:
@@ -759,6 +759,37 @@ class CellComplex(topologic.CellComplex):
             print("CellComplex.Prism - Error: Could not create a prism. Returning None.")
             return None
 
+    @staticmethod
+    def RemoveCollinearEdges(cellComplex: topologic.CellComplex, angTolerance: float = 0.1, tolerance: float = 0.0001) -> topologic.Wire:
+        """
+        Removes any collinear edges in the input cellComplex.
+
+        Parameters
+        ----------
+        cellComplex : topologic.CellComplex
+            The input cellComplex.
+        angTolerance : float , optional
+            The desired angular tolerance. The default is 0.1.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic.CellComplex
+            The created cellComplex without any collinear edges.
+
+        """
+        from topologicpy.Cell import Cell
+
+        if not isinstance(cellComplex, topologic.CellComplex):
+            print("CellComplex.RemoveCollinearEdges - Error: The input cellComplex parameter is not a valid cellComplex. Returning None.")
+            return None
+        cells = CellComplex.Cells(cellComplex)
+        clean_cells = []
+        for cell in cells:
+            clean_cells.append(Cell.RemoveCollinearEdges(cell, angTolerance=angTolerance, tolerance=tolerance))
+        return CellComplex.ByCells(clean_cells, tolerance=tolerance)
+    
     @staticmethod
     def Shells(cellComplex: topologic.CellComplex) -> list:
         """

{topologicpy-0.4.55 → topologicpy-0.4.57}/src/topologicpy/DGL.py

@@ -2234,7 +2234,10 @@ class DGL:
             validate_ds = DGL.DatasetByGraphs({'graphs': graph_sublists[1], 'labels' :labels_sublists[1]})
         if split[2] > 0 and len(graph_sublists[2]) > 0:
             test_ds = DGL.DatasetByGraphs({'graphs': graph_sublists[2], 'labels' :labels_sublists[2]})
-
+        # Print label shapes for debugging
+        print("Train Labels Shapes:", [labels.shape for labels in labels_sublists[0]])
+        print("Validate Labels Shapes:", [labels.shape for labels in labels_sublists[1]])
+        print("Test Labels Shapes:", [labels.shape for labels in labels_sublists[2]])
         return {
             "train_ds" : train_ds,
             "validate_ds" : validate_ds,

{topologicpy-0.4.55 → topologicpy-0.4.57}/src/topologicpy/Edge.py

@@ -140,7 +140,7 @@ class Edge():
             return None
         n = Face.Normal(face)
         v2 = Topology.Translate(origin, n[0], n[1], n[2])
-        edge = Edge.ByStartVertexEndVertex(origin, v2, tolerance=tolerance)
+        edge = Edge.ByStartVertexEndVertex(origin, v2, tolerance=tolerance, verbose=False)
         if not isinstance(edge, topologic.Edge):
             print("Edge.ByFaceNormal - Error: Could not create an edge. Returning None.")
             return None

{topologicpy-0.4.55 → topologicpy-0.4.57}/src/topologicpy/Face.py

@@ -356,7 +356,9 @@ class Face(topologic.Face):
         from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Shell import Shell
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
         
         def planarizeList(wireList):
             returnList = []
@@ -369,14 +371,20 @@ class Face(topologic.Face):
             return None
         
         if origin == None:
-            origin = Vertex.Origin()
+            origin = Topology.Centroid(shell)
         if not isinstance(origin, topologic.Vertex):
-            print("Shell.Planarize - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            print("Face.ByShell - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        
+        world_origin = Vertex.Origin()
         planar_shell = Shell.Planarize(shell)
         normal = Face.Normal(Topology.Faces(planar_shell)[0])
-        planar_shell = Topology.Flatten(planar_shell, origin=origin, vector=normal)
+        planar_shell = Topology.Flatten(planar_shell, origin=origin, direction=normal)
+        d = Topology.Dictionary(planar_shell)
+        phi = Dictionary.ValueAtKey(d, 'phi')
+        theta = Dictionary.ValueAtKey(d, 'theta')
+        x_tran = Dictionary.ValueAtKey(d, 'x')
+        y_tran = Dictionary.ValueAtKey(d, 'y')
+        z_tran = Dictionary.ValueAtKey(d, 'z')
         vertices = Shell.Vertices(planar_shell)
         new_vertices = []
         for v in vertices:
@@ -395,10 +403,12 @@ class Face(topologic.Face):
                 ext_boundary = Wire.Planarize(ext_boundary, origin=origin, tolerance=tolerance)
             ext_boundary = Topology.RemoveCollinearEdges(ext_boundary, angTolerance)
             try:
-                return Face.ByWire(ext_boundary)
+                face = Face.ByWire(ext_boundary)
+                face = Topology.Rotate(face, world_origin, 0, 1, 0, theta)
+                face = Topology.Rotate(face, world_origin, 0, 0, 1, phi)
+                face = Topology.Translate(face, x_tran, y_tran, z_tran)
+                return face
             except:
-                normal = Face.Normal(Topology.Faces(ext_boundary)[0])
-                planar_shell = Topology.Flatten(planar_shell, vector=normal)
                 print("Face.ByShell - Error: The operation failed. Returning None.")
                 return None
         elif isinstance(ext_boundary, topologic.Cluster): # The shell has holes.
@@ -407,10 +417,9 @@ class Face(topologic.Face):
             faces = []
             areas = []
             for wire in wires:
-                #wire = Wire.Planarize(Wire.RemoveCollinearEdges(Wire.Planarize(wire, origin=origin, tolerance=tolerance), angTolerance), origin=origin, tolerance=tolerance)
                 aFace = Face.ByWire(wire, tolerance=tolerance)
                 if not isinstance(aFace, topologic.Face):
-                    print("2. Face.ByShell - Error: The operation failed. Returning None.")
+                    print("Face.ByShell - Error: The operation failed. Returning None.")
                     return None
                 anArea = abs(Face.Area(aFace))
                 faces.append(aFace)
@@ -422,13 +431,15 @@ class Face(topologic.Face):
             for int_boundary in int_boundaries:
                 temp_wires = []
                 _ = int_boundary.Wires(None, temp_wires)
-                int_wires.append(temp_wires[0])
+                int_wires.append(Topology.RemoveCollinearEdges(temp_wires[0], angTolerance))
             temp_wires = []
             _ = ext_boundary.Wires(None, temp_wires)
             ext_wire = Topology.RemoveCollinearEdges(temp_wires[0], angTolerance)
             face = Face.ByWires(ext_wire, int_wires)
-            face = Topology.Orient(face, origin=origin, dirA=[0,0,1], dirB=normal)
-            #face = Topology.Translate(face, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+           
+            face = Topology.Rotate(face, world_origin, 0, 1, 0, theta)
+            face = Topology.Rotate(face, world_origin, 0, 0, 1, phi)
+            face = Topology.Translate(face, x_tran, y_tran, z_tran)
             return face
         else:
             return None
@@ -523,8 +534,12 @@ class Face(topologic.Face):
             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. Returning None.")
-            return None
+            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
         
         edges = Wire.Edges(wire)
         wire = Topology.SelfMerge(Cluster.ByTopologies(edges), tolerance=tolerance)
@@ -1036,7 +1051,7 @@ class Face(topologic.Face):
             tempVertices = rotate_vertices(tempVertices, temp_v)
             flatInternalBoundaries.append(Wire.ByVertices(tempVertices))
         flatFace = Face.ByWires(flatExternalBoundary, flatInternalBoundaries, tolerance=tolerance)
-        dictionary = Dictionary.ByKeysValues(["xTran", "yTran", "zTran", "phi", "theta"], [cm.X(), cm.Y(), cm.Z(), phi, theta])
+        dictionary = Dictionary.ByKeysValues(["x", "y", "z", "phi", "theta"], [cm.X(), cm.Y(), cm.Z(), phi, theta])
         flatFace = Topology.SetDictionary(flatFace, dictionary)
         return flatFace
 
@@ -1064,14 +1079,17 @@ class Face(topologic.Face):
         from topologicpy.Dictionary import Dictionary
 
         if not isinstance(face, topologic.Face):
+            print("Face.Harmonize - Error: The input face parameter is not a valid face. Returning None.")
             return None
-        flatFace = Face.Flatten(face, tolerance=tolerance)
-        world_origin = Vertex.ByCoordinates(0,0,0)
+        normal = Face.Normal(face)
+        origin = Topology.Centroid(face)
+        flatFace = Topology.Flatten(face, origin=origin, direction=normal)
+        world_origin = Vertex.Origin()
         # Retrieve the needed transformations
         dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-        yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-        zTran = Dictionary.ValueAtKey(dictionary,"zTran")
+        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 = Wire.Vertices(Face.ExternalBoundary(flatFace))
@@ -1259,7 +1277,6 @@ class Face(topologic.Face):
         except:
             print("Face.IsInternal - Warning: Could not determine if vertex is inside face. Returning False.")
             clus = Cluster.ByTopologies([vertex, face])
-            Topology.Show(clus, renderer="browser")
             status = False
         return status
     
@@ -1311,17 +1328,19 @@ class Face(topologic.Face):
             return False
 
         # Flatten the input face
-        flatFace = Face.Flatten(face, tolerance=tolerance)
+        origin = Topology.Centroid(face)
+        normal = Face.Normal(face)
+        flatFace = Topology.Flatten(face, origin=origin, direction=normal)
         # Retrieve the needed transformations
         dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-        yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-        zTran = Dictionary.ValueAtKey(dictionary,"zTran")
+        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")
 
         # Create a Vertex at the world's origin (0,0,0)
-        world_origin = Vertex.ByCoordinates(0,0,0)
+        world_origin = Vertex.Origin()
 
         faceEdges = Face.Edges(flatFace)
         vertices = []
@@ -1560,17 +1579,17 @@ class Face(topologic.Face):
         if not isinstance(face, topologic.Face):
             return None
         if not isinstance(origin, topologic.Vertex):
-            origin = Topology.CenterOfMass(face)
+            origin = Topology.Centroid(face)
         if not isinstance(direction, list):
-            direction = Face.NormalAtParameters(face, 0.5, 0.5)
-        flatFace = Face.Flatten(face, oldLocation=origin, direction=direction, tolerance=tolerance)
+            normal = Face.Normal(face)
+        flatFace = Topology.Flatten(face, origin=origin, direction=normal)
 
         world_origin = Vertex.ByCoordinates(0,0,0)
         # Retrieve the needed transformations
         dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-        yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-        zTran = Dictionary.ValueAtKey(dictionary,"zTran")
+        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")
 
@@ -1678,6 +1697,35 @@ class Face(topologic.Face):
             return None
         return Face.ByWire(wire, tolerance=tolerance)
     
+    @staticmethod
+    def RemoveCollinearEdges(face: topologic.Face, angTolerance: float = 0.1, tolerance: float = 0.0001) -> topologic.Wire:
+        """
+        Removes any collinear edges in the input face.
+
+        Parameters
+        ----------
+        face : topologic.Face
+            The input face.
+        angTolerance : float , optional
+            The desired angular tolerance. The default is 0.1.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic.Face
+            The created face without any collinear edges.
+
+        """
+        from topologicpy.Wire import Wire
+
+        if not isinstance(face, topologic.Face):
+            print("Face.RemoveCollinearEdges - Error: The input face parameter is not a valid face. Returning None.")
+            return None
+        eb = Wire.RemoveCollinearEdges(Face.Wire(face), angTolerance=angTolerance, tolerance=tolerance)
+        ib = [Wire.RemoveCollinearEdges(w, angTolerance=angTolerance, tolerance=tolerance) for w in Face.InternalBoundaries(face)]
+        return Face.ByWires(eb, ib)
+    
     @staticmethod
     def Skeleton(face, tolerance=0.001):
         """
@@ -1823,43 +1871,17 @@ class Face(topologic.Face):
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
+        from topologicpy.Shell import Shell
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
         if not isinstance(face, topologic.Face):
+            print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
             return None
-        flatFace = Face.Flatten(face, tolerance=tolerance)
-        world_origin = Vertex.ByCoordinates(0,0,0)
-        # Retrieve the needed transformations
-        dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-        yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-        zTran = Dictionary.ValueAtKey(dictionary,"zTran")
-        phi = Dictionary.ValueAtKey(dictionary,"phi")
-        theta = Dictionary.ValueAtKey(dictionary,"theta")
-    
-        faceTriangles = []
-        for i in range(0,5,1):
-            try:
-                _ = topologic.FaceUtility.Triangulate(flatFace, float(i)*0.1, faceTriangles)
-                break
-            except:
-                continue
-        if len(faceTriangles) < 1:
-            return [face]
-        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 finalFaces
+        vertices = Topology.Vertices(face)
+        shell = Shell.Delaunay(vertices=vertices, face=face, tolerance=tolerance)
+        triangles = Topology.Faces(shell)
+        return triangles
 
     @staticmethod
     def TrimByWire(face: topologic.Face, wire: topologic.Wire, reverse: bool = False) -> topologic.Face: