topologicpy 0.8.57__py3-none-any.whl → 0.8.59__py3-none-any.whl

topologicpy/Graph.py

@@ -1901,11 +1901,28 @@ class Graph:
                                    mantissa= mantissa)
         return bot_graph.serialize(format=format)
 
+
     @staticmethod
-    def BetweennessCentrality(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nxCompatible: bool = False, key: str = "betweenness_centrality", colorKey="bc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def BetweennessCentrality(
+        graph,
+        method: str = "vertex",
+        weightKey: str = "length",
+        normalize: bool = False,
+        nxCompatible: bool = False,
+        key: str = "betweenness_centrality",
+        colorKey: str = "bc_color",
+        colorScale: str = "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.
-
+        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.
+        Optimized betweenness centrality (undirected) using Brandes:
+        - Unweighted: O(VE) BFS per source
+        - Weighted: Dijkstra-Brandes with binary heap
+        - Vertex or Edge mode
+        - Optional NetworkX-compatible normalization or 0..1 rescale
         Parameters
         ----------
         graph : topologic_core.Graph
@@ -1936,60 +1953,337 @@ class Graph:
         -------
         list
             The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
-
         """
-        import warnings
+        from collections import deque
+        import math
 
-        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
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        # We are inside Graph.* context; Graph.<...> methods available.
 
-        if weightKey:
-            if "len" in weightKey.lower() or "dis" in weightKey.lower():
+        # ---------- validate ----------
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.BetweennessCentrality - Error: The input is not a valid Graph. Returning None.")
+            return None
+
+        vertices = Graph.Vertices(graph)
+        n = len(vertices)
+        if n == 0:
+            if not silent:
+                print("Graph.BetweennessCentrality - Warning: Graph has no vertices. Returning [].")
+            return []
+
+        method_l = (method or "vertex").lower()
+        compute_edges = "edge" in method_l
+
+        # ---------- stable vertex indexing ----------
+        def vkey(v, r=9):
+            d = Topology.Dictionary(v)
+            vid = Dictionary.ValueAtKey(d, "id")
+            if vid is not None:
+                return ("id", vid)
+            return ("xyz", round(Vertex.X(v), r), round(Vertex.Y(v), r), round(Vertex.Z(v), r))
+
+        idx_of = {vkey(v): i for i, v in enumerate(vertices)}
+
+        # ---------- weight handling ----------
+        dist_attr = None
+        if isinstance(weightKey, str) and weightKey:
+            wl = weightKey.lower()
+            if ("len" in wl) or ("dis" in wl):
                 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 = [round(value, mantissa) for value in 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 nxCompatible == 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)]
+            dist_attr = weightKey
+
+        def edge_weight(e):
+            if dist_attr == "length":
+                try:
+                    return float(Edge.Length(e))
+                except Exception:
+                    return 1.0
+            elif dist_attr:
+                try:
+                    d = Topology.Dictionary(e)
+                    w = Dictionary.ValueAtKey(d, dist_attr)
+                    return float(w) if (w is not None) else 1.0
+                except Exception:
+                    return 1.0
             else:
-                values = Helper.Normalize(values)
-            min_value = 0
-            max_value = 1
+                return 1.0
+
+        # ---------- build undirected adjacency (min weight on multi-edges) ----------
+        edges = Graph.Edges(graph)
+        # For per-edge outputs in input order:
+        edge_end_idx = []  # [(iu, iv)] aligned with edges list (undirected as sorted pair)
+        tmp_adj = [dict() for _ in range(n)]  # temporary: dedup by neighbor with min weight
+
+        for e in edges:
+            try:
+                u = Edge.StartVertex(e)
+                v = Edge.EndVertex(e)
+            except Exception:
+                continue
+            iu = idx_of.get(vkey(u))
+            iv = idx_of.get(vkey(v))
+            if iu is None or iv is None or iu == iv:
+                # still store mapping for return list to avoid index error
+                pair = None
+            else:
+                w = edge_weight(e)
+                # keep minimal weight for duplicates
+                pu = tmp_adj[iu].get(iv)
+                if (pu is None) or (w < pu):
+                    tmp_adj[iu][iv] = w
+                    tmp_adj[iv][iu] = w
+                pair = (iu, iv) if iu < iv else (iv, iu)
+            edge_end_idx.append(pair)
+
+        # finalize adjacency as list-of-tuples for fast loops
+        adj = [list(neigh.items()) for neigh in tmp_adj]  # adj[i] = [(j, w), ...]
+        del tmp_adj
+
+        # detect weightedness
+        weighted = False
+        for i in range(n):
+            if any(abs(w - 1.0) > 1e-12 for _, w in adj[i]):
+                weighted = True
+                break
+
+        # ---------- Brandes ----------
+        CB_v = [0.0] * n
+        CB_e = {}  # key: (min_i, max_j) -> score (only if compute_edges)
+
+        if n > 1:
+            if not weighted:
+                # Unweighted BFS Brandes
+                for s in range(n):
+                    S = []
+                    P = [[] for _ in range(n)]
+                    sigma = [0.0] * n
+                    sigma[s] = 1.0
+                    dist = [-1] * n
+                    dist[s] = 0
+                    Q = deque([s])
+                    pushQ, popQ = Q.append, Q.popleft
+
+                    while Q:
+                        v = popQ()
+                        S.append(v)
+                        dv = dist[v]
+                        sv = sigma[v]
+                        for w, _ in adj[v]:
+                            if dist[w] < 0:
+                                dist[w] = dv + 1
+                                pushQ(w)
+                            if dist[w] == dv + 1:
+                                sigma[w] += sv
+                                P[w].append(v)
+
+                    delta = [0.0] * n
+                    while S:
+                        w = S.pop()
+                        sw = sigma[w]
+                        dw = 1.0 + delta[w]
+                        for v in P[w]:
+                            c = (sigma[v] / sw) * dw
+                            delta[v] += c
+                            if compute_edges:
+                                a, b = (v, w) if v < w else (w, v)
+                                CB_e[a, b] = CB_e.get((a, b), 0.0) + c
+                        if w != s:
+                            CB_v[w] += delta[w]
+            else:
+                # Weighted Dijkstra-Brandes
+                import heapq
+                EPS = 1e-12
+                for s in range(n):
+                    S = []
+                    P = [[] for _ in range(n)]
+                    sigma = [0.0] * n
+                    sigma[s] = 1.0
+                    dist = [math.inf] * n
+                    dist[s] = 0.0
+                    H = [(0.0, s)]
+                    pushH, popH = heapq.heappush, heapq.heappop
+
+                    while H:
+                        dv, v = popH(H)
+                        if dv > dist[v] + EPS:
+                            continue
+                        S.append(v)
+                        sv = sigma[v]
+                        for w, wgt in adj[v]:
+                            nd = dv + wgt
+                            dw = dist[w]
+                            if nd + EPS < dw:
+                                dist[w] = nd
+                                sigma[w] = sv
+                                P[w] = [v]
+                                pushH(H, (nd, w))
+                            elif abs(nd - dw) <= EPS:
+                                sigma[w] += sv
+                                P[w].append(v)
+
+                    delta = [0.0] * n
+                    while S:
+                        w = S.pop()
+                        sw = sigma[w]
+                        if sw == 0.0:
+                            continue
+                        dw = 1.0 + delta[w]
+                        for v in P[w]:
+                            c = (sigma[v] / sw) * dw
+                            delta[v] += c
+                            if compute_edges:
+                                a, b = (v, w) if v < w else (w, v)
+                                CB_e[a, b] = CB_e.get((a, b), 0.0) + c
+                        if w != s:
+                            CB_v[w] += delta[w]
+
+        # ---------- normalization ----------
+        # NetworkX-compatible normalization (undirected):
+        # vertices/edges factor = 2/((n-1)(n-2)) for n > 2 when normalized=True
+        if nxCompatible:
+            if normalize and n > 2:
+                scale = 2.0 / ((n - 1) * (n - 2))
+                CB_v = [v * scale for v in CB_v]
+                if compute_edges:
+                    for k in list(CB_e.keys()):
+                        CB_e[k] *= scale
+            # else: leave raw Brandes scores (normalized=False behavior)
+            values_raw = CB_v if not compute_edges else [
+                CB_e.get(tuple(sorted(pair)) if pair else None, 0.0) if pair else 0.0
+                for pair in edge_end_idx
+            ]
+            values_for_return = values_raw
         else:
-            min_value = min(values)
-            max_value = max(values)
+            # Rescale to [0,1] regardless of theoretical normalization
+            values_raw = CB_v if not compute_edges else [
+                CB_e.get(tuple(sorted(pair)) if pair else None, 0.0) if pair else 0.0
+                for pair in edge_end_idx
+            ]
+            values_for_return = Helper.Normalize(values_raw)
 
-        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)
+        # rounding once
+        if mantissa is not None and mantissa >= 0:
+            values_for_return = [round(v, mantissa) for v in values_for_return]
 
-        return values
+        # ---------- color mapping ----------
+        if values_for_return:
+            min_v, max_v = min(values_for_return), max(values_for_return)
+        else:
+            min_v, max_v = 0.0, 1.0
+        if abs(max_v - min_v) < tolerance:
+            max_v = min_v + tolerance
+
+        # annotate (vertices or edges) in input order
+        if compute_edges:
+            elems = edges
+        else:
+            elems = vertices
+        for i, value in enumerate(values_for_return):
+            d = Topology.Dictionary(elems[i])
+            color_hex = Color.AnyToHex(
+                Color.ByValueInRange(value, minValue=min_v, maxValue=max_v, colorScale=colorScale)
+            )
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color_hex])
+            elems[i] = Topology.SetDictionary(elems[i], d)
+
+        return values_for_return
+
+    # @staticmethod
+    # def BetweennessCentrality_old(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nxCompatible: 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.
+
+    #     Parameters
+    #     ----------
+    #     graph : topologic_core.Graph
+    #         The input graph.
+    #     method : str , optional
+    #         The method of computing the betweenness centrality. The options are "vertex" or "edge". 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. Default is False.
+    #     nxCompatible : 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. Default is False.
+    #     key : str , optional
+    #         The desired dictionary key under which to store the betweenness centrality score. Default is "betweenness_centrality".
+    #     colorKey : str , optional
+    #         The desired dictionary key under which to store the betweenness centrality color. Default is "betweenness_centrality".
+    #     colorScale : str , optional
+    #         The desired type of plotly color scales to use (e.g. "viridis", "plasma"). 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 number of decimal places to round the result to. Default is 6.
+    #     tolerance : float , optional
+    #         The desired tolerance. Default is 0.0001.
+
+    #     Returns
+    #     -------
+    #     list
+    #         The betweenness centrality of the input list of vertices within the input graph. The values are in the range 0 to 1.
+
+    #     """
+    #     import warnings
+
+    #     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.Dictionary import Dictionary
+    #     from topologicpy.Color import Color
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Helper import Helper
+
+    #     if weightKey:
+    #         if "len" in weightKey.lower() or "dis" in weightKey.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 = [round(value, mantissa) for value in 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 nxCompatible == 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:
+    #         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 BetweennessPartition(graph, n=2, m=10, key="partition", tolerance=0.0001, silent=False):
@@ -3246,432 +3540,432 @@ class Graph:
         edges = get_edges(relationships, vertices)
         return Graph.ByVerticesEdges(vertices, edges)
         
-    @staticmethod
-    def ByIFCFile_old(file,
-                  includeTypes: list = [],
-                  excludeTypes: list = [],
-                  includeRels: list = [],
-                  excludeRels: list = [],
-                  transferDictionaries: bool = False,
-                  useInternalVertex: bool = False,
-                  storeBREP: bool = False,
-                  removeCoplanarFaces: bool = False,
-                  xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
-                  xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
-                  tolerance: float = 0.0001):
-        """
-        Create a Graph from an IFC file. This code is partially based on code from Bruno Postle.
+    # @staticmethod
+    # def ByIFCFile_old(file,
+    #               includeTypes: list = [],
+    #               excludeTypes: list = [],
+    #               includeRels: list = [],
+    #               excludeRels: list = [],
+    #               transferDictionaries: bool = False,
+    #               useInternalVertex: bool = False,
+    #               storeBREP: bool = False,
+    #               removeCoplanarFaces: bool = False,
+    #               xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
+    #               xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
+    #               tolerance: float = 0.0001):
+    #     """
+    #     Create a Graph from an IFC file. This code is partially based on code from Bruno Postle.
 
-        Parameters
-        ----------
-        file : file
-            The input IFC file
-        includeTypes : list , optional
-            A list of IFC object types to include in the graph. Default is [] which means all object types are included.
-        excludeTypes : list , optional
-            A list of IFC object types to exclude from the graph. Default is [] which mean no object type is excluded.
-        includeRels : list , optional
-            A list of IFC relationship types to include in the graph. Default is [] which means all relationship types are included.
-        excludeRels : list , optional
-            A list of IFC relationship types to exclude from the graph. Default is [] which mean no relationship type is excluded.
-        transferDictionaries : bool , optional
-            If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. Default is False.
-        useInternalVertex : bool , optional
-            If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. Default is False.
-        storeBREP : bool , optional
-            If set to True, store the BRep of the subtopology in its representative vertex. Default is False.
-        removeCoplanarFaces : bool , optional
-            If set to True, coplanar faces are removed. Otherwise they are not. Default is False.
-        xMin : float, optional
-            The desired minimum value to assign for a vertex's X coordinate. Default is -0.5.
-        yMin : float, optional
-            The desired minimum value to assign for a vertex's Y coordinate. Default is -0.5.
-        zMin : float, optional
-            The desired minimum value to assign for a vertex's Z coordinate. Default is -0.5.
-        xMax : float, optional
-            The desired maximum value to assign for a vertex's X coordinate. Default is 0.5.
-        yMax : float, optional
-            The desired maximum value to assign for a vertex's Y coordinate. Default is 0.5.
-        zMax : float, optional
-            The desired maximum value to assign for a vertex's Z coordinate. Default is 0.5.
-        tolerance : float , optional
-            The desired tolerance. Default is 0.0001.
-        
-        Returns
-        -------
-        topologic_core.Graph
-            The created graph.
+    #     Parameters
+    #     ----------
+    #     file : file
+    #         The input IFC file
+    #     includeTypes : list , optional
+    #         A list of IFC object types to include in the graph. Default is [] which means all object types are included.
+    #     excludeTypes : list , optional
+    #         A list of IFC object types to exclude from the graph. Default is [] which mean no object type is excluded.
+    #     includeRels : list , optional
+    #         A list of IFC relationship types to include in the graph. Default is [] which means all relationship types are included.
+    #     excludeRels : list , optional
+    #         A list of IFC relationship types to exclude from the graph. Default is [] which mean no relationship type is excluded.
+    #     transferDictionaries : bool , optional
+    #         If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. Default is False.
+    #     useInternalVertex : bool , optional
+    #         If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. Default is False.
+    #     storeBREP : bool , optional
+    #         If set to True, store the BRep of the subtopology in its representative vertex. Default is False.
+    #     removeCoplanarFaces : bool , optional
+    #         If set to True, coplanar faces are removed. Otherwise they are not. Default is False.
+    #     xMin : float, optional
+    #         The desired minimum value to assign for a vertex's X coordinate. Default is -0.5.
+    #     yMin : float, optional
+    #         The desired minimum value to assign for a vertex's Y coordinate. Default is -0.5.
+    #     zMin : float, optional
+    #         The desired minimum value to assign for a vertex's Z coordinate. Default is -0.5.
+    #     xMax : float, optional
+    #         The desired maximum value to assign for a vertex's X coordinate. Default is 0.5.
+    #     yMax : float, optional
+    #         The desired maximum value to assign for a vertex's Y coordinate. Default is 0.5.
+    #     zMax : float, optional
+    #         The desired maximum value to assign for a vertex's Z coordinate. Default is 0.5.
+    #     tolerance : float , optional
+    #         The desired tolerance. Default is 0.0001.
         
-        """
-        from topologicpy.Topology import Topology
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Edge import Edge
-        from topologicpy.Graph import Graph
-        from topologicpy.Dictionary import Dictionary
-        try:
-            import ifcopenshell
-            import ifcopenshell.util.placement
-            import ifcopenshell.util.element
-            import ifcopenshell.util.shape
-            import ifcopenshell.geom
-        except:
-            print("Graph.ByIFCFile - Warning: Installing required ifcopenshell library.")
-            try:
-                os.system("pip install ifcopenshell")
-            except:
-                os.system("pip install ifcopenshell --user")
-            try:
-                import ifcopenshell
-                import ifcopenshell.util.placement
-                import ifcopenshell.util.element
-                import ifcopenshell.util.shape
-                import ifcopenshell.geom
-                print("Graph.ByIFCFile - Warning: ifcopenshell library installed correctly.")
-            except:
-                warnings.warn("Graph.ByIFCFile - Error: Could not import ifcopenshell. Please try to install ifcopenshell manually. Returning None.")
-                return None
+    #     Returns
+    #     -------
+    #     topologic_core.Graph
+    #         The created graph.
         
-        import random
-
-        def vertexAtKeyValue(vertices, key, value):
-            for v in vertices:
-                d = Topology.Dictionary(v)
-                d_value = Dictionary.ValueAtKey(d, key)
-                if value == d_value:
-                    return v
-            return None
-
-        def IFCObjects(ifc_file, include=[], exclude=[]):
-            include = [s.lower() for s in include]
-            exclude = [s.lower() for s in exclude]
-            all_objects = ifc_file.by_type('IfcProduct')
-            return_objects = []
-            for obj in all_objects:
-                is_a = obj.is_a().lower()
-                if is_a in exclude:
-                    continue
-                if is_a in include or len(include) == 0:
-                    return_objects.append(obj)
-            return return_objects
-
-        def IFCObjectTypes(ifc_file):
-            products = IFCObjects(ifc_file)
-            obj_types = []
-            for product in products:
-                obj_types.append(product.is_a())  
-            obj_types = list(set(obj_types))
-            obj_types.sort()
-            return obj_types
-
-        def IFCRelationshipTypes(ifc_file):
-            rel_types = [ifc_rel.is_a() for ifc_rel in ifc_file.by_type("IfcRelationship")]
-            rel_types = list(set(rel_types))
-            rel_types.sort()
-            return rel_types
-
-        def IFCRelationships(ifc_file, include=[], exclude=[]):
-            include = [s.lower() for s in include]
-            exclude = [s.lower() for s in exclude]
-            rel_types = [ifc_rel.is_a() for ifc_rel in ifc_file.by_type("IfcRelationship")]
-            rel_types = list(set(rel_types))
-            relationships = []
-            for ifc_rel in ifc_file.by_type("IfcRelationship"):
-                rel_type = ifc_rel.is_a().lower()
-                if rel_type in exclude:
-                    continue
-                if rel_type in include or len(include) == 0:
-                    relationships.append(ifc_rel)
-            return relationships
+    #     """
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Vertex import Vertex
+    #     from topologicpy.Edge import Edge
+    #     from topologicpy.Graph import Graph
+    #     from topologicpy.Dictionary import Dictionary
+    #     try:
+    #         import ifcopenshell
+    #         import ifcopenshell.util.placement
+    #         import ifcopenshell.util.element
+    #         import ifcopenshell.util.shape
+    #         import ifcopenshell.geom
+    #     except:
+    #         print("Graph.ByIFCFile - Warning: Installing required ifcopenshell library.")
+    #         try:
+    #             os.system("pip install ifcopenshell")
+    #         except:
+    #             os.system("pip install ifcopenshell --user")
+    #         try:
+    #             import ifcopenshell
+    #             import ifcopenshell.util.placement
+    #             import ifcopenshell.util.element
+    #             import ifcopenshell.util.shape
+    #             import ifcopenshell.geom
+    #             print("Graph.ByIFCFile - Warning: ifcopenshell library installed correctly.")
+    #         except:
+    #             warnings.warn("Graph.ByIFCFile - Error: Could not import ifcopenshell. Please try to install ifcopenshell manually. Returning None.")
+    #             return None
+        
+    #     import random
+
+    #     def vertexAtKeyValue(vertices, key, value):
+    #         for v in vertices:
+    #             d = Topology.Dictionary(v)
+    #             d_value = Dictionary.ValueAtKey(d, key)
+    #             if value == d_value:
+    #                 return v
+    #         return None
 
-        def get_psets(entity):
-            # Initialize the PSET dictionary for this entity
-            psets = {}
+    #     def IFCObjects(ifc_file, include=[], exclude=[]):
+    #         include = [s.lower() for s in include]
+    #         exclude = [s.lower() for s in exclude]
+    #         all_objects = ifc_file.by_type('IfcProduct')
+    #         return_objects = []
+    #         for obj in all_objects:
+    #             is_a = obj.is_a().lower()
+    #             if is_a in exclude:
+    #                 continue
+    #             if is_a in include or len(include) == 0:
+    #                 return_objects.append(obj)
+    #         return return_objects
+
+    #     def IFCObjectTypes(ifc_file):
+    #         products = IFCObjects(ifc_file)
+    #         obj_types = []
+    #         for product in products:
+    #             obj_types.append(product.is_a())  
+    #         obj_types = list(set(obj_types))
+    #         obj_types.sort()
+    #         return obj_types
+
+    #     def IFCRelationshipTypes(ifc_file):
+    #         rel_types = [ifc_rel.is_a() for ifc_rel in ifc_file.by_type("IfcRelationship")]
+    #         rel_types = list(set(rel_types))
+    #         rel_types.sort()
+    #         return rel_types
+
+    #     def IFCRelationships(ifc_file, include=[], exclude=[]):
+    #         include = [s.lower() for s in include]
+    #         exclude = [s.lower() for s in exclude]
+    #         rel_types = [ifc_rel.is_a() for ifc_rel in ifc_file.by_type("IfcRelationship")]
+    #         rel_types = list(set(rel_types))
+    #         relationships = []
+    #         for ifc_rel in ifc_file.by_type("IfcRelationship"):
+    #             rel_type = ifc_rel.is_a().lower()
+    #             if rel_type in exclude:
+    #                 continue
+    #             if rel_type in include or len(include) == 0:
+    #                 relationships.append(ifc_rel)
+    #         return relationships
+
+    #     def get_psets(entity):
+    #         # Initialize the PSET dictionary for this entity
+    #         psets = {}
             
-            # Check if the entity has a GlobalId
-            if not hasattr(entity, 'GlobalId'):
-                raise ValueError("The provided entity does not have a GlobalId.")
+    #         # Check if the entity has a GlobalId
+    #         if not hasattr(entity, 'GlobalId'):
+    #             raise ValueError("The provided entity does not have a GlobalId.")
             
-            # Get the property sets related to this entity
-            for definition in entity.IsDefinedBy:
-                if definition.is_a('IfcRelDefinesByProperties'):
-                    property_set = definition.RelatingPropertyDefinition
+    #         # Get the property sets related to this entity
+    #         for definition in entity.IsDefinedBy:
+    #             if definition.is_a('IfcRelDefinesByProperties'):
+    #                 property_set = definition.RelatingPropertyDefinition
                     
-                    # Check if it is a property set
-                    if not property_set == None:
-                        if property_set.is_a('IfcPropertySet'):
-                            pset_name = "IFC_"+property_set.Name
+    #                 # Check if it is a property set
+    #                 if not property_set == None:
+    #                     if property_set.is_a('IfcPropertySet'):
+    #                         pset_name = "IFC_"+property_set.Name
                             
-                            # Dictionary to hold individual properties
-                            properties = {}
+    #                         # Dictionary to hold individual properties
+    #                         properties = {}
                             
-                            # Iterate over the properties in the PSET
-                            for prop in property_set.HasProperties:
-                                if prop.is_a('IfcPropertySingleValue'):
-                                    # Get the property name and value
-                                    prop_name = "IFC_"+prop.Name
-                                    prop_value = prop.NominalValue.wrappedValue if prop.NominalValue else None
-                                    properties[prop_name] = prop_value
+    #                         # Iterate over the properties in the PSET
+    #                         for prop in property_set.HasProperties:
+    #                             if prop.is_a('IfcPropertySingleValue'):
+    #                                 # Get the property name and value
+    #                                 prop_name = "IFC_"+prop.Name
+    #                                 prop_value = prop.NominalValue.wrappedValue if prop.NominalValue else None
+    #                                 properties[prop_name] = prop_value
                             
-                            # Add this PSET to the dictionary for this entity
-                            psets[pset_name] = properties
-            return psets
+    #                         # Add this PSET to the dictionary for this entity
+    #                         psets[pset_name] = properties
+    #         return psets
         
-        def get_color_transparency_material(entity):
-            import random
+    #     def get_color_transparency_material(entity):
+    #         import random
 
-            # Set default Material Name and ID
-            material_list = []
-            # Set default transparency based on entity type or material
-            default_transparency = 0.0
+    #         # Set default Material Name and ID
+    #         material_list = []
+    #         # Set default transparency based on entity type or material
+    #         default_transparency = 0.0
             
-            # Check if the entity is an opening or made of glass
-            is_a = entity.is_a().lower()
-            if "opening" in is_a or "window" in is_a or "door" in is_a or "space" in is_a:
-                default_transparency = 0.7
-            elif "space" in is_a:
-                default_transparency = 0.8
+    #         # Check if the entity is an opening or made of glass
+    #         is_a = entity.is_a().lower()
+    #         if "opening" in is_a or "window" in is_a or "door" in is_a or "space" in is_a:
+    #             default_transparency = 0.7
+    #         elif "space" in is_a:
+    #             default_transparency = 0.8
             
-            # Check if the entity has constituent materials (e.g., glass)
-            else:
-                # Check for associated materials (ConstituentMaterial or direct material assignment)
-                materials_checked = False
-                if hasattr(entity, 'HasAssociations'):
-                    for rel in entity.HasAssociations:
-                        if rel.is_a('IfcRelAssociatesMaterial'):
-                            material = rel.RelatingMaterial
-                            if material.is_a('IfcMaterial') and 'glass' in material.Name.lower():
-                                default_transparency = 0.5
-                                materials_checked = True
-                            elif material.is_a('IfcMaterialLayerSetUsage'):
-                                material_layers = material.ForLayerSet.MaterialLayers
-                                for layer in material_layers:
-                                    material_list.append(layer.Material.Name)
-                                    if 'glass' in layer.Material.Name.lower():
-                                        default_transparency = 0.5
-                                        materials_checked = True
+    #         # Check if the entity has constituent materials (e.g., glass)
+    #         else:
+    #             # Check for associated materials (ConstituentMaterial or direct material assignment)
+    #             materials_checked = False
+    #             if hasattr(entity, 'HasAssociations'):
+    #                 for rel in entity.HasAssociations:
+    #                     if rel.is_a('IfcRelAssociatesMaterial'):
+    #                         material = rel.RelatingMaterial
+    #                         if material.is_a('IfcMaterial') and 'glass' in material.Name.lower():
+    #                             default_transparency = 0.5
+    #                             materials_checked = True
+    #                         elif material.is_a('IfcMaterialLayerSetUsage'):
+    #                             material_layers = material.ForLayerSet.MaterialLayers
+    #                             for layer in material_layers:
+    #                                 material_list.append(layer.Material.Name)
+    #                                 if 'glass' in layer.Material.Name.lower():
+    #                                     default_transparency = 0.5
+    #                                     materials_checked = True
                                         
-                # Check for ConstituentMaterial if available
-                if hasattr(entity, 'HasAssociations') and not materials_checked:
-                    for rel in entity.HasAssociations:
-                        if rel.is_a('IfcRelAssociatesMaterial'):
-                            material = rel.RelatingMaterial
-                            if material.is_a('IfcMaterialConstituentSet'):
-                                for constituent in material.MaterialConstituents:
-                                    material_list.append(constituent.Material.Name)
-                                    if 'glass' in constituent.Material.Name.lower():
-                                        default_transparency = 0.5
-                                        materials_checked = True
-
-                # Check if the entity has ShapeAspects with associated materials or styles
-                if hasattr(entity, 'HasShapeAspects') and not materials_checked:
-                    for shape_aspect in entity.HasShapeAspects:
-                        if hasattr(shape_aspect, 'StyledByItem') and shape_aspect.StyledByItem:
-                            for styled_item in shape_aspect.StyledByItem:
-                                for style in styled_item.Styles:
-                                    if style.is_a('IfcSurfaceStyle'):
-                                        for surface_style in style.Styles:
-                                            if surface_style.is_a('IfcSurfaceStyleRendering'):
-                                                transparency = getattr(surface_style, 'Transparency', default_transparency)
-                                                if transparency > 0:
-                                                    default_transparency = transparency
-
-            # Try to get the actual color and transparency if defined
-            if hasattr(entity, 'Representation') and entity.Representation:
-                for rep in entity.Representation.Representations:
-                    for item in rep.Items:
-                        if hasattr(item, 'StyledByItem') and item.StyledByItem:
-                            for styled_item in item.StyledByItem:
-                                if hasattr(styled_item, 'Styles'):
-                                    for style in styled_item.Styles:
-                                        if style.is_a('IfcSurfaceStyle'):
-                                            for surface_style in style.Styles:
-                                                if surface_style.is_a('IfcSurfaceStyleRendering'):
-                                                    color = surface_style.SurfaceColour
-                                                    transparency = getattr(surface_style, 'Transparency', default_transparency)
-                                                    return (color.Red*255, color.Green*255, color.Blue*255), transparency, material_list
+    #             # Check for ConstituentMaterial if available
+    #             if hasattr(entity, 'HasAssociations') and not materials_checked:
+    #                 for rel in entity.HasAssociations:
+    #                     if rel.is_a('IfcRelAssociatesMaterial'):
+    #                         material = rel.RelatingMaterial
+    #                         if material.is_a('IfcMaterialConstituentSet'):
+    #                             for constituent in material.MaterialConstituents:
+    #                                 material_list.append(constituent.Material.Name)
+    #                                 if 'glass' in constituent.Material.Name.lower():
+    #                                     default_transparency = 0.5
+    #                                     materials_checked = True
+
+    #             # Check if the entity has ShapeAspects with associated materials or styles
+    #             if hasattr(entity, 'HasShapeAspects') and not materials_checked:
+    #                 for shape_aspect in entity.HasShapeAspects:
+    #                     if hasattr(shape_aspect, 'StyledByItem') and shape_aspect.StyledByItem:
+    #                         for styled_item in shape_aspect.StyledByItem:
+    #                             for style in styled_item.Styles:
+    #                                 if style.is_a('IfcSurfaceStyle'):
+    #                                     for surface_style in style.Styles:
+    #                                         if surface_style.is_a('IfcSurfaceStyleRendering'):
+    #                                             transparency = getattr(surface_style, 'Transparency', default_transparency)
+    #                                             if transparency > 0:
+    #                                                 default_transparency = transparency
+
+    #         # Try to get the actual color and transparency if defined
+    #         if hasattr(entity, 'Representation') and entity.Representation:
+    #             for rep in entity.Representation.Representations:
+    #                 for item in rep.Items:
+    #                     if hasattr(item, 'StyledByItem') and item.StyledByItem:
+    #                         for styled_item in item.StyledByItem:
+    #                             if hasattr(styled_item, 'Styles'):
+    #                                 for style in styled_item.Styles:
+    #                                     if style.is_a('IfcSurfaceStyle'):
+    #                                         for surface_style in style.Styles:
+    #                                             if surface_style.is_a('IfcSurfaceStyleRendering'):
+    #                                                 color = surface_style.SurfaceColour
+    #                                                 transparency = getattr(surface_style, 'Transparency', default_transparency)
+    #                                                 return (color.Red*255, color.Green*255, color.Blue*255), transparency, material_list
             
-            # If no color is defined, return a consistent random color based on the entity type
-            if "wall" in is_a:
-                color = (175, 175, 175)
-            elif "slab" in is_a:
-                color = (200, 200, 200)
-            elif "space" in is_a:
-                color = (250, 250, 250)
-            else:
-                random.seed(hash(is_a))
-                color = (random.random(), random.random(), random.random())
+    #         # If no color is defined, return a consistent random color based on the entity type
+    #         if "wall" in is_a:
+    #             color = (175, 175, 175)
+    #         elif "slab" in is_a:
+    #             color = (200, 200, 200)
+    #         elif "space" in is_a:
+    #             color = (250, 250, 250)
+    #         else:
+    #             random.seed(hash(is_a))
+    #             color = (random.random(), random.random(), random.random())
             
-            return color, default_transparency, material_list
+    #         return color, default_transparency, material_list
 
-        def vertexByIFCObject(ifc_object, object_types, restrict=False):
-            settings = ifcopenshell.geom.settings()
-            settings.set(settings.USE_WORLD_COORDS,True)
-            try:
-                shape = ifcopenshell.geom.create_shape(settings, ifc_object)
-            except:
-                shape = None
-            if shape or restrict == False: #Only add vertices of entities that have 3D geometries.
-                obj_id = ifc_object.id()
-                psets = ifcopenshell.util.element.get_psets(ifc_object)
-                obj_type = ifc_object.is_a()
-                obj_type_id = object_types.index(obj_type)
-                name = "Untitled"
-                LongName = "Untitled"
-                try:
-                    name = ifc_object.Name
-                except:
-                    name = "Untitled"
-                try:
-                    LongName = ifc_object.LongName
-                except:
-                    LongName = name
-
-                if name == None:
-                    name = "Untitled"
-                if LongName == None:
-                    LongName = "Untitled"
-                label = str(obj_id)+" "+LongName+" ("+obj_type+" "+str(obj_type_id)+")"
-                try:
-                    grouped_verts = ifcopenshell.util.shape.get_vertices(shape.geometry)
-                    vertices = [Vertex.ByCoordinates(list(coords)) for coords in grouped_verts]
-                    centroid = Vertex.Centroid(vertices)
-                except:
-                    x = random.uniform(xMin,xMax)
-                    y = random.uniform(yMin,yMax)
-                    z = random.uniform(zMin,zMax)
-                    centroid = Vertex.ByCoordinates(x, y, z)
+    #     def vertexByIFCObject(ifc_object, object_types, restrict=False):
+    #         settings = ifcopenshell.geom.settings()
+    #         settings.set(settings.USE_WORLD_COORDS,True)
+    #         try:
+    #             shape = ifcopenshell.geom.create_shape(settings, ifc_object)
+    #         except:
+    #             shape = None
+    #         if shape or restrict == False: #Only add vertices of entities that have 3D geometries.
+    #             obj_id = ifc_object.id()
+    #             psets = ifcopenshell.util.element.get_psets(ifc_object)
+    #             obj_type = ifc_object.is_a()
+    #             obj_type_id = object_types.index(obj_type)
+    #             name = "Untitled"
+    #             LongName = "Untitled"
+    #             try:
+    #                 name = ifc_object.Name
+    #             except:
+    #                 name = "Untitled"
+    #             try:
+    #                 LongName = ifc_object.LongName
+    #             except:
+    #                 LongName = name
+
+    #             if name == None:
+    #                 name = "Untitled"
+    #             if LongName == None:
+    #                 LongName = "Untitled"
+    #             label = str(obj_id)+" "+LongName+" ("+obj_type+" "+str(obj_type_id)+")"
+    #             try:
+    #                 grouped_verts = ifcopenshell.util.shape.get_vertices(shape.geometry)
+    #                 vertices = [Vertex.ByCoordinates(list(coords)) for coords in grouped_verts]
+    #                 centroid = Vertex.Centroid(vertices)
+    #             except:
+    #                 x = random.uniform(xMin,xMax)
+    #                 y = random.uniform(yMin,yMax)
+    #                 z = random.uniform(zMin,zMax)
+    #                 centroid = Vertex.ByCoordinates(x, y, z)
                 
-                # Store relevant information
-                if transferDictionaries == True:
-                    color, transparency, material_list = get_color_transparency_material(ifc_object)
-                    if color == None:
-                        color = "white"
-                    if transparency == None:
-                        transparency = 0
-                    entity_dict = {
-                        "TOPOLOGIC_id": str(Topology.UUID(centroid)),
-                        "TOPOLOGIC_name": getattr(ifc_object, 'Name', "Untitled"),
-                        "TOPOLOGIC_type": Topology.TypeAsString(centroid),
-                        "TOPOLOGIC_color": color,
-                        "TOPOLOGIC_opacity": 1.0 - transparency,
-                        "IFC_global_id": getattr(ifc_object, 'GlobalId', 0),
-                        "IFC_name": getattr(ifc_object, 'Name', "Untitled"),
-                        "IFC_type": ifc_object.is_a(),
-                        "IFC_material_list": material_list,
-                    }
-                    topology_dict = Dictionary.ByPythonDictionary(entity_dict)
-                    # Get PSETs dictionary
-                    pset_python_dict = get_psets(ifc_object)
-                    pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
-                    topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
-                    if storeBREP == True or useInternalVertex == True:
-                        shape_topology = None
-                        if hasattr(ifc_object, "Representation") and ifc_object.Representation:
-                            for rep in ifc_object.Representation.Representations:
-                                if rep.is_a("IfcShapeRepresentation"):
-                                    try:
-                                        # Generate the geometry for this entity
-                                        shape = ifcopenshell.geom.create_shape(settings, ifc_object)
-                                        # Get grouped vertices and grouped faces     
-                                        grouped_verts = shape.geometry.verts
-                                        verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
-                                        grouped_edges = shape.geometry.edges
-                                        edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
-                                        grouped_faces = shape.geometry.faces
-                                        faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
-                                        shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
-                                        if not shape_topology == None:
-                                            if removeCoplanarFaces == True:
-                                                shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
-                                    except:
-                                        pass
-                        if not shape_topology == None and storeBREP:
-                            topology_dict = Dictionary.SetValuesAtKeys(topology_dict, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(shape_topology), Topology.Type(shape_topology), Topology.TypeAsString(shape_topology)])
-                        if not shape_topology == None and useInternalVertex == True:
-                            centroid = Topology.InternalVertex(shape_topology)
-                    centroid = Topology.SetDictionary(centroid, topology_dict)
-                return centroid
-            return None
-
-        def edgesByIFCRelationships(ifc_relationships, ifc_types, vertices):
-            tuples = []
-            edges = []
+    #             # Store relevant information
+    #             if transferDictionaries == True:
+    #                 color, transparency, material_list = get_color_transparency_material(ifc_object)
+    #                 if color == None:
+    #                     color = "white"
+    #                 if transparency == None:
+    #                     transparency = 0
+    #                 entity_dict = {
+    #                     "TOPOLOGIC_id": str(Topology.UUID(centroid)),
+    #                     "TOPOLOGIC_name": getattr(ifc_object, 'Name', "Untitled"),
+    #                     "TOPOLOGIC_type": Topology.TypeAsString(centroid),
+    #                     "TOPOLOGIC_color": color,
+    #                     "TOPOLOGIC_opacity": 1.0 - transparency,
+    #                     "IFC_global_id": getattr(ifc_object, 'GlobalId', 0),
+    #                     "IFC_name": getattr(ifc_object, 'Name', "Untitled"),
+    #                     "IFC_type": ifc_object.is_a(),
+    #                     "IFC_material_list": material_list,
+    #                 }
+    #                 topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+    #                 # Get PSETs dictionary
+    #                 pset_python_dict = get_psets(ifc_object)
+    #                 pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+    #                 topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+    #                 if storeBREP == True or useInternalVertex == True:
+    #                     shape_topology = None
+    #                     if hasattr(ifc_object, "Representation") and ifc_object.Representation:
+    #                         for rep in ifc_object.Representation.Representations:
+    #                             if rep.is_a("IfcShapeRepresentation"):
+    #                                 try:
+    #                                     # Generate the geometry for this entity
+    #                                     shape = ifcopenshell.geom.create_shape(settings, ifc_object)
+    #                                     # Get grouped vertices and grouped faces     
+    #                                     grouped_verts = shape.geometry.verts
+    #                                     verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+    #                                     grouped_edges = shape.geometry.edges
+    #                                     edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+    #                                     grouped_faces = shape.geometry.faces
+    #                                     faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
+    #                                     shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
+    #                                     if not shape_topology == None:
+    #                                         if removeCoplanarFaces == True:
+    #                                             shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+    #                                 except:
+    #                                     pass
+    #                     if not shape_topology == None and storeBREP:
+    #                         topology_dict = Dictionary.SetValuesAtKeys(topology_dict, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(shape_topology), Topology.Type(shape_topology), Topology.TypeAsString(shape_topology)])
+    #                     if not shape_topology == None and useInternalVertex == True:
+    #                         centroid = Topology.InternalVertex(shape_topology)
+    #                 centroid = Topology.SetDictionary(centroid, topology_dict)
+    #             return centroid
+    #         return None
 
-            for ifc_rel in ifc_relationships:
-                source = None
-                destinations = []
-                if ifc_rel.is_a("IfcRelConnectsPorts"):
-                    source = ifc_rel.RelatingPort
-                    destinations = ifc_rel.RelatedPorts
-                elif ifc_rel.is_a("IfcRelConnectsPortToElement"):
-                    source = ifc_rel.RelatingPort
-                    destinations = [ifc_rel.RelatedElement]
-                elif ifc_rel.is_a("IfcRelAggregates"):
-                    source = ifc_rel.RelatingObject
-                    destinations = ifc_rel.RelatedObjects
-                elif ifc_rel.is_a("IfcRelNests"):
-                    source = ifc_rel.RelatingObject
-                    destinations = ifc_rel.RelatedObjects
-                elif ifc_rel.is_a("IfcRelAssignsToGroup"):
-                    source = ifc_rel.RelatingGroup
-                    destinations = ifc_rel.RelatedObjects
-                elif ifc_rel.is_a("IfcRelConnectsPathElements"):
-                    source = ifc_rel.RelatingElement
-                    destinations = [ifc_rel.RelatedElement]
-                elif ifc_rel.is_a("IfcRelConnectsStructuralMember"):
-                    source = ifc_rel.RelatingStructuralMember
-                    destinations = [ifc_rel.RelatedStructuralConnection]
-                elif ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
-                    source = ifc_rel.RelatingStructure
-                    destinations = ifc_rel.RelatedElements
-                elif ifc_rel.is_a("IfcRelFillsElement"):
-                    source = ifc_rel.RelatingOpeningElement
-                    destinations = [ifc_rel.RelatedBuildingElement]
-                elif ifc_rel.is_a("IfcRelSpaceBoundary"):
-                    source = ifc_rel.RelatingSpace
-                    destinations = [ifc_rel.RelatedBuildingElement]
-                elif ifc_rel.is_a("IfcRelVoidsElement"):
-                    source = ifc_rel.RelatingBuildingElement
-                    destinations = [ifc_rel.RelatedOpeningElement]
-                elif ifc_rel.is_a("IfcRelDefinesByProperties") or ifc_rel.is_a("IfcRelAssociatesMaterial") or ifc_rel.is_a("IfcRelDefinesByType"):
-                    source = None
-                    destinations = None
-                else:
-                    print("Graph.ByIFCFile - Warning: The relationship", ifc_rel, "is not supported. Skipping.")
-                if source:
-                    sv = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(source, 'GlobalId', 0))
-                    if sv:
-                        si = Vertex.Index(sv, vertices, tolerance=tolerance)
-                        if not si == None:
-                            for destination in destinations:
-                                if destination == None:
-                                    continue
-                                ev = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(destination, 'GlobalId', 0),)
-                                if ev:
-                                    ei = Vertex.Index(ev, vertices, tolerance=tolerance)
-                                    if not ei == None:
-                                        if not([si,ei] in tuples or [ei,si] in tuples):
-                                            tuples.append([si,ei])
-                                            e = Edge.ByVertices([sv,ev])
-                                            d = Dictionary.ByKeysValues(["IFC_global_id", "IFC_name", "IFC_type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
-                                            e = Topology.SetDictionary(e, d)
-                                            edges.append(e)
-            return edges
-        
-        ifc_types = IFCObjectTypes(file)
-        ifc_objects = IFCObjects(file, include=includeTypes, exclude=excludeTypes)
-        vertices = []
-        for ifc_object in ifc_objects:
-            v = vertexByIFCObject(ifc_object, ifc_types)
-            if v:
-                vertices.append(v)
-        if len(vertices) > 0:
-            ifc_relationships = IFCRelationships(file, include=includeRels, exclude=excludeRels)
-            edges = edgesByIFCRelationships(ifc_relationships, ifc_types, vertices)
-            g = Graph.ByVerticesEdges(vertices, edges)
-        else:
-            g = None
-        return g
+    #     def edgesByIFCRelationships(ifc_relationships, ifc_types, vertices):
+    #         tuples = []
+    #         edges = []
+
+    #         for ifc_rel in ifc_relationships:
+    #             source = None
+    #             destinations = []
+    #             if ifc_rel.is_a("IfcRelConnectsPorts"):
+    #                 source = ifc_rel.RelatingPort
+    #                 destinations = ifc_rel.RelatedPorts
+    #             elif ifc_rel.is_a("IfcRelConnectsPortToElement"):
+    #                 source = ifc_rel.RelatingPort
+    #                 destinations = [ifc_rel.RelatedElement]
+    #             elif ifc_rel.is_a("IfcRelAggregates"):
+    #                 source = ifc_rel.RelatingObject
+    #                 destinations = ifc_rel.RelatedObjects
+    #             elif ifc_rel.is_a("IfcRelNests"):
+    #                 source = ifc_rel.RelatingObject
+    #                 destinations = ifc_rel.RelatedObjects
+    #             elif ifc_rel.is_a("IfcRelAssignsToGroup"):
+    #                 source = ifc_rel.RelatingGroup
+    #                 destinations = ifc_rel.RelatedObjects
+    #             elif ifc_rel.is_a("IfcRelConnectsPathElements"):
+    #                 source = ifc_rel.RelatingElement
+    #                 destinations = [ifc_rel.RelatedElement]
+    #             elif ifc_rel.is_a("IfcRelConnectsStructuralMember"):
+    #                 source = ifc_rel.RelatingStructuralMember
+    #                 destinations = [ifc_rel.RelatedStructuralConnection]
+    #             elif ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
+    #                 source = ifc_rel.RelatingStructure
+    #                 destinations = ifc_rel.RelatedElements
+    #             elif ifc_rel.is_a("IfcRelFillsElement"):
+    #                 source = ifc_rel.RelatingOpeningElement
+    #                 destinations = [ifc_rel.RelatedBuildingElement]
+    #             elif ifc_rel.is_a("IfcRelSpaceBoundary"):
+    #                 source = ifc_rel.RelatingSpace
+    #                 destinations = [ifc_rel.RelatedBuildingElement]
+    #             elif ifc_rel.is_a("IfcRelVoidsElement"):
+    #                 source = ifc_rel.RelatingBuildingElement
+    #                 destinations = [ifc_rel.RelatedOpeningElement]
+    #             elif ifc_rel.is_a("IfcRelDefinesByProperties") or ifc_rel.is_a("IfcRelAssociatesMaterial") or ifc_rel.is_a("IfcRelDefinesByType"):
+    #                 source = None
+    #                 destinations = None
+    #             else:
+    #                 print("Graph.ByIFCFile - Warning: The relationship", ifc_rel, "is not supported. Skipping.")
+    #             if source:
+    #                 sv = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(source, 'GlobalId', 0))
+    #                 if sv:
+    #                     si = Vertex.Index(sv, vertices, tolerance=tolerance)
+    #                     if not si == None:
+    #                         for destination in destinations:
+    #                             if destination == None:
+    #                                 continue
+    #                             ev = vertexAtKeyValue(vertices, key="IFC_global_id", value=getattr(destination, 'GlobalId', 0),)
+    #                             if ev:
+    #                                 ei = Vertex.Index(ev, vertices, tolerance=tolerance)
+    #                                 if not ei == None:
+    #                                     if not([si,ei] in tuples or [ei,si] in tuples):
+    #                                         tuples.append([si,ei])
+    #                                         e = Edge.ByVertices([sv,ev])
+    #                                         d = Dictionary.ByKeysValues(["IFC_global_id", "IFC_name", "IFC_type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
+    #                                         e = Topology.SetDictionary(e, d)
+    #                                         edges.append(e)
+    #         return edges
+        
+    #     ifc_types = IFCObjectTypes(file)
+    #     ifc_objects = IFCObjects(file, include=includeTypes, exclude=excludeTypes)
+    #     vertices = []
+    #     for ifc_object in ifc_objects:
+    #         v = vertexByIFCObject(ifc_object, ifc_types)
+    #         if v:
+    #             vertices.append(v)
+    #     if len(vertices) > 0:
+    #         ifc_relationships = IFCRelationships(file, include=includeRels, exclude=excludeRels)
+    #         edges = edgesByIFCRelationships(ifc_relationships, ifc_types, vertices)
+    #         g = Graph.ByVerticesEdges(vertices, edges)
+    #     else:
+    #         g = None
+    #     return g
 
     @staticmethod
     def ByIFCPath(path,
@@ -6007,6 +6301,8 @@ class Graph:
         return graph
     
 
+
+
     @staticmethod
     def ClosenessCentrality(
         graph,
@@ -6021,144 +6317,396 @@ class Graph:
         silent: bool = False
     ):
         """
-        Returns the closeness centrality of the input graph. The order of the returned
-        list matches the order of Graph.Vertices(graph).
-        See: https://en.wikipedia.org/wiki/Closeness_centrality
-
-        Parameters
-        ----------
-        graph : topologic_core.Graph
-            The input graph.
-        weightKey : str , optional
-            If specified, this edge attribute will be used as the distance weight when
-            computing shortest paths. If set to a name containing "Length" or "Distance",
-            it will be mapped to "length".
-            Note: Graph.NetworkXGraph automatically provides a "length" attribute on all edges.
-        normalize : bool , optional
-            If True, the returned values are rescaled to [0, 1]. Otherwise raw values
-            from NetworkX (optionally using the improved formula) are returned.
-        nxCompatible : bool , optional
-            If True, use NetworkX's wf_improved scaling (Wasserman and Faust).
-            For single-component graphs it matches the original formula.
-        key : str , optional
-            The dictionary key under which to store the closeness centrality score.
-        colorKey : str , optional
-            The dictionary key under which to store a color derived from the score.
-        colorScale : str , optional
-            Plotly color scale name (e.g., "viridis", "plasma").
-        mantissa : int , optional
-            The number of decimal places to round the result to. Default is 6.
-        tolerance : float , optional
-            The desired tolerance. Default is 0.0001.
-        silent : bool , optional
-            If set to True, error and warning messages are suppressed. Default is False.
-
-        Returns
-        -------
-        list[float]
-            Closeness centrality values for vertices in the same order as Graph.Vertices(graph).
+        Optimized closeness centrality:
+        - Avoids NetworkX and costly per-vertex Topologic calls.
+        - Builds integer-index adjacency once from edges (undirected).
+        - Unweighted: multi-source BFS (one per node).
+        - Weighted: Dijkstra per node (heapq), or SciPy csgraph if available.
+        - Supports 'wf_improved' scaling (nxCompatible) and optional normalization.
         """
-        import warnings
-        try:
-            import networkx as nx
-        except Exception as e:
-            warnings.warn(
-                f"Graph.ClosenessCentrality - Error: networkx is required but not installed ({e}). Returning None."
-            )
-            return None
+        from collections import deque
+        import math
 
+        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
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        # NOTE: We are inside Graph.*, so Graph.<...> methods are available.
 
-        # Topology.IsInstance is case-insensitive, so a single call is sufficient.
+        # Validate graph
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
                 print("Graph.ClosenessCentrality - Error: The input is not a valid Graph. Returning None.")
             return None
+
         vertices = Graph.Vertices(graph)
-        if len(vertices) == 0:
+        n = len(vertices)
+        if n == 0:
             if not silent:
                 print("Graph.ClosenessCentrality - Warning: Graph has no vertices. Returning [].")
             return []
 
-        # Normalize the weight key semantics
+        # Stable vertex key (prefer an 'id' in the vertex dictionary; else rounded coords)
+        def vkey(v, r=9):
+            d = Topology.Dictionary(v)
+            vid = Dictionary.ValueAtKey(d, "id")
+            if vid is not None:
+                return ("id", vid)
+            return ("xyz", round(Vertex.X(v), r), round(Vertex.Y(v), r), round(Vertex.Z(v), r))
+
+        idx_of = {vkey(v): i for i, v in enumerate(vertices)}
+
+        # Normalize weight key
         distance_attr = None
         if isinstance(weightKey, str) and weightKey:
-            if ("len" in weightKey.lower()) or ("dis" in weightKey.lower()):
+            wl = weightKey.lower()
+            if ("len" in wl) or ("dis" in wl):
                 weightKey = "length"
-            distance_attr = weightKey
-
-        # Build the NX graph
-        nx_graph = Graph.NetworkXGraph(graph)
-
-        # Graph.NetworkXGraph automatically adds "length" to all edges.
-        # So if distance_attr == "length", we trust it and skip per-edge checks.
-        if distance_attr and distance_attr != "length":
-            # For any non-"length" custom attribute, verify presence; else fall back unweighted.
-            attr_missing = any(
-                (distance_attr not in data) or (data[distance_attr] is None)
-                for _, _, data in nx_graph.edges(data=True)
-            )
-            if attr_missing:
-                if not silent:
-                    print("Graph.ClosenessCentrality - Warning: The specified edge attribute was not found on all edges. Falling back to unweighted closeness.")
-                distance_arg = None
+            distance_attr = weightKey  # may be "length" or a custom key
+
+        # Build undirected adjacency with minimal weights per edge
+        # Use dict-of-dict to collapse multi-edges to minimal weight
+        adj = [dict() for _ in range(n)]  # adj[i][j] = weight
+        edges = Graph.Edges(graph)
+
+        def edge_weight(e):
+            if distance_attr == "length":
+                try:
+                    return float(Edge.Length(e))
+                except Exception:
+                    return 1.0
+            elif distance_attr:
+                try:
+                    d = Topology.Dictionary(e)
+                    w = Dictionary.ValueAtKey(d, distance_attr)
+                    return float(w) if (w is not None) else 1.0
+                except Exception:
+                    return 1.0
             else:
-                distance_arg = distance_attr
+                return 1.0
+
+        for e in edges:
+            try:
+                u = Edge.StartVertex(e)
+                v = Edge.EndVertex(e)
+            except Exception:
+                # Fallback in odd cases
+                continue
+            iu = idx_of.get(vkey(u))
+            iv = idx_of.get(vkey(v))
+            if iu is None or iv is None or iu == iv:
+                continue
+            w = edge_weight(e)
+            # Keep minimal weight if duplicates
+            prev = adj[iu].get(iv)
+            if (prev is None) or (w < prev):
+                adj[iu][iv] = w
+                adj[iv][iu] = w
+
+        # Detect weighted vs unweighted
+        weighted = False
+        for i in range(n):
+            if any(abs(w - 1.0) > 1e-12 for w in adj[i].values()):
+                weighted = True
+                break
+
+        INF = float("inf")
+
+        # ---- shortest paths helpers ----
+        def bfs_sum(i):
+            """Sum of unweighted shortest path distances from i; returns (tot, reachable)."""
+            dist = [-1] * n
+            q = deque([i])
+            dist[i] = 0
+            reachable = 1
+            tot = 0
+            pop = q.popleft; push = q.append
+            while q:
+                u = pop()
+                du = dist[u]
+                for v in adj[u].keys():
+                    if dist[v] == -1:
+                        dist[v] = du + 1
+                        reachable += 1
+                        tot += dist[v]
+                        push(v)
+            return float(tot), reachable
+
+        def dijkstra_sum(i):
+            """Sum of weighted shortest path distances from i; returns (tot, reachable)."""
+            import heapq
+            dist = [INF] * n
+            dist[i] = 0.0
+            hq = [(0.0, i)]
+            push = heapq.heappush; pop = heapq.heappop
+            while hq:
+                du, u = pop(hq)
+                if du > dist[u]:
+                    continue
+                for v, w in adj[u].items():
+                    nd = du + w
+                    if nd < dist[v]:
+                        dist[v] = nd
+                        push(hq, (nd, v))
+            # Exclude self (0.0) and unreachable (INF)
+            reachable = 0
+            tot = 0.0
+            for d in dist:
+                if d < INF:
+                    reachable += 1
+                    tot += d
+            # subtract self-distance
+            tot -= 0.0
+            return float(tot), reachable
+
+        # SciPy acceleration if weighted and available
+        use_scipy = False
+        if weighted:
+            try:
+                import numpy as np
+                from scipy.sparse import csr_matrix
+                from scipy.sparse.csgraph import dijkstra as sp_dijkstra
+                use_scipy = True
+                # Build CSR once
+                rows, cols, data = [], [], []
+                for i in range(n):
+                    for j, w in adj[i].items():
+                        rows.append(i); cols.append(j); data.append(float(w))
+                if len(data) == 0:
+                    use_scipy = False  # empty graph; fall back
+                else:
+                    A = csr_matrix((np.array(data), (np.array(rows), np.array(cols))), shape=(n, n))
+            except Exception:
+                use_scipy = False
+
+        # ---- centrality computation ----
+        values = [0.0] * n
+        if n == 1:
+            values[0] = 0.0
         else:
-            # Use "length" directly or unweighted if distance_attr is falsy.
-            distance_arg = distance_attr if distance_attr else None
+            if not weighted:
+                for i in range(n):
+                    tot, reachable = bfs_sum(i)
+                    s = max(reachable - 1, 0)
+                    if tot > 0.0:
+                        if nxCompatible:
+                            # Wasserman–Faust improved scaling for disconnected graphs
+                            values[i] = (s / (n - 1)) * (s / tot)
+                        else:
+                            values[i] = s / tot
+                    else:
+                        values[i] = 0.0
+            else:
+                if use_scipy:
+                    # All-pairs from SciPy (fast)
+                    import numpy as np
+                    D = sp_dijkstra(A, directed=False, return_predecessors=False)
+                    for i in range(n):
+                        di = D[i]
+                        finite = di[np.isfinite(di)]
+                        # di includes self at 0; reachable count is len(finite)
+                        reachable = int(finite.size)
+                        s = max(reachable - 1, 0)
+                        tot = float(finite.sum())  # includes self=0
+                        if s > 0:
+                            if nxCompatible:
+                                values[i] = (s / (n - 1)) * (s / tot)
+                            else:
+                                values[i] = s / tot
+                        else:
+                            values[i] = 0.0
+                else:
+                    # Per-source Dijkstra
+                    for i in range(n):
+                        tot, reachable = dijkstra_sum(i)
+                        s = max(reachable - 1, 0)
+                        if tot > 0.0:
+                            if nxCompatible:
+                                values[i] = (s / (n - 1)) * (s / tot)
+                            else:
+                                values[i] = s / tot
+                        else:
+                            values[i] = 0.0
+
+        # Optional normalization, round once
+        out_vals = Helper.Normalize(values) if normalize else values
+        if mantissa is not None and mantissa >= 0:
+            out_vals = [round(v, mantissa) for v in out_vals]
+
+        # Color mapping range (use displayed numbers)
+        if out_vals:
+            min_v, max_v = min(out_vals), max(out_vals)
+        else:
+            min_v, max_v = 0.0, 1.0
+        if abs(max_v - min_v) < tolerance:
+            max_v = min_v + tolerance
+
+        # Annotate vertices
+        for i, value in enumerate(out_vals):
+            d = Topology.Dictionary(vertices[i])
+            color_hex = Color.AnyToHex(
+                Color.ByValueInRange(value, minValue=min_v, maxValue=max_v, colorScale=colorScale)
+            )
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color_hex])
+            vertices[i] = Topology.SetDictionary(vertices[i], d)
+
+        return out_vals
+
+
+    # @staticmethod
+    # def ClosenessCentrality_old(
+    #     graph,
+    #     weightKey: str = "length",
+    #     normalize: bool = False,
+    #     nxCompatible: bool = True,
+    #     key: str = "closeness_centrality",
+    #     colorKey: str = "cc_color",
+    #     colorScale: str = "viridis",
+    #     mantissa: int = 6,
+    #     tolerance: float = 0.0001,
+    #     silent: bool = False
+    # ):
+    #     """
+    #     Returns the closeness centrality of the input graph. The order of the returned
+    #     list matches the order of Graph.Vertices(graph).
+    #     See: https://en.wikipedia.org/wiki/Closeness_centrality
+
+    #     Parameters
+    #     ----------
+    #     graph : topologic_core.Graph
+    #         The input graph.
+    #     weightKey : str , optional
+    #         If specified, this edge attribute will be used as the distance weight when
+    #         computing shortest paths. If set to a name containing "Length" or "Distance",
+    #         it will be mapped to "length".
+    #         Note: Graph.NetworkXGraph automatically provides a "length" attribute on all edges.
+    #     normalize : bool , optional
+    #         If True, the returned values are rescaled to [0, 1]. Otherwise raw values
+    #         from NetworkX (optionally using the improved formula) are returned.
+    #     nxCompatible : bool , optional
+    #         If True, use NetworkX's wf_improved scaling (Wasserman and Faust).
+    #         For single-component graphs it matches the original formula.
+    #     key : str , optional
+    #         The dictionary key under which to store the closeness centrality score.
+    #     colorKey : str , optional
+    #         The dictionary key under which to store a color derived from the score.
+    #     colorScale : str , optional
+    #         Plotly color scale name (e.g., "viridis", "plasma").
+    #     mantissa : int , optional
+    #         The number of decimal places to round the result to. Default is 6.
+    #     tolerance : float , optional
+    #         The desired tolerance. Default is 0.0001.
+    #     silent : bool , optional
+    #         If set to True, error and warning messages are suppressed. Default is False.
+
+    #     Returns
+    #     -------
+    #     list[float]
+    #         Closeness centrality values for vertices in the same order as Graph.Vertices(graph).
+    #     """
+    #     import warnings
+    #     try:
+    #         import networkx as nx
+    #     except Exception as e:
+    #         warnings.warn(
+    #             f"Graph.ClosenessCentrality - Error: networkx is required but not installed ({e}). Returning None."
+    #         )
+    #         return None
+
+    #     from topologicpy.Dictionary import Dictionary
+    #     from topologicpy.Color import Color
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Helper import Helper
+
+    #     # Topology.IsInstance is case-insensitive, so a single call is sufficient.
+    #     if not Topology.IsInstance(graph, "graph"):
+    #         if not silent:
+    #             print("Graph.ClosenessCentrality - Error: The input is not a valid Graph. Returning None.")
+    #         return None
+    #     vertices = Graph.Vertices(graph)
+    #     if len(vertices) == 0:
+    #         if not silent:
+    #             print("Graph.ClosenessCentrality - Warning: Graph has no vertices. Returning [].")
+    #         return []
 
-        # Compute centrality (dict keyed by NetworkX nodes)
-        try:
-            cc_dict = nx.closeness_centrality(nx_graph, distance=distance_arg, wf_improved=nxCompatible)
-        except Exception as e:
-            if not silent:
-                print(f"Graph.ClosenessCentrality - Error: NetworkX failed to compute centrality ({e}). Returning None.")
-            return None
+    #     # Normalize the weight key semantics
+    #     distance_attr = None
+    #     if isinstance(weightKey, str) and weightKey:
+    #         if ("len" in weightKey.lower()) or ("dis" in weightKey.lower()):
+    #             weightKey = "length"
+    #         distance_attr = weightKey
+
+    #     # Build the NX graph
+    #     nx_graph = Graph.NetworkXGraph(graph)
+
+    #     # Graph.NetworkXGraph automatically adds "length" to all edges.
+    #     # So if distance_attr == "length", we trust it and skip per-edge checks.
+    #     if distance_attr and distance_attr != "length":
+    #         # For any non-"length" custom attribute, verify presence; else fall back unweighted.
+    #         attr_missing = any(
+    #             (distance_attr not in data) or (data[distance_attr] is None)
+    #             for _, _, data in nx_graph.edges(data=True)
+    #         )
+    #         if attr_missing:
+    #             if not silent:
+    #                 print("Graph.ClosenessCentrality - Warning: The specified edge attribute was not found on all edges. Falling back to unweighted closeness.")
+    #             distance_arg = None
+    #         else:
+    #             distance_arg = distance_attr
+    #     else:
+    #         # Use "length" directly or unweighted if distance_attr is falsy.
+    #         distance_arg = distance_attr if distance_attr else None
+
+    #     # Compute centrality (dict keyed by NetworkX nodes)
+    #     try:
+    #         cc_dict = nx.closeness_centrality(nx_graph, distance=distance_arg, wf_improved=nxCompatible)
+    #     except Exception as e:
+    #         if not silent:
+    #             print(f"Graph.ClosenessCentrality - Error: NetworkX failed to compute centrality ({e}). Returning None.")
+    #         return None
 
-        # NetworkX vertex ids are in the same numerice order as the list of vertices starting from 0.
-        raw_values = []
-        for i, v in enumerate(vertices):
-            try:
-                raw_values.append(float(cc_dict.get(i, 0.0)))
-            except Exception:
-                if not silent:
-                    print(f,"Graph.ClosenessCentrality - Warning: Could not retrieve score for vertex {i}. Assigning a Zero (0).")
-                raw_values.append(0.0)
+    #     # NetworkX vertex ids are in the same numerice order as the list of vertices starting from 0.
+    #     raw_values = []
+    #     for i, v in enumerate(vertices):
+    #         try:
+    #             raw_values.append(float(cc_dict.get(i, 0.0)))
+    #         except Exception:
+    #             if not silent:
+    #                 print(f,"Graph.ClosenessCentrality - Warning: Could not retrieve score for vertex {i}. Assigning a Zero (0).")
+    #             raw_values.append(0.0)
 
-        # Optional normalization ONLY once, then rounding once at the end
-        values_for_return = Helper.Normalize(raw_values) if normalize else raw_values
+    #     # Optional normalization ONLY once, then rounding once at the end
+    #     values_for_return = Helper.Normalize(raw_values) if normalize else raw_values
 
-        # Values for color scaling should reflect the displayed numbers
-        color_values = values_for_return
+    #     # Values for color scaling should reflect the displayed numbers
+    #     color_values = values_for_return
 
-        # Single rounding at the end for return values
-        if mantissa is not None and mantissa >= 0:
-            values_for_return = [round(v, mantissa) for v in values_for_return]
+    #     # Single rounding at the end for return values
+    #     if mantissa is not None and mantissa >= 0:
+    #         values_for_return = [round(v, mantissa) for v in values_for_return]
 
-        # Prepare color mapping range, guarding equal-range case
-        if color_values:
-            min_value = min(color_values)
-            max_value = max(color_values)
-        else:
-            min_value, max_value = 0.0, 1.0
+    #     # Prepare color mapping range, guarding equal-range case
+    #     if color_values:
+    #         min_value = min(color_values)
+    #         max_value = max(color_values)
+    #     else:
+    #         min_value, max_value = 0.0, 1.0
 
-        if abs(max_value - min_value) < tolerance:
-            max_value = min_value + tolerance
+    #     if abs(max_value - min_value) < tolerance:
+    #         max_value = min_value + tolerance
 
-        # Annotate vertices with score and color
-        for i, value in enumerate(color_values):
-            d = Topology.Dictionary(vertices[i])
-            color_hex = Color.AnyToHex(
-                Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale)
-            )
-            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [values_for_return[i], color_hex])
-            vertices[i] = Topology.SetDictionary(vertices[i], d)
+    #     # Annotate vertices with score and color
+    #     for i, value in enumerate(color_values):
+    #         d = Topology.Dictionary(vertices[i])
+    #         color_hex = Color.AnyToHex(
+    #             Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale)
+    #         )
+    #         d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [values_for_return[i], color_hex])
+    #         vertices[i] = Topology.SetDictionary(vertices[i], d)
 
-        return values_for_return
+    #     return values_for_return
 
     @staticmethod
     def Community(graph, key: str = "partition", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -6929,44 +7477,146 @@ class Graph:
         return graph.Edge(vertexA, vertexB, tolerance) # Hook to Core
     
     @staticmethod
-    def Edges(graph, vertices=None, tolerance=0.0001):
+    def Edges(
+        graph,
+        vertices: list = None,
+        strict: bool = False,
+        sortBy: str = None,
+        reverse: bool = False,
+        silent: bool = False,
+        tolerance: float = 0.0001
+    ) -> list:  # list[topologic_core.Edge]
         """
-        Returns the edges found in the input graph. If the input list of vertices is specified, this method returns the edges connected to this list of vertices. Otherwise, it returns all graph edges.
+        Returns the list of edges from `graph` whose endpoints match the given `vertices`
+        according to the `strict` rule.
+
+        If `strict` is True, both endpoints of an edge must be in `vertices`.
+        If `strict` is False, at least one endpoint must be in `vertices`.
 
         Parameters
         ----------
-        graph : topologic_core.Graph
+        graph : topologicpy.Graph
             The input graph.
-        vertices : list , optional
-            An optional list of vertices to restrict the returned list of edges only to those connected to this list.
+        vertices : list[topologicpy.Vertex]
+            The list of vertices to test membership against.
+        strict : bool, optional
+            If set to True, require both endpoints to be in `vertices`. Otherwise,
+            require at least one endpoint to be in `vertices`. Default is False.
+        sortBy : str , optional
+            The dictionary key to use for sorting the returned edges. Special strings include "length" and "distance" to sort by the length of the edge. Default is None.
+        reverse : bool , optional
+            If set to True, the sorted list is reversed. This has no effect if the sortBy parameter is not set. Default is False.
+        silent : bool, optional
+            Isilent : bool, optional
+            If set to True, all errors and warnings are suppressed. Default is False.
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
 
         Returns
         -------
-        list
-            The list of edges in the graph.
+        list[topologic_core.Edge]
+            The list of matching edges from the original graph (not recreated).
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        from topologicpy.Edge import Edge
+        from topologicpy.Helper import Helper
+        from topologicpy.Dictionary import Dictionary
+
+        def sort_edges(edges, sortBy, reverse):
+            if not sortBy is None:
+                if "length" in sortBy.lower() or "dist" in sortBy.lower():
+                    edge_values = [Edge.Length(e) for e in edges]
+                else:
+                    edge_values = [Dictionary.ValueAtKey(Topology.Dictionary(e), sortBy, "0") for e in edges]
+                edges = Helper.Sort(edges, edge_values)
+            if reverse:
+                edges.reverse()
+            return edges
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.Edges - Error: The input graph is not a valid graph. Returning None.")
-            return None
+            if not silent:
+                print("Graph.InducedEdges - Error: The input 'graph' is not a valid Graph. Returning [].")
+            return []
+
+        graph_edges = []
+        _ = graph.Edges(graph_edges, tolerance) # Hook to Core
+        graph_edges = list(dict.fromkeys(graph_edges)) # remove duplicates
+
+        if not graph_edges:
+            return []
         if not vertices:
-            edges = []
-            _ = graph.Edges(edges, tolerance) # Hook to Core
-            if not edges:
-                return []
-            return list(dict.fromkeys(edges)) # remove duplicates
-        else:
-            vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 1:
-            print("Graph.Edges - Error: The input list of vertices does not contain any valid vertices. Returning None.")
-            return None
-        edges = []
-        _ = graph.Edges(vertices, tolerance, edges) # Hook to Core
-        return list(dict.fromkeys(edges)) # remove duplicates
+            graph_edges = sort_edges(graph_edges, sortBy, reverse)
+            return graph_edges
+        
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.Edges - Error: The input 'vertices' is not a list. Returning [].")
+            return []
+
+        valid_vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        if not valid_vertices:
+            if not silent:
+                print("Graph.Edges - Warning: No valid vertices provided. Returning [].")
+            return []
+
+        return_edges = []
+        for e in graph_edges:
+            sv = Edge.StartVertex(e)
+            ev = Edge.EndVertex(e)
+
+            in_start = not Vertex.Index(sv, valid_vertices) is None
+            in_end   = not Vertex.Index(ev, valid_vertices) is None
+            if strict:
+                if in_start and in_end:
+                    return_edges.append(e)
+            else:
+                if in_start or in_end:
+                    return_edges.append(e)
+
+        return_edges = sort_edges(return_edges, sortBy, reverse)
+        return return_edges
+
+    # @staticmethod
+    # def Edges(graph, vertices=None, tolerance=0.0001):
+    #     """
+    #     Returns the edges found in the input graph. If the input list of vertices is specified, this method returns the edges connected to this list of vertices. Otherwise, it returns all graph edges.
+
+    #     Parameters
+    #     ----------
+    #     graph : topologic_core.Graph
+    #         The input graph.
+    #     vertices : list , optional
+    #         An optional list of vertices to restrict the returned list of edges only to those connected to this list.
+    #     tolerance : float , optional
+    #         The desired tolerance. Default is 0.0001.
+
+    #     Returns
+    #     -------
+    #     list
+    #         The list of edges in the graph.
+
+    #     """
+    #     from topologicpy.Topology import Topology
+
+    #     if not Topology.IsInstance(graph, "Graph"):
+    #         print("Graph.Edges - Error: The input graph is not a valid graph. Returning None.")
+    #         return None
+    #     if not vertices:
+    #         edges = []
+    #         _ = graph.Edges(edges, tolerance) # Hook to Core
+    #         if not edges:
+    #             return []
+    #         return list(dict.fromkeys(edges)) # remove duplicates
+    #     else:
+    #         vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+    #     if len(vertices) < 1:
+    #         print("Graph.Edges - Error: The input list of vertices does not contain any valid vertices. Returning None.")
+    #         return None
+    #     edges = []
+    #     _ = graph.Edges(vertices, tolerance, edges) # Hook to Core
+    #     return list(dict.fromkeys(edges)) # remove duplicates
     
     @staticmethod
     def EigenVectorCentrality(graph, normalize: bool = False, key: str = "eigen_vector_centrality", colorKey: str = "evc_color", colorScale: str = "viridis", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -8412,6 +9062,57 @@ class Graph:
                 edge = Topology.SetDictionary(edge, d)
         return graph
 
+
+    @staticmethod
+    def InducedSubgraph(graph, vertices: list = None, strict: bool = False, silent: bool = False, tolerance: float = 0.0001):
+        """
+        Returns the subgraph whose edges are connected to the given `vertices`
+        according to the `strict` rule. Isolated vertices are included as-is.
+
+        If `strict` is True, both endpoints of an edge must be in `vertices`.
+        If `strict` is False, at least one endpoint must be in `vertices`.
+
+        Parameters
+        ----------
+        graph : topologicpy.Graph
+            The input graph.
+        vertices : list[topologicpy.Vertex]
+            The list of vertices to test membership against.
+        strict : bool, optional
+            If set to True, require both endpoints to be in `vertices`. Otherwise,
+            require at least one endpoint to be in `vertices`. Default is False.
+        silent : bool, optional
+            Isilent : bool, optional
+            If set to True, all errors and warnings are suppressed. Default is False
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+
+        Returns
+        -------
+        list[topologic_core.Edge]
+            The list of matching edges from the original graph (not recreated).
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.InducedSubgraph - Error: The input graph parameter is not a valid graph. Returning None.")
+        
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.InducedSubgraph - Error: The input 'vertices' is not a list. Returning None.")
+            return None
+
+        valid_vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        if not valid_vertices:
+            if not silent:
+                print("Graph.InducedSubgraph - Warning: No valid vertices provided. Returning None.")
+            return None
+        connected_vertices = [v for v in valid_vertices if Graph.VertexDegree(graph, v) > 0]
+        edges = Graph.Edges(graph, connected_vertices, strict=strict, tolerance=tolerance)
+        return Graph.ByVerticesEdges(valid_vertices, edges)
+
     @staticmethod
     def IsEmpty(graph, silent: bool = False):
         """
@@ -11215,7 +11916,166 @@ class Graph:
                 print(f'Graph.Kernel - Error: Unsupported method "{method}". '
                     f'Supported methods are "WL" and "Hopper". Returning None.')
             return None
-    
+
+    @staticmethod
+    def KHopsSubgraph(
+        graph,
+        vertices: list,
+        k: int = 1,
+        direction: str = "both",
+        silent: bool = False,
+    ):
+        """
+        Returns a subgraph consisting of the k-hop neighborhood around the input list of seed vertices.
+
+        Parameters
+        ----------
+        graph : topologicpy.Graph
+            The input graph.
+        vertices : list
+            The input list of seed vertices.
+        k : int, optional
+            Number of hops. Default is 1.
+        direction : str, optional
+            'both', 'out', or 'in'. Default 'both'.
+        silent : bool, optional
+            Suppress warnings/errors. Default False.
+
+        Returns
+        -------
+        topologicpy.Graph or None
+            The resulting subgraph, or None on error.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        # ---- validate inputs ----
+        if not Topology.IsInstance(graph, "graph"):
+            if not silent:
+                print("Graph.KHopsSubgraph - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.KHopsSubgraph - Error: The input vertices parameter is not a valid list. Returning None.")
+            return None
+
+        graph_vertices = Graph.Vertices(graph)
+        if not graph_vertices:
+            if not silent:
+                print("Graph.KHopsSubgraph - Error: The input graph does not contain any vertices. Returning None.")
+            return None
+
+        # Keep only valid vertex objects
+        seed_vertices = [v for v in vertices if Topology.IsInstance(v, "vertex")]
+        if not seed_vertices:
+            if not silent:
+                print("Graph.KHopsSubgraph - Error: The input vertices list does not contain any valid vertices. Returning None.")
+            return None
+
+        # ---- map seeds to vertex indices (prefer identity; fallback to list.index) ----
+        id_to_index = {Topology.UUID(v): i for i, v in enumerate(graph_vertices)}
+        seed_indices = []
+        for sv in seed_vertices:
+            idx = id_to_index.get(Topology.UUID(sv))
+            if idx is None:
+                try:
+                    idx = graph_vertices.index(sv)  # fallback if same object not used
+                except ValueError:
+                    idx = None
+            if idx is not None:
+                seed_indices.append(idx)
+
+        if not seed_indices:
+            if not silent:
+                print("Graph.KHopsSubgraph - Error: None of the seed vertices are found in the graph. Returning None.")
+            return None
+
+        # ---- get mesh data (index-based edge list) ----
+        # Expect: mesh_data["vertices"] (list), mesh_data["edges"] (list of [a, b] indices)
+        mesh_data = Graph.MeshData(graph)
+        edges_idx = mesh_data.get("edges") or []
+        # Compute number of vertices robustly
+        n_verts = len(mesh_data.get("vertices") or graph_vertices)
+
+        # ---- build adjacency (directed; BFS respects 'direction') ----
+        adj_out = {i: set() for i in range(n_verts)}
+        adj_in  = {i: set() for i in range(n_verts)}
+        for (a, b) in edges_idx:
+            if 0 <= a < n_verts and 0 <= b < n_verts:
+                adj_out[a].add(b)
+                adj_in[b].add(a)
+
+        # ---- BFS up to k hops ----
+        dir_norm = (direction or "both").lower()
+        if dir_norm not in ("both", "out", "in"):
+            dir_norm = "both"
+
+        visited = set(seed_indices)
+        frontier = set(seed_indices)
+        for _ in range(max(0, int(k))):
+            nxt = set()
+            for v in frontier:
+                if dir_norm in ("both", "out"):
+                    nxt |= adj_out.get(v, set())
+                if dir_norm in ("both", "in"):
+                    nxt |= adj_in.get(v, set())
+            nxt -= visited
+            if not nxt:
+                break
+            visited |= nxt
+            frontier = nxt
+
+        if not visited:
+            if not silent:
+                print("Graph.KHopsSubgraph - Warning: No vertices found within the specified k hops. Returning None.")
+            return None
+
+        # ---- assemble subgraph ----
+        # Vertices: actual TopologicPy Vertex objects
+        sub_vertex_indices = sorted(visited)
+        sub_vertices = [graph_vertices[i] for i in sub_vertex_indices]
+
+        # Edges: include only those whose endpoints are both in the subgraph
+        sub_index_set = set(sub_vertex_indices)
+        # Map from global index -> actual Vertex object for edge reconstruction
+        idx_to_vertex = {i: graph_vertices[i] for i in sub_vertex_indices}
+
+        sub_edges = []
+        for (a, b) in edges_idx:
+            if a in sub_index_set and b in sub_index_set:
+                # Recreate edge to ensure it references the subgraph vertices
+                ea = idx_to_vertex[a]
+                eb = idx_to_vertex[b]
+                try:
+                    e = Edge.ByStartVertexEndVertex(ea, eb)
+                except Exception:
+                    # If creation fails, skip this edge
+                    continue
+                # Preserve edge label if present
+                try:
+                    # Find original edge and copy its dictionary if possible
+                    # (best-effort; safe if Graph.Edges aligns with edges_idx order)
+                    # Otherwise, leave edge as-is.
+                    pass
+                except Exception:
+                    pass
+                sub_edges.append(e)
+
+        try:
+            return Graph.ByVerticesEdges(sub_vertices, sub_edges)
+        except Exception:
+            # As a fallback, some environments accept edges alone
+            try:
+                return Graph.ByEdges(sub_edges)
+            except Exception:
+                if not silent:
+                    print("Graph.KHopsSubgraph - Error: Failed to construct the subgraph. Returning None.")
+                return None
+
     @staticmethod
     def Laplacian(graph, silent: bool = False, normalized: bool = False):
         """
@@ -12650,90 +13510,201 @@ class Graph:
         return outgoing_vertices
     
     @staticmethod
-    def PageRank(graph, alpha: float = 0.85, maxIterations: int = 100, normalize: bool = True, directed: bool = False, key: str = "page_rank", colorKey="pr_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.0001):
+    def PageRank(
+        graph,
+        alpha: float = 0.85,
+        maxIterations: int = 100,
+        normalize: bool = True,
+        directed: bool = False,
+        key: str = "page_rank",
+        colorKey: str = "pr_color",
+        colorScale: str = "viridis",
+        mantissa: int = 6,
+        tolerance: float = 1e-4
+    ):
         """
-        Calculates PageRank scores for vertices in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
-
-        Parameters
-        ----------
-        graph : topologic_core.Graph
-            The input graph.
-        alpha : float , optional
-            The damping (dampening) factor. Default is 0.85. See https://en.wikipedia.org/wiki/PageRank.
-        maxIterations : int , optional
-            The maximum number of iterations to calculate the page rank. Default is 100.
-        normalize : bool , optional
-            If set to True, the results will be normalized from 0 to 1. Otherwise, they won't be. Default is True.
-        directed : bool , optional
-            If set to True, the graph is considered as a directed graph. Otherwise, it will be considered as an undirected graph. Default is False.
-        key : str , optional
-            The dictionary key under which to store the page_rank score. Default is "page_rank"
-        colorKey : str , optional
-            The desired dictionary key under which to store the pagerank color. Default is "pr_color".
-        colorScale : str , optional
-            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). 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.
-        tolerance : float , optional
-            The desired tolerance. Default is 0.0001.
-
-        Returns
-        -------
-        list
-            The list of page ranks for the vertices in the graph.
+        PageRank with stable vertex mapping (by coordinates) so neighbors resolve correctly.
+        Handles dangling nodes; uses cached neighbor lists and L1 convergence.
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Helper import Helper
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
         from topologicpy.Color import Color
+        from topologicpy.Graph import Graph
 
         vertices = Graph.Vertices(graph)
-        num_vertices = len(vertices)
-        if num_vertices < 1:
+        n = len(vertices)
+        if n < 1:
             print("Graph.PageRank - Error: The input graph parameter has no vertices. Returning None")
             return None
-        initial_score = 1.0 / num_vertices
-        values = [initial_score for vertex in vertices]
+
+        # ---- stable vertex key (coord-based) ----
+        # Use a modest rounding to be robust to tiny numerical noise.
+        # If your graphs can have distinct vertices at the exact same coords,
+        # switch to a stronger key (e.g., include a unique ID from the vertex dictionary).
+        def vkey(v, r=9):
+            return (round(Vertex.X(v), r), round(Vertex.Y(v), r), round(Vertex.Z(v), r))
+
+        idx_of = {vkey(v): i for i, v in enumerate(vertices)}
+
+        # Helper that resolves an arbitrary Topologic vertex to our index
+        def to_idx(u):
+            return idx_of.get(vkey(u), None)
+
+        # ---- build neighbor lists ONCE (by indices) ----
+        if directed:
+            in_neighbors = [[] for _ in range(n)]
+            out_neighbors = [[] for _ in range(n)]
+
+            for i, v in enumerate(vertices):
+                inv = Graph.IncomingVertices(graph, v, directed=True)
+                onv = Graph.OutgoingVertices(graph, v, directed=True)
+                # map to indices, drop misses
+                in_neighbors[i] = [j for u in inv if (j := to_idx(u)) is not None]
+                out_neighbors[i] = [j for u in onv if (j := to_idx(u)) is not None]
+        else:
+            in_neighbors = [[] for _ in range(n)]
+            out_neighbors = in_neighbors  # same list objects is fine; we set both below
+            for i, v in enumerate(vertices):
+                nbrs = Graph.AdjacentVertices(graph, v)
+                idxs = [j for u in nbrs if (j := to_idx(u)) is not None]
+                in_neighbors[i] = idxs
+            out_neighbors = in_neighbors  # undirected: in == out
+
+        out_degree = [len(out_neighbors[i]) for i in range(n)]
+        dangling = [i for i in range(n) if out_degree[i] == 0]
+
+        # ---- power iteration ----
+        pr = [1.0 / n] * n
+        base = (1.0 - alpha) / n
+
         for _ in range(maxIterations):
-            new_scores = [0 for vertex in vertices]
-            for i, vertex in enumerate(vertices):
-                incoming_score = 0
-                for incoming_vertex in Graph.IncomingVertices(graph, vertex, directed=directed):
-                    if len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed)) > 0:
-                        vi = Vertex.Index(incoming_vertex, vertices, tolerance=tolerance)
-                        if not vi == None:
-                            incoming_score += values[vi] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
-                new_scores[i] = alpha * incoming_score + (1 - alpha) / num_vertices
-
-            # Check for convergence
-            if all(abs(new_scores[i] - values[i]) <= tolerance for i in range(len(vertices))):
+            # Distribute dangling mass uniformly
+            dangling_mass = alpha * (sum(pr[i] for i in dangling) / n) if dangling else 0.0
+
+            new_pr = [base + dangling_mass] * n
+
+            # Sum contributions from incoming neighbors j: alpha * pr[j] / out_degree[j]
+            for i in range(n):
+                acc = 0.0
+                for j in in_neighbors[i]:
+                    deg = out_degree[j]
+                    if deg > 0:
+                        acc += pr[j] / deg
+                new_pr[i] += alpha * acc
+
+            # L1 convergence
+            if sum(abs(new_pr[i] - pr[i]) for i in range(n)) <= tolerance:
+                pr = new_pr
                 break
+            pr = new_pr
 
-            values = new_scores
-        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
+        # ---- normalize & write dictionaries ----
+        if normalize:
+            pr = Helper.Normalize(pr)
+            if mantissa > 0:
+                pr = [round(v, mantissa) for v in pr]
+            min_v, max_v = 0.0, 1.0
         else:
-            min_value = min(values)
-            max_value = max(values)
+            min_v, max_v = (min(pr), max(pr)) if n > 0 else (0.0, 0.0)
 
-        for i, value in enumerate(values):
+        for i, value in enumerate(pr):
             d = Topology.Dictionary(vertices[i])
-            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            color = Color.AnyToHex(
+                Color.ByValueInRange(value, minValue=min_v, maxValue=max_v, colorScale=colorScale)
+            )
             d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
             vertices[i] = Topology.SetDictionary(vertices[i], d)
-        
-        for i, v in enumerate(vertices):
-            d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, values[i])
-            v = Topology.SetDictionary(v, d)
-        return values
+
+        return pr
+
+
+    # @staticmethod
+    # def PageRank_old(graph, alpha: float = 0.85, maxIterations: int = 100, normalize: bool = True, directed: bool = False, key: str = "page_rank", colorKey="pr_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.0001):
+    #     """
+    #     Calculates PageRank scores for vertices in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
+
+    #     Parameters
+    #     ----------
+    #     graph : topologic_core.Graph
+    #         The input graph.
+    #     alpha : float , optional
+    #         The damping (dampening) factor. Default is 0.85. See https://en.wikipedia.org/wiki/PageRank.
+    #     maxIterations : int , optional
+    #         The maximum number of iterations to calculate the page rank. Default is 100.
+    #     normalize : bool , optional
+    #         If set to True, the results will be normalized from 0 to 1. Otherwise, they won't be. Default is True.
+    #     directed : bool , optional
+    #         If set to True, the graph is considered as a directed graph. Otherwise, it will be considered as an undirected graph. Default is False.
+    #     key : str , optional
+    #         The dictionary key under which to store the page_rank score. Default is "page_rank"
+    #     colorKey : str , optional
+    #         The desired dictionary key under which to store the pagerank color. Default is "pr_color".
+    #     colorScale : str , optional
+    #         The desired type of plotly color scales to use (e.g. "viridis", "plasma"). 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.
+    #     tolerance : float , optional
+    #         The desired tolerance. Default is 0.0001.
+
+    #     Returns
+    #     -------
+    #     list
+    #         The list of page ranks for the vertices in the graph.
+    #     """
+    #     from topologicpy.Vertex import Vertex
+    #     from topologicpy.Helper import Helper
+    #     from topologicpy.Dictionary import Dictionary
+    #     from topologicpy.Topology import Topology
+    #     from topologicpy.Color import Color
+
+    #     vertices = Graph.Vertices(graph)
+    #     num_vertices = len(vertices)
+    #     if num_vertices < 1:
+    #         print("Graph.PageRank - Error: The input graph parameter has no vertices. Returning None")
+    #         return None
+    #     initial_score = 1.0 / num_vertices
+    #     values = [initial_score for vertex in vertices]
+    #     for _ in range(maxIterations):
+    #         new_scores = [0 for vertex in vertices]
+    #         for i, vertex in enumerate(vertices):
+    #             incoming_score = 0
+    #             for incoming_vertex in Graph.IncomingVertices(graph, vertex, directed=directed):
+    #                 if len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed)) > 0:
+    #                     vi = Vertex.Index(incoming_vertex, vertices, tolerance=tolerance)
+    #                     if not vi == None:
+    #                         incoming_score += values[vi] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
+    #             new_scores[i] = alpha * incoming_score + (1 - alpha) / num_vertices
+
+    #         # Check for convergence
+    #         if all(abs(new_scores[i] - values[i]) <= tolerance for i in range(len(vertices))):
+    #             break
+
+    #         values = new_scores
+    #     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:
+    #         min_value = min(values)
+    #         max_value = max(values)
+
+    #     for i, value in enumerate(values):
+    #         d = Topology.Dictionary(vertices[i])
+    #         color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+    #         d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+    #         vertices[i] = Topology.SetDictionary(vertices[i], d)
+        
+    #     for i, v in enumerate(vertices):
+    #         d = Topology.Dictionary(v)
+    #         d = Dictionary.SetValueAtKey(d, key, values[i])
+    #         v = Topology.SetDictionary(v, d)
+    #     return values
 
     @staticmethod
     def Partition(graph, method: str = "Betweenness", n: int = 2, m: int = 10, key: str ="partition",
@@ -14267,7 +15238,7 @@ class Graph:
         return round(degree, mantissa)
     
     @staticmethod
-    def Vertices(graph, vertexKey=None, reverse=False):
+    def Vertices(graph, sortBy=None, reverse=False):
         """
         Returns the list of vertices in the input graph.
 
@@ -14275,11 +15246,14 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
-        vertexKey : str , optional
-            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. Default is None.
+        sortBy : str , optional
+            The dictionary key to use for sorting the returned edges. Special strings include "length" and "distance" to sort by the length of the edge. Default is None.
         reverse : bool , optional
-            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. Default is False.
-        
+            If set to True, the sorted list is reversed. This has no effect if the sortBy parameter is not set. Default is False.
+        silent : bool, optional
+            Isilent : bool, optional
+            If set to True, all errors and warnings are suppressed. Default is False.
+                    
         Returns
         -------
         list
@@ -14299,13 +15273,13 @@ class Graph:
                 _ = graph.Vertices(vertices) # Hook to Core
             except:
                 vertices = []
-        if not vertexKey == None:
-            sorting_values = []
+        if not sortBy == None:
+            vertex_values = []
             for v in vertices:
                 d = Topology.Dictionary(v)
-                value = Dictionary.ValueAtKey(d, vertexKey)
-                sorting_values.append(value)
-            vertices = Helper.Sort(vertices, sorting_values)
+                value = str(Dictionary.ValueAtKey(d, sortBy, "0"))
+                vertex_values.append(value)
+            vertices = Helper.Sort(vertices, vertex_values)
             if reverse == True:
                 vertices.reverse()
         return vertices