Implement exclude list in compare

Author: arneboockmeyer

test/compare_test.py

@@ -94,6 +94,54 @@ def test_identical_topologies_but_ids():
         assert result.edge_matching.element_matching[edge_a5] == edge_b5
 
 
+def test_exclude_element_list():
+    topology_a = Topology()
+    node_a1 = Node(geo_node=EuclideanGeoNode(0, 0))
+    node_a2 = Node(geo_node=EuclideanGeoNode(0, 10))
+    node_a3 = Node(geo_node=EuclideanGeoNode(10, 0))
+    node_a4 = Node(geo_node=EuclideanGeoNode(20, 0))
+    node_a5 = Node(geo_node=EuclideanGeoNode(30, 0))
+    node_a6 = Node(geo_node=EuclideanGeoNode(30, 10))
+    edge_a1 = Edge(node_a1, node_a3)
+    edge_a2 = Edge(node_a2, node_a3)
+    edge_a3 = Edge(node_a4, node_a3)
+    edge_a4 = Edge(node_a4, node_a5)
+    edge_a5 = Edge(node_a4, node_a6)
+    topology_a.add_nodes([node_a1, node_a2, node_a3, node_a4, node_a5, node_a6])
+    topology_a.add_edges([edge_a1, edge_a2, edge_a3, edge_a4, edge_a5])
+    topology_a.update_edge_lengths()
+
+    topology_b = Topology()
+    node_b1 = Node(geo_node=EuclideanGeoNode(0, 0))
+    node_b2 = Node(geo_node=EuclideanGeoNode(0, 10))
+    node_b3 = Node(geo_node=EuclideanGeoNode(12, 0))  # x differs from Node A3
+    node_b4 = Node(geo_node=EuclideanGeoNode(20, 3))  # y differs from Node A4
+    node_b5 = Node(geo_node=EuclideanGeoNode(30, 0))
+    node_b6 = Node(geo_node=EuclideanGeoNode(30, 10))
+    edge_b1 = Edge(node_b1, node_b3)
+    edge_b2 = Edge(node_b2, node_b3)
+    edge_b3 = Edge(node_b4, node_b3)
+    edge_b4 = Edge(node_b4, node_b5)
+    edge_b5 = Edge(node_b4, node_b6)
+    topology_b.add_nodes([node_b1, node_b2, node_b3, node_b4, node_b5, node_b6])
+    topology_b.add_edges([edge_b1, edge_b2, edge_b3, edge_b4, edge_b5])
+    topology_b.update_edge_lengths()
+
+    compare_modes = [CompareMode.ISOMORPHIC]
+
+    for compare_mode in compare_modes:
+        result = Compare.compare(
+            topology_a, topology_b, compare_mode, given_node_matching={node_a1: node_b1}, exclude_element_list=[node_b4]
+        )
+        assert result.node_distance == 2.0
+        assert node_a1 in result.node_matching.element_matching
+        assert result.node_matching.element_matching[node_a1] == node_b1
+        assert node_a3 in result.node_matching.element_matching
+        assert result.node_matching.element_matching[node_a3] == node_b3
+        assert edge_a5 in result.edge_matching.element_matching
+        assert result.edge_matching.element_matching[edge_a5] == edge_b5
+
+
 def test_edge_diff_and_signal_distance():
     topology_a = Topology()
     node_a1 = Node(geo_node=EuclideanGeoNode(0, 0))

yaramo/operations/compare.py

@@ -1,17 +1,15 @@
 from enum import Enum, auto
-from typing import Dict, List, Set, Tuple
+from typing import Dict, List, Tuple
 
 import networkx as nx
 
 from ..model import (
-    DbrefGeoNode,
     Edge,
     GeoNode,
     Node,
     Signal,
     SignalDirection,
     Topology,
-    Wgs84GeoNode,
 )
 
 
@@ -44,11 +42,13 @@ def compare(
         topology_b: Topology,
         compare_mode: CompareMode,
         given_node_matching: Dict[Node, Node] | None = None,
-        exclude_ends_in_calculation: bool = False,
+        exclude_element_list=None,
         skip_signals: bool = False,
     ) -> CompareResult:
         if given_node_matching is None:
             given_node_matching = {}
+        if exclude_element_list is None:
+            exclude_element_list = []
 
         result: CompareResult = CompareResult()
 
@@ -66,14 +66,14 @@ def compare(
             )
 
         result.node_distance = Compare._calc_distance_for_matching(
-            result.node_matching, exclude_ends_in_calculation
+            result.node_matching, exclude_element_list
         )
         result.edge_length_difference = Compare._calc_distance_for_matching(
-            result.edge_matching, exclude_ends_in_calculation, element_type="edge"
+            result.edge_matching, exclude_element_list, element_type="edge"
         )
         if not skip_signals:
             result.signal_distance = Compare._calc_distance_for_matching(
-                result.signal_matching, exclude_ends_in_calculation, element_type="signal"
+                result.signal_matching, exclude_element_list, element_type="signal"
             )
         return result
 
@@ -125,6 +125,7 @@ def __add_to_open_nodes(__node_a: Node, __node_b: Node):
         def __add_edges_to_matching(__edge_a: Edge, __edge_b: Edge):
             if __edge_a in result.edge_matching.element_matching:
                 if result.edge_matching.element_matching[__edge_a] != __edge_b:
+                    print(f"bad edge {__edge_a.uuid} {__edge_b.uuid}")
                     raise ValueError(
                         "Graph topology is isomorphic, but railway network graph differs (edge graph broken)"
                     )
@@ -225,7 +226,7 @@ def _are_topologies_isomorphic(topology_a: Topology, topology_b: Topology):
     @staticmethod
     def _calc_distance_for_matching(
         matching: CompareMatching,
-        exclude_ends_in_calculation,
+        exclude_element_list,
         element_type: str = "node",
     ):
         if not matching.element_matching:
@@ -234,20 +235,16 @@ def _calc_distance_for_matching(
         distance_sum: float = 0.0
         for element_a in matching.element_matching:
             element_b = matching.element_matching[element_a]
+            if element_a in exclude_element_list or element_b in exclude_element_list:
+                continue
 
             if element_type == "node":
-                if exclude_ends_in_calculation and not element_a.is_point():
-                    continue
                 geo_node_a: GeoNode = element_a.geo_node
                 geo_node_b: GeoNode = element_b.geo_node
                 distance = abs(geo_node_a.get_distance_to_other_geo_node(geo_node_b))
                 print(f"From {element_a.uuid} to {element_b.uuid}: {distance}")
                 distance_sum += distance
             elif element_type == "edge":
-                if exclude_ends_in_calculation and (
-                    not element_a.node_a.is_point() or not element_a.node_b.is_point()
-                ):
-                    continue
                 print(
                     f"Edge {element_a.uuid} compared to {element_b.uuid}: {abs(element_a.length - element_b.length)}"
                 )