topologicpy 0.8.19__py3-none-any.whl → 0.8.21__py3-none-any.whl

topologicpy/Graph.py

@@ -4377,6 +4377,302 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return graph
     
+    @staticmethod
+    def Compare(graphA, graphB,
+                weightAttributes: float = 1.0,
+                weightGeometry: float = 1.0,
+                weightMetrics: float = 1.0,
+                weightStructure: float = 1.0,
+                weightWL: float = 1.0,
+                weightJaccard: float = 1.0,
+                vertexIDKey: str = "id",
+                edgeWeightKey: str = None,
+                iterations: int = 3,
+                mantissa: int = 6,
+                silent: bool = False):
+        """
+        Compares two graphs and returns a similarity score based on attributres, geometry, metrics, structure, 
+        the Weisfeiler-Lehman graph kernel. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+        , and the weight Jaccard Similarity. See https://www.statology.org/jaccard-similarity/
+
+        Parameters
+        ----------
+        graphA : topologic Graph
+            The first input graph.
+        graphB : topologic Graph
+            The second input graph.
+        weightAttributes : float , optional
+            The desired weight for attribute similarity (dictionary key overlap at vertices). Default is 1.0.
+        weightGeometry : float , optional
+            The desired weight for geometric similarity (vertex positions). Default is 1.0.
+        weightMetrics : float , optional
+            The desired weight for metric similarity (graph-level and node-level). Default is 1.0.
+            The compared metrics are: betweenness centrality, closeness centrality, clustering coefficient, degree, diameter, and pagerank.
+        weightStructure : float , optional
+            The desired weight for structural similarity (number of vertices and edges). Default is 1.0.
+        weightWL : float , optional
+            The desired weight for Weisfeiler-Lehman kernel similarity (iterative label propagation). Default is 1.0.
+        weightJaccard: float , optional
+            The desired weight for the Weighted Jaccard similarity. Default is 1.0.
+        vertexIDKey: str , optional
+            The dictionary key under which to find the unique vertex ID. The default is "id".
+        edgeWeightKey: str , optional
+            The dictionary key under which to find the weight of the edge for weighted graphs.
+            If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+            The default is None which means all edges are treated as if they have a weight of 1.
+        iterations : int , optional
+            The desired number of Weisfeiler-Lehman iterations. Default is 3.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        dict
+            A dictionary of similarity scores between 0 (completely dissimilar) and 1 (identical), based on weighted components.
+            The keys in the dictionary are:
+            "attribute"
+            "geometry"
+            "metrics"
+            "structure"
+            "wl"
+            "overall"
+
+        """
+        
+        import hashlib
+        from collections import Counter
+        from topologicpy.Graph import Graph
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        def attribute_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            if len(v1) != len(v2) or len(v1) == 0:
+                return 0
+
+            match_score = 0
+            for a, b in zip(v1, v2):
+                dict_a = Topology.Dictionary(a)
+                dict_b = Topology.Dictionary(b)
+
+                keys_a = set(Dictionary.Keys(dict_a)) if dict_a else set()
+                keys_b = set(Dictionary.Keys(dict_b)) if dict_b else set()
+
+                if not keys_a and not keys_b:
+                    match_score += 1
+                else:
+                    intersection = len(keys_a & keys_b)
+                    union = len(keys_a | keys_b)
+                    match_score += intersection / union if union > 0 else 0
+
+            return round(match_score / len(v1), mantissa)
+        
+        def geometry_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            if len(v1) != len(v2) or len(v1) == 0:
+                return 0
+
+            total_dist = 0
+            for a, b in zip(v1, v2):  # assumes same order
+                p1 = Vertex.Coordinates(a, mantissa=mantissa)
+                p2 = Vertex.Coordinates(b, mantissa=mantissa)
+                total_dist += sum((i - j) ** 2 for i, j in zip(p1, p2)) ** 0.5
+            avg_dist = total_dist / len(v1)
+            return round(1 / (1 + avg_dist), mantissa) # Inverse average distance
+        
+        def weighted_jaccard_similarity(graph1, graph2, vertexIDKey="id", edgeWeightKey=None, mantissa=6):
+            """
+            Computes weighted Jaccard similarity between two graphs by comparing their edge weights.
+
+            Parameters
+            ----------
+            graph1 : topologic Graph
+                First graph.
+            graph2 : topologic Graph
+                Second graph.
+            vertexIDKey: str , optional
+                The dictionary key under which to find the unique vertex ID. The default is "id".
+            edgeWeightKey: str , optional
+                The dictionary key under which to find the weight of the edge for weighted graphs.
+                If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+                The default is None which means all edges are treated as if they have a weight of 1.
+            iterations : int , optional
+                The desired number of Weisfeiler-Lehman iterations. Default is 3.
+            mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+
+            Returns
+            -------
+            float
+                Similarity score between 0 and 1.
+            """
+            from topologicpy.Vertex import Vertex
+            from topologicpy.Graph import Graph
+            from topologicpy.Topology import Topology
+            from topologicpy.Dictionary import Dictionary
+            from topologicpy.Edge import Edge
+
+
+            def edge_id(edge, vertexIDKey="id", mantissa=6):
+                v1 = Edge.StartVertex(edge)
+                v2 = Edge.EndVertex(edge)
+                d1 = Topology.Dictionary(v1)
+                d2 = Topology.Dictionary(v2)
+                v1_id = Dictionary.ValueAtKey(d1, vertexIDKey) if d1 and Dictionary.ValueAtKey(d1, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v1, mantissa=mantissa)))
+                v2_id = Dictionary.ValueAtKey(d2, vertexIDKey) if d2 and Dictionary.ValueAtKey(d2, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v2, mantissa=mantissa)))
+
+                return tuple(sorted(tuple([v1_id, v2_id])))
+
+            def edge_weights(graph, edgeWeightKey=None, mantissa=6):
+                weights = {}
+                for edge in Graph.Edges(graph):
+                    if edgeWeightKey == None:
+                        weight = 1
+                    elif edgeWeightKey.lower() == "length" or edgeWeightKey.lower() == "distance":
+                        weight = Edge.Length(edge)
+                    else:
+                        d = Topology.Dictionary(edge)
+                        weight = Dictionary.ValueAtKey(d, edgeWeightKey) if d and Dictionary.ValueAtKey(d, edgeWeightKey) is not None else 1.0
+                    eid = edge_id(edge, vertexIDKey=vertexIDKey, mantissa=mantissa)
+                    weights[eid] = weight
+                return weights
+            
+            w1 = edge_weights(graph1, edgeWeightKey=edgeWeightKey)
+            w2 = edge_weights(graph2, edgeWeightKey=edgeWeightKey)
+            keys = set(w1.keys()) | set(w2.keys())
+
+            numerator = sum(min(w1.get(k, 0), w2.get(k, 0)) for k in keys)
+            denominator = sum(max(w1.get(k, 0), w2.get(k, 0)) for k in keys)
+
+            return numerator / denominator if denominator > 0 else 0.0
+        
+        def metrics_similarity(graphA, graphB, mantissa=6):
+            # Example using global metrics + mean of node metrics
+            def safe_mean(lst):
+                return sum(lst)/len(lst) if lst else 0
+
+            metrics1 = {
+                "closeness": safe_mean(Graph.ClosenessCentrality(graphA)),
+                "betweenness": safe_mean(Graph.BetweennessCentrality(graphA)),
+                "degree": safe_mean(Graph.DegreeCentrality(graphA)),
+                "pagerank": safe_mean(Graph.PageRank(graphA)),
+                "clustering": Graph.GlobalClusteringCoefficient(graphA),
+                "diameter": Graph.Diameter(graphA)
+            }
+
+            metrics2 = {
+                "closeness": safe_mean(Graph.ClosenessCentrality(graphB)),
+                "betweenness": safe_mean(Graph.BetweennessCentrality(graphB)),
+                "degree": safe_mean(Graph.DegreeCentrality(graphB)),
+                "pagerank": safe_mean(Graph.PageRank(graphB)),
+                "clustering": Graph.GlobalClusteringCoefficient(graphB),
+                "diameter": Graph.Diameter(graphB)
+            }
+
+            # Compute similarity as 1 - normalized absolute difference
+            similarities = []
+            for key in metrics1:
+                v1, v2 = metrics1[key], metrics2[key]
+                if v1 == 0 and v2 == 0:
+                    similarities.append(1)
+                else:
+                    diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+                    similarities.append(1 - diff)
+
+            return round(sum(similarities) / len(similarities), mantissa)
+        
+        def structure_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            e1 = Graph.Edges(graphA)
+            e2 = Graph.Edges(graphB)
+
+            vertex_score = 1 - abs(len(v1) - len(v2)) / max(len(v1), len(v2), 1)
+            edge_score = 1 - abs(len(e1) - len(e2)) / max(len(e1), len(e2), 1)
+
+            return round((vertex_score + edge_score) / 2, mantissa)
+
+        def weisfeiler_lehman_fingerprint(graph, iterations=3):
+            vertices = Graph.Vertices(graph)
+            labels = {}
+
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                label = str(Dictionary.ValueAtKey(d, "label")) if d and Dictionary.ValueAtKey(d, "label") else "0"
+                labels[v] = label
+
+            all_label_counts = Counter()
+
+            for _ in range(iterations):
+                new_labels = {}
+                for v in vertices:
+                    neighbors = Graph.AdjacentVertices(graph, v)
+                    neighbor_labels = sorted(labels.get(n, "0") for n in neighbors)
+                    long_label = labels[v] + "_" + "_".join(neighbor_labels)
+                    hashed_label = hashlib.md5(long_label.encode()).hexdigest()
+                    new_labels[v] = hashed_label
+                    all_label_counts[hashed_label] += 1
+                labels = new_labels
+
+            return all_label_counts
+
+        def weisfeiler_lehman_similarity(graphA, graphB, iterations=3, mantissa=6):
+            f1 = weisfeiler_lehman_fingerprint(graphA, iterations)
+            f2 = weisfeiler_lehman_fingerprint(graphB, iterations)
+
+            common_labels = set(f1.keys()) & set(f2.keys())
+            score = sum(min(f1[label], f2[label]) for label in common_labels)
+            norm = max(sum(f1.values()), sum(f2.values()), 1)
+
+            return round(score / norm, mantissa)
+        
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Compare - Error: The graphA input parameter is not a valid topologic graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "graph"):
+            if not silent:
+                print("Graph.Compare - Error: The graphB input parameter is not a valid topologic graph. Returning None.")
+            return 
+        
+        total_weight = weightAttributes + weightGeometry + weightMetrics + weightStructure + weightWL + weightJaccard
+
+        attribute_score = attribute_similarity(graphA, graphB, mantissa=mantissa) if weightAttributes else 0
+        geometry_score = geometry_similarity(graphA, graphB, mantissa=mantissa) if weightGeometry else 0
+        jaccard_score = weighted_jaccard_similarity(graphA, graphB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa) if weightJaccard else 0
+        metrics_score = metrics_similarity(graphA, graphB, mantissa=mantissa) if weightMetrics else 0
+        structure_score = structure_similarity(graphA, graphB, mantissa=mantissa) if weightStructure else 0
+        wl_score = weisfeiler_lehman_similarity(graphA, graphB, iterations, mantissa=mantissa) if weightWL else 0
+
+        weighted_sum = (
+            attribute_score * weightAttributes +
+            geometry_score * weightGeometry +
+            jaccard_score * weightJaccard +
+            metrics_score * weightMetrics +
+            structure_score * weightStructure +
+            wl_score * weightWL
+        )
+
+        if total_weight <= 0:
+            overall_score = 0
+        else:
+            overall_score = weighted_sum / total_weight
+        
+        return  {
+                 "attribute": round(attribute_score, mantissa),
+                 "geometry": round(geometry_score, mantissa),
+                 "jaccard": round(jaccard_score, mantissa),
+                 "metrics": round(metrics_score, mantissa),
+                 "structure": round(structure_score, mantissa),
+                 "wl": round(wl_score, mantissa),
+                 "overall": round(overall_score, mantissa)
+                }
+
     @staticmethod
     def Complement(graph, tolerance=0.0001, silent=False):
         """
@@ -10804,3 +11100,85 @@ class Graph:
             g = Graph.ByVerticesEdges(final_vertices, final_edges)
             return g
         return None
+
+    @staticmethod
+    def WeightedJaccardSimilarity(graphA, graphB, vertexA, vertexB, vertexIDKey="id", edgeWeightKey=None, mantissa=6, silent=False):
+        """
+        Computes the weighted Jaccard similarity between two vertices based on their neighbors and
+        edge weights. Accepts either one graph (both vertices are in the same graph) or two graphs
+        (each vertex is in a separate graph).
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first graph
+        graphB : topologic_core.Graph
+            The second graph (this can be the same as the first graph)
+        vertexA : topologic_core.Vertex
+            The first vertex.
+        vertexB : topologic_core.Vertex
+            The second vertex.
+        vertexIDKey : str , optional
+            The dictionary key under which to find the unique vertex ID. The default is "id".
+        edgeWeightKey : str , optional
+            The dictionary key under which to find the weight of the edge for weighted graphs.
+            If this parameter is specified as "length" or "distance" then the length of the edge is used as its weight.
+            The default is None which means all edges are treated as if they have a weight of 1.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        float
+            Weighted Jaccard similarity score between 0 (no overlap) and 1 (perfect match).
+
+        """
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+
+        if graphB == None:
+            graphB = graphA
+
+        def edge_id(edge, vertexIDKey="id", mantissa=6):
+            v1 = Edge.StartVertex(edge)
+            v2 = Edge.EndVertex(edge)
+            d1 = Topology.Dictionary(v1)
+            d2 = Topology.Dictionary(v2)
+            v1_id = Dictionary.ValueAtKey(d1, vertexIDKey) if d1 and Dictionary.ValueAtKey(d1, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v1, mantissa=mantissa)))
+            v2_id = Dictionary.ValueAtKey(d2, vertexIDKey) if d2 and Dictionary.ValueAtKey(d2, vertexIDKey) is not None else str(sorted(Vertex.Coordinates(v2, mantissa=mantissa)))
+            return tuple(sorted([v1_id, v2_id]))
+        
+        def get_neighbors_with_weights(graph, vertex, vertexIDKey="id", edgeWeightKey=None, mantissa=6):
+            weights = {}
+            for edge in Graph.Edges(graph, [vertex]):
+                eid = edge_id(edge, vertexIDKey=vertexIDKey, mantissa=mantissa)
+                if edgeWeightKey == None:
+                    weight = 1.0
+                elif edgeWeightKey.lower() == "length" or edgeWeightKey.lower() == "distance":
+                    weight = Edge.Length(edge, mantissa=mantissa)
+                else:
+                    d = Topology.Dictionary(edge)
+                    d_weight = Dictionary.ValueAtKey(d, edgeWeightKey, silent=silent)
+                    if not d or d_weight is None:
+                        if not silent:
+                            print(f"Graph.WeightedJaccardSimilarity - Warning: The dictionary of edge {eid} is missing '{edgeWeightKey}' key. Defaulting the edge weight to 1.0.")
+                        weight = 1.0
+                    else:
+                        weight = d_weight
+                weights[eid] = weight
+            return weights
+
+        weights1 = get_neighbors_with_weights(graphA, vertexA, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa)
+        weights2 = get_neighbors_with_weights(graphB, vertexB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa)
+
+        keys = set(weights1.keys()) | set(weights2.keys())
+
+        numerator = sum(min(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
+        denominator = sum(max(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
+
+        return round(numerator / denominator, mantissa) if denominator != 0 else 0.0

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.19'
+__version__ = '0.8.21'

{topologicpy-0.8.19.dist-info → topologicpy-0.8.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.19
+Version: 0.8.21
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.19.dist-info → topologicpy-0.8.21.dist-info}/RECORD

@@ -11,7 +11,7 @@ topologicpy/Dictionary.py,sha256=7h-Gszgnt2OEOvOSADJ4pa-mTNlhQ9cuIiB5WHEW6aY,339
 topologicpy/Edge.py,sha256=yxkCVDYBflJNEYxnjMmlyvbkpg8TNy7y5bSH3yQ4jzs,71418
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=SlhB8L7BpDjd4a9YZE4UJ3zoGuF1oq9MSpuesEWro_Q,184847
-topologicpy/Graph.py,sha256=FOG3TyXfA1K9c4V3PXKP2vbO2L7HOnGj28pAVnuVRqo,505547
+topologicpy/Graph.py,sha256=Iq2UI-CdW3usxpgxRi-caxQeUmkFfGhD37c6mPT2Gd8,523908
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
 topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
 topologicpy/Vertex.py,sha256=q99IrWwdNlvVfUXz6iP8icmP8NzP2nsiqtgnF9Jnpx8,80913
 topologicpy/Wire.py,sha256=IVPzBKsckuxC-rHvwxmvtVF7PpApz2lhPHomtQMo_kg,228499
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=-CEaM_uLk3M3OyXlLqkLmTj4IViw6vFkTKIRWVX31LI,23
-topologicpy-0.8.19.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.19.dist-info/METADATA,sha256=pFjIJ2TfH28CMrW4rFY9OZMo-4ROp3hzpRns8o6CF08,10535
-topologicpy-0.8.19.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-topologicpy-0.8.19.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.19.dist-info/RECORD,,
+topologicpy/version.py,sha256=zZ7tNz8qiJpD43ZZY6gDLsQEo04V3AXFbZKZwwi4Pww,23
+topologicpy-0.8.21.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.21.dist-info/METADATA,sha256=uin9-ogEkyhyjro0BGZPrFB4abynjZPuv7G3lTk6XzA,10535
+topologicpy-0.8.21.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+topologicpy-0.8.21.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.21.dist-info/RECORD,,