topologicpy 0.7.57__py3-none-any.whl → 0.7.58__py3-none-any.whl

topologicpy/BVH.py

@@ -0,0 +1,296 @@
+# Copyright (C) 2024
+# Wassim Jabi <wassim.jabi@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along with
+# this program. If not, see <https://www.gnu.org/licenses/>.
+
+import topologic_core as topologic
+import warnings
+
+try:
+    import numpy as np
+except:
+    print("BVH - Installing required numpy library.")
+    try:
+        os.system("pip install numpy")
+    except:
+        os.system("pip install numpy --user")
+    try:
+        import numpy as np
+        print("BVH - numpy library installed correctly.")
+    except:
+        warnings.warn("ANN - Error: Could not import numpy.")
+
+class BVH:
+    # A class for Axis-Aligned Bounding Box (AABB)
+    class AABB:
+        def __init__(self, min_point, max_point):
+            self.min_point = np.array(min_point)
+            self.max_point = np.array(max_point)
+            self.centroid = (self.min_point + self.max_point) / 2.0
+
+        def intersects(self, other):
+            # Check if this AABB intersects with another AABB
+            return np.all(self.min_point <= other.max_point) and np.all(self.max_point >= other.min_point)
+
+        def contains(self, point):
+            # Check if a point is contained within the AABB
+            return np.all(self.min_point <= point) and np.all(self.max_point >= point)
+
+    # MeshObject class that stores a reference to the Topologic object
+    class MeshObject:
+        def __init__(self, vertices, topologic_object):
+            self.vertices = np.array(vertices)
+            self.aabb = BVH.AABB(np.min(vertices, axis=0), np.max(vertices, axis=0))
+            self.centroid = np.mean(vertices, axis=0)
+            self.topologic_object = topologic_object  # Store the Topologic object reference
+
+    # BVH Node class
+    class BVHNode:
+        def __init__(self, aabb, left=None, right=None, objects=None):
+            self.aabb = aabb
+            self.left = left
+            self.right = right
+            self.objects = objects if objects else []
+
+    @staticmethod
+    def ByTopologies(*topologies, silent: bool = False):
+        """
+        Creates a BVH Tree from the input list of topologies. The input can be individual topologies each as an input argument or a list of topologies stored in one input argument.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        BVH tree
+            The created BVH tree.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if len(topologies) == 0:
+            print("BVH.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+            return None
+        if len(topologies) == 1:
+            topologyList = topologies[0]
+            if isinstance(topologyList, list):
+                if len(topologyList) == 0:
+                    if not silent:
+                        print("BVH.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+                    if len(topologyList) == 0:
+                        if not silent:
+                            print("BVH.ByTopologies - Error: The input topologies parameter does not contain any valid topologies. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("BVH.ByTopologies - Warning: The input topologies parameter contains only one topology. Returning the same topology.")
+                return topologies
+        else:
+            topologyList = Helper.Flatten(list(topologies))
+            topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+        if len(topologyList) == 0:
+            if not silent:
+                print("BVH.ByTopologies - Error: The input parameters do not contain any valid topologies. Returning None.")
+            return None
+        # Recursive BVH construction
+        def build_bvh(objects, depth=0):
+            if len(objects) == 1:
+                return BVH.BVHNode(objects[0].aabb, objects=objects)
+            
+            # Split objects along the median axis based on their centroids
+            axis = depth % 3
+            objects.sort(key=lambda obj: obj.centroid[axis])
+            
+            mid = len(objects) // 2
+            left_bvh = build_bvh(objects[:mid], depth + 1)
+            right_bvh = build_bvh(objects[mid:], depth + 1)
+
+            # Merge left and right bounding boxes
+            combined_aabb = BVH.AABB(
+                np.minimum(left_bvh.aabb.min_point, right_bvh.aabb.min_point),
+                np.maximum(left_bvh.aabb.max_point, right_bvh.aabb.max_point)
+            )
+            
+            return BVH.BVHNode(combined_aabb, left_bvh, right_bvh)
+        
+        mesh_objects = []
+        for topology in topologyList:
+            vertices = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in Topology.Vertices(topology)]
+            mesh_objects.append(BVH.MeshObject(vertices, topology))
+        
+        return build_bvh(mesh_objects)
+    
+    @staticmethod
+    def QueryByTopologies(*topologies, silent: bool = False):
+        """
+        Creates a BVH Query from the input list of topologies. The input can be individual topologies each as an input argument or a list of topologies stored in one input argument.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        BVH query
+            The created BVH query.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+
+        if len(topologies) == 0:
+            print("BVH.QueryByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+            return None
+        if len(topologies) == 1:
+            topologyList = topologies[0]
+            if isinstance(topologyList, list):
+                if len(topologyList) == 0:
+                    if not silent:
+                        print("BVH.QueryByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+                    if len(topologyList) == 0:
+                        if not silent:
+                            print("BVH.QueryByTopologies - Error: The input topologies parameter does not contain any valid topologies. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("BVH.QueryByTopologies - Warning: The input topologies parameter contains only one topology. Returning the same topology.")
+                return topologies
+        else:
+            topologyList = Helper.Flatten(list(topologies))
+            topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+        if len(topologyList) == 0:
+            if not silent:
+                print("BVH.ByTopologies - Error: The input parameters do not contain any valid topologies. Returning None.")
+            return None
+        vertices = []
+        for topology in topologyList:
+            if Topology.IsInstance(topology, "Vertex"):
+                vertices.append(topology)
+            else:
+                vertices.extend(Topology.Vertices(topology))
+        cluster = Cluster.ByTopologies(vertices)
+        bb = Topology.BoundingBox(cluster)
+        d = Topology.Dictionary(bb)
+        min_x = Dictionary.ValueAtKey(d, "minx")
+        min_y = Dictionary.ValueAtKey(d, "miny")
+        min_z = Dictionary.ValueAtKey(d, "minz")
+        max_x = Dictionary.ValueAtKey(d, "maxx")
+        max_y = Dictionary.ValueAtKey(d, "maxy")
+        max_z = Dictionary.ValueAtKey(d, "maxz")
+        query_aabb = BVH.AABB(min_point=(min_x, min_y, min_z), max_point=(max_x,max_y,max_z))
+        return query_aabb
+    
+    def Clashes(bvh, query):
+        """
+        Returns a list of topologies in the input bvh tree that clashes (broad phase) with the list of topologies in the input query.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        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 clashing topologies (based on their axis-aligned bounding box (AABB))
+
+        """
+        # Function to perform clash detection (broad-phase) and return Topologic objects
+        def clash_detection(bvh_node, query_aabb, clashing_objects=None):
+            if clashing_objects is None:
+                clashing_objects = []
+            
+            # Check if the query AABB intersects with the current node's AABB
+            if not bvh_node.aabb.intersects(query_aabb):
+                return clashing_objects
+            
+            # If this is a leaf node, check each object in the node
+            if bvh_node.objects:
+                for obj in bvh_node.objects:
+                    if obj.aabb.intersects(query_aabb):
+                        clashing_objects.append(obj.topologic_object)  # Return the Topologic object
+                return clashing_objects
+            
+            # Recursively check the left and right child nodes
+            clash_detection(bvh_node.left, query_aabb, clashing_objects)
+            clash_detection(bvh_node.right, query_aabb, clashing_objects)
+            
+            return clashing_objects
+        return clash_detection(bvh, query)
+
+    # Function to recursively add nodes and edges to the TopologicPy Graph
+    def Graph(bvh, tolerance=0.0001):
+        """
+        Creates a graph from the input bvh tree.
+
+        Parameters
+        ----------
+        bvh : BVH Tree
+            The input BVH Tree.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            The created graph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        import random
+        def add_bvh_to_graph(bvh_node, graph, parent_vertex=None, tolerance=0.0001):
+            # Create a vertex for the current node's AABB centroid
+            centroid = bvh_node.aabb.centroid
+            current_vertex = Vertex.ByCoordinates(x=centroid[0], y=centroid[1], z=centroid[2])
+
+            # Add an edge from the parent to this vertex (if a parent exists)
+            if parent_vertex is not None:
+                d = Vertex.Distance(parent_vertex, current_vertex)
+                if d < tolerance:
+                    current_vertex = Topology.Translate(current_vertex, tolerance*random.uniform(2,50), tolerance*random.uniform(2,50), tolerance*random.uniform(2,50))
+                edge = Edge.ByVertices(parent_vertex, current_vertex, tolerance=tolerance)
+                graph = Graph.AddEdge(graph, edge, silent=True)
+            
+            # Recursively add child nodes
+            if bvh_node.left:
+                graph = add_bvh_to_graph(bvh_node.left, graph, parent_vertex=current_vertex, tolerance=tolerance)
+            if bvh_node.right:
+                graph = add_bvh_to_graph(bvh_node.right, graph, parent_vertex=current_vertex, tolerance=tolerance)
+
+            return graph
+        graph = Graph.ByVerticesEdges([Vertex.Origin()], [])
+        return add_bvh_to_graph(bvh, graph, parent_vertex = None, tolerance=tolerance)

topologicpy/Graph.py

@@ -500,7 +500,7 @@ class Graph:
         return adjList
 
     @staticmethod
-    def AddEdge(graph, edge, transferVertexDictionaries=False, transferEdgeDictionaries=False, tolerance=0.0001):
+    def AddEdge(graph, edge, transferVertexDictionaries: bool = False, transferEdgeDictionaries: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Adds the input edge to the input Graph.
 
@@ -516,6 +516,8 @@ class Graph:
             If set to True, the dictionaries of the edges are transferred to the 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
         -------
@@ -555,11 +557,13 @@ class Graph:
             return [graph_vertices, returnVertex]
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(edge, "Edge"):
-            print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning None.")
-            return None
+            if not silent:
+                print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
+            return graph
         graph_vertices = Graph.Vertices(graph)
         graph_edges = Graph.Edges(graph, graph_vertices, tolerance)
         vertices = Edge.Vertices(edge)
@@ -579,7 +583,7 @@ class Graph:
         return new_graph
     
     @staticmethod
-    def AddVertex(graph, vertex, tolerance=0.0001):
+    def AddVertex(graph, vertex, tolerance: float = 0.0001, silent: bool = False):
         """
         Adds the input vertex to the input graph.
 
@@ -591,6 +595,8 @@ class Graph:
             The input vertex.
         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
         -------
@@ -601,16 +607,18 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(vertex, "Vertex"):
-            print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning None.")
-            return None
+            if not silent:
+                print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
+            return graph
         _ = graph.AddVertices([vertex], tolerance)
         return graph
 
     @staticmethod
-    def AddVertices(graph, vertices, tolerance=0.0001):
+    def AddVertices(graph, vertices, tolerance: float = 0.0001, silent: bool = False):
         """
         Adds the input vertex to the input graph.
 
@@ -622,6 +630,8 @@ class Graph:
             The input list of vertices.
         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
         -------
@@ -632,20 +642,23 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not isinstance(vertices, list):
-            print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
+            if not silent:
+                print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
             return None
         vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
         if len(vertices) < 1:
-            print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
+            if not silent:
+                print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
             return None
         _ = graph.AddVertices(vertices, tolerance)
         return graph
     
     @staticmethod
-    def AdjacentVertices(graph, vertex):
+    def AdjacentVertices(graph, vertex, silent: bool = False):
         """
         Returns the list of vertices connected to the input vertex.
 
@@ -655,6 +668,8 @@ class Graph:
             The input graph.
         vertex : topologic_core.Vertex
             the input vertex.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -665,17 +680,19 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(vertex, "Vertex"):
-            print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
             return None
         vertices = []
         _ = graph.AdjacentVertices(vertex, vertices)
         return list(vertices)
     
     @staticmethod
-    def AllPaths(graph, vertexA, vertexB, timeLimit=10):
+    def AllPaths(graph, vertexA, vertexB, timeLimit=10, silent: bool = False):
         """
         Returns all the paths that connect the input vertices within the allowed time limit in seconds.
 
@@ -689,6 +706,8 @@ class Graph:
             The second input vertex.
         timeLimit : int , optional
             The time limit in second. The default is 10 seconds.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -699,20 +718,23 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.AllPaths - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.AllPaths - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(vertexA, "Vertex"):
-            print("Graph.AllPaths - Error: The input vertexA is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.AllPaths - Error: The input vertexA is not a valid vertex. Returning None.")
             return None
         if not Topology.IsInstance(vertexB, "Vertex"):
-            print("Graph.AllPaths - Error: The input vertexB is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.AllPaths - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
         paths = []
         _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths)
         return paths
 
     @staticmethod
-    def AverageClusteringCoefficient(graph, mantissa: int = 6):
+    def AverageClusteringCoefficient(graph, mantissa: int = 6, silent: bool = False):
         """
         Returns the average clustering coefficient of the input graph. See https://en.wikipedia.org/wiki/Clustering_coefficient.
 
@@ -732,11 +754,13 @@ class Graph:
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.LocalClusteringCoefficient - Error: The input graph parameter is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.LocalClusteringCoefficient - Error: The input graph parameter is not a valid graph. Returning None.")
             return None
         vertices = Graph.Vertices(graph)
         if len(vertices) < 1:
-            print("Graph.LocalClusteringCoefficient - Error: The input graph parameter is a NULL graph. Returning None.")
+            if not silent:
+                print("Graph.LocalClusteringCoefficient - Error: The input graph parameter is a NULL graph. Returning None.")
             return None
         if len(vertices) == 1:
             return 0.0
@@ -5988,7 +6012,6 @@ class Graph:
             flat_list = Helper.Flatten(edge_list)
             flat_list = [x for x in flat_list if not x == None]
             num_nodes = max(flat_list) + 1
-            print("Number of Nodes:", num_nodes)
 
             # Create an adjacency matrix.
             adjacency_matrix = np.zeros((num_nodes, num_nodes))

topologicpy/Plotly.py

@@ -397,10 +397,12 @@ class Plotly:
                 mode = "markers+text"
             else:
                 mode = "markers"
-            # Normalize categories to a range between 0 and 1 for the color scale
-            min_category = 0
-            max_category = max(len(vertexGroups), 1)
-            normalized_categories = [(cat - min_category) / (max_category - min_category) for cat in v_groupList]
+            normalized_categories = vertexColor # Start with the default vertexColor
+            if len(vertexGroups) > 0:
+                # Normalize categories to a range between 0 and 1 for the color scale
+                min_category = 0
+                max_category = max(len(vertexGroups), 1)
+                normalized_categories = [(cat - min_category) / (max_category - min_category) for cat in v_groupList]
             v_trace=go.Scatter3d(x=Xn,
                 y=Yn,
                 z=Zn,

topologicpy/Topology.py

@@ -1344,7 +1344,23 @@ class Topology():
         if not x_flag and not y_flag and not z_flag:
             print("Topology.BoundingBox - Error: the input axes parameter is not a recognized string. Returning None.")
             return None
+        if Topology.IsInstance(topology, "Vertex"):
+            minX = Vertex.X(topology)
+            minY = Vertex.Y(topology)
+            minZ = Vertex.Z(topology)
+            dictionary = Dictionary.ByKeysValues(["xrot","yrot","zrot", "minx", "miny", "minz", "maxx", "maxy", "maxz", "width", "length", "height"], [0, 0, 0, minX, minY, minZ, minX, minY, minZ, 0, 0, 0])
+            box = Vertex.ByCoordinates(minX, minY, minZ)
+            box = Topology.SetDictionary(box, dictionary)
+            return box
         vertices = Topology.SubTopologies(topology, subTopologyType="vertex")
+        if len(vertices) == 1: # A Cluster made of one vertex. Rare, but can happen!
+            minX = Vertex.X(vertices[0])
+            minY = Vertex.Y(vertices[0])
+            minZ = Vertex.Z(vertices[0])
+            dictionary = Dictionary.ByKeysValues(["xrot","yrot","zrot", "minx", "miny", "minz", "maxx", "maxy", "maxz", "width", "length", "height"], [0, 0, 0, minX, minY, minZ, minX, minY, minZ, 0, 0, 0])
+            box = Vertex.ByCoordinates(minX, minY, minZ)
+            box = Topology.SetDictionary(box, dictionary)
+            return box
         topology = Cluster.ByTopologies(vertices)
         boundingBox = bb(topology)
         minX = boundingBox[0]

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.57'
+__version__ = '0.7.58'

{topologicpy-0.7.57.dist-info → topologicpy-0.7.58.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.57
+Version: 0.7.58
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.57.dist-info → topologicpy-0.7.58.dist-info}/RECORD

@@ -1,5 +1,6 @@
 topologicpy/ANN.py,sha256=XAuUjNvDRK1hhXfo82S-zXmnAPZGEdHJMRdfpu0aJ8I,47901
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
+topologicpy/BVH.py,sha256=dfVQyn5OPN1_50nusS0AxAcmUfqTzpl0vWT7RBEz-WM,12870
 topologicpy/Cell.py,sha256=_vEYx1kNc3JZJUCCS8nhLM_j8EV4SyZYt3DjNHNRoDw,107707
 topologicpy/CellComplex.py,sha256=YNmNkH6IUplM9f7agZQd6IL2xnHf5ds3JkGQk4jiSXQ,48029
 topologicpy/Cluster.py,sha256=TZXuxzdaUr6OHSWnjWpjCOMlVj6YHBH8aUVbDVsncVA,54999
@@ -10,26 +11,26 @@ topologicpy/Dictionary.py,sha256=cURg452wwk2WeSxWY46ncgAUo5XD1c2c5EtO6ESZHaY,273
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
 topologicpy/EnergyModel.py,sha256=NM3_nAdY9_YDtbp9CaEZ0x0xVsetTqVDzm_VSjmq_mI,53746
 topologicpy/Face.py,sha256=YjU6TxxW2Mf5InumMvzXUXVVRdtjxyRGauRIhGXzkao,116411
-topologicpy/Graph.py,sha256=l1Q_ES-iLPET0EpNGzboBHYjKot79z9Qq6Px2vDvo2U,407613
+topologicpy/Graph.py,sha256=6jeS8ViWSdSoieISY0iZnZN19f6Ow0WRtF68SoA6s3E,408932
 topologicpy/Grid.py,sha256=3-sn7CHWGcXk18XCnHjsUttNJTWwmN63g_Insj__p04,18218
 topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=Oc8mfGBNSjs6wxkPzCKmEw1ZPQPbp9XtiYWaAF62oSk,21893
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=BezQ-sdpU8B0W4X_kaF7alZrlN0-h4779HFrB3Fsn-w,22033
-topologicpy/Plotly.py,sha256=xkBzK4TDGBpZ97aFbWWFQpoqENyLbcwESd1oD9EDIx0,106387
+topologicpy/Plotly.py,sha256=_cgTZmMhp2EOWNazA-GGBgPy5tx_vdl-6hVl0xjhp90,106526
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=joahFtpRQTWJpQOmi3qU4Xe0Sx2XXeayHlXTNx8CzMk,87610
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=jTff8K144q4sccF93u8lrLqsH5r5ar5w40zPcmKgm0I,396181
+topologicpy/Topology.py,sha256=cFYSb93kxqcsdGLdeVcdE9td-KZ9X967sEn98NQAYfM,397243
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=bLY60YWoMsgCgHk7F7k9F93Sq2FJ6AzUcTfJ83NZfHA,71107
 topologicpy/Wire.py,sha256=OoPb7SJl0VpZDZpGL0-VkYJ35zPANS7gHDt9tixOSxc,157629
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=i3eXr4TreTY2cKyyMkt49YK22jCkMWn3M2kxi8z-nJM,23
-topologicpy-0.7.57.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.57.dist-info/METADATA,sha256=AsGmeeIIy0llFWnyj1Cp7w8nVawRLopOJAqyW-MAmv0,10918
-topologicpy-0.7.57.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-topologicpy-0.7.57.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.57.dist-info/RECORD,,
+topologicpy/version.py,sha256=_LZYqF4sncRmxYtm8gZrX2loMxAZar5Q6FHbJDatzH0,23
+topologicpy-0.7.58.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.58.dist-info/METADATA,sha256=XLAiGFSE_Wlh15I97O2XsTqjKkgBWhqoi4iHYCwr1HQ,10918
+topologicpy-0.7.58.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+topologicpy-0.7.58.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.58.dist-info/RECORD,,