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

topologicpy/Graph.py

@@ -264,7 +264,7 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
-    def AdjacencyDictionary(graph, vertexLabelKey: str = "label", edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
+    def AdjacencyDictionary(graph, vertexLabelKey: str = None, edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
         """
         Returns the adjacency dictionary of the input Graph.
 
@@ -274,7 +274,7 @@ class Graph:
             The input graph.
         vertexLabelKey : str , optional
             The returned vertices are labelled according to the dictionary values stored under this key.
-            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is "label".
+            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is None.
         edgeKey : str , optional
             If set, the edges' dictionaries will be searched for this key to set their weight. If the key is set to "length" (case insensitive), the length of the edge will be used as its weight. If set to None, a weight of 1 will be used. The default is "Length".
         includeWeights : bool , optional
@@ -298,6 +298,8 @@ class Graph:
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.AdjacencyDictionary - Error: The input graph is not a valid graph. Returning None.")
             return None
+        if vertexLabelKey == None:
+            vertexLabelKey = "__label__"
         if not isinstance(vertexLabelKey, str):
             print("Graph.AdjacencyDictionary - Error: The input vertexLabelKey is not a valid string. Returning None.")
             return None
@@ -353,6 +355,12 @@ class Graph:
                         temp_list.append(adjLabel)
             temp_list.sort()
             adjDict[vertex_label] = temp_list
+        if vertexLabelKey == "__label__": # This is label we added, so remove it
+            vertices = Graph.Vertices(graph)
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                d = Dictionary.RemoveKey(d, vertexLabelKey)
+                v = Topology.SetDictionary(v, d)
         return adjDict
     
     @staticmethod
@@ -1328,22 +1336,16 @@ 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 BetweennessCentrality(graph, key: str = "betweenness_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.
+            Returns the betweenness 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.
-        vertices : list , optional
-            The input list of vertices. The default is None which means all vertices in the input graph are considered.
-        sources : list , optional
-            The input list of source vertices. The default is None which means all vertices in the input graph are considered.
-        destinations : list , optional
-            The input list of destination vertices. The default is None which means all vertices in the input graph are considered.
         key : str , optional
-            The dictionary key under which to save the betweeness centrality score. The default is "betweneess_centrality".
+            The dictionary key under which to save the betweeness centrality score. The default is "betweenness_centrality".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -1352,88 +1354,79 @@ class Graph:
         Returns
         -------
         list
-            The betweeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+            The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
 
         """
-        from topologicpy.Vertex import Vertex
+        def bfs_paths(source):
+            queue = [(source, [source])]
+            while queue:
+                (vertex, path) = queue.pop(0)
+                for next in set(py_graph[vertex]) - set(path):
+                    queue.append((next, path + [next]))
+                    yield path + [next]
+
+        def shortest_paths_count(source):
+            paths = list(bfs_paths(source))
+            shortest_paths = {v: [] for v in py_graph}
+            for path in paths:
+                shortest_paths[path[-1]].append(path)
+            return shortest_paths
+
+        def calculate_betweenness():
+            betweenness = {v: 0.0 for v in py_graph}
+            for s in py_graph:
+                shortest_paths = shortest_paths_count(s)
+                dependency = {v: 0.0 for v in py_graph}
+                for t in py_graph:
+                    if t != s:
+                        for path in shortest_paths[t]:
+                            for v in path[1:-1]:
+                                dependency[v] += 1.0 / len(shortest_paths[t])
+                for v in py_graph:
+                    if v != s:
+                        betweenness[v] += dependency[v]
+            return betweenness
+        
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
-        def betweeness(vertices, topologies, tolerance=0.001):
-            returnList = [0] * len(vertices)
-            for topology in topologies:
-                t_vertices = Topology.Vertices(topology)
-                for t_v in t_vertices:
-                    index = Vertex.Index(t_v, vertices, strict=False, tolerance=tolerance)
-                    if not index == None:
-                        returnList[index] = returnList[index]+1
-            return returnList
-
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.BetweenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+            if not silent:
+                print("Graph.BetweenessCentrality - Error: The input graph is not a valid graph. Returning None.")
             return None
-        graphVertices = Graph.Vertices(graph)
         
-        if not isinstance(vertices, list):
-            vertices = graphVertices
-        else:
-            vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        vertices = Graph.Vertices(graph)
+
         if len(vertices) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of vertices does not contain valid vertices. Returning None.")
-            return None
-        if not isinstance(sources, list):
-            sources = graphVertices
-        else:
-            sources = [v for v in sources if Topology.IsInstance(v, "Vertex")]
-        if len(sources) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of sources does not contain valid vertices. Returning None.")
+            if not silent:
+                print("Graph.BetweenessCentrality - Error: The input graph does not contain valid vertices. Returning None.")
             return None
-        if not isinstance(destinations, list):
-            destinations = graphVertices
-        else:
-            destinations = [v for v in destinations if Topology.IsInstance(v, "Vertex")]
-        if len(destinations) < 1:
-            print("Graph.BetweenessCentrality - Error: The input list of destinations does not contain valid vertices. Returning None.")
-            return None
-        graphEdges = Graph.Edges(graph)
-        if len(graphEdges) == 0:
-            print("Graph.BetweenessCentrality - Warning: The input graph is a null graph.")
-            scores = [0 for t in vertices]
-            for i, v in enumerate(vertices):
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, key, scores[i])
-                v = Topology.SetDictionary(v, d)
-            return scores
-        paths = []
-        try:
-            for so in tqdm(sources, desc="Computing Shortest Paths", leave=False):
-                v1 = Graph.NearestVertex(graph, so)
-                for si in destinations:
-                    v2 = Graph.NearestVertex(graph, si)
-                    if not v1 == v2:
-                        path = Graph.ShortestPath(graph, v1, v2)
-                        if path:
-                            paths.append(path)
-        except:
-            for so in sources:
-                v1 = Graph.NearestVertex(graph, so)
-                for si in destinations:
-                    v2 = Graph.NearestVertex(graph, si)
-                    if not v1 == v2:
-                        path = Graph.ShortestPath(graph, v1, v2)
-                        if path:
-                            paths.append(path)
-
-        scores = betweeness(vertices, paths, tolerance=tolerance)
-        minValue = min(scores)
-        maxValue = max(scores)
-        size = maxValue - minValue
-        scores = [round((v-minValue)/size, mantissa) for v in scores]
-        for i, v in enumerate(vertices):
-            d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, scores[i])
-            v = Topology.SetDictionary(v, d)
-        return scores
+        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]
+        
+        py_graph = Graph.AdjacencyDictionary(g)
+        betweenness = calculate_betweenness()
+        for v in betweenness:
+            betweenness[v] /= 2.0  # Each shortest path is counted twice
+
+        max_betweenness = max(betweenness.values())
+        if max_betweenness > 0:
+            for v in betweenness:
+                betweenness[v] /= max_betweenness  # Normalize to [0, 1]
+        
+        
+        return_betweenness = [0]*len(vertices)
+        for i, v in betweenness.items():
+            vertex = vertices[int(i)]
+            d = Topology.Dictionary(vertex)
+            d = Dictionary.SetValueAtKey(d, key, round(v, mantissa))
+            vertex = Topology.SetDictionary(vertex, d)
+            return_betweenness[int(i)] = v
+        
+        return return_betweenness
     
     @staticmethod
     def ByAdjacencyMatrixCSVPath(path: str, dictionaries: list = None, silent: bool = False):
@@ -1465,17 +1458,21 @@ class Graph:
         return Graph.ByAdjacencyMatrix(adjacencyMatrix=adjacency_matrix, dictionaries=dictionaries, silent=silent)
 
     @staticmethod
-    def ByAdjacencyMatrix(adjacencyMatrix, dictionaries = None, xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5, silent=False):
+    def ByAdjacencyMatrix(adjacencyMatrix, dictionaries = None, edgeKeyFwd="weightFwd", edgeKeyBwd="weightBwd", xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5, silent=False):
         """
         Returns graphs according to the input folder path. This method assumes the CSV files follow DGL's schema.
 
         Parameters
         ----------
         adjacencyMatrix : list
-            The adjacency matrix expressed as a nested list of 0s and 1s.
+            The adjacency matrix expressed as a nested list of 0s and a number not 0 which represents the edge weight.
         dictionaries : list , optional
             A list of dictionaries to assign to the vertices of the graph. This list should be in
             the same order and of the same length as the rows in the adjacency matrix.
+        edgeKeyFwd : str , optional
+            The dictionary key under which to store the edge weight value for forward edge. The default is "weight".
+        edgeKeyBwd : str , optional
+            The dictionary key under which to store the edge weight value for backward edge. The default is "weight".
         xMin : float , optional
             The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
         yMin : float , optional
@@ -1500,6 +1497,7 @@ class Graph:
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
         import  random
 
         if not isinstance(adjacencyMatrix, list):
@@ -1526,11 +1524,17 @@ class Graph:
         
         # Add edges based on the adjacency matrix
         edges = []
+        visited = []
         for i in range(len(adjacencyMatrix)):
             for j in range(len(adjacencyMatrix)):
                 if not i == j:
-                    if not adjacencyMatrix[i][j] == 0:
-                        edges.append(Edge.ByVertices([vertices[i], vertices[j]]))
+                    if (adjacencyMatrix[i][j] != 0 or adjacencyMatrix[j][i] != 0) and not (i,j) in visited:
+                        edge = Edge.ByVertices([vertices[i], vertices[j]]) # Create only one edge
+                        d = Dictionary.ByKeysValues([edgeKeyFwd, edgeKeyBwd], [adjacencyMatrix[i][j], adjacencyMatrix[j][i]])
+                        edge = Topology.SetDictionary(edge, d)
+                        edges.append(edge)
+                        visited.append((i,j))
+                        visited.append((j,i))
         
         return Graph.ByVerticesEdges(vertices, edges)
 
@@ -2729,7 +2733,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 +4181,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 +4487,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 +4596,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 +6128,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 +6147,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 +6166,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 +6397,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 +6419,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 +6589,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 +6611,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 +6641,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 +6656,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 +6682,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 +6699,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 +6724,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 +6739,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 +6916,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 +7079,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 +7110,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 +7647,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 +8413,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 +8460,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 +8478,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 +9561,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 +9576,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 +9590,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 = ""