topologicpy 0.7.87__py3-none-any.whl → 0.7.90__py3-none-any.whl

topologicpy/Cell.py

@@ -1471,7 +1471,7 @@ class Cell():
         return shells
     
     @staticmethod
-    def InternalVertex(cell, tolerance: float = 0.0001):
+    def InternalVertex(cell, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a vertex that is guaranteed to be inside the input cell.
 
@@ -1481,6 +1481,8 @@ class Cell():
             The input cell.
         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
         -------
@@ -1491,12 +1493,14 @@ class Cell():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(cell, "Cell"):
-            print("Cell.InternalVertex - Error: The input cell parameter is not a valid topologic cell. Returning None.")
+            if not silent:
+                print("Cell.InternalVertex - Error: The input cell parameter is not a valid topologic cell. Returning None.")
             return None
         try:
             return topologic.CellUtility.InternalVertex(cell, tolerance) # Hook to Core
         except:
-            print("Cell.InternalVertex - Error: Could not create an internal vertex. Returning None.")
+            if not silent:
+                print("Cell.InternalVertex - Error: Could not create an internal vertex. Returning None.")
             return None
     
     @staticmethod

topologicpy/Face.py

@@ -1518,7 +1518,7 @@ class Face():
         return list(wires)
 
     @staticmethod
-    def InternalVertex(face, tolerance: float = 0.0001):
+    def InternalVertex(face, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a vertex guaranteed to be inside the input face.
 
@@ -1528,6 +1528,8 @@ class Face():
             The input face.
         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
         -------
@@ -1535,22 +1537,53 @@ class Face():
             The created vertex.
 
         """
+        def get_uv_radially():
+            """
+            Generate the points of a grid with a given size n, sorted radially from the center to the periphery.
+            n should be an odd number, ensuring that there's a center point (0, 0).
+            
+            Args:
+                n (int): The size of the grid. It should be odd for a clear center point.
+                
+            Returns:
+                list: A list of tuples (x, y) sorted by radial distance from the center (0, 0).
+            """
+            import math
+
+            points = []
+            n = 100
+            # Iterate over the grid, ranging from -n//2 to n//2
+            for x in range(-n//2, n//2 + 1):
+                for y in range(-n//2, n//2 + 1):
+                    points.append((x, y))
+            
+            # Sort points by their Euclidean distance from the center (0, 0)
+            points.sort(key=lambda point: math.sqrt(point[0]**2 + point[1]**2))
+            return_points = []
+            for p in points:
+                new_p = ((p[0]+50)*0.01, (p[1]+50)*0.01)
+                return_points.append(new_p)
+            return return_points
+        
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
             return None
-        v = Topology.Centroid(face)
-        if Vertex.IsInternal(v, face, tolerance=tolerance):
-            return v
-        l = [0.4,0.6,0.3,0.7,0.2,0.8,0.1,0.9]
-        for u in l:
-            for v in l:
-                v = Face.VertexByParameters(face, u, v)
-                if Vertex.IsInternal(v, face, tolerance=tolerance):
-                    return v
-        v = topologic.FaceUtility.InternalVertex(face, tolerance) # Hook to Core
-        return v
+        vert = Topology.Centroid(face)
+        if Vertex.IsInternal(vert, face, tolerance=tolerance):
+            return vert
+        uv_list = get_uv_radially()
+        for uv in uv_list:
+            u, v = uv
+            vert = Face.VertexByParameters(face, u, v)
+            if Vertex.IsInternal(vert, face, tolerance=tolerance):
+                return vert
+        if not silent:
+            print("Face.InternalVertex - Warning: Could not find an internal vertex. Returning the first vertex of the face.")
+        vert = Topology.Vertices(face)[0]
+        #v = topologic.FaceUtility.InternalVertex(face, tolerance) # Hook to Core
+        return vert
 
     @staticmethod
     def Invert(face, tolerance: float = 0.0001):
@@ -2365,6 +2398,8 @@ class Face():
             The desired length of the normal edge. The default is 1.
         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
         -------

topologicpy/Graph.py

@@ -2160,9 +2160,14 @@ class Graph:
         return {'graphs':graphs, 'labels':labels}
 
     @staticmethod
-    def ByIFCFile(file, includeTypes: list = [], excludeTypes: list = [],
-                  includeRels: list = [], excludeRels: list = [],
-                  transferDictionaries: bool = False, storeBREP: bool = False,
+    def ByIFCFile(file,
+                  includeTypes: list = [],
+                  excludeTypes: list = [],
+                  includeRels: list = [],
+                  excludeRels: list = [],
+                  transferDictionaries: bool = False,
+                  useInternalVertex: bool = False,
+                  storeBREP: bool = False,
                   removeCoplanarFaces: bool = False,
                   xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
                   xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
@@ -2184,6 +2189,8 @@ class Graph:
             A list of IFC relationship types to exclude from the graph. The default is [] which mean no relationship type is excluded.
         transferDictionaries : bool , optional
             If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        useInternalVertex : bool , optional
+            If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. The default is False.
         storeBREP : bool , optional
             If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
         removeCoplanarFaces : bool , optional
@@ -2466,7 +2473,7 @@ class Graph:
                     pset_python_dict = get_psets(ifc_object)
                     pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
                     topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
-                    if storeBREP == True:
+                    if storeBREP == True or useInternalVertex == True:
                         shape_topology = None
                         if hasattr(ifc_object, "Representation") and ifc_object.Representation:
                             for rep in ifc_object.Representation.Representations:
@@ -2484,8 +2491,10 @@ class Graph:
                                     if not shape_topology == None:
                                         if removeCoplanarFaces == True:
                                             shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
-                        if not shape_topology == None:
+                        if not shape_topology == None and storeBREP:
                             topology_dict = Dictionary.SetValuesAtKeys(topology_dict, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(shape_topology), Topology.Type(shape_topology), Topology.TypeAsString(shape_topology)])
+                        if not shape_topology == None and useInternalVertex == True:
+                            centroid = Topology.InternalVertex(shape_topology)
                     centroid = Topology.SetDictionary(centroid, topology_dict)
                 return centroid
             return None
@@ -2571,7 +2580,16 @@ class Graph:
         return g
 
     @staticmethod
-    def ByIFCPath(path, includeTypes=[], excludeTypes=[], includeRels=[], excludeRels=[], transferDictionaries=False, storeBREP=False, removeCoplanarFaces=False, xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5):
+    def ByIFCPath(path,
+                  includeTypes=[],
+                  excludeTypes=[],
+                  includeRels=[],
+                  excludeRels=[],
+                  transferDictionaries=False,
+                  useInternalVertex=False,
+                  storeBREP=False,
+                  removeCoplanarFaces=False,
+                  xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5):
         """
         Create a Graph from an IFC path. This code is partially based on code from Bruno Postle.
 
@@ -2589,6 +2607,8 @@ class Graph:
             A list of IFC relationship types to exclude from the graph. The default is [] which mean no relationship type is excluded.
         transferDictionaries : bool , optional
             If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        useInternalVertex : bool , optional
+            If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. The default is False.
         storeBREP : bool , optional
             If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
         removeCoplanarFaces : bool , optional
@@ -2647,6 +2667,7 @@ class Graph:
                                includeRels=includeRels,
                                excludeRels=excludeRels,
                                transferDictionaries=transferDictionaries,
+                               useInternalVertex=useInternalVertex,
                                storeBREP=storeBREP,
                                removeCoplanarFaces=removeCoplanarFaces,
                                xMin=xMin, yMin=yMin, zMin=zMin, xMax=xMax, yMax=yMax, zMax=zMax)
@@ -4081,6 +4102,79 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return graph
     
+    @staticmethod
+    def ConnectedComponents(graph, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the connected components (islands) of the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        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
+        -------
+        list
+            The list of connected components (island graphs).
+            The list is sorted by the number of vertices in each component (from highest to lowest).
+
+        """
+        def find_connected_components(adjacency_dict):
+            visited = set()
+            components = []
+
+            for vertex_id in adjacency_dict:
+                if vertex_id not in visited:
+                    # Perform DFS using a stack
+                    stack = [vertex_id]
+                    current_island = set()
+                    
+                    while stack:
+                        current = stack.pop()
+                        if current not in visited:
+                            visited.add(current)
+                            current_island.add(current)
+                            stack.extend(set(adjacency_dict[current]) - visited)
+
+                    components.append(current_island)
+
+            return components
+        
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.ConnectedComponents - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        
+        labelKey = "__label__"
+        lengths = [] #List of lengths to sort the list of components by number of their vertices
+        vertices = Graph.Vertices(graph)
+        g_dict = Graph.AdjacencyDictionary(graph, vertexLabelKey=labelKey)
+        components = find_connected_components(g_dict)
+        return_components = []
+        for component in components:
+            i_verts = []
+            for v in component:        
+                vert = Topology.Filter(vertices, searchType="equal to", key=labelKey, value=v)['filtered'][0]
+                d = Topology.Dictionary(vert)
+                d = Dictionary.RemoveKey(d, labelKey)
+                vert = Topology.SetDictionary(vert, d)
+                i_verts.append(vert)
+            i_edges = Graph.Edges(graph, i_verts)
+            lengths.append(len(i_verts))
+            g_component = Graph.ByVerticesEdges(i_verts, i_edges)
+            return_components.append(g_component)
+        return_components = Helper.Sort(return_components, lengths)
+        return_components.reverse()
+        return return_components
+
     @staticmethod
     def ContractEdge(graph, edge, vertex=None, tolerance=0.0001):
         """
@@ -4184,7 +4278,7 @@ class Graph:
         return graph
     
     @staticmethod
-    def ClosenessCentrality(graph, vertices=None, key: str = "closeness_centrality", mantissa: int = 6, tolerance = 0.0001):
+    def ClosenessCentrality(graph, vertices=None, key: str = "closeness_centrality", mantissa: int = 6, tolerance = 0.0001, silent = False):
         """
         Return the closeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the closeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Closeness_centrality.
 
@@ -4200,6 +4294,8 @@ class Graph:
             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
         -------
@@ -4207,56 +4303,68 @@ class Graph:
             The closeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
 
         """
+
+        def closeness_centrality(g):
+            """
+            Computes the closeness centrality for each vertex in the graph.
+
+            Parameters:
+                graph (dict): A dictionary representing the graph where keys are vertices and 
+                            values are lists of neighboring vertices.
+
+            Returns:
+                dict: A dictionary where keys are vertices and values are their closeness centrality.
+            """
+            keys = list(g.keys())
+            N = len(keys)
+
+            centralities = []
+            for v in keys:
+                total_distance = 0
+                reachable_count = 0
+                
+                for u in keys:
+                    if v != u:
+                        distance = Graph._topological_distance(g, v, u)
+                        if distance != None:
+                            total_distance += distance
+                            reachable_count += 1
+                
+                if reachable_count > 0:  # Avoid division by zero
+                    centrality = (reachable_count / total_distance)
+                else:
+                    centrality = 0.0  # Isolated vertex
+            
+                centralities.append(centrality)
+            return centralities
+        
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
             return None
+        g = Graph.AdjacencyDictionary(graph)
+        centralities = closeness_centrality(g)
         graphVertices = Graph.Vertices(graph)
-        if not isinstance(vertices, list):
-            vertices = graphVertices
+        if vertices == None:
+            for i, v in enumerate(graphVertices):
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, key, centralities[i])
+                v = Topology.SetDictionary(v, d)
+            return centralities
         else:
-            vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 1:
-            print("Graph.ClosenessCentrality - Error: The input list of vertices does not contain any valid vertices. Returning None.")
-            return None
-        n = len(graphVertices)
-
-        scores = []
-        try:
-            for va in tqdm(vertices, desc="Computing Closeness Centrality", leave=False):
-                top_dist = 0
-                for vb in graphVertices:
-                    if Topology.IsSame(va, vb):
-                        d = 0
-                    else:
-                        d = Graph.TopologicalDistance(graph, va, vb, tolerance=tolerance)
-                    top_dist += d
-                if top_dist == 0:
-                    print("Graph.ClosenessCentrality - Warning: Topological Distance is Zero.")
-                    scores.append(0)
-                else:
-                    scores.append(round((n-1)/top_dist, mantissa))
-        except:
-            print("Graph.ClosenessCentrality - Warning: Could not use tqdm.")
-            for va in vertices:
-                top_dist = 0
-                for vb in graphVertices:
-                    if Topology.IsSame(va, vb):
-                        d = 0
-                    else:
-                        d = Graph.TopologicalDistance(graph, va, vb, tolerance=tolerance)
-                    top_dist += d
-                if top_dist == 0:
-                    scores.append(0)
-                else:
-                    scores.append(round((n-1)/top_dist, mantissa))
-        for i, v in enumerate(vertices):
-            d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, scores[i])
-            v = Topology.SetDictionary(v, d)
-        return scores
+            return_centralities = []
+            for v in vertices:
+                i = Vertex.Index(v, graphVertices)
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, key, centralities[i])
+                v = Topology.SetDictionary(v, d)
+                return_centralities.append(centralities[i])
+            return centralities
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -8879,6 +8987,28 @@ class Graph:
             return None
         return len(Graph.Edges(graph))
 
+    @staticmethod
+    def _topological_distance(g, start, target):
+        from collections import deque
+        if start == target:
+            return 0
+        visited = set()
+        queue = deque([(start, 0)])  # Each element is a tuple (vertex, distance)
+
+        while queue:
+            current, distance = queue.popleft()
+            if current in visited:
+                continue
+            
+            visited.add(current)
+            for neighbor in g.get(current, []):
+                if neighbor == target:
+                    return distance + 1
+                if neighbor not in visited:
+                    queue.append((neighbor, distance + 1))
+        
+        return None  # Target not reachable
+    
     @staticmethod
     def TopologicalDistance(graph, vertexA, vertexB, tolerance=0.0001):
         """
@@ -8901,6 +9031,8 @@ class Graph:
             The topological distance between the input vertices.
 
         """
+        
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
@@ -8912,7 +9044,19 @@ class Graph:
         if not Topology.IsInstance(vertexB, "Vertex"):
             print("Graph.TopologicalDistance - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
-        return graph.TopologicalDistance(vertexA, vertexB, tolerance) # Hook to Core
+        
+        g = Graph.AdjacencyDictionary(graph)
+        vertices = Graph.Vertices(graph)
+        keys = list(g.keys())
+        index_a = Vertex.Index(vertexA, vertices, tolerance=tolerance)
+        if index_a == None:
+            return 0
+        start = keys[index_a]
+        index_b = Vertex.Index(vertexB, vertices, tolerance=tolerance)
+        if index_b == None:
+            return 0
+        target = keys[index_b]
+        return Graph._topological_distance(g, start, target)
     
     @staticmethod
     def Topology(graph):

topologicpy/Topology.py

@@ -6240,7 +6240,7 @@ class Topology():
             return Topology.Type(topology)
 
     @staticmethod
-    def _InternalVertex(topology, tolerance: float = 0.0001):
+    def _InternalVertex(topology, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns a vertex guaranteed to be inside the input topology.
 
@@ -6250,6 +6250,8 @@ class Topology():
             The input topology.
         tolerance : float , ptional
             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
         -------
@@ -6271,20 +6273,20 @@ class Topology():
         top = Topology.Copy(topology)
         if Topology.IsInstance(top, "CellComplex"): #CellComplex
             tempCell = Topology.Cells(top)[0]
-            vst = Cell.InternalVertex(tempCell, tolerance=tolerance)
+            vst = Cell.InternalVertex(tempCell, tolerance=tolerance, silent=silent)
         elif Topology.IsInstance(top, "Cell"): #Cell
-            vst = Cell.InternalVertex(top, tolerance=tolerance)
+            vst = Cell.InternalVertex(top, tolerance=tolerance, silent=silent)
         elif Topology.IsInstance(top, "Shell"): #Shell
             tempFace = Topology.Faces(top)[0]
-            vst = Face.InternalVertex(tempFace, tolerance=tolerance)
+            vst = Face.InternalVertex(tempFace, tolerance=tolerance, silent=silent)
         elif Topology.IsInstance(top, "Face"): #Face
-            vst = Face.InternalVertex(top, tolerance=tolerance)
+            vst = Face.InternalVertex(top, tolerance=tolerance, silent=silent)
         elif Topology.IsInstance(top, "Wire"): #Wire
             if top.IsClosed():
                 internalBoundaries = []
                 try:
                     tempFace = topologic.Face.ByExternalInternalBoundaries(top, internalBoundaries)
-                    vst = Face.InternalVertex(tempFace, tolerance=tolerance)
+                    vst = Face.InternalVertex(tempFace, tolerance=tolerance, silent=silent)
                 except:
                     vst = Topology.Centroid(top)
             else:
@@ -6295,7 +6297,7 @@ class Topology():
         elif Topology.IsInstance(top, "Vertex"): #Vertex
             vst = top
         elif Topology.IsInstance(topology, "Aperture"): #Aperture
-            vst = Face.InternalVertex(Aperture.Topology(top), tolerance=tolerance)
+            vst = Face.InternalVertex(Aperture.Topology(top), tolerance=tolerance, silent=silent)
         else:
             vst = Topology.Centroid(top)
         return vst
@@ -6303,7 +6305,7 @@ class Topology():
     
 
     @staticmethod
-    def InternalVertex(topology, timeout: int = 10, tolerance: float = 0.0001):
+    def InternalVertex(topology, timeout: int = 30, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns a vertex guaranteed to be inside the input topology.
 
@@ -6312,9 +6314,11 @@ class Topology():
         topology : topologic_core.Topology
             The input topology.
         timeout : int , optional
-            The amount of seconds to wait before timing out. The default is 10 seconds.
+            The amount of seconds to wait before timing out. The default is 30 seconds.
         tolerance : float , ptional
             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
         -------
@@ -6325,22 +6329,21 @@ class Topology():
         import concurrent.futures
         import time
         # Wrapper function with timeout
-        def run_with_timeout(func, topology, tolerance=0.0001, timeout=10):
+        def run_with_timeout(func, topology, tolerance=0.0001, silent=False, timeout=10):
             with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(func, topology, tolerance=tolerance)
+                future = executor.submit(func, topology, tolerance=tolerance, silent=silent)
                 try:
                     result = future.result(timeout=timeout)  # Wait for the result with a timeout
                     return result
                 except concurrent.futures.TimeoutError:
-                    print("Function took too long, retrying with a different solution.")
                     return None  # or try another approach here
 
-        result = run_with_timeout(Topology._InternalVertex, topology=topology, tolerance=tolerance, timeout=timeout)  # Set a 10 second timeout
+        result = run_with_timeout(Topology._InternalVertex, topology=topology, tolerance=tolerance, silent=silent, timeout=timeout)  # Set a 10 second timeout
         if result is None:
             # Handle failure case (e.g., try a different solution)
-            print("Using a different approach.")
-            result = Topology.Centroid(topology)
-            print("Result is:", result)
+            if not silent:
+                print("Topology.InternalVertex - Warning: Operation took too long. Returning None")
+            return None
         return result
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.87'
+__version__ = '0.7.90'

{topologicpy-0.7.87.dist-info → topologicpy-0.7.90.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.87
+Version: 0.7.90
 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.7.87.dist-info → topologicpy-0.7.90.dist-info}/RECORD

@@ -1,7 +1,7 @@
 topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=mKVCAu9K8qzcWXtPDVH5usXZV1DNNNJl4n3rU5Lh1ZM,12931
-topologicpy/Cell.py,sha256=nVJEFgj6nnHDNUYIlMf1NS2xiufDMj18szKGqf9HwDM,108090
+topologicpy/Cell.py,sha256=Fdqf2GCWfKe50EecBVcB8PCHKWENRUTTH8yPrOSF3-0,108321
 topologicpy/CellComplex.py,sha256=ncjfvJ2QJzz4Fu8BMaQBLxAQ6WHx6HfUCddaLP8kXsc,51480
 topologicpy/Cluster.py,sha256=__PvNVjRnFfy12aawd7HSrb3UBX3Rtd1iWSSQnPGpfk,55768
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
@@ -10,8 +10,8 @@ topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,33186
 topologicpy/Edge.py,sha256=KWOJCkLDwCWyZJ5MKwDhT5umWwCYBHtLOz6ulHrSOfY,67205
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
-topologicpy/Face.py,sha256=qiQmvCRFHO248VMqPxcE4Jrrw2JvNIJDdWHMopCPWGQ,142173
-topologicpy/Graph.py,sha256=YKVo3ePAesJL4pt8GBekzPhujGeTc2XbErnzqEOZITQ,431147
+topologicpy/Face.py,sha256=f4DrZJ2AgwnTwIorJpwuOXtWq501wOMRixMgHZC78so,143843
+topologicpy/Graph.py,sha256=Zxmoy2FAl5m_MGUd62jDeajmZAFlKXVHf1Fy68TrsSw,436694
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
@@ -23,14 +23,14 @@ topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=UdDz3zfIYmGRjoZIseviJ2cXNtR5Kx5tIsZLhWMyO_U,87906
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=E683mKTwx4a1p1l6vN5KWFqX9gVJwV78S12EdtkfQjM,441297
+topologicpy/Topology.py,sha256=d99wryPPXvw7eRw12GVKV-DT6jhlmVq6GsMAjg-E-40,441693
 topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
 topologicpy/Vertex.py,sha256=sYWTbAHqKGRUAJRCIUqrCO_xFhvsXK09Sx7E4dafPLQ,73754
 topologicpy/Wire.py,sha256=HjagWKoJb8Z3zhgOij_4k6ZnKIl5gk8LletHbsT1ZKU,190632
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=9To1hhHw5YQrfDyVdFvuKgwM_UIfjviXKudPl9B2kdE,23
-topologicpy-0.7.87.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.87.dist-info/METADATA,sha256=UWltJr_9E-eV2trZxj7ZsvXZlVD8GHtBWdIxgUvn6zM,10513
-topologicpy-0.7.87.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.87.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.87.dist-info/RECORD,,
+topologicpy/version.py,sha256=mYCzbNDO5wSdD-Yv5YhtOF5hGlgyQ-E65V4XiSUOLnk,23
+topologicpy-0.7.90.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.90.dist-info/METADATA,sha256=h8bGLDHNJXflEvDHHSsD0bDwwj39F_AvSqvvwVvi5Ec,10513
+topologicpy-0.7.90.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.90.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.90.dist-info/RECORD,,