topologicpy 0.8.10__py3-none-any.whl → 0.8.12__py3-none-any.whl

topologicpy/Graph.py

@@ -522,7 +522,7 @@ class Graph:
         return adjDict
     
     @staticmethod
-    def AdjacencyMatrix(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, tolerance=0.0001):
+    def AdjacencyMatrix(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, mantissa: int = 6, tolerance=0.0001):
         """
         Returns the adjacency matrix of the input Graph. See https://en.wikipedia.org/wiki/Adjacency_matrix.
 
@@ -542,10 +542,12 @@ class Graph:
             If set to True or False, this key in the connecting edge will be used to determine is the edge is supposed to be bidirectional or not. If set to None, the input variable bidrectional will be used instead. The default is None
         bidirectional : bool , optional
             If set to True, the edges in the graph that do not have a bidireKey in their dictionaries will be treated as being bidirectional. Otherwise, the start vertex and end vertex of the connecting edge will determine the direction. The default is True.
-        useEdgeIndex : bool , False
+        useEdgeIndex : bool , optional
             If set to True, the adjacency matrix values will the index of the edge in Graph.Edges(graph). The default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
-        useEdgeLength : bool , False
+        useEdgeLength : bool , optional
             If set to True, the adjacency matrix values will the length of the edge in Graph.Edges(graph). The default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -599,12 +601,16 @@ class Graph:
                     bidir = bidirectional
             if edgeKeyFwd == None:
                 valueFwd = 1
+            elif "len" in edgeKeyFwd.lower() or "dis" in edgeKeyFwd.lower():
+                valueFwd = Edge.Length(edge, mantissa=mantissa)
             else:
                 valueFwd = Dictionary.ValueAtKey(Topology.Dictionary(edge), edgeKeyFwd)
                 if valueFwd == None:
                     valueFwd = 1
             if edgeKeyBwd == None:
                 valueBwd = 1
+            elif "len" in edgeKeyBwd.lower() or "dis" in edgeKeyBwd.lower():
+                valueBwd = Edge.Length(edge, mantissa=mantissa)
             else:
                 valueBwd = Dictionary.ValueAtKey(Topology.Dictionary(edge), edgeKeyBwd)
                 if valueBwd == None:
@@ -613,8 +619,8 @@ class Graph:
                 valueFwd = i+1
                 valueBwd = i+1
             if useEdgeLength:
-                valueFwd = Edge.Length(edge)
-                valueBwd = Edge.Length(edge)
+                valueFwd = Edge.Length(edge, mantissa=mantissa)
+                valueBwd = Edge.Length(edge, mantissa=mantissa)
             if not svi == None and not evi == None:
                 matrix[svi][evi] = valueFwd
                 if bidir:
@@ -1352,7 +1358,7 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweennessCentrality(graph, key: str = "betweenness_centrality", method="vertex", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def BetweennessCentrality(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nx: bool = False, key: str = "betweenness_centrality", colorKey="bc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
             Returns the betweenness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
@@ -1360,10 +1366,23 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
-        key : str , optional
-            The dictionary key under which to store the betweeness centrality score. The default is "betweenness_centrality".
         method : str , optional
             The method of computing the betweenness centrality. The options are "vertex" or "edge". The default is "vertex".
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey string will be aggregated to calculate
+            the shortest path. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead.
+            This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+        normalize : bool , optional
+            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
+        nx : bool , optional
+            If set to True, and normalize input parameter is also set to True, the values are set to be identical to NetworkX values. Otherwise, they are normalized between 0 and 1. The default is False.
+        key : str , optional
+            The desired dictionary key under which to store the betweenness centrality score. The default is "betweenness_centrality".
+        colorKey : str , optional
+            The desired dictionary key under which to store the betweenness centrality color. The default is "betweenness_centrality".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -1375,163 +1394,58 @@ class Graph:
             The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
 
         """
-        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_vertex_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
-        
-        def calculate_edge_betweenness(graph_adj_matrix):
-            n = len(graph_adj_matrix)
-            edge_betweenness_scores = {}
-
-            # Iterate over all node pairs as source and target nodes
-            for source in range(n):
-                # Initialize the 'distance' and 'predecessors' for each node
-                distance = [-1] * n
-                predecessors = [[] for _ in range(n)]
-                distance[source] = 0
-                stack = []
-                queue = [source]
-
-                # Breadth-first search to find shortest paths
-                while queue:
-                    current_node = queue.pop(0)
-                    stack.append(current_node)
-                    for neighbor in range(n):
-                        if graph_adj_matrix[current_node][neighbor] == 1:
-                            if distance[neighbor] == -1:  # First time visiting neighbor
-                                distance[neighbor] = distance[current_node] + 1
-                                queue.append(neighbor)
-                            if distance[neighbor] == distance[current_node] + 1:  # Shortest path
-                                predecessors[neighbor].append(current_node)
-
-                # Initialize the dependency values for each node
-                dependency = [0] * n
-
-                # Process the nodes in reverse order of discovery
-                while stack:
-                    current_node = stack.pop()
-                    for pred in predecessors[current_node]:
-                        dependency[pred] += (1 + dependency[current_node]) / len(predecessors[current_node])
-
-                        # Update edge betweenness scores
-                        if pred < current_node:
-                            edge = (pred, current_node)
-                        else:
-                            edge = (current_node, pred)
-                        
-                        if edge not in edge_betweenness_scores:
-                            edge_betweenness_scores[edge] = 0
-                        edge_betweenness_scores[edge] += dependency[current_node]
-
-            # Normalize edge betweenness scores by dividing by 2 (since each edge is counted twice)
-            for edge in edge_betweenness_scores:
-                edge_betweenness_scores[edge] /= 2
+        import warnings
 
-            return edge_betweenness_scores
+        try:
+            import networkx as nx
+        except:
+            print("Graph.BetwennessCentrality - Information: Installing required networkx library.")
+            try:
+                os.system("pip install networkx")
+            except:
+                os.system("pip install networkx --user")
+            try:
+                import networkx as nx
+                print("Graph.BetwennessCentrality - Infromation: networkx library installed correctly.")
+            except:
+                warnings.warn("Graph.BetwennessCentrality - Error: Could not import networkx. Please try to install networkx manually. Returning None.")
+                return None
         
-        from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
 
-        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
-        
-        if "v" in method.lower():
-            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]
-            
-            py_graph = Graph.AdjacencyDictionary(graph)
-            vertex_betweenness = calculate_vertex_betweenness()
-            for v in vertex_betweenness:
-                vertex_betweenness[v] /= 2.0  # Each shortest path is counted twice
-
-            min_betweenness = min(vertex_betweenness.values())
-            max_betweenness = max(vertex_betweenness.values())
-            if (max_betweenness - min_betweenness) > 0:
-                for v in vertex_betweenness:
-                    vertex_betweenness[v] = (vertex_betweenness[v] - min_betweenness)/ (max_betweenness - min_betweenness)  # Normalize to [0, 1]
-            
-            
-            vertex_betweenness_scores = [0]*len(vertices)
-            for i, score in vertex_betweenness.items():
-                vertex = vertices[int(i)]
-                d = Topology.Dictionary(vertex)
-                d = Dictionary.SetValueAtKey(d, key, round(score, mantissa))
-                vertex = Topology.SetDictionary(vertex, d)
-                vertex_betweenness_scores[int(i)] = round(score, mantissa)
-            
-            return vertex_betweenness_scores
+        if weightKey:
+            if "len" in weightKey.lower() or "dis" in wireightKey.lower():
+                weightKey = "length"
+        nx_graph = Graph.NetworkXGraph(graph)
+        if "vert" in method.lower():
+            elements = Graph.Vertices(graph)
+            elements_dict = nx.betweenness_centrality(nx_graph, normalized=normalize, weight=weightKey)
+            values = list(elements_dict.values())
+        else:
+            elements = Graph.Edges(graph)
+            elements_dict = nx.edge_betweenness_centrality(nx_graph, normalized=normalize, weight=weightKey)
+            values = [round(value, mantissa) for value in list(elements_dict.values())]
+        if nx == False:
+            if mantissa > 0: # We cannot have values in the range 0 to 1 with a mantissa < 1
+                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+            else:
+                values = Helper.Normalize(values)
+            min_value = 0
+            max_value = 1
         else:
-            graph_edges = Graph.Edges(graph)
-            adj_matrix = Graph.AdjacencyMatrix(graph)
-            meshData = Graph.MeshData(graph)
-            edges = meshData["edges"]
-            if len(graph_edges) < 1:
-                if not silent:
-                    print("Graph.BetweenessCentrality - Error: The input graph does not contain any edges. Returning None.")
-                return None
-            if len(graph_edges) == 1:
-                d = Topology.Dictionary(graph_edges[0])
-                d = Dictionary.SetValueAtKey(d, key, 1.0)
-                graph_edges[0] = Topology.SetDictionary(graph_edges[0], d)
-                return [1.0]
-            
-            edge_betweenness = calculate_edge_betweenness(adj_matrix)
-            keys = list(edge_betweenness.keys())
-            values = list(edge_betweenness.values())
             min_value = min(values)
             max_value = max(values)
-            edge_betweenness_scores = []
-            for i, edge in enumerate(edges):
-                u,v = edge
-                if (u,v) in keys:
-                    score = edge_betweenness[(u,v)]
-                elif (v,u) in keys:
-                    score = edge_betweenness[(v,u)]
-                else:
-                    score = 0
-                score = (score - min_value)/(max_value - min_value)
-                edge_betweenness_scores.append(round(score, mantissa))
-                d = Topology.Dictionary(graph_edges[i])
-                d = Dictionary.SetValueAtKey(d, key, round(score, mantissa))
-                graph_edges[i] = Topology.SetDictionary(graph_edges[i], d)
-            return edge_betweenness_scores
+
+        for i, value in enumerate(values):
+            d = Topology.Dictionary(elements[i])
+            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            elements[i] = Topology.SetDictionary(elements[i], d)
+
+        return values
 
     @staticmethod
     def BetweennessPartition(graph, n=2, m=10, key="partition", tolerance=0.0001, silent=False):
@@ -4772,93 +4686,93 @@ class Graph:
         return graph
     
     @staticmethod
-    def ClosenessCentrality(graph, vertices=None, key: str = "closeness_centrality", mantissa: int = 6, tolerance = 0.0001, silent = False):
+    def ClosenessCentrality(graph, weightKey="length", normalize: bool = False, nx: bool = True, key: str = "closeness_centrality", colorKey="cc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
-        Return the closeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the closeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Closeness_centrality.
+            Returns the closeness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. 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.
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey string will be aggregated to calculate
+            the shortest path. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead.
+            This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+        normalize : bool , optional
+            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
+        nx : bool , optional
+            If set to True, use networkX to scale by the fraction of nodes reachable. This gives the Wasserman and Faust improved formula.
+            For single component graphs it is the same as the original formula.
         key : str , optional
-            The dictionary key under which to store the closeness centrality score. The default is "closeness_centrality".
+            The desired dictionary key under which to store the closeness centrality score. The default is "closeness_centrality".
+        colorKey : str , optional
+            The desired dictionary key under which to store the closeness centrality color. The default is "cc_color".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
         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
         -------
         list
-            The closeness 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.
 
         """
+        import warnings
 
-        def closeness_centrality(g):
-            """
-            Computes the closeness centrality for each vertex in the graph.
-
-            Parameters:
-                graph (dict): A dictionary representing the graph where keys are vertices and 
-                            values are lists of neighboring vertices.
-
-            Returns:
-                dict: A dictionary where keys are vertices and values are their closeness centrality.
-            """
-            keys = list(g.keys())
-            N = len(keys)
-
-            centralities = []
-            for v in keys:
-                total_distance = 0
-                reachable_count = 0
-                
-                for u in keys:
-                    if v != u:
-                        distance = Graph._topological_distance(g, v, u)
-                        if distance != None:
-                            total_distance += distance
-                            reachable_count += 1
-                
-                if reachable_count > 0:  # Avoid division by zero
-                    centrality = (reachable_count / total_distance)
-                else:
-                    centrality = 0.0  # Isolated vertex
-            
-                centralities.append(centrality)
-            return centralities
+        try:
+            import networkx as nx
+        except:
+            print("Graph.ClosenessCentrality - Information: Installing required networkx library.")
+            try:
+                os.system("pip install networkx")
+            except:
+                os.system("pip install networkx --user")
+            try:
+                import networkx as nx
+                print("Graph.ClosenessCentrality - Infromation: networkx library installed correctly.")
+            except:
+                warnings.warn("Graph.ClosenessCentrality - Error: Could not import networkx. Please try to install networkx manually. Returning None.")
+                return None
         
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
 
-        if not Topology.IsInstance(graph, "Graph"):
+        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
-        g = Graph.AdjacencyDictionary(graph)
-        centralities = closeness_centrality(g)
-        graphVertices = Graph.Vertices(graph)
-        if vertices == None:
-            for i, v in enumerate(graphVertices):
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, key, centralities[i])
-                v = Topology.SetDictionary(v, d)
-            return centralities
+        
+        if weightKey:
+            if "len" in weightKey.lower() or "dis" in weightKey.lower():
+                weightKey = "length"
+        nx_graph = Graph.NetworkXGraph(graph)
+        elements = Graph.Vertices(graph)
+        elements_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nx)
+        values = [round(v, mantissa) for v in list(elements_dict.values())]
+        if normalize == True:
+            if mantissa > 0: # We cannot round numbers from 0 to 1 with a mantissa = 0.
+                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+            else:
+                values = Helper.Normalize(values)
+            min_value = 0
+            max_value = 1
         else:
-            return_centralities = []
-            for v in vertices:
-                i = Vertex.Index(v, graphVertices)
-                d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, key, centralities[i])
-                v = Topology.SetDictionary(v, d)
-                return_centralities.append(centralities[i])
-            return centralities
+            min_value = min(values)
+            max_value = max(values)
+
+        for i, value in enumerate(values):
+            d = Topology.Dictionary(elements[i])
+            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            elements[i] = Topology.SetDictionary(elements[i], d)
+
+        return values
 
     @staticmethod
     def Community(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -5026,7 +4940,7 @@ class Graph:
         return graph
     
     @staticmethod
-    def Connectivity(graph, vertices=None, key: str = "connectivity", edgeKey: str = None, tolerance = 0.0001, silent = False):
+    def Connectivity(graph, vertices=None, weightKey: str = None, normalize: bool = False, key: str = "connectivity", colorKey: str = "cn_color", colorScale="Viridis", mantissa: int = 6, 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/.
 
@@ -5035,15 +4949,22 @@ class Graph:
         graph : topologic_core.Graph
             The input graph.
         vertices : list , optional
-            The input list of vertices. The default is None.
+            The input list of vertices. The default is None which means all graph vertices are computed.
+        normalize : bool , optional
+            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey 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. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
         key : str , optional
             The dictionary key under which to store 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.
-
+        colorKey : str , optional
+            The desired dictionary key under which to store the connectivity color. The default is "cn_color".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+        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
@@ -5052,25 +4973,40 @@ class Graph:
         Returns
         -------
         list
-            The closeness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+            The connectivity score of the input list of vertices within the input graph. The values are in the range 0 to 1 if normalized.
 
         """
         
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+        from topologicpy.Color import Color
 
         if not Topology.IsInstance(graph, "Graph"):
             if not silent:
-                print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.Connectivity - 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
+        values = [Graph.VertexDegree(graph, v, weightKey=weightKey, mantissa=mantissa, tolerance=tolerance, silent=silent) for v in vertices]
+        values = [round(v, mantissa) for v in values]
+        if normalize == True:
+            if mantissa > 0:
+                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+            else:
+                values = Helper.Normalize(values)
+            min_value = 0
+            max_value = 1
+        else:
+            min_value = min(values)
+            max_value = max(values)
+
+        for i, value in enumerate(values):
+            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            d = Topology.Dictionary(vertices[i])
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            v = Topology.SetDictionary(vertices[i], d)
+        return values
     
     @staticmethod
     def ContainsEdge(graph, edge, tolerance=0.0001):
@@ -5193,23 +5129,38 @@ class Graph:
             vertex = Topology.SetDictionary(vertex, d)
                 
         return cut_vertices
-
+    
     @staticmethod
-    def Degree(graph, vertices=None, key: str = "degree", edgeKey: str = None, mantissa: int = 6, tolerance = 0.0001):
-        """
-        Return the degree measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the closeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Degree_(graph_theory).
+    def DegreeCentrality(graph,
+                         vertices: list = None,
+                         weightKey: str= None,
+                         normalize: bool = False,
+                         key: str = "degree_centrality",
+                         colorKey="dc_color",
+                         colorScale="viridis",
+                         mantissa: int = 6,
+                         tolerance: float = 0.001,
+                         silent: bool = False):
+        """
+            Returns the degree centrality of the input graph. The order of the returned list is the same as the order of vertices. See https://en.wikipedia.org/wiki/Degree_centrality.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
-        vertices : list , optional
-            The input list of vertices. The default is None.
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey 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. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+       normalize : bool , optional
+            If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
         key : str , optional
-            The dictionary key under which to store the closeness centrality score. The default is "degree".
-        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.
+            The desired dictionary key under which to store the degree centrality score. The default is "degree_centrality".
+        colorKey : str , optional
+            The desired dictionary key under which to store the degree centrality color. The default is "dc_color".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -5218,35 +5169,30 @@ class Graph:
         Returns
         -------
         list
-            The degree of the input list of vertices within the input graph.
+            The betweenness 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
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
 
-        if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
-            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")]
-        if len(vertices) < 1:
-            print("Graph.Degree - Error: The input list of vertices does not contain any valid vertices. Returning None.")
-            return None
-        n = len(graphVertices)
-
-        scores = []
-        for i, v in enumerate(vertices):
-            degree = Graph.VertexDegree(graph, v, edgeKey= edgeKey, tolerance = tolerance)
-            if isinstance(degree, float):
-                degree = round(degree, mantissa)
-            d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, degree)
-            v = Topology.SetDictionary(v, d)
-            scores.append(degree)
-        return scores
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.DegreeCentrality - Error: The input graph is not a valid graph. Returning None.")
+            return None
+
+        return Graph.Connectivity(graph,
+                                  vertices=vertices,
+                                  weightKey=weightKey,
+                                  normalize=normalize,
+                                  key=key,
+                                  colorKey=colorKey,
+                                  colorScale=colorScale,
+                                  mantissa=mantissa,
+                                  tolerance=tolerance,
+                                  silent=silent)
     
     @staticmethod
     def DegreeMatrix(graph):
@@ -8468,7 +8414,7 @@ class Graph:
         return laplacian.tolist()
 
     @staticmethod
-    def Leaves(graph, edgeKey: str = None, tolerance: float = 0.0001, silent: bool = False):
+    def Leaves(graph, weightKey: str = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns a list of all vertices that have a degree of 1, also called leaf nodes.
 
@@ -8476,9 +8422,12 @@ class Graph:
         ----------
         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.
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey 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. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+        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
@@ -8496,7 +8445,7 @@ class 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]
+        return [v for v in Graph.Vertices(graph) if Graph.VertexDegree(graph, v, weightKey=weightKey, mantissa=mantissa, tolerance=tolerance, silent=silent) == 1]
     
     @staticmethod
     def LineGraph(graph, transferVertexDictionaries=False, transferEdgeDictionaries=False, tolerance=0.0001, silent=False):
@@ -9264,6 +9213,7 @@ class Graph:
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        import warnings
 
         try:
             import networkx as nx
@@ -9275,11 +9225,11 @@ class Graph:
                 os.system("pip install networkx --user")
             try:
                 import networkx as nx
-                print("Graph.NetworkXGraph - Infromation: networkx library installed correctly.")
+                print("Graph.NetworkXGraph - Information: networkx library installed correctly.")
             except:
                 warnings.warn("Graph - Error: Could not import networkx. Please try to install networkx manually. Returning None.")
                 return None
-        
+
         if not Topology.IsInstance(graph, "Graph"):
             if not silent:
                 print("Graph.NetworkXGraph - Error: The input graph is not a valid graph. Returning None.")
@@ -9287,6 +9237,8 @@ class Graph:
 
         nxGraph = nx.Graph()
         vertices = Graph.Vertices(graph)
+        edges = Graph.Edges(graph)
+        mesh_data = Graph.MeshData(graph)
         order = len(vertices)
         nodes = []
         for i in range(order):
@@ -9299,23 +9251,28 @@ class Graph:
                 values = Dictionary.Values(d)
                 if not values:
                     values = []
-                keys += [xKey,yKey,zKey]
+                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)
+                d = Dictionary.ByKeysValues(keys, values)
                 pythonD = Dictionary.PythonDictionary(d)
                 nodes.append((i, pythonD))
             else:
                 nodes.append((i, {"name": str(i)}))
         nxGraph.add_nodes_from(nodes)
-        for i in range(order):
-            v = vertices[i]
-            adjVertices = Graph.AdjacentVertices(graph, vertices[i])
-            for adjVertex in adjVertices:
-                adjIndex = Vertex.Index(vertex=adjVertex, vertices=vertices, strict=True, tolerance=tolerance)
-                if not adjIndex == None:
-                    nxGraph.add_edge(i,adjIndex, length=(Vertex.Distance(v, adjVertex, mantissa=mantissa)))
 
-        pos=nx.spring_layout(nxGraph, k=0.2)
+        mesh_edges = mesh_data['edges']
+        for i, mesh_edge in enumerate(mesh_edges):
+            sv_i = mesh_edge[0]
+            ev_i = mesh_edge[1]
+            sv = vertices[sv_i]
+            ev = vertices[ev_i]
+            edge_length = Vertex.Distance(sv, ev, mantissa=mantissa)
+            edge_dict = Topology.Dictionary(edges[i])
+            edge_attributes = Dictionary.PythonDictionary(edge_dict) if edge_dict else {}
+            edge_attributes['length'] = edge_length
+            nxGraph.add_edge(sv_i, ev_i, **edge_attributes)
+
+        pos = nx.spring_layout(nxGraph, k=0.2)
         nx.set_node_attributes(nxGraph, pos, "pos")
         return nxGraph
 
@@ -10515,7 +10472,7 @@ class Graph:
         return Graph.ByVerticesEdges(dictionary['vertices'], dictionary['edges'])
     
     @staticmethod
-    def VertexDegree(graph, vertex, edgeKey: str = None, tolerance: float = 0.0001, silent: bool = False):
+    def VertexDegree(graph, vertex, weightKey: str = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the degree of the input vertex. See https://en.wikipedia.org/wiki/Degree_(graph_theory).
 
@@ -10525,9 +10482,12 @@ class Graph:
             The input graph.
         vertex : topologic_core.Vertex
             The input vertex.
-        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.
+        weightKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the weightKey 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. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
+        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
@@ -10539,6 +10499,7 @@ class Graph:
             The degree of the input vertex.
 
         """
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
         import numbers
@@ -10551,18 +10512,20 @@ class Graph:
             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 = ""
         edges = Graph.Edges(graph, [vertex], tolerance=tolerance)
         degree = 0
         for edge in edges:
-            d = Topology.Dictionary(edge)
-            value = Dictionary.ValueAtKey(d, edgeKey)
-            if isinstance(value, numbers.Number):
-                degree += value
+            if weightKey == None:
+                value = 1
+            elif "len" in weightKey.lower() or "dis" in weightKey.lower():
+                value = Edge.Length(edge, mantissa=mantissa)
             else:
-                degree += 1
-        return degree
+                d = Topology.Dictionary(edge)
+                value = Dictionary.ValueAtKey(d, weightKey)
+                if not isinstance(value, numbers.Number):
+                    value = 1
+            degree += value
+        return round(degree, mantissa)
     
     @staticmethod
     def Vertices(graph, vertexKey=None, reverse=False):