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

topologicpy/Topology.py

@@ -3075,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],
@@ -3303,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]))
@@ -5893,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.
 
@@ -5901,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
         -------
@@ -5913,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)
@@ -5951,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):
@@ -5986,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):
@@ -6477,45 +6616,26 @@ class Topology():
         """
         from topologicpy.Vertex import Vertex
 
+    
         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)
             
+            total_coordinates = len(list1)
+            unmatched_ratio = unmatched_count / total_coordinates
             return round(unmatched_ratio, mantissa)
 
         if not Topology.IsInstance(topologyA, "topology"):
@@ -6680,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):
         """
@@ -9765,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.
 
@@ -9792,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
         -------
@@ -9806,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)
@@ -9840,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

topologicpy/Vertex.py

@@ -313,17 +313,17 @@ class Vertex():
             return None
         if len(args) > 0:
             value = args[0]
-            if isinstance(value, list) and len(value) > 3:
+            if (isinstance(value, list) or isinstance(value, tuple)) and len(value) > 3:
                 print("Vertex.ByCoordinates - Error: Input parameters are greater than 3. Returning None.")
                 return None
-            elif isinstance(value, list) and len(value) == 3:
+            elif (isinstance(value, list) or isinstance(value, tuple)) and len(value) == 3:
                 x = value[0]
                 y = value[1]
                 z = value[2]
-            elif isinstance(value, list) and len(value) == 2:
+            elif (isinstance(value, list) or isinstance(value, tuple)) and len(value) == 2:
                 x = value[0]
                 y = value[1]
-            elif isinstance(value, list) and len(value) == 1:
+            elif (isinstance(value, list) or isinstance(value, tuple)) and len(value) == 1:
                 x = value[0]
             elif len(args) == 3:
                 x = args[0]

topologicpy/Wire.py

@@ -3862,26 +3862,26 @@ class Wire():
                 source = subtree.source
                 height = subtree.height
                 z = slope * height
-                source_vertex = Vertex.ByCoordinates(source.x, source.y, z)
+                source_vertex = Vertex.ByCoordinates(source.X(), source.Y(), z)
 
                 for sink in subtree.sinks:
-                    if (sink.x, sink.y) in polygon_z:
+                    if (sink.X(), sink.Y()) in polygon_z:
                         z = 0
                     else:
                         z = None
                         for st in subtrees:
-                            if st.source.x == sink.x and st.source.y == sink.y:
+                            if st.source.X() == sink.X() and st.source.Y() == sink.Y():
                                 z = slope * st.height
                                 break
                             for sk in st.sinks:
-                                if sk.x == sink.x and sk.y == sink.y:
+                                if sk.X() == sink.X() and sk.Y() == sink.Y():
                                     z = slope * st.height
                                     break
                         if z is None:
                             height = subtree.height
                             z = slope * height
-                    sink_vertex = Vertex.ByCoordinates(sink.x, sink.y, z)
-                    if (source.x, source.y) == (sink.x, sink.y):
+                    sink_vertex = Vertex.ByCoordinates(sink.X(), sink.Y(), z)
+                    if (source.X(), source.Y()) == (sink.X(), sink.Y()):
                         continue
                     e = Edge.ByStartVertexEndVertex(source_vertex, sink_vertex, tolerance=tolerance, silent=True)
                     if e not in edges and e != None:

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.15'
+__version__ = '0.8.17'

{topologicpy-0.8.15.dist-info → topologicpy-0.8.17.dist-info}/METADATA

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

{topologicpy-0.8.15.dist-info → topologicpy-0.8.17.dist-info}/RECORD

@@ -7,10 +7,10 @@ topologicpy/Cluster.py,sha256=o5jdMRpcGfSGGiXQdFg-e9XcnBF5AqTj3xb1nSpwJWE,58606
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=M_znFtyPBJJz-iXLYZs2wwBj24fhevIo739dGha0chM,139041
-topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,33186
+topologicpy/Dictionary.py,sha256=7h-Gszgnt2OEOvOSADJ4pa-mTNlhQ9cuIiB5WHEW6aY,33949
 topologicpy/Edge.py,sha256=yxkCVDYBflJNEYxnjMmlyvbkpg8TNy7y5bSH3yQ4jzs,71418
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
-topologicpy/Face.py,sha256=tn3PI-t9rXikgI1QMclw0PFwQ5vvyLi-wJKqZZZ9xmw,182755
+topologicpy/Face.py,sha256=SlhB8L7BpDjd4a9YZE4UJ3zoGuF1oq9MSpuesEWro_Q,184847
 topologicpy/Graph.py,sha256=FBmiMObzztPwZFJ2T846Ivz0Y1kpzMF0sF-PDUMPk4o,498946
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
@@ -18,19 +18,19 @@ topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
 topologicpy/Matrix.py,sha256=i22RLP5ebUAMuU7V1tZ__Z4lf1pg9fzq9nENsDZUV74,22779
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
 topologicpy/Plotly.py,sha256=RU_VioIRLGIYzwyKI9OQHOx9OxxGppdpagysgTbdxIE,115942
-topologicpy/Polyskel.py,sha256=DDUayC29LI1EkxdK09F0DgGyH-NCOU1LE3J2Imz0rEI,19832
+topologicpy/Polyskel.py,sha256=ro5in--VT_uag55r5xymU5ufyAahsovIiJwyiqG_qH8,27082
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=--dJoSdz6BapxVEyG2DI0W5apO_xwLORj5qmR15yl2Y,87983
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=O91rRl32hG3YvKowSDGbxaq3zdM16RIChT4HF9hNODM,463786
+topologicpy/Topology.py,sha256=gkKLazHKrSwrCt4lZckNuUlXQ1e9rUvK2XqjUMscFGM,476658
 topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
-topologicpy/Vertex.py,sha256=xr8KSgKnx-hgVp-eIvMPAKRv04R-wk-_4zc57xVyEqE,80793
-topologicpy/Wire.py,sha256=x7tOeR1o5qi5cXp_d9JrQrSXfYztCWiBC1OnVl6Yp7A,228463
+topologicpy/Vertex.py,sha256=q99IrWwdNlvVfUXz6iP8icmP8NzP2nsiqtgnF9Jnpx8,80913
+topologicpy/Wire.py,sha256=IVPzBKsckuxC-rHvwxmvtVF7PpApz2lhPHomtQMo_kg,228499
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=HbO2F5YBMLHRpphNJizV3_Sp8T0xTu3xaqHhjkNWPRc,23
-topologicpy-0.8.15.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.15.dist-info/METADATA,sha256=ft8T8ED9kou73cq52cvDshxjosXDKXdtXLqososiUNM,10513
-topologicpy-0.8.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.15.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.15.dist-info/RECORD,,
+topologicpy/version.py,sha256=jgMQSjzTF3zegQBB2-KO1QeuJ1ufZ8T-ts7A2g5atuc,23
+topologicpy-0.8.17.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.17.dist-info/METADATA,sha256=KNPPFYSnLPlGCabjuBHARXEBTvQQFuFlUtH7ZutDPJ8,10513
+topologicpy-0.8.17.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+topologicpy-0.8.17.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.17.dist-info/RECORD,,

{topologicpy-0.8.15.dist-info → topologicpy-0.8.17.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any