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

topologicpy/Face.py

@@ -1690,6 +1690,8 @@ class Face():
         """
         Returns the face representing the isovist projection from the input viewpoint.
         This method assumes all input is in 2D. Z coordinates are ignored.
+        This method and the metrics are largely derived from isovists.org. Even if not explicitly listed, please assume that all credit
+        goes to the authors of that website and its associated software.
 
         Parameters
         ----------
@@ -1731,6 +1733,12 @@ class Face():
             - d_f : float, Fractal Dimension measures the complexity of the isovist's boundary.
             - e_c : float , Edge Complexity measures how complex the edges of the isovist boundary are.
             - theta : float, Mean Visual Field Angle measures the average angular extent of the visible area from the observation point.
+            - occlusivity: float, the proportion of edges of an isovist that are not physically defined.
+            - drift: float, the distance from the observation point to the centroid of its isovist.
+            - closed_perimeter: float, the total length of non-occluded edges of the isovist.
+            - average_radial: float, "the mean view length of all space visible from a location." (from isovists.org)
+            - variance: float, "the mean of the square of deviation between all radial lengths and average radial length of an isovist (Benedikt, 1979)." (from isovists.org)
+            - skewness: float, "the mean of the cube of deviation between all radial lengths and average radial length of an isovist (Benediky, 1979)." (from isovists.org) 
         triangles : bool , optional
             If set to True, the subtended triangles of the isovist are created and stored as contents of the returned isovist face. The default is False.
         mantissa : int , optional
@@ -1934,6 +1942,81 @@ class Face():
             
             return float(distance), Vertex.ByCoordinates(list(closest_point))
         
+        
+        
+        def compute_average_radial_variance_skewness(vertex, edges, mantissa=6):
+            from math import atan2, pi, sqrt, pow
+
+            def subtended_angle(vertex, edge, mantissa=6):
+                """Compute the angle subtended by the edge at point V."""
+                v = Vertex.Coordinates(vertex, mantissa=mantissa)
+                start = Vertex.Coordinates(Edge.StartVertex(edge), mantissa=mantissa)
+                end = Vertex.Coordinates(Edge.EndVertex(edge), mantissa=mantissa)
+                # Calculate the angles of the start and end vertices relative to V
+                angle_start = atan2(start[1] - v[1], start[0] - v[0])
+                angle_end = atan2(end[1] - v[1], end[0] - v[0])
+                # Ensure the angle is in the range [0, 2*pi]
+                angle_start = angle_start if angle_start >= 0 else angle_start + 2 * pi
+                angle_end = angle_end if angle_end >= 0 else angle_end + 2 * pi
+                # Compute the difference and handle wrapping around 2*pi
+                angle_diff = abs(angle_end - angle_start)
+                return min(angle_diff, 2 * pi - angle_diff)
+        
+            total_weighted_distance = 0
+            total_angle_weight = 0
+            total_weighted_squared_deviation = 0
+            total_weighted_cubed_deviation = 0
+            distances = []
+            angles = []
+            for edge in edges:
+                # Calculate the distance between V and the edge
+                distance = Vertex.Distance(vertex, edge, mantissa=mantissa)
+                distances.append(distance)
+
+                # Calculate the subtended angle for the edge
+                angle = subtended_angle(vertex, edge, mantissa=mantissa)
+                angles.append(angle)
+
+                # Weight the distance by the subtended angle
+                total_weighted_distance += distance * angle
+                total_angle_weight += angle
+
+            # Compute the Average Radial value
+            if total_angle_weight == 0:
+                average_radial = 0  # Avoid division by zero
+            else:
+                average_radial = round(total_weighted_distance / total_angle_weight, mantissa)
+
+            # Compute Variance
+            for i, edge in enumerate(edges):
+                # Calculate the distance between V and the edge
+                distance = distances[i]
+                # Calculate the subtended angle for the edge
+                angle = angles[i]
+
+                # Calculate the deviation squared from the average radial
+                deviation_squared = (distance - average_radial) ** 2
+                # Calculate the deviation cubed from the average radial
+                deviation_cubed = (distance - average_radial) ** 3
+                # Weight the squared deviation by the subtended angle
+                total_weighted_squared_deviation += deviation_squared * angle
+                total_weighted_cubed_deviation += deviation_cubed * angle
+
+            # Compute the Variance value
+            if total_angle_weight == 0:
+                variance = 0  # Avoid division by zero
+            else:
+                variance = round(sqrt(total_weighted_squared_deviation / total_angle_weight), mantissa)
+            
+            # Compute the Skewness value
+            if total_angle_weight == 0:
+                skewness = 0  # Avoid division by zero
+            else:
+                skewness = round(pow(total_weighted_cubed_deviation / total_angle_weight, 1/3), mantissa)
+
+            return average_radial, variance, skewness
+        
+        # Main Code
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flat_face = Topology.Flatten(face, origin=origin, direction=normal)
@@ -2022,7 +2105,7 @@ class Face():
             return None
         simpler_face = Face.RemoveCollinearEdges(return_face)
         if Topology.IsInstance(simpler_face, "face"):
-            if transferDictionaries == True:
+            if transferDictionaries == True or metrics == True:
                 j_edges = [Topology.Edges(t) for t in obstacles]
                 j_edges = Helper.Flatten(j_edges)
                 j_edges += Topology.Edges(face)
@@ -2030,19 +2113,24 @@ class Face():
                 used = [0 for _ in range(len(j_edges))]
                 for i, i_edge in enumerate(i_edges):
                     d_i = Topology.Dictionary(i_edge)
+                    d_i = Dictionary.SetValueAtKey(d_i, "occlusive", True)
+                    i_edge = Topology.SetDictionary(i_edge, d_i)
                     for j, j_edge in enumerate(j_edges):
                         if used[j] == 0:
                             if Edge.IsCollinear(i_edge, j_edge):
+                                d_i = Dictionary.SetValueAtKey(d_i, "occlusive", False)
+                                i_edge = Topology.SetDictionary(i_edge, d_i)
                                 d_j = Topology.Dictionary(j_edge)
                                 d_result = Dictionary.ByMergedDictionaries([d_i, d_j])
-                                i_edge = Topology.SetDictionary(i_edge, d_result)
+                                if transferDictionaries == True:
+                                    i_edge = Topology.SetDictionary(i_edge, d_result)
                                 used[j] == 1
             
             return_face = Topology.Unflatten(simpler_face, origin=origin, direction=normal)
-        return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
+        else:
+            return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
         if metrics == True:
             vertices = Topology.Vertices(return_face)
-            edges = Topology.Edges(return_face)
             # 1 Viewpoint
             viewpoint = Vertex.Coordinates(vertex, mantissa=mantissa)
             # 2 Direction
@@ -2110,6 +2198,27 @@ class Face():
             e_c = round(edge_complexity(coords), mantissa)
             # 18 Mean Visual Field Angle
             theta = round(mean_visual_field_angle(viewpoint, coords), mantissa)
+            # 19 Occlusivity
+            occ_length = 0
+            edges = Topology.Edges(return_face)
+            for edge in edges:
+                d = Topology.Dictionary(edge)
+                if Dictionary.ValueAtKey(d, "occlusive") == True:
+                    occ_length += Edge.Length(edge)
+            if perimeter > 0:
+                occlusivity = round(occ_length/perimeter, mantissa)
+            else:
+                occlusivity = round(0.0, 6)
+            
+            # 20 Drift
+            drift = Vertex.Distance(vertex, Topology.Centroid(return_face), mantissa=mantissa)
+
+            # 21 Closed Perimeter
+            closed_perimeter = round(perimeter - occ_length, mantissa)
+
+            # 22/23/24 Average Radial, Variance, and Skewness
+            average_radial, variance, skewness = compute_average_radial_variance_skewness(vertex, edges, mantissa=6)
+
             keys = ["viewpoint",
                     "direction",
                     "fov",
@@ -2127,7 +2236,14 @@ class Face():
                     "symmetry",
                     "d_f",
                     "e_c",
-                    "theta"]
+                    "theta",
+                    "occlusivity",
+                    "drift",
+                    "closed_perimeter",
+                    "average_radial",
+                    "variance",
+                    "skewness"]
+            
             values = [viewpoint,
                       direction,
                       fov,
@@ -2145,7 +2261,13 @@ class Face():
                       symmetry,
                       d_f,
                       e_c,
-                      theta]
+                      theta,
+                      occlusivity,
+                      drift,
+                      closed_perimeter,
+                      average_radial,
+                      variance,
+                      skewness]
             d = Dictionary.ByKeysValues(keys, values)
             return_face = Topology.SetDictionary(return_face, d)
         if triangles:

topologicpy/Graph.py

@@ -1328,7 +1328,113 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweenessCentrality(graph, vertices=None, sources=None, destinations=None, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001):
+    def BetweenessCentrality(graph, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+        """
+            Returns the betweeness 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 betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        key : str , optional
+            The dictionary key under which to save the betweeness centrality score. The default is "betweneess_centrality".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The betweeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+
+        """
+        def vertex_betweenness_centrality(graph, vertices):
+            """
+            Compute the betweenness centrality for vertices in the given TopologicPy graph.
+
+            Args:
+                graph: The TopologicPy Graph object.
+
+            Returns:
+                dict: A dictionary mapping each vertex to its betweenness centrality value.
+            """
+            from collections import defaultdict
+            n = len(vertices)
+            idList = []
+            vertex_map = {}
+            for i, v in enumerate(vertices):
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, "__id_", str(i))
+                v = Topology.SetDictionary(v, d)
+                idList.append(str(i))
+                vertex_map[str(i)] = v
+            if n < 2:
+                return {v: 0.0 for v in idList}
+            centrality = defaultdict(float)
+
+            for source in idList:
+                stack, paths, sigma = [], {}, {v: 0.0 for v in idList}
+                sigma[source] = 1.0
+                paths[source] = []
+
+                queue = [source]
+                while queue:
+                    v = queue.pop(0)
+                    stack.append(v)
+                    vertex = vertex_map[v]
+                    for neighbor in Graph.AdjacentVertices(graph, vertex):
+                        d = Topology.Dictionary(neighbor)
+                        neighbor_id = Dictionary.ValueAtKey(d, "__id_")
+                        if neighbor_id not in paths:
+                            queue.append(neighbor_id)
+                            paths[neighbor_id] = [v]
+                        elif v not in paths[neighbor_id]:
+                            paths[neighbor_id].append(v)
+                        sigma[neighbor_id] += sigma[v]
+
+                delta = {v: 0.0 for v in idList}
+                while stack:
+                    w = stack.pop()
+                    for v in paths.get(w, []):
+                        delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w])
+                    if w != source:
+                        centrality[w] += delta[w]
+            # Normalize centrality values
+            max_centrality = max([centrality[v] for v in idList])
+            min_centrality = min([centrality[v] for v in idList])
+            centrality = [round((centrality[v]-min_centrality)/max_centrality, mantissa) for v in idList]
+            for i, v in enumerate(vertices):
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, "betweeness_centrality", centrality[i])
+                d = Dictionary.RemoveKey(d, "__id_")
+                v = Topology.SetDictionary(v, d)
+            return centrality
+        
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.BetweenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        
+        vertices = Graph.Vertices(graph)
+
+        if len(vertices) < 1:
+            if not silent:
+                print("Graph.BetweenessCentrality - Error: The input graph does not contain valid vertices. Returning None.")
+            return None
+        if len(vertices) == 1:
+            d = Topology.Dictionary(vertices[0])
+            d = Dictionary.SetValueAtKey(d, key, 1.0)
+            vertices[0] = Topology.SetDictionary(vertices[0], d)
+            return [1.0]
+        
+        return vertex_betweenness_centrality(graph, vertices)
+
+    @staticmethod
+    def BetweenessCentrality_old(graph, vertices=None, sources=None, destinations=None, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001):
         """
             Returns the betweeness 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 betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
@@ -2729,7 +2835,82 @@ class Graph:
                         g_e = Topology.SetDictionary(g_e, d)
             g_edges.append(g_e)
         return Graph.ByVerticesEdges(g_vertices, g_edges)
-    
+
+    @staticmethod
+    def ByNetworkXGraph(nxGraph, xKey="x", yKey="y", zKey="z", range=(-1, 1), mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Converts the input NetworkX graph into a topologic Graph. See http://networkx.org
+
+        Parameters
+        ----------
+        nxGraph : NetworkX graph
+            The input NetworkX graph.
+        xKey : str , optional
+            The dictionary key under which to find the X-Coordinate of the vertex. The default is 'x'.
+        yKey : str , optional
+            The dictionary key under which to find the Y-Coordinate of the vertex. The default is 'y'.
+        zKey : str , optional
+            The dictionary key under which to find the Z-Coordinate of the vertex. The default is 'z'.
+        range : tuple , optional
+            The range to use for position coordinates if no values are found in the dictionaries. The default is (-1,1)
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologicpy.Graph
+            The created topologic graph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        import random
+        import numpy as np
+
+        # Create a mapping from NetworkX nodes to TopologicPy vertices
+        nx_to_topologic_vertex = {}
+
+        # Create TopologicPy vertices for each node in the NetworkX graph
+        vertices = []
+        for node, data in nxGraph.nodes(data=True):
+            # Attempt to get X, Y, Z from the node data
+            x = round(data.get(xKey, random.uniform(*range)), mantissa)
+            y = round(data.get(yKey, random.uniform(*range)), mantissa)
+            z = round(data.get(zKey, 0), mantissa) # If there are no Z values, this is probably a flat graph.
+            # Create a TopologicPy vertex with the node data dictionary
+            vertex = Vertex.ByCoordinates(x,y,z)
+            cleaned_values = []
+            for value in data.values():
+                if isinstance(value, np.ndarray):
+                    value = list(value)
+                cleaned_values.append(value)
+                
+            node_dict = Dictionary.ByKeysValues(list(data.keys()), cleaned_values)
+            vertex = Topology.SetDictionary(vertex, node_dict)
+            nx_to_topologic_vertex[node] = vertex
+            vertices.append(vertex)
+
+        # Create TopologicPy edges for each edge in the NetworkX graph
+        edges = []
+        for u, v, data in nxGraph.edges(data=True):
+            start_vertex = nx_to_topologic_vertex[u]
+            end_vertex = nx_to_topologic_vertex[v]
+
+            # Create a TopologicPy edge with the edge data dictionary
+            edge_dict = Dictionary.ByKeysValues(list(data.keys()), list(data.values()))
+            edge = Edge.ByVertices([start_vertex, end_vertex], tolerance=tolerance)
+            edge = Topology.SetDictionary(edge, edge_dict)
+            edges.append(edge)
+
+        # Create and return the TopologicPy graph
+        topologic_graph = Graph.ByVerticesEdges(vertices, edges)
+        return topologic_graph
+
     @staticmethod
     def ByTopology(topology,
                    direct: bool = True,
@@ -4102,6 +4283,48 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return graph
     
+    @staticmethod
+    def Complete(graph, silent: bool = False):
+        """
+        Completes the graph by conneting unconnected vertices.
+
+        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
+        -------
+        topologicpy.Graph
+            the completed graph
+        """
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+
+        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
+        
+        vertices = Graph.Vertices(graph)
+        edges = Graph.Edges(graph)
+        visited = set()
+        new_edges = []
+        for sv in vertices:
+            for ev in vertices:
+                if sv != ev and not (sv, ev) in visited:
+                    visited.add((sv, ev))
+                    visited.add((ev,sv))
+                    edge = Graph.Edge(graph, sv, ev)
+                    if edge == None:
+                        new_edges.append(Edge.ByVertices(sv, ev))
+        edges += new_edges
+        return Graph.ByVerticesEdges(vertices, edges)
+
     @staticmethod
     def ConnectedComponents(graph, tolerance: float = 0.0001, silent: bool = False):
         """
@@ -4366,6 +4589,68 @@ class Graph:
                 return_centralities.append(centralities[i])
             return centralities
 
+    @staticmethod
+    def Community(graph, key: str = "community", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Computes the best community partition of the input graph based on the Louvain method. See https://en.wikipedia.org/wiki/Louvain_method.
+        This method depends on NetworkX and the python-louvain libraries
+
+        Parameters
+        ----------
+        graph : topologicp.Graph
+            The input topologic graph.
+        key : str , optional
+            The dictionary key under which to save the closeness centrality score. The default is "community".
+        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
+        -------
+        topologicpy.Graph
+            The created topologic graph.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        import os
+        import warnings
+        
+        try:
+            import community as community_louvain
+        except:
+            print("Graph.Community - Installing required pyhon-louvain library.")
+            try:
+                os.system("pip install python-louvain")
+            except:
+                os.system("pip install python-louvain --user")
+            try:
+                import community as community_louvain
+                print("Graph.Community - python-louvain library installed correctly.")
+            except:
+                warnings.warn("Graph.Community - Error: Could not import python-louvain. Please install manually.")
+        
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.Community - Error: The input graph parameter is not a valid topologic graph. Returning None")
+            return None
+        
+        vertices = Graph.Vertices(graph)
+        nx_graph = Graph.NetworkXGraph(graph, mantissa=mantissa, tolerance=tolerance)
+        # Apply the Louvain algorithm
+        partition = community_louvain.best_partition(nx_graph)
+        communities = []
+        # Add the partition value to each node's properties
+        for node, community_id in partition.items():
+            nx_graph.nodes[node][key] = community_id
+            d = Topology.Dictionary(vertices[node])
+            d = Dictionary.SetValueAtKey(d, key, community_id)
+            vertices[node] = Topology.SetDictionary(vertices[node], d)
+            communities.append(community_id)
+        return communities
+
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
         """
@@ -4413,6 +4698,53 @@ class Graph:
         _ = graph.Connect(verticesA, verticesB, tolerance) # Hook to Core
         return graph
     
+    @staticmethod
+    def Connectivity(graph, vertices=None, key: str = "connectivity", edgeKey: str = None, tolerance = 0.0001, silent = False):
+        """
+        Return the connectivity 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 connectivity of all the vertices in the input graph is computed. See https://www.spacesyntax.online/term/connectivity/.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertices : list , optional
+            The input list of vertices. The default is None.
+        key : str , optional
+            The dictionary key under which to save the connectivity score. The default is "connectivity".
+        edgeKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the edgeKey string will be aggregated to calculate
+            the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        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 closeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+
+        """
+        
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if vertices == None:
+            vertices = Graph.Vertices(graph)
+        connectivities = [Graph.VertexDegree(graph, v, edgeKey=edgeKey, tolerance=tolerance, silent=silent) for v in vertices]
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, connectivities[i])
+            v = Topology.SetDictionary(v, d)
+        return connectivities
+    
     @staticmethod
     def ContainsEdge(graph, edge, tolerance=0.0001):
         """
@@ -5898,11 +6230,12 @@ class Graph:
     
     @staticmethod
     def Reshape(graph,
-                shape="spring_2d",
+                shape="spring 2D",
                 k=0.8, seed=None,
                 iterations=50,
                 rootVertex=None,
                 size=1,
+                factor=1,
                 sides=16,
                 key="",
                 tolerance=0.0001,
@@ -5916,16 +6249,17 @@ class Graph:
             The input graph.
         shape : str , optional
             The desired shape of the graph.
-            If set to 'spring_2d' or 'spring_3d', the algorithm uses a simplified version of the Fruchterman-Reingold force-directed algorithm to distribute the vertices.
-            If set to 'radial_2d', the nodes will be distributed along concentric circles in the XY plane.
-            If set to 'tree_2d' or 'tree_3d', the nodes will be distributed using the Reingold-Tillford layout.
-            If set to 'circle_2d', the nodes will be distributed on the cirumference of a segemented circles  in the XY plane, based on the size and sides input parameter (radius=size/2).
-            If set to 'line_2d', the nodes will be distributed on a line in the XY plane based on the size input parameter (length=size).
-            If set to 'spehere_3d', the nodes will be distributed on the surface of a sphere based on the size input parameter raidus=size/2).
-            If set to 'grid_2d', the nodes will be distributed on a grid in the XY plane with size based on the size input parameter (length=width=size).
-            If set to 'grid_3d', the nodes will be distributed on a 3D cubic grid/matrix based on the size input parameter(width=length=height=size).
-            If set to 'cluster_2d', or 'cluster_3d, the nodes will be clustered according to the 'key' input parameter. The overall radius of the cluster is determined by the size input parameter (radius = size/2)
-            The default is 'spring_2d'.
+            ['circle 2D', 'grid 2D', 'line 2D', 'radial 2D', 'spring 2D', 'tree 2D', 'grid 3D', 'sphere 3D', 'tree 3D']
+            If set to 'spring 2D' or 'spring_3d', the algorithm uses a simplified version of the Fruchterman-Reingold force-directed algorithm to distribute the vertices.
+            If set to 'radial 2D', the nodes will be distributed along concentric circles in the XY plane.
+            If set to 'tree 2D' or 'tree 3D', the nodes will be distributed using the Reingold-Tillford layout.
+            If set to 'circle 2D', the nodes will be distributed on the cirumference of a segemented circles  in the XY plane, based on the size and sides input parameter (radius=size/2).
+            If set to 'line 2D', the nodes will be distributed on a line in the XY plane based on the size input parameter (length=size).
+            If set to 'spehere 3D', the nodes will be distributed on the surface of a sphere based on the size input parameter raidus=size/2).
+            If set to 'grid 2D', the nodes will be distributed on a grid in the XY plane with size based on the size input parameter (length=width=size).
+            If set to 'grid 3D', the nodes will be distributed on a 3D cubic grid/matrix based on the size input parameter(width=length=height=size).
+            If set to 'cluster 2D', or 'cluster 3D, the nodes will be clustered according to the 'key' input parameter. The overall radius of the cluster is determined by the size input parameter (radius = size/2)
+            The default is 'spring 2D'.
         k : float, optional
             The desired spring constant to use for the attractive and repulsive forces. The default is 0.8.
         seed : int , optional
@@ -5934,6 +6268,8 @@ class Graph:
             The desired maximum number of iterations to solve the forces in the 'spring' mode. The default is 50.
         rootVertex : topologic_core.Vertex , optional
             The desired vertex to use as the root of the tree and radial layouts.
+        size : float , optional
+            The desired overall size of the graph.
         sides : int , optional
             The desired number of sides of the circle layout option. The default is 16
         length : float, optional
@@ -6163,7 +6499,7 @@ class Graph:
 
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
-                c_v = Topology.SetDictionary(c_v, d)
+                c_v = Topology.SetDictionary(c_v, d, silent=True)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
             
@@ -6185,7 +6521,7 @@ class Graph:
                         orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
                         if orig_edge_index:
                             d = Topology.Dictionary(edges[orig_edge_index])
-                            e = Topology.SetDictionary(e, d)
+                            e = Topology.SetDictionary(e, d, silent=True)
                             c_edges.append(e)
                             used[x][y] = 1
                             used[y][x] = 1
@@ -6355,7 +6691,7 @@ class Graph:
             c_vertices = [Vertex.ByCoordinates(coord) for coord in c_points]
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
-                c_v = Topology.SetDictionary(c_v, d)
+                c_v = Topology.SetDictionary(c_v, d, silent=True)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
             
@@ -6377,7 +6713,7 @@ class Graph:
                         orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
                         if orig_edge_index:
                             d = Topology.Dictionary(edges[orig_edge_index])
-                            e = Topology.SetDictionary(e, d)
+                            e = Topology.SetDictionary(e, d, silent=True)
                             c_edges.append(e)
                             used[x][y] = 1
                             used[y][x] = 1
@@ -6407,7 +6743,7 @@ class Graph:
 
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
-                c_v = Topology.SetDictionary(c_v, d)
+                c_v = Topology.SetDictionary(c_v, d, silent=True)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
             
@@ -6422,7 +6758,7 @@ class Graph:
                         orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
                         if orig_edge_index:
                             d = Topology.Dictionary(edges[orig_edge_index])
-                            e = Topology.SetDictionary(e, d)
+                            e = Topology.SetDictionary(e, d, silent=True)
                             c_edges.append(e)
                             used[x][y] = 1
                             used[y][x] = 1
@@ -6448,7 +6784,7 @@ class Graph:
 
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
-                c_v = Topology.SetDictionary(c_v, d)
+                c_v = Topology.SetDictionary(c_v, d, silent=True)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
             c_edges = []
@@ -6465,7 +6801,7 @@ class Graph:
                         
                         orig_edge_index = edge_dict[str(x)+"_"+str(y)]
                         d = Topology.Dictionary(edges[orig_edge_index])
-                        e = Topology.SetDictionary(e, d)
+                        e = Topology.SetDictionary(e, d, silent=True)
                         c_edges.append(e)
                         used[x][y] = 1
                         used[y][x] = 1
@@ -6490,7 +6826,7 @@ class Graph:
 
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
-                c_v = Topology.SetDictionary(c_v, d)
+                c_v = Topology.SetDictionary(c_v, d, silent=True)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
             
@@ -6505,7 +6841,7 @@ class Graph:
                         orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
                         if orig_edge_index:
                             d = Topology.Dictionary(edges[orig_edge_index])
-                            e = Topology.SetDictionary(e, d)
+                            e = Topology.SetDictionary(e, d, silent=True)
                             c_edges.append(e)
                             used[x][y] = 1
                             used[y][x] = 1
@@ -6682,46 +7018,97 @@ class Graph:
 
             return pos
 
+        
+
         def radial_layout_2d(edge_list, root_index=0):
+            import numpy as np
+            from collections import deque
+            # Build tree and get layout from Buchheim
             root, num_nodes = tree_from_edge_list(edge_list, root_index)
             dt = buchheim(root)
-            pos = np.zeros((num_nodes, 2))
 
-            pos[int(dt.tree.node), 0] = dt.x
-            pos[int(dt.tree.node), 1] = dt.y
-
-            old_roots = [dt]
-            new_roots = []
-
-            while(len(old_roots) > 0):
-                new_roots = []
-                for temp_root in old_roots:
-                    children = temp_root.children
-                    for child in children:
-                        pos[int(child.tree.node), 0] = child.x
-                        pos[int(child.tree.node), 1] = child.y
-                    new_roots.extend(children)
-                    
-                old_roots = new_roots
-
-            # pos[:, 1] = np.max(pos[:, 1]) - pos[:, 1]
-            pos[:, 0] = pos[:, 0] - np.min(pos[:, 0])
-            pos[:, 1] = pos[:, 1] - np.min(pos[:, 1])
-
-            pos[:, 0] = pos[:, 0] / np.max(pos[:, 0])
-            pos[:, 0] = pos[:, 0] - pos[:, 0][root_index]
-            
-            range_ = np.max(pos[:, 0]) - np.min(pos[:, 0])
-            pos[:, 0] = pos[:, 0] / range_
-
-            pos[:, 0] = pos[:, 0] * np.pi * 1.98
-            pos[:, 1] = pos[:, 1] / np.max(pos[:, 1]) 
+            # Initialize positions array
+            pos = np.zeros((num_nodes, 2))
+            pos[int(dt.tree.node)] = [dt.x, dt.y]
 
-            new_pos = np.zeros((num_nodes, 2))
+            # Efficient tree traversal using a queue
+            queue = deque([dt])
+            while queue:
+                current = queue.popleft()
+                for child in current.children:
+                    pos[int(child.tree.node)] = [child.x, child.y]
+                    queue.append(child)
+
+            # Normalize positions
+            pos[:, 0] -= np.min(pos[:, 0])
+            pos[:, 1] -= np.min(pos[:, 1])
+            pos[:, 0] /= np.max(pos[:, 0])
+            pos[:, 1] /= np.max(pos[:, 1])
+
+            # Center the root and scale the x-coordinates
+            pos[:, 0] -= pos[root_index, 0]
+            pos[:, 0] /= (np.max(pos[:, 0]) - np.min(pos[:, 0]))
+            pos[:, 0] *= np.pi * 1.98
+
+            # Convert to polar coordinates
+            new_pos = np.zeros_like(pos)
             new_pos[:, 0] = pos[:, 1] * np.cos(pos[:, 0])
             new_pos[:, 1] = pos[:, 1] * np.sin(pos[:, 0])
-            
+
             return new_pos
+        
+        def dendrimer_layout_2d(graph, root_index=0, base_radius=1, radius_factor=1.5):
+            """
+            Given a graph as an adjacency dictionary, this function generates a dendrimer layout
+            and returns positions of the nodes in 2D space.
+            
+            :param graph: dict, adjacency dictionary where keys are node ids and values are sets/lists of neighboring nodes
+            :param root_index: int, index of the node to start the layout (default: 0)
+            :return: list of positions [x, y] for each node, sorted by node id
+            """
+            import numpy as np
+            
+            # Initialize variables
+            positions = {}
+            visited = set()
+            layers = {}
+
+            # Helper function to perform a DFS and organize nodes in layers
+            def dfs(node, depth):
+                visited.add(node)
+                if depth not in layers:
+                    layers[depth] = []
+                layers[depth].append(node)
+                for neighbor in graph.get(node, []):
+                    if neighbor not in visited:
+                        dfs(neighbor, depth + 1)
+            
+            # Start DFS from the given root node
+            starting_node = list(graph.keys())[root_index]
+            dfs(starting_node, 0)
+            
+            # Perform DFS for all nodes to handle disconnected components
+            for node in graph.keys():
+                if node not in visited:
+                    dfs(node, 0)  # Start a new DFS for each unvisited node
+
+            # Compute positions based on layers
+            for depth, nodes in layers.items():
+                print("depth:", depth)
+                # Place nodes in a circular arrangement at each layer
+                num_nodes = len(nodes)
+                angle_step = 2 * np.pi / num_nodes if num_nodes > 0 else 0
+                for i, node in enumerate(nodes):
+                    angle = i * angle_step
+                    x = base_radius*depth*np.cos(angle)
+                    y = base_radius*depth*np.sin(angle)
+                    positions[node] = (x, y)
+
+            # Sort the positions by node id and return them
+            keys = list(positions.keys())
+            keys.sort()
+            return_values = [list(positions[key]) for key in keys]
+            return return_values
 
         def spherical_layout_3d(edge_list, root_index=0):
             root, num_nodes = tree_from_edge_list(edge_list, root_index)
@@ -6794,7 +7181,7 @@ class Graph:
             return line_layout_2d(graph, length=size)
         elif 'grid' in shape.lower() and '2d' in shape.lower():
             return grid_layout_2d(graph, size=size)
-        elif 'sphere' == shape.lower() and '3d' in shape.lower():
+        elif 'sphere' in shape.lower() and '3d' in shape.lower():
             return sphere_layout_3d(graph, radius=size/2)
         elif 'grid' in shape.lower() and '3d' in shape.lower():
             return grid_layout_3d(graph, size=size)
@@ -6825,12 +7212,13 @@ class Graph:
             elif 'tree' in shape.lower() and '2d' in shape.lower():
                 positions = tree_layout_2d(edges, root_index=root_index)
             elif 'tree' in shape.lower() and '3d' in shape.lower():
-                positions = tree_layout_3d(edges, root_index=root_index, base_radius=1.0, radius_factor=1.5)
+                positions = tree_layout_3d(edges, root_index=root_index, base_radius=size/2, radius_factor=factor)
+            elif 'dendrimer' in shape.lower() and '2d' in shape.lower():
+                positions = dendrimer_layout_2d(Graph.AdjacencyDictionary(graph), root_index=root_index, base_radius=size/2, radius_factor=factor)
             else:
                 if not silent:
                     print(f"{shape} is not implemented yet. Please choose from ['circle 2D', 'grid 2D', 'line 2D', 'radial 2D', 'spring 2D', 'tree 2D', 'grid 3D', 'sphere 3D', 'tree 3D']. Returning None.")
                 return None
-            positions = positions.tolist()
             if len(positions[0]) == 3:
                 positions = [[p[0], p[1], p[2]] for p in positions]
             else:
@@ -7361,6 +7749,113 @@ class Graph:
         json_string = json.dumps(json_data, indent=indent, sort_keys=sortKeys)
         return json_string
     
+    @staticmethod
+    def Leaves(graph, edgeKey: str = None, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns a list of all vertices that have a degree of 1, also called leaf nodes.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        edgeKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the edgeKey string will be aggregated to calculate
+            the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
+        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 leaf nodes
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.Leaves - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        return [v for v in Graph.Vertices(graph) if Graph.VertexDegree(graph, v, edgeKey=edgeKey, tolerance=tolerance, silent=silent) == 1]
+    
+    @staticmethod
+    def LineGraph(graph, transferVertexDictionaries=False, transferEdgeDictionaries=False, tolerance=0.0001, silent=False):
+        """
+        Create a line graph based on the input graph. See https://en.wikipedia.org/wiki/Line_graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        transferVertexDictionaries : bool, optional
+            If set to True, the dictionaries of the vertices of the input graph are transferred to the edges of the line graph.
+        transferEdgeDictionaries : bool, optional
+            If set to True, the dictionaries of the edges of the input graph are transferred to the vertices of the line 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
+        -------
+        topologic_core.Graph
+            The created line graph.
+
+        """
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.LineGraph - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        graph_vertices = Graph.Vertices(graph)
+        graph_edges = Graph.Edges(graph)
+
+        # Create line graph vertices (centroids of original graph edges)
+        if transferEdgeDictionaries == True:
+            lg_vertices = [
+                Topology.SetDictionary(Topology.Centroid(edge), Topology.Dictionary(edge), silent=silent)
+                for edge in graph_edges
+            ]
+        else:
+            lg_vertices = [Topology.Centroid(edge) for edge in graph_edges]
+        
+        lg_edges = []
+        if transferVertexDictionaries == True:
+            for v in graph_vertices:
+                edges = Graph.Edges(graph, vertices=[v])
+                if len(edges) > 1:
+                    d = Topology.Dictionary(v)  # Only need to call Dictionary once
+                    visited = set()  # Use a set to track visited pairs of edges
+                    centroids = [Topology.Centroid(e) for e in edges]  # Precompute centroids once
+                    for i in range(len(edges)):
+                        for j in range(i + 1, len(edges)):  # Only loop over pairs (i, j) where i < j
+                            if (i, j) not in visited:
+                                lg_edge = Edge.ByVertices([centroids[i], centroids[j]], tolerance=tolerance, silent=silent)
+                                lg_edge = Topology.SetDictionary(lg_edge, d, silent=silent)
+                                lg_edges.append(lg_edge)
+                                visited.add((i, j))
+                                visited.add((j, i))  # Ensure both directions are marked as visited
+        else:
+            for v in graph_vertices:
+                edges = Graph.Edges(graph, vertices=[v])
+                if len(edges) > 1:
+                    visited = set()  # Use a set to track visited pairs of edges
+                    centroids = [Topology.Centroid(e) for e in edges]  # Precompute centroids once
+                    for i in range(len(edges)):
+                        for j in range(i + 1, len(edges)):  # Only loop over pairs (i, j) where i < j
+                            if (i, j) not in visited:
+                                lg_edge = Edge.ByVertices([centroids[i], centroids[j]], tolerance=tolerance, silent=silent)
+                                lg_edges.append(lg_edge)
+                                visited.add((i, j))
+                                visited.add((j, i))  # Ensure both directions are marked as visited
+
+        return Graph.ByVerticesEdges(lg_vertices, lg_edges)
+
     @staticmethod
     def LocalClusteringCoefficient(graph, vertices: list = None, key: str = "lcc", mantissa: int = 6, tolerance: float = 0.0001):
         """
@@ -8020,18 +8515,26 @@ class Graph:
         return nearestVertex
 
     @staticmethod
-    def NetworkXGraph(graph, mantissa: int = 6, tolerance: float = 0.0001):
+    def NetworkXGraph(graph, xKey='x', yKey='y', zKey='z', mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        converts the input graph into a NetworkX Graph. See http://networkx.org
+        Converts the input graph into a NetworkX Graph. See http://networkx.org
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
+        xKey : str , optional
+            The dictionary key under which to save the X-Coordinate of the vertex. The default is 'x'.
+        yKey : str , optional
+            The dictionary key under which to save the Y-Coordinate of the vertex. The default is 'y'.
+        zKey : str , optional
+            The dictionary key under which to save the Z-Coordinate of the vertex. The default is 'z'.
         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
         -------
@@ -8059,7 +8562,8 @@ class Graph:
                 return None
         
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.NetworkXGraph - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.NetworkXGraph - Error: The input graph is not a valid graph. Returning None.")
             return None
 
         nxGraph = nx.Graph()
@@ -8076,8 +8580,7 @@ class Graph:
                 values = Dictionary.Values(d)
                 if not values:
                     values = []
-                keys += ["x","y","z"]
-                import random
+                keys += [xKey,yKey,zKey]
                 values += [Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)]
                 d = Dictionary.ByKeysValues(keys,values)
                 pythonD = Dictionary.PythonDictionary(d)
@@ -9160,7 +9663,7 @@ class Graph:
         return Graph.ByVerticesEdges(dictionary['vertices'], dictionary['edges'])
     
     @staticmethod
-    def VertexDegree(graph, vertex, edgeKey: str = None, tolerance: float = 0.0001):
+    def VertexDegree(graph, vertex, edgeKey: str = None, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the degree of the input vertex. See https://en.wikipedia.org/wiki/Degree_(graph_theory).
 
@@ -9175,6 +9678,8 @@ class Graph:
             the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
         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
         -------
@@ -9187,10 +9692,12 @@ class Graph:
         import numbers
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.VertexDegree - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.VertexDegree - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(vertex, "Vertex"):
-            print("Graph.VertexDegree - Error: The input vertex is not a valid vertex. Returning None.")
+            if not silent:
+                print("Graph.VertexDegree - Error: The input vertex is not a valid vertex. Returning None.")
             return None
         if not isinstance(edgeKey, str):
             edgeKey = ""

topologicpy/Plotly.py

@@ -411,29 +411,46 @@ class Plotly:
         
         if showVertices:
             vertices = Graph.Vertices(graph)
-            #v_dictionaries = [Topology.Dictionary(v) for v in vertices]
+            v_dictionaries = [Topology.Dictionary(v) for v in vertices]
             e_cluster = Cluster.ByTopologies(vertices)
             geo = Topology.Geometry(e_cluster, mantissa=mantissa)
             vertices = geo['vertices']
             if len(vertices) > 0:
-                v_data = Plotly.DataByTopology(e_cluster,
-                                        vertexColor=vertexColor,
-                                        vertexColorKey=vertexColorKey,
-                                        vertexSize=vertexSize,
-                                        vertexSizeKey=vertexSizeKey,
-                                        vertexLabelKey=vertexLabelKey,
-                                        showVertexLabel=showVertexLabel,
-                                        vertexGroupKey=vertexGroupKey,
-                                        vertexMinGroup=vertexMinGroup,
-                                        vertexMaxGroup=vertexMaxGroup,
-                                        vertexGroups=vertexGroups,
-                                        showVertexLegend=showVertexLegend,
-                                        vertexLegendLabel=vertexLegendLabel,
-                                        vertexLegendGroup=vertexLegendGroup,
-                                        vertexLegendRank=vertexLegendRank,
-                                        colorScale=colorScale)
-
-                data += v_data
+                v_data = Plotly.vertexData(vertices,
+                                   dictionaries=v_dictionaries,
+                                   color=vertexColor,
+                                   colorKey=vertexColorKey,
+                                   size=vertexSize,
+                                   sizeKey=vertexSizeKey,
+                                   labelKey=vertexLabelKey,
+                                   showVertexLabel=showVertexLabel,
+                                   groupKey=vertexGroupKey,
+                                   minGroup=vertexMinGroup,
+                                   maxGroup=vertexMaxGroup,
+                                   groups=vertexGroups,
+                                   legendLabel=vertexLegendLabel,
+                                   legendGroup=vertexLegendGroup,
+                                   legendRank=vertexLegendRank,
+                                   showLegend=showVertexLegend,
+                                   colorScale=colorScale)
+
+                # v_data = Plotly.DataByTopology(e_cluster,
+                #                         vertexColor=vertexColor,
+                #                         vertexColorKey=vertexColorKey,
+                #                         vertexSize=vertexSize,
+                #                         vertexSizeKey=vertexSizeKey,
+                #                         vertexLabelKey=vertexLabelKey,
+                #                         showVertexLabel=showVertexLabel,
+                #                         vertexGroupKey=vertexGroupKey,
+                #                         vertexMinGroup=vertexMinGroup,
+                #                         vertexMaxGroup=vertexMaxGroup,
+                #                         vertexGroups=vertexGroups,
+                #                         showVertexLegend=showVertexLegend,
+                #                         vertexLegendLabel=vertexLegendLabel,
+                #                         vertexLegendGroup=vertexLegendGroup,
+                #                         vertexLegendRank=vertexLegendRank,
+                #                         colorScale=colorScale)
+                data += [v_data]
         
         if showEdges:
             e_dictionaries = []
@@ -501,7 +518,7 @@ class Plotly:
                 z.append(v[2])
                 colors.append(Color.AnyToHex(color))
                 labels.append("Vertex_"+str(m+1).zfill(n))
-                sizes.append(size)
+                sizes.append(max(size, 1.1))
                 if len(dictionaries) > 0:
                     d = dictionaries[m]
                     if d:
@@ -512,7 +529,11 @@ class Plotly:
                         if not labelKey == None:
                             labels[m] = str(Dictionary.ValueAtKey(d, key=labelKey)) or labels[m]
                         if not sizeKey == None:
-                            sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey) or sizes[m]
+                            sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey)
+                            if sizes[m] == None:
+                               sizes[m] = size
+                            if sizes[m] <= 0:
+                                sizes[m] = 1.1
                         if not groupKey == None:
                             c_value = Dictionary.ValueAtKey(d, key=groupKey)
                             if not c_value == None:
@@ -540,7 +561,7 @@ class Plotly:
         if len(labels) < 1:
             labels = "Vertex_1"
         if len(sizes) < 1:
-            sizes = size
+            sizes = [size]*len(x)
         if showVertexLabel == True:
             mode = "markers+text"
         else:

topologicpy/version.py

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

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

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

@@ -10,14 +10,14 @@ 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=f4DrZJ2AgwnTwIorJpwuOXtWq501wOMRixMgHZC78so,143843
-topologicpy/Graph.py,sha256=Zxmoy2FAl5m_MGUd62jDeajmZAFlKXVHf1Fy68TrsSw,436694
+topologicpy/Face.py,sha256=2k1vSRK1M-s588RcqGHEalwIHJ9nT3qgx3pU4ktN0dU,150077
+topologicpy/Graph.py,sha256=Qm0V17oeIlhr62faoYqJpNUMzAB5d0F-3zes4jCtRi8,460350
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
-topologicpy/Plotly.py,sha256=Ld-VrYAn_FwONYwdVoz-7Kqt-5fs-qbVl35Utmcu7OE,114508
+topologicpy/Plotly.py,sha256=Tvo0_zKVEHtPhsMNNvLy5G0HIys5FPAOyp_o4QN_I_A,115760
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=UdDz3zfIYmGRjoZIseviJ2cXNtR5Kx5tIsZLhWMyO_U,87906
@@ -28,9 +28,9 @@ 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=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,,
+topologicpy/version.py,sha256=em3O4PG8JKL9957EgCcS5zUXOhgyMhAa6bmjZHQ7UmE,23
+topologicpy-0.7.91.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.91.dist-info/METADATA,sha256=m96FnumZC4Hy2QqaPuRryOZron2mQdjkGJvv5HJs3kM,10513
+topologicpy-0.7.91.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.91.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.91.dist-info/RECORD,,