topologicpy 0.8.40__py3-none-any.whl → 0.8.41__py3-none-any.whl

topologicpy/Graph.py

@@ -7751,6 +7751,34 @@ class Graph:
                 edge = Topology.SetDictionary(edge, d)
         return graph
 
+    @staticmethod
+    def IsEmpty(graph, silent: bool = False):
+        """
+        Tests if the input graph is empty (Has no vertices).
+        
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+        
+        Returns
+        -------
+        bool
+            True if the two input graphs are isomorphic. False otherwise
+
+        """
+        
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.IsEmpty - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        return (len(Graph.Vertices(graph)) == 0)
+    
     @staticmethod
     def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
@@ -9192,6 +9220,142 @@ class Graph:
             return None
         return graph.GetGUID()
 
+    @staticmethod
+    def HasseDiagram(topology, types=["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"], topDown: bool = False, minDistance: float=0.1, vertexLabelKey: str="label", vertexTypeKey: str="type", vertexColorKey: str="color", colorScale: str="viridis", storeBREP: bool = False, tolerance: float=0.0001, silent: bool=False):
+        """
+            Constructs a Hasse diagram from the input topology as a directed graph. See: https://en.wikipedia.org/wiki/Hasse_diagram
+            Vertices represent topologies (vertices, edges, wires, faces, shells, cells, cellComplexes).
+            Edges represent inclusion (e.g. vertex ⊂ edge, edge ⊂ wire).
+
+            Parameters
+            ----------
+            topology : topologic_core.Topology
+                The input topology
+            types : optional, list
+                The list of topology types that you wish to encode in the Hasse diagram.
+                This list must be ordered according to topologic_core's class hierarchy.
+                If you are not interested in representing some topology types. These can be omitted.
+                The default is:
+                ["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"].
+            topDown : bool , optional
+                If set to True, the graph edges are directed from topologies to their subtopologies.
+                Otherwise, they are directed from topologies to their supertopologies. The default is False. 
+            minDistance : float , optional
+                The desired minimum distance between the vertices of the graph. The default is 0.1.
+            vertexLabelKey: str , optional
+                The desired vertex dictionary key under which to store a unique label (of the form Type_Index). The default is "label".
+            vertexTypeKey: str , optional
+                The desired vertex dictionary key under which to store the topology type (e.g. "vertex", "edge", "wire"). The default is "type".
+            vertexColorKey: str , optional
+                The desired vertex dictionary key under which to store the topology color. The default is "color".
+            colorScale : str , optional
+                The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+                In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+            storeBREP : bool , optional
+                If set to True, store the BRep of the topology in its representative vertex. The default is False.
+            tolerance : float
+                The desired tolerance. The default is 0.0001.
+            silent : bool , optional
+                    If set to True, error and warning messages are suppressed. The default is False.
+
+            Returns
+            -------
+            topologic_core.Graph
+                The created Hesse diagram graph.
+
+            """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
+
+        def label(topo, index):
+            cls = Topology.TypeAsString(topo)
+            return f"{cls}_{index}"
+        
+        def collect_topologies(topology, topo_types):
+            """
+            Returns a dict of all sub-topologies by dimension.
+            """
+            topo_by_type = {}
+            for sub_type in topo_types:
+                topo_by_type[sub_type] = Topology.SubTopologies(topology, subTopologyType=sub_type)
+            return topo_by_type
+        
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if minDistance <= tolerance:
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input minDistance parameter cannot be less than the input tolerance parameter. Returning None.")
+            return None
+        types = [t.lower() for t in types]
+        for type in types:
+            if type not in ["vertex", "edge", "wire", "face", "shell", "cell", "cellcomplex"]:
+                if not silent:
+                    print("Graph.HasseDiagram - Error: Unknown type found in the types input parameter. Returning None.")
+                return None
+
+        topology_type = Topology.TypeAsString(topology).lower()
+        try:
+            sub_types = types[:types.index(topology_type)]
+        except:
+            sub_types = types
+        topo_by_type = collect_topologies(topology, sub_types)
+        all_topos = []
+        topo_ids = {}
+        index = 0
+
+        # Flatten and assign unique labels
+        for sub_type in sub_types:
+            color = Color.AnyToHex(Color.ByValueInRange(float(types.index(sub_type)), minValue=0, maxValue=6, colorScale=colorScale))
+            lbl_index = 1
+            for t in topo_by_type[sub_type]:
+                lbl = label(t, lbl_index)
+                d = Topology.Dictionary(t)
+                d = Dictionary.SetValuesAtKeys(d, [vertexLabelKey, vertexTypeKey, vertexColorKey], [lbl, sub_type, color])
+                t = Topology.SetDictionary(t, d)
+                all_topos.append(t)
+                topo_ids[lbl] = index
+                index += 1
+                lbl_index += 1
+
+        # Create graph vertices
+        graph_vertices = [Topology.Centroid(_) for _ in all_topos]
+
+        # Add dictionaries to each vertex
+        for i, t in enumerate(all_topos):
+            d = Topology.Dictionary(t)
+            if storeBREP == True:
+                d = Dictionary.SetValueAtKey(d,"brep", Topology.BREPString(t))
+            graph_vertices[i] = Topology.SetDictionary(graph_vertices[i], d)
+        
+        graph_vertices = Vertex.Separate(graph_vertices, minDistance= minDistance, tolerance=tolerance)
+        # Build edges of Hasse diagram
+        graph_edges = []
+        for parent_type in sub_types[1:]:
+            for parent in topo_by_type[parent_type]:
+                parent_label = Dictionary.ValueAtKey(Topology.Dictionary(parent), vertexLabelKey)
+                children = Topology.SubTopologies(parent, subTopologyType=types[types.index(parent_type) - 1])
+                for child in children:
+                    child_label = Dictionary.ValueAtKey(Topology.Dictionary(child), vertexLabelKey)
+                    child_id = topo_ids.get(child_label)
+                    parent_id = topo_ids.get(parent_label)
+                    if child_id is not None and parent_id is not None:
+                        if topDown:
+                            sv = graph_vertices[parent_id]
+                            ev = graph_vertices[child_id]
+                        else:
+                            sv = graph_vertices[child_id]
+                            ev = graph_vertices[parent_id]
+                        graph_edges.append(Edge.ByVertices(sv, ev, tolerance=tolerance, silent=silent))
+
+        return_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
+        return_graph = Graph.SetDictionary(return_graph, Topology.Dictionary(topology))
+        return return_graph
+
     @staticmethod
     def IncomingEdges(graph, vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """

topologicpy/Plotly.py

@@ -277,6 +277,9 @@ class Plotly:
                     absolute: bool = False,
                     sides: int = 8,
                     angle: float = 0,
+                    directed: bool = False,
+                    arrowSize: int = 0.1,
+                    arrowSizeKey: str = None,
                     vertexColor: str = "black",
                     vertexColorKey: str = None,
                     vertexSize: float = 10,
@@ -330,6 +333,12 @@ class Plotly:
             For example, if the length of the edge is 10, the sagitta is set to 0.5, and absolute is set to False, the sagitta length will be 5. The default is True.
         sides : int , optional
             The number of sides of the arc. The default is 8.
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         vertexColor : str , optional
             The desired color of the output vertices. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -479,7 +488,7 @@ class Plotly:
                 geo = Topology.Geometry(e_cluster, mantissa=mantissa)
                 vertices = geo['vertices']
                 edges = geo['edges']
-                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, dash=edgeDash, dashKey=edgeDashKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
+                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, dash=edgeDash, dashKey=edgeDashKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
         return data
     
     @staticmethod
@@ -638,11 +647,60 @@ class Plotly:
         return return_value
 
     @staticmethod
-    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
+    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, directed=False, arrowSize=0.1, arrowSizeKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
     
         from topologicpy.Color import Color
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
+
+        def create_arrowheads(x, y, z, arrowSize=4):
+            import plotly.graph_objects as go
+            import numpy as np
+
+            arrow_traces = []
+
+            # Compute segment directions
+            cone_x, cone_y, cone_z = [], [], []
+            cone_u, cone_v, cone_w = [], [], []
+
+            for i in range(len(x) - 1):
+                if x[i] == None or x[i+1] == None:
+                    continue
+                u = x[i+1] - x[i]
+                v = y[i+1] - y[i]
+                w = z[i+1] - z[i]
+
+                norm = np.linalg.norm([u, v, w])
+                if norm > 0:
+                    u /= norm
+                    v /= norm
+                    w /= norm
+                    cone_x.append(x[i+1])
+                    cone_y.append(y[i+1])
+                    cone_z.append(z[i+1])
+                    cone_u.append(u)
+                    cone_v.append(v)
+                    cone_w.append(w)
+
+            cone_trace = go.Cone(
+                x=cone_x,
+                y=cone_y,
+                z=cone_z,
+                u=cone_u,
+                v=cone_v,
+                w=cone_w,
+                sizemode="raw",
+                sizeref=arrowSize,
+                showscale=False,
+                colorscale=[[0, color], [1, color]],
+                anchor="tip",
+                name="",  # Hide legend
+                hoverinfo="skip",
+                showlegend=False
+            )
+            arrow_traces.append(cone_trace)
+
+            return arrow_traces
         traces = []
         x = []
         y = []
@@ -676,8 +734,8 @@ class Plotly:
             maxGroup = 1
         
 
-        if colorKey or widthKey or labelKey or groupKey or dashKey:
-            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey] if not x == None]
+        if colorKey or widthKey or labelKey or groupKey or dashKey or arrowSizeKey:
+            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey, arrowSizeKey] if not x == None]
             temp_dict = Helper.ClusterByKeys(edges, dictionaries, keys, silent=False)
             dict_clusters = temp_dict["dictionaries"]
             elements_clusters = temp_dict['elements']
@@ -692,6 +750,8 @@ class Plotly:
                         d_color = Color.AnyToHex(d_color)
                     if not dashKey == None:
                         d_dash = Dictionary.ValueAtKey(d, key=dashKey) or dash
+                    if not arrowSizeKey == None:
+                        d_arrowSize = Dictionary.ValueAtKey(d, key=arrowSizeKey) or arrowSize
                     if not labelKey == None:
                         labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
@@ -744,6 +804,9 @@ class Plotly:
                                     text=labels,
                                     hoverinfo='text',
                                     hovertext=labels)
+                if directed:
+                    arrow_traces = create_arrowheads(x, y, z, arrowSize=d_arrowSize)
+                    traces += arrow_traces
                 traces.append(trace)
         else:
             x = []
@@ -775,6 +838,9 @@ class Plotly:
                                 legendrank=legendRank,
                                 text=label,
                                 hoverinfo='text')
+            if directed:
+                arrow_traces = create_arrowheads(x, y, z, arrowSize=arrowSize)
+                traces += arrow_traces
             traces.append(trace)
         return traces
 
@@ -799,6 +865,9 @@ class Plotly:
                        vertexLegendLabel="Topology Vertices",
                        vertexLegendRank=1,
                        vertexLegendGroup=1,
+                       directed=False,
+                       arrowSize=0.1,
+                       arrowSizeKey=None,
                        showEdges=True,
                        edgeWidth=1,
                        edgeWidthKey=None,
@@ -884,7 +953,12 @@ class Plotly:
             The legend rank order of the vertices of this topology. The default is 1.
         vertexLegendGroup : int , optional
             The number of the vertex legend group to which the vertices of this topology belong. The default is 1.
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -1194,7 +1268,7 @@ class Plotly:
                 vertices = geo['vertices']
                 edges = geo['edges']
                 if len(edges) > 0:
-                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
+                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and Topology.Type(topology) >= Topology.TypeID("Face"):
             if not faceColorKey == None:

topologicpy/Topology.py

@@ -8162,7 +8162,10 @@ class Topology():
              vertexMaxGroup=None, 
              showVertexLegend=False,
              vertexLegendLabel="Vertices",
-
+             
+             directed=False,
+             arrowSize=0.1,
+             arrowSizeKey=None,
              showEdges=True,
              edgeWidth=None,
              edgeWidthKey=None,
@@ -8281,7 +8284,12 @@ class Topology():
             If set to True, the legend for the vertices of this topology is shown. Otherwise, it isn't. The default is False.
         vertexLegendLabel : str , optional
             The legend label string used to identify vertices. The default is "Topology Vertices".
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -8470,6 +8478,9 @@ class Topology():
                                            absolute=absolute,
                                            sides=sides,
                                            angle=angle,
+                                           directed=directed,
+                                           arrowSize=arrowSize,
+                                           arrowSizeKey=arrowSizeKey,
                                            vertexColor=vertexColor,
                                            vertexColorKey=vertexColorKey,
                                            vertexSize=vSize,
@@ -8543,6 +8554,9 @@ class Topology():
                                               vertexLegendLabel=str(i+1)+": "+name+" ("+vertexLegendLabel+")",
                                               vertexLegendRank=topology_counter+1,
                                               vertexLegendGroup=topology_counter+1,
+                                              directed=directed,
+                                              arrowSize=arrowSize,
+                                              arrowSizeKey=arrowSizeKey,
                                               showEdges=showEdges,
                                               edgeWidth=eWidth,
                                               edgeWidthKey=edgeWidthKey,

topologicpy/Vertex.py

@@ -1819,7 +1819,7 @@ class Vertex():
         return Vertex.ByCoordinates(pt[0], pt[1], pt[2])
 
     @staticmethod
-    def Separate(*vertices, minDistance: float = 0.0001, silent: bool = False):
+    def Separate(*vertices, minDistance: float = 0.0001, iterations: int = 100, strength: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Separates the input vertices such that no two vertices are within the input minimum distance.
 
@@ -1829,6 +1829,12 @@ class Vertex():
             One or more instances of a topologic vertex to be processed.
         minDistance : float , optional
             The desired minimum distance. The default is 0.0001.
+        iterations : int
+            The number of iterations to run the repulsion simulation. The default is 100.
+        strength : float
+            The force multiplier controlling how strongly vertices repel each other. The default is 0.1.
+        tolerance : float
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
                 If set to True, error and warning messages are suppressed. The default is False.
 
@@ -1840,10 +1846,7 @@ class Vertex():
         """
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
-        from topologicpy.Dictionary import Dictionary
-        from math import sqrt
-        from scipy.spatial import KDTree
-        import numpy as np
+        import math
 
         if len(vertices) == 0:
             if not silent:
@@ -1873,33 +1876,37 @@ class Vertex():
             if not silent:
                 print("Vertex.Separate - Error: The input parameters do not contain any valid vertices. Returning None.")
             return None
-    
-        coords = np.array([[v.X(), v.Y(), v.Z()] for v in vertexList])  # Extract coordinates
-        tree = KDTree(coords)  # Build k-d tree for efficient neighbor search
+
+        minDistance = minDistance + tolerance # Add a bit of a safety factor
+
+        # Convert to mutable coordinates
+        coords = [[v.X(), v.Y(), v.Z()] for v in vertices]
+        
+        for _ in range(iterations):
+            for i in range(len(coords)):
+                for j in range(i + 1, len(coords)):
+                    dx = coords[j][0] - coords[i][0]
+                    dy = coords[j][1] - coords[i][1]
+                    dz = coords[j][2] - coords[i][2]
+                    dist = math.sqrt(dx*dx + dy*dy + dz*dz)
+                    
+                    if dist < minDistance and dist > 1e-9:
+                        # Calculate repulsion vector
+                        repel = (minDistance - dist) / dist * strength
+                        shift = [dx * repel * 0.5, dy * repel * 0.5, dz * repel * 0.5]
+                        coords[i][0] -= shift[0]
+                        coords[i][1] -= shift[1]
+                        coords[i][2] -= shift[2]
+                        coords[j][0] += shift[0]
+                        coords[j][1] += shift[1]
+                        coords[j][2] += shift[2]
         
-        for i, vertex in enumerate(coords):
-            neighbors = tree.query_ball_point(vertex, minDistance)
-            for neighbor_index in neighbors:
-                if neighbor_index != i:  # Avoid self-comparison
-                    direction = coords[neighbor_index] - vertex
-                    distance = np.linalg.norm(direction)
-                    if distance < minDistance:
-                        # Move current vertex away from its neighbor
-                        adjustment = (minDistance - distance) / 2
-                        unit_vector = direction / distance if distance != 0 else np.random.rand(3)
-                        coords[i] -= unit_vector * adjustment
-                        coords[neighbor_index] += unit_vector * adjustment
-
-            # Rebuild the k-d tree after adjustment
-            tree = KDTree(coords)
-
-        # Convert adjusted coordinates back to Vertex objects
-        separated_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
-        for i, vertex in enumerate(vertexList):
-            d = Topology.Dictionary(vertex)
-            if len(Dictionary.Keys(d)) > 0:
-                separated_vertices[i] = Topology.SetDictionary(separated_vertices[i], d)
-        return separated_vertices
+        # Reconstruct TopologicPy Vertex objects
+        new_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
+        # Transfer the dictionaries
+        for i, v in enumerate(new_vertices):
+            v = Topology.SetDictionary(v, Topology.Dictionary(vertices[i]))
+        return new_vertices
 
     @staticmethod
     def Transform(vertex, matrix, mantissa: int = 6, silent: bool = False):

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.40'
+__version__ = '0.8.41'

{topologicpy-0.8.40.dist-info → topologicpy-0.8.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.40
+Version: 0.8.41
 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.40.dist-info → topologicpy-0.8.41.dist-info}/RECORD

@@ -12,27 +12,27 @@ topologicpy/Dictionary.py,sha256=2Sxm8twR1W4ksZho0YXQB_EltK2qbZWK4UHskP3jvFQ,408
 topologicpy/Edge.py,sha256=CPdQKaE7ft6zgh0vxekkfGRRUY_yEqkEJ14NvjSgJOA,73190
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
 topologicpy/Face.py,sha256=BT_5ymb7-s-Wb1tuaBtkopJpeNg-RbooTUk_-KInQ6c,201618
-topologicpy/Graph.py,sha256=z_9TeMkmwFXlCfVDW9Z56PX0sHxGj8iVKlCdJLreMo0,639785
+topologicpy/Graph.py,sha256=GykBbB8KKcy2oPV2Dsnz_vkyWGgczxLi0puVx5NJUYU,648088
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=qEsE4yaboEGW94q9lFCff0I_JwwTTQnDAFXw006yHaQ,31203
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=LqVckk2qTwKwEo79eyNsOrHVSHdO82JCREcfy6WIk4I,22716
 topologicpy/Neo4j.py,sha256=ELKmON7R16j1kQD8xRHDGGCvzjIM2HGHNekdaXDUw6w,22371
-topologicpy/Plotly.py,sha256=Dmy9i9puSfvB42mrBUip3v0TCXIzHpAETWDUCDxfqNA,120556
+topologicpy/Plotly.py,sha256=3jTy-bFNS_zFsfqpY_WdhHlt9kdexDq_Jvp5jxR16tQ,123710
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=UVb8VPwVKd6V3zDTNzpBecQPgYo1EjSsS10XJ8k5YcI,23364
 topologicpy/Shell.py,sha256=fx0WTndC8blkvWe38nKsJsI_AmklOA0qsjU0gbZp4b4,90501
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=G6KtKRKabV1gNUKCZ3rzZJkCogGkOJDnCl-_S7DuHKc,466648
+topologicpy/Topology.py,sha256=hGjePUb2-1MmyMva9nNtPiWr4CAWMa__BGX17mIOHfA,467519
 topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
-topologicpy/Vertex.py,sha256=epBfbD7fm87T-TZ0WuwrioXdYqg9NgRlHn_qUFtVbkc,84562
+topologicpy/Vertex.py,sha256=RlGQnxQSb_kAus3tJgXd-v-Ptubtt09PQPA9IMwfXmI,84835
 topologicpy/Wire.py,sha256=vE6IoObVucOZVTFMPiHuNN4DDezRHHyFbwhF5WRBm3s,231547
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=9UtSkYQrOL8TXxQBwLoy5jvQKNWp84nSX32fmM7V0Ac,23
-topologicpy-0.8.40.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.40.dist-info/METADATA,sha256=8YuR3I1XDjArnIbbajaveZEDc7Q8eVk4aBOvtaLhULA,10535
-topologicpy-0.8.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.40.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.40.dist-info/RECORD,,
+topologicpy/version.py,sha256=tObOvnnCfxEdJFf4I6CjFR-B5fIFs3s0EygfFnJZgQM,23
+topologicpy-0.8.41.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.41.dist-info/METADATA,sha256=Fqkthwxq-nQkwkhyhz3ZvFA9C4tU6vPVwo2i3Q9QVmU,10535
+topologicpy-0.8.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.41.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.41.dist-info/RECORD,,