topologicpy 0.8.14__py3-none-any.whl → 0.8.17__py3-none-any.whl

topologicpy/Topology.py

@@ -1498,6 +1498,8 @@ class Topology():
         edges = [e for e in edges if e]
         faces = [f for f in faces if f]
 
+        return_topology = None
+
         if not vertices:
             return None
 
@@ -1527,7 +1529,7 @@ class Topology():
         if topologyType == "wire" and edges:
             topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
             if topEdges:
-                returnTopology = topologyByEdges(topEdges, topologyType)
+                return_topology = topologyByEdges(topEdges, topologyType)
         elif faces:
             for aFace in faces:
                 faceEdges = [Edge.ByVertices([topVerts[aFace[i]], topVerts[aFace[i + 1]]], tolerance=tolerance) for i in range(len(aFace) - 1)]
@@ -1545,14 +1547,14 @@ class Topology():
                     except:
                         pass
             if topFaces:
-                returnTopology = topologyByFaces(topFaces, topologyType=topologyType, tolerance=tolerance)
+                return_topology = topologyByFaces(topFaces, topologyType=topologyType, tolerance=tolerance)
         elif edges:
             topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
             if topEdges:
-                returnTopology = topologyByEdges(topEdges, topologyType)
+                return_topology = topologyByEdges(topEdges, topologyType)
         else:
-            returnTopology = Cluster.ByTopologies(topVerts)
-        return returnTopology
+            return_topology = Cluster.ByTopologies(topVerts)
+        return return_topology
     
     @staticmethod
     def ByBIMPath(path, guidKey: str = "guid", colorKey: str = "color", typeKey: str = "type",
@@ -3073,6 +3075,118 @@ class Topology():
         json_dict = json.loads(string)
         return Topology.ByJSONDictionary(json_dict, tolerance=tolerance)
 
+    @staticmethod
+    def ByMeshData(dictionary, transferDictionaries: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Create a cluster by the input python dictionary of vertices, edges, faces, and cells.
+
+        Parameters
+        ----------
+        dictionary : dict
+            The input python dictionary of vertices, edges, faces, and cells in the form of:
+            { 'mode': int,  The expected mode of input face data:
+                                0: The faces list is indexed into the vertices list.
+                                1: The faces list is indexesd into the edges list.
+            'vertices': list, (list of coordinates)
+            'edges': list,   (list of indices into the list of vertices)
+            'faces': list,   (list of indices into the list of edges)
+            'cells': list,   (list of indices into the list of faces)
+            'vertex_dict': list of dicts,
+            'edge_dicts': list of dicts,
+            'face_dicts', list of dicts,
+            'cell_dicts', list of dicts
+            }
+        transferDictionaries : bool , optional
+            If set to True, the python dictionaries will be transferred to the coorespoding topologies. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Cluster
+            The created cluster of vertices, edges, faces, and cells.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+
+        if not type(dictionary) == type({}):
+            if not silent:
+                print("Topology.ByMeshData - Error: The input dictionary parameter is not a valid dictionary. Returning None.")
+            return None
+        
+        vertices = dictionary['vertices']
+        edges = dictionary['edges']
+        faces = dictionary['faces']
+        cells = dictionary['cells']
+        if not 'mode' in dictionary.keys():
+            mode = 0
+        else:
+            mode = dictionary['mode']
+        if transferDictionaries == True:
+            vertex_dicts = dictionary['vertex_dicts']
+            edge_dicts = dictionary['edge_dicts']
+            face_dicts = dictionary['face_dicts']
+            cell_dicts = dictionary['cell_dicts']
+        else:
+            vertex_dicts = [{}]*len(vertices)
+            edge_dicts = [{}]*len(edges)
+            face_dicts = [{}]*len(faces)
+            cell_dicts = [{}]*len(cells)
+                
+        top_verts = []
+        for i, vertex in enumerate(vertices):
+            top_vertex = Vertex.ByCoordinates(vertex)
+            if Topology.IsInstance(top_vertex, "Vertex"):
+                if transferDictionaries:
+                    d = Dictionary.ByPythonDictionary(vertex_dicts[i])
+                    top_vertex = Topology.SetDictionary(top_vertex, d, silent=True)
+                top_verts.append(top_vertex)
+        
+        top_edges = []
+        for i, edge in enumerate(edges):
+            top_edge = Edge.ByVertices(top_verts[edge[0]], top_verts[edge[1]], tolerance=tolerance, silent=silent)
+            if Topology.IsInstance(top_edge, "Edge"):
+                if transferDictionaries:
+                    d = Dictionary.ByPythonDictionary(edge_dicts[i])
+                    top_edge = Topology.SetDictionary(top_edge, d, silent=True)
+                top_edges.append(top_edge)
+        
+        top_faces = []
+        for i, face in enumerate(faces):
+            if mode == 0:
+                face_vertices = [top_verts[v] for v in face]
+                top_face = Face.ByVertices(face_vertices, tolerance=tolerance, silent=silent)
+            else:
+                face_edges = [top_edges[e] for e in face]
+                top_face = Face.ByEdges(face_edges, tolerance=tolerance, silent=silent)
+            if Topology.IsInstance(top_face, "Face"):
+                if transferDictionaries:
+                    d = Dictionary.ByPythonDictionary(face_dicts[i])
+                    top_face = Topology.SetDictionary(top_face, d, silent=True)
+                top_faces.append(top_face)
+
+        top_cells = []
+        for i, cell in enumerate(cells):
+            cell_faces = [top_faces[f] for f in cell]
+            top_cell = Cell.ByFaces(cell_faces, tolerance=tolerance, silent=silent)
+            if Topology.IsInstance(top_cell, "Cell"):
+                if transferDictionaries:
+                    d = Dictionary.ByPythonDictionary(cell_dicts[i])
+                    top_cell = Topology.SetDictionary(top_cell, d, silent=True)
+                top_cells.append(top_cell)
+        
+        return Cluster.ByTopologies(top_verts+top_edges+top_faces+top_cells)
+
     @staticmethod
     def ByOBJFile(objFile, mtlFile = None,
                 defaultColor: list = [255,255,255],
@@ -3301,7 +3415,7 @@ class Topology():
                 vertex = list(map(float, parts[1:4]))
                 vertex = [round(coord, mantissa) for coord in vertex]
                 if transposeAxes == True:
-                    vertex = [vertex[0], vertex[2], vertex[1]]
+                    vertex = [vertex[0], -vertex[2], vertex[1]]
                 vertices.append(vertex)
             elif parts[0] == 'vt':
                 texture = list(map(float, parts[1:3]))
@@ -5891,7 +6005,7 @@ class Topology():
         return flat_topology
     
     @staticmethod
-    def Geometry(topology, mantissa: int = 6):
+    def Geometry(topology, transferDictionaries: bool = False, mantissa: int = 6, silent: bool = False):
         """
         Returns the geometry (mesh data format) of the input topology as a dictionary of vertices, edges, and faces.
 
@@ -5899,8 +6013,12 @@ class Topology():
         ----------
         topology : topologic_core.Topology
             The input topology.
+        transferDictionaries : bool , optional
+            If set to True, vertex, edge, and face dictionaries will be included in the output. Otherwise, they are not. The default is False.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -5911,22 +6029,34 @@ class Topology():
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Face import Face
+        from topologicpy.Dictionary import Dictionary
 
         vertices = []
         edges = []
         faces = []
-        if topology == None:
-            return [None, None, None]
+        vertex_dicts = []
+        edge_dicts = []
+        face_dicts = []
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Topology.Geometry - Error: The input topology parameter is not a valid topology. Retruning None.")
+            return None
         topVerts = []
         if Topology.Type(topology) == Topology.TypeID("Vertex"): #input is a vertex, just add it and process it
             topVerts.append(topology)
         else:
             topVerts = Topology.Vertices(topology)
         for aVertex in topVerts:
+            py_dict = {}
+            if transferDictionaries == True:
+                d = Topology.Dictionary(aVertex)
+                if len(Dictionary.Keys(d)) > 0:
+                    py_dict = Dictionary.PythonDictionary(d)
             try:
                 vertices.index(Vertex.Coordinates(aVertex, mantissa=mantissa)) # Vertex already in list
             except:
                 vertices.append(Vertex.Coordinates(aVertex, mantissa=mantissa)) # Vertex not in list, add it.
+                vertex_dicts.append(py_dict)
         topEdges = []
         if (Topology.Type(topology) == Topology.TypeID("Edge")): #Input is an Edge, just add it and process it
             topEdges.append(topology)
@@ -5949,13 +6079,18 @@ class Topology():
             e.append(svIndex)
             e.append(evIndex)
             edges.append(e)
+            py_dict = {}
+            if transferDictionaries == True:
+                d = Topology.Dictionary(anEdge)
+                if len(Dictionary.Keys(d)) > 0:
+                    py_dict = Dictionary.PythonDictionary(d)
+                edge_dicts.append(py_dict)
         topFaces = []
         if (Topology.Type(topology) == Topology.TypeID("Face")): # Input is a Face, just add it and process it
             topFaces.append(topology)
         elif (Topology.Type(topology) > Topology.TypeID("Face")):
             _ = topology.Faces(None, topFaces)
         for aFace in topFaces:
-            f_dir = Face.Normal(aFace)
             ib = []
             _ = aFace.InternalBoundaries(ib)
             if(len(ib) > 0):
@@ -5984,7 +6119,13 @@ class Topology():
                         fVertexIndex = len(vertices)-1
                     f.append(fVertexIndex)
                 faces.append(f)
-        return {"vertices":vertices, "edges":edges, "faces":faces}
+            py_dict = {}
+            if transferDictionaries == True:
+                d = Topology.Dictionary(aFace)
+                if len(Dictionary.Keys(d)) > 0:
+                    py_dict = Dictionary.PythonDictionary(d)
+                face_dicts.append(py_dict)
+        return {"vertices":vertices, "edges":edges, "faces":faces, "vertex_dicts": vertex_dicts, "edge_dicts": edge_dicts, "face_dicts": face_dicts}
 
     @staticmethod
     def HighestType(topology):
@@ -6264,7 +6405,7 @@ class Topology():
     @staticmethod
     def IsSimilar(topologyA, topologyB, removeCoplanarFaces: bool = False, mantissa: int = 6, epsilon: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
-        Returns True if the input topologies are similar. False otherwise. See https://en.wikipedia.org/wiki/Similarity_(geometry).
+        Calculates if the input topologies are similar. See https://en.wikipedia.org/wiki/Similarity_(geometry).
 
         Parameters
         ----------
@@ -6286,7 +6427,8 @@ class Topology():
         Returns
         -------
         [bool, list]
-            True if the input topologies are similar., False otherwise and the matrix needed to tranform topologyA to match topologyB
+            True if the input topologies are similar, False otherwise and the matrix needed to tranform topologyA to match topologyB.
+            If the topologies are not similar, the transformation matrix is None.
 
         """
         from topologicpy.Vertex import Vertex
@@ -6308,7 +6450,6 @@ class Topology():
         if removeCoplanarFaces == True:
             topologyA = Topology.RemoveCoplanarFaces(topologyA, epsilon=epsilon, tolerance=tolerance)
             topologyB = Topology.RemoveCoplanarFaces(topologyB, epsilon=epsilon, tolerance=tolerance)
-        Topology.Show(topologyA, topologyB)
         len_vertices_a = len(Topology.Vertices(topologyA))
         if len_vertices_a < 1 and not Topology.IsInstance(topologyA, "vertex"):
             if not silent:
@@ -6398,90 +6539,58 @@ class Topology():
         if len(faces_a) > 0 and len(faces_b) > 0:
             largest_faces_a = Topology.LargestFaces(topologyA)
             largest_faces_b = Topology.LargestFaces(topologyB)
-
+        else:
+            if not silent:
+                print("Topology.IsSimilar - Error: The topologies do not have faces. Returning None.")
+            return False, None
 
     # Process largest faces
-        largest_faces_a = Topology.LargestFaces(topologyA)
-        largest_faces_b = Topology.LargestFaces(topologyB)
-        face_a_d = Dictionary.ByKeyValue("faceColor", "red")
-        face_b_d = Dictionary.ByKeyValue("faceColor", "blue")
         for face_a in largest_faces_a:
+            l_edge_a = Topology.LongestEdges(face_a)[0]
+            length_a = Edge.Length(l_edge_a)
             centroid_a = Topology.Centroid(face_a)
-            normal_a = Face.Normal(face_a)
+            origin_a = Vertex.Coordinates(centroid_a)
+            zaxis_a = Face.Normal(face_a)
             third_vertex_a = Face.ThirdVertex(face_a)  # Pick a third vertex for orientation
-            orientation_a = Vector.Normalize(Vector.ByVertices(centroid_a, third_vertex_a))
+            xaxis_a = Vector.Normalize(Vector.ByVertices(centroid_a, third_vertex_a))
+            yaxis_a = Vector.Cross(xaxis_a, zaxis_a)
+            # Build Coordinate System matrix. The origin will be (0,0,0) once the trans matrix is applied.
+            cs_a = [[0,0,0]]+[xaxis_a]+[yaxis_a]+[zaxis_a]
+            tran_matrix_a = Matrix.ByTranslation(translateX=-origin_a[0], translateY=-origin_a[1], translateZ=-origin_a[2])
 
+            # Check against the faces of B:
             for face_b in largest_faces_b:
-                face_copy_b = Topology.SetDictionary(Topology.Copy(face_b), face_b_d)
+                l_edge_b = Topology.LongestEdges(face_b)[0]
+                length_b = Edge.Length(l_edge_b)
+                scale_factor = length_b/length_a
+                scale_matrix = Matrix.ByScaling(scaleX=scale_factor, scaleY=scale_factor, scaleZ=scale_factor)
                 centroid_b = Topology.Centroid(face_b)
-                normal_b = Face.Normal(face_b)
+                origin_b = Vertex.Coordinates(centroid_b)
+                zaxis_b = Face.Normal(face_b)
                 third_vertex_b = Face.ThirdVertex(face_b)
-                orientation_b = Vector.Normalize(Vector.ByVertices(centroid_b, third_vertex_b))
-
+                xaxis_b = Vector.Normalize(Vector.ByVertices(centroid_b, third_vertex_b))
+                yaxis_b = Vector.Cross(xaxis_b, zaxis_b)
+                cs_b = [origin_b]+[xaxis_b]+[yaxis_b]+[zaxis_b]
                 # Compute transformation matrix
-                rotation_matrix = Matrix.ByVectors(normal_a, normal_b, orientation_a, orientation_b)
-                scaling_factor = (Face.Area(face_b) / Face.Area(face_a)) ** (1/2)
-                scaling_matrix = Matrix.ByScaling(scaling_factor, scaling_factor, scaling_factor)
-                
-                translation_matrix = Matrix.ByTranslation(
-                    Vertex.X(centroid_b) - Vertex.X(centroid_a),
-                    Vertex.Y(centroid_b) - Vertex.Y(centroid_a),
-                    Vertex.Z(centroid_b) - Vertex.Z(centroid_a)
-                )
-                combined_matrix = Matrix.Multiply(rotation_matrix, scaling_matrix)
-                combined_matrix = Matrix.Multiply(translation_matrix, combined_matrix)
-                
-                transformed_centroid_a = Topology.Transform(centroid_a, combined_matrix)
-
-                # One last translation to synchronise the two centroids.
-                translation_matrix = Matrix.ByTranslation(
-                    Vertex.X(centroid_b) - Vertex.X(transformed_centroid_a),
-                    Vertex.Y(centroid_b) - Vertex.Y(transformed_centroid_a),
-                    Vertex.Z(centroid_b) - Vertex.Z(transformed_centroid_a)
-                )
-                combined_matrix = Matrix.Multiply(translation_matrix, combined_matrix)
+                # translate to origin, scale, then transform coordinate systems
+                combined_matrix = Matrix.Multiply(scale_matrix, tran_matrix_a)
+                matching_matrix = Matrix.ByCoordinateSystems(cs_a, cs_b)
+                combined_matrix = Matrix.Multiply(matching_matrix, combined_matrix)
                 # Apply transformation and compare
-                transformedA = Topology.Transform(topologyA, combined_matrix)
-                transformed_face_a = Topology.Transform(face_a, combined_matrix)
-                transformed_face_a = Topology.SetDictionary(face_a, face_a_d)
-
-                Topology.Show(transformedA, topologyB, transformed_face_a, face_copy_b, faceColorKey="faceColor", vertexSizeKey="vertexSize")
-                if Topology.IsVertexCongruent(transformedA, topologyB, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent):
-                    return True, combined_matrix
+                try:
+                    transformedA = Topology.Transform(topologyA, combined_matrix)
+                    status = Topology.IsVertexCongruent(transformedA, topologyB, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent)
+                    if status:
+                        return True, combined_matrix
+                except:
+                    pass
 
         return False, None
-        # for l_f_a in largest_faces_a:
-        #     l_e_a = Face.NormalEdge(l_f_a)
-        #     centroid_a = Edge.StartVertex(l_e_a)
-        #     dir_a = Vector.Normalize(Edge.Direction(l_e_a))
-        #     trans_matrix_a = Matrix.ByTranslation(-Vertex.X(centroid_a), -Vertex.Y(centroid_a), -Vertex.Z(centroid_a))
-        #     sf_a = 1/Face.Area(l_f_a)
-        #     scaling_matrix_a = Matrix.ByScaling(sf_a, sf_a, sf_a)
-        #     for l_f_b in largest_faces_b:
-        #         l_e_b = Face.NormalEdge(l_f_b)
-        #         centroid_b = Edge.StartVertex(l_e_b)
-        #         dir_b = Vector.Normalize(Edge.Direction(l_e_b))
-        #         rotation_matrix = Matrix.ByVectors(dir_a, dir_b)
-        #         sf_b = 1/Face.Area(l_f_b)
-        #         scaling_matrix_b = Matrix.ByScaling(sf_b, sf_b, sf_b)
-        #         trans_matrix_b = Matrix.ByTranslation(-Vertex.X(centroid_b), -Vertex.Y(centroid_b), -Vertex.Z(centroid_b))
-        #         combined_matrix_a = Matrix.Multiply(rotation_matrix, scaling_matrix_a)
-        #         combined_matrix_a = Matrix.Multiply(combined_matrix_a, trans_matrix_a)
-        #         combined_matrix_b = Matrix.Multiply(scaling_matrix_b, trans_matrix_b)
-        #         top_a = Topology.Transform(topologyA, combined_matrix_a)
-        #         top_b = Topology.Transform(topologyB, combined_matrix_b)
-        #         Topology.Show(top_a, top_b)
-        #         if Topology.IsVertexCongruent(top_a, top_b, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent):
-        #             Topology.Show(top_a, top_b)
-        #             final_matrix = Matrix.Multiply(Matrix.Invert(combined_matrix_b), combined_matrix_a)
-        #             return True, final_matrix
 
-        return False, None
- 
     @staticmethod
     def IsVertexCongruent(topologyA, topologyB, mantissa: int = 6, epsilon: float = 0.1, tolerance: float = 0.0001, silent : bool = False):
         """
-        Returns True if the input topologies are vertex matched (have same number of vertices and all vertices are congruent within a tolerance). Returns False otherwise.
+        Returns True if the input topologies are vertex congruent (have same number of vertices and all vertices are congruent within a tolerance). Returns False otherwise.
 
         Parameters
         ----------
@@ -6491,6 +6600,9 @@ class Topology():
             The second input topology.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        epsilon : float , optional
+            The desired accepted tolerance for the number of matched number of vertices. For example, an epsilon of 0.1 indicates that
+            the algorithm will return True even if 10% of the vertices do not match. The default is 0.1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -6504,46 +6616,27 @@ class Topology():
         """
         from topologicpy.Vertex import Vertex
 
-        def coordinates_unmatched_ratio(list1, list2, tolerance):
+    
+        def coordinates_unmatched_ratio(list1, list2, mantissa, tolerance):
             """
-            Calculates the percentage of coordinates in list1 that do not have a corresponding
-            coordinate in list2 within a specified tolerance, with each match being unique.
-
-            Parameters
-            ----------
-            list1 : list of list of float
-                The first list of coordinates, where each coordinate is [x, y, z].
-            list2 : list of list of float
-                The second list of coordinates, where each coordinate is [x, y, z].
-            tolerance : float
-                The maximum distance within which two coordinates are considered matching.
-
-            Returns
-            -------
-            float
-                The percentage of coordinates in list1 that did not find a match in list2.
+            Optimized version using KDTree for faster nearest-neighbor search.
             """
-            def distance(coord1, coord2):
-                """Calculate the Euclidean distance between two coordinates."""
-                return np.linalg.norm(np.array(coord1) - np.array(coord2))
-
+            from scipy.spatial import KDTree
+            import numpy as np
+            rounded_list1 = [np.round(coord, mantissa) for coord in list1]
+            rounded_list2 = [np.round(coord, mantissa) for coord in list2]
+            
+            tree = KDTree(rounded_list2)
             unmatched_count = 0
-            unmatched = list2.copy()
-
-            for coord1 in list1:
-                match_found = False
-                for i, coord2 in enumerate(unmatched):
-                    if distance(coord1, coord2) <= tolerance:
-                        unmatched.pop(i)  # Remove matched coordinate
-                        match_found = True
-                        break
-                if not match_found:
+            
+            for coord in rounded_list1:
+                distances, indices = tree.query(coord, k=1)
+                if distances > tolerance:
                     unmatched_count += 1
-
-            total_coordinates = len(list1)
-            unmatched_ratio = (unmatched_count / total_coordinates)
             
-            return unmatched_ratio
+            total_coordinates = len(list1)
+            unmatched_ratio = unmatched_count / total_coordinates
+            return round(unmatched_ratio, mantissa)
 
         if not Topology.IsInstance(topologyA, "topology"):
             if not silent:
@@ -6568,11 +6661,12 @@ class Topology():
             return None
         # Number of vertices
         max_len = max([len_vertices_a, len_vertices_b])
-        if abs(len_vertices_a - len_vertices_a)/max_len >= epsilon:
+        ratio = round(float(abs(len_vertices_a - len_vertices_b))/float(max_len), mantissa)
+        if ratio > epsilon:
             return False
         coords_a = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices_a]
         coords_b = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices_b]
-        unmatched_ratio = coordinates_unmatched_ratio(coords_a, coords_b, tolerance=tolerance)
+        unmatched_ratio = coordinates_unmatched_ratio(coords_a, coords_b, mantissa=mantissa, tolerance=tolerance)
         if unmatched_ratio <= epsilon:
             return True
         return False
@@ -6706,6 +6800,161 @@ class Topology():
             return None
         return Topology.SelfMerge(Cluster.ByTopologies(topologyList), tolerance=tolerance)
     
+    @staticmethod
+    def MeshData(topology, mode: int = 1, transferDictionaries: bool = False, mantissa: int = 6, silent: bool = False):
+        """
+        Creates a mesh data python dictionary from the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        mode : int , optional
+            The desired mode of conversion:
+            0: The faces list indexes into the vertices list.
+            1: The faces list indexes into the edges list.
+            The default is 1.
+        transferDictionaries : bool , optional
+            If set to True, the python dictionaries will be transferred to the coorespoding topologies. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        dict
+            The created mesh data python dictionary of vertices, edges, faces, and cells in the form of:
+            { 'mode' : int (the mode of the face data)
+            'vertices': list, (list of coordinates)
+            'edges': list,   (list of indices into the list of vertices)
+            'faces': list,   (list of indices into the list of edges or list of vertices based on mode)
+            'cells': list,   (list of indices into the list of faces)
+            'vertex_dict': list of dicts,
+            'edge_dicts': list of dicts,
+            'face_dicts', list of dicts,
+            'cell_dicts', list of dicts
+            }
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Dictionary import Dictionary
+
+        vertex_dicts = []
+        edge_dicts = []
+        face_dicts = []
+        cell_dicts = []
+        top = Topology.Copy(topology)
+        top = Topology.Triangulate(top, transferDictionaries=transferDictionaries)
+        vertices = Topology.Vertices(top)
+        edges = Topology.Edges(top)
+        faces = Topology.Faces(top)
+        if Topology.IsInstance(top, "Vertex"):
+            vertices = [top]
+            edges = []
+            faces = []
+            cells = []
+        elif Topology.IsInstance(top, "Edge"):
+            vertices = Topology.Vertices(top)
+            edges = [top]
+            faces = []
+            cells = []
+        elif Topology.IsInstance(top, "Wire"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = []
+            cells = []
+        elif Topology.IsInstance(top, "Face"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = [top]
+            cells = []
+        elif Topology.IsInstance(top, "Shell"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = Topology.Faces(top)
+            cells = []
+        elif Topology.IsInstance(top, "Cell"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = Topology.Faces(top)
+            cells = [top]
+        elif Topology.IsInstance(top, "CellComplex"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = Topology.Faces(top)
+            cells = Topology.Cells(top)
+        elif Topology.IsInstance(top, "Cluster"):
+            vertices = Topology.Vertices(top)
+            edges = Topology.Edges(top)
+            faces = Topology.Faces(top)
+            cells = Topology.Cells(top)
+        else:
+            if not silent:
+                print("Topology.MeshData - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+
+        m_verts = []
+        m_edges = []
+        m_faces = []
+        m_cells = []
+        key = "_n_"
+
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            v = Topology.SetDictionary(v, Dictionary.ByKeyValue(key, i))
+            m_verts.append(Vertex.Coordinates(v, mantissa=mantissa))
+            vertex_dicts.append(Dictionary.PythonDictionary(d))
+
+        for i, e in enumerate(edges):
+            d = Topology.Dictionary(e)
+            e = Topology.SetDictionary(e, Dictionary.ByKeyValue(key, i), silent=True)
+            sv, ev = Topology.Vertices(e)
+            sv_n = Dictionary.ValueAtKey(Topology.Dictionary(sv), key)
+            ev_n = Dictionary.ValueAtKey(Topology.Dictionary(ev), key)
+            m_edges.append([sv_n, ev_n])
+            edge_dicts.append(Dictionary.PythonDictionary(d))
+
+        for i, f in enumerate(faces):
+            d = Topology.Dictionary(f)
+            f = Topology.SetDictionary(f, Dictionary.ByKeyValue(key, i), silent=True)
+            if mode == 1:
+                f_edges = Topology.Edges(f)
+                edge_indices = []
+                for f_edge in f_edges:
+                    edge_indices.append(Dictionary.ValueAtKey(Topology.Dictionary(f_edge), key))
+                m_faces.append(edge_indices)
+            else:
+                f_vertices = Topology.Vertices(f)
+                vertex_indices = []
+                for f_vertex in f_vertices:
+                    vertex_indices.append(Dictionary.ValueAtKey(Topology.Dictionary(f_vertex), key))
+                m_faces.append(vertex_indices)
+            face_dicts.append(Dictionary.PythonDictionary(d))
+
+        for i, c in enumerate(cells):
+            d = Topology.Dictionary(c)
+            c = Topology.SetDictionary(c, Dictionary.ByKeyValue(key, i), silent=True)
+            c_faces = Topology.Faces(c)
+            face_indices = []
+            for c_face in c_faces:
+                face_indices.append(Dictionary.ValueAtKey(Topology.Dictionary(c_face), key))
+            m_cells.append(face_indices)
+            cell_dicts.append(Dictionary.PythonDictionary(d))
+        
+        return {"mode": mode,
+                "vertices": m_verts,
+                "edges": m_edges,
+                "faces": m_faces,
+                "cells": m_cells,
+                "vertex_dicts": vertex_dicts,
+                "edge_dicts": edge_dicts,
+                "face_dicts": face_dicts,
+                "cell_dicts": cell_dicts
+                }
+
     @staticmethod
     def Move(topology, x=0, y=0, z=0):
         """
@@ -9791,7 +10040,7 @@ class Topology():
 
     
     @staticmethod
-    def Triangulate(topology, transferDictionaries: bool = False, mode: int = 0, meshSize: float = None, tolerance: float = 0.0001):
+    def Triangulate(topology, transferDictionaries: bool = False, mode: int = 0, meshSize: float = None, tolerance: float = 0.0001, silent: bool = False):
         """
         Triangulates the input topology.
 
@@ -9818,6 +10067,8 @@ class Topology():
             calculated automatically and set to 10% of the overall size of the face.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no warnings or errors will be printed. The default is False.
 
         Returns
         -------
@@ -9832,28 +10083,33 @@ class Topology():
         from topologicpy.Cluster import Cluster
 
         if not Topology.IsInstance(topology, "Topology"):
-            print("Topology.Triangulate - Error: The input parameter is not a valid topology. Returning None.")
+            if not silent:
+                print("Topology.Triangulate - Error: The input parameter is not a valid topology. Returning None.")
             return None
         t = Topology.Type(topology)
         if (t == Topology.TypeID("Vertex")) or (t == Topology.TypeID("Edge")) or (t == Topology.TypeID("Wire")):
+            if not silent:
+                print("Topology.Triangulate - Warning: The input topology parameter contains no faces. Returning the original topology.")
             return topology
         elif t == Topology.TypeID("Cluster"):
             temp_topologies = []
             cellComplexes = Topology.SubTopologies(topology, subTopologyType="cellcomplex") or []
             for cc in cellComplexes:
-                temp_topologies.append(Topology.Triangulate(cc, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance))
+                temp_topologies.append(Topology.Triangulate(cc, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance, silent=silent))
             cells = Cluster.FreeCells(topology, tolerance=tolerance) or []
             for c in cells:
-                temp_topologies.append(Topology.Triangulate(c, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance))
+                temp_topologies.append(Topology.Triangulate(c, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance, silent=silent))
             shells = Cluster.FreeShells(topology, tolerance=tolerance) or []
             for s in shells:
-                temp_topologies.append(Topology.Triangulate(s, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance))
+                temp_topologies.append(Topology.Triangulate(s, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance, silent=silent))
             faces = Cluster.FreeFaces(topology, tolerance=tolerance) or []
             for f in faces:
-                temp_topologies.append(Topology.Triangulate(f, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance))
+                temp_topologies.append(Topology.Triangulate(f, transferDictionaries=transferDictionaries, mode=mode, meshSize=meshSize, tolerance=tolerance, silent=silent))
             if len(temp_topologies) > 0:
                 return Cluster.ByTopologies(temp_topologies)
             else:
+                if not silent:
+                    print("Topology.Triangulate - Warning: The input topology parameter contains no faces. Returning the original topology.")
                 return topology
         topologyFaces = []
         _ = topology.Faces(None, topologyFaces)
@@ -9866,7 +10122,7 @@ class Topology():
                 triFaces = [aFace]
             for triFace in triFaces:
                 if transferDictionaries:
-                    selectors.append(Topology.SetDictionary(Face.Centroid(triFace), Topology.Dictionary(aFace)))
+                    selectors.append(Topology.SetDictionary(Topology.Centroid(triFace), Topology.Dictionary(aFace), silent=True))
                 faceTriangles.append(triFace)
         return_topology = None
         if t == Topology.TypeID("Face") or t == Topology.TypeID("Shell"): # Face or Shell