Merge branch 'operations' into compare-operation

# Conflicts:
#	yaramo/operations/__init__.py

Author: arneboockmeyer

test/split_test.py

@@ -11,7 +11,7 @@
     Topology,
     Wgs84GeoNode,
 )
-from yaramo.operations import Split
+from yaramo.operations import Label, Split
 
 
 def test_simple_split():
@@ -179,7 +179,7 @@ def test_invalid_split_not_enough_edges():
         topology_a, topology_b = Split.split(topology, split_edges={edge_4: 5.0})
 
 
-def test_invalid_split_more_than_two_partitions():
+def test_split_in_three_partitions():
     topology = Topology()
     node_1 = Node(geo_node=Wgs84GeoNode(0, 10))
     node_2 = Node(geo_node=Wgs84GeoNode(0, 0))
@@ -193,14 +193,91 @@ def test_invalid_split_more_than_two_partitions():
     edge_2 = Edge(node_2, node_3)
     edge_3 = Edge(node_3, node_4)
     edge_4 = Edge(node_4, node_5)
-    edge_5 = Edge(node_4, node_6)
+    edge_5 = Edge(node_6, node_4)
     edge_6 = Edge(node_6, node_7)
     edge_7 = Edge(node_6, node_8)
     topology.add_nodes([node_1, node_2, node_3, node_4, node_5, node_6, node_7, node_8])
     topology.add_edges([edge_1, edge_2, edge_3, edge_4, edge_5, edge_6, edge_7])
 
-    with pytest.raises(ValueError):
-        topology_a, topology_b = Split.split(topology, split_edges={edge_3: 5.0, edge_5: 5.0})
+    topology_a, topology_b = Split.split(topology, split_edges={edge_3: 5.0, edge_5: 5.0})
+    assert set([node_1, node_2, node_3, node_6, node_7, node_8]).issubset(topology_a.nodes.values())
+    assert set([node_4, node_5]).issubset(topology_b.nodes.values())
+    assert set([edge_1, edge_2, edge_6, edge_7]).issubset(topology_a.edges.values())
+    assert set([edge_4]).issubset(topology_b.edges.values())
+
+
+def test_split_in_more_than_three_partitions():
+    topology = Topology()
+    node_1 = Node(geo_node=Wgs84GeoNode(0, 10))
+    node_2 = Node(geo_node=Wgs84GeoNode(0, 0))
+    node_3 = Node(geo_node=Wgs84GeoNode(10, 0))  # Point
+    node_4 = Node(geo_node=Wgs84GeoNode(20, 0))  # Point
+    node_5 = Node(geo_node=Wgs84GeoNode(30, 0))  # Point
+    node_6 = Node(geo_node=Wgs84GeoNode(40, 10))  # Point
+    node_7 = Node(geo_node=Wgs84GeoNode(50, 10))
+    node_8 = Node(geo_node=Wgs84GeoNode(50, 20))
+    node_9 = Node(geo_node=Wgs84GeoNode(50, 5))
+    node_A = Node(geo_node=Wgs84GeoNode(50, 0))
+    edge_1 = Edge(node_1, node_3)
+    edge_2 = Edge(node_2, node_3)
+    edge_3 = Edge(node_3, node_4)
+    edge_4 = Edge(node_4, node_5)
+    edge_5 = Edge(node_6, node_4)
+    edge_6 = Edge(node_6, node_7)
+    edge_7 = Edge(node_6, node_8)
+    edge_8 = Edge(node_5, node_9)
+    edge_9 = Edge(node_5, node_A)
+    topology.add_nodes(
+        [node_1, node_2, node_3, node_4, node_5, node_6, node_7, node_8, node_9, node_A]
+    )
+    topology.add_edges([edge_1, edge_2, edge_3, edge_4, edge_5, edge_6, edge_7, edge_8, edge_9])
+
+    topology_a, topology_b = Split.split(
+        topology, split_edges={edge_3: 5.0, edge_5: 5.0, edge_4: 5.0}
+    )
+    assert set([node_1, node_2, node_3, node_5, node_6, node_7, node_8, node_9, node_A]).issubset(
+        topology_a.nodes.values()
+    )
+    assert set([node_4]).issubset(topology_b.nodes.values())
+    assert set([edge_1, edge_2, edge_6, edge_7, edge_8, edge_9]).issubset(topology_a.edges.values())
+    # No predefined edges are left in topology B due to split edges
+
+
+def test_add_non_connected_elements_to_a_partition():
+    topology = Topology()
+    node_1 = Node(geo_node=Wgs84GeoNode(0, 0))
+    node_2 = Node(geo_node=Wgs84GeoNode(0, 10))
+    node_3 = Node(geo_node=Wgs84GeoNode(10, 0))  # Point
+    node_4 = Node(geo_node=Wgs84GeoNode(20, 0))  # Point
+    node_5 = Node(geo_node=Wgs84GeoNode(30, 0))
+    node_6 = Node(geo_node=Wgs84GeoNode(30, 10))
+    node_b1 = Node(geo_node=Wgs84GeoNode(100, 0))
+    node_b2 = Node(geo_node=Wgs84GeoNode(110, 0))  # Point
+    node_b3 = Node(geo_node=Wgs84GeoNode(120, 0))
+    node_b4 = Node(geo_node=Wgs84GeoNode(120, 10))
+    edge_1 = Edge(node_1, node_3)
+    edge_2 = Edge(node_2, node_3)
+    edge_3 = Edge(node_3, node_4)
+    edge_4 = Edge(node_4, node_5)
+    edge_5 = Edge(node_4, node_6)
+    edge_b1 = Edge(node_b1, node_b2)
+    edge_b2 = Edge(node_b2, node_b3)
+    edge_b3 = Edge(node_b2, node_b4)
+    topology.add_nodes(
+        [node_1, node_2, node_3, node_4, node_5, node_6, node_b1, node_b2, node_b3, node_b4]
+    )
+    topology.add_edges([edge_1, edge_2, edge_3, edge_4, edge_5, edge_b1, edge_b2, edge_b3])
+
+    topology_a, topology_b = Split.split(
+        topology, split_edges={edge_3: 5.0}, add_missing_elements_to_topology=Label.A_Topology
+    )
+
+    assert set([node_1, node_2, node_3, node_b1, node_b2, node_b3, node_b4]).issubset(
+        topology_a.nodes.values()
+    )
+    assert set([node_4, node_5, node_6]).issubset(topology_b.nodes.values())
+    assert set([edge_1, edge_2, edge_b1, edge_b2, edge_b3]).issubset(topology_a.edges.values())
+    assert set([edge_4, edge_5]).issubset(topology_b.edges.values())
 
 
 def test_elements_on_split_edges():

yaramo/operations/__init__.py

@@ -1,3 +1,3 @@
 from .compare import Compare, CompareMode, CompareResult
-from .split import Split
+from .split import Label, Split
 from .union import Union

yaramo/operations/compare.py

@@ -61,10 +61,15 @@ def compare(
                 raise ValueError(
                     "For isomorphic topologies, at least one mathing node needs to be given."
                 )
-            Compare._calc_isomorphic_matching(result, topology_a, topology_b, given_node_matching, skip_signals)
+            Compare._calc_isomorphic_matching(
+                result, topology_a, topology_b, given_node_matching, skip_signals
+            )
 
         result.node_distance = Compare._calc_distance_for_matching(
-            result.node_matching, exclude_ends_in_calculation, start_node_a=list(given_node_matching.keys())[0], start_node_b=list(given_node_matching.values())[0]
+            result.node_matching,
+            exclude_ends_in_calculation,
+            start_node_a=list(given_node_matching.keys())[0],
+            start_node_b=list(given_node_matching.values())[0],
         )
         result.edge_length_difference = Compare._calc_distance_for_matching(
             result.edge_matching, exclude_ends_in_calculation, element_type="edge"
@@ -159,6 +164,7 @@ def __add_edges_to_matching(__edge_a: Edge, __edge_b: Edge):
                 )
 
         if not skip_signals:
+
             def __add_signal_lists_to_matching(
                 signal_list_a: List[Signal], signal_list_b: List[Signal]
             ):
@@ -173,7 +179,9 @@ def __add_signal_lists_to_matching(
                 if not edge_a.signals and not edge_b.signals:
                     continue
                 if not edge_a.signals or not edge_b.signals:
-                    raise ValueError(f"Signals on edges {edge_a.uuid} and {edge_b.uuid} does not match")
+                    raise ValueError(
+                        f"Signals on edges {edge_a.uuid} and {edge_b.uuid} does not match"
+                    )
                 in_direction_a = [
                     signal for signal in edge_a.signals if signal.direction == SignalDirection.IN
                 ]
@@ -219,7 +227,11 @@ def _are_topologies_isomorphic(topology_a: Topology, topology_b: Topology):
 
     @staticmethod
     def _calc_distance_for_matching(
-        matching: CompareMatching, exclude_ends_in_calculation, element_type: str = "node", start_node_a: Node = None, start_node_b: Node = None,
+        matching: CompareMatching,
+        exclude_ends_in_calculation,
+        element_type: str = "node",
+        start_node_a: Node = None,
+        start_node_b: Node = None,
     ):
         if not matching.element_matching:
             return -1.0
@@ -235,15 +247,20 @@ def _calc_distance_for_matching(
                 start_geo_node_b = start_node_b.geo_node
                 geo_node_a: GeoNode = element_a.geo_node
                 geo_node_b: GeoNode = element_b.geo_node
-                distance = abs(start_geo_node_a.get_distance_to_other_geo_node(geo_node_a) - start_geo_node_b.get_distance_to_other_geo_node(geo_node_b))
+                distance = abs(
+                    start_geo_node_a.get_distance_to_other_geo_node(geo_node_a)
+                    - start_geo_node_b.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)}")
+                print(
+                    f"Edge {element_a.uuid} compared to {element_b.uuid}: {abs(element_a.length - element_b.length)}"
+                )
                 distance_sum += abs(element_a.length - element_b.length)
             elif element_type == "signal":
                 x_a, y_a = element_a.get_calculated_coordinates()

yaramo/operations/split.py

@@ -8,10 +8,20 @@ class Label(Enum):
     A_Topology = auto()
     B_Topology = auto()
 
+    @staticmethod
+    def get_opposite_label(label):
+        if label == Label.A_Topology:
+            return Label.B_Topology
+        return Label.A_Topology
+
 
 class Split:
     @staticmethod
-    def split(topology: Topology, split_edges: Dict[Edge, float]) -> Tuple[Topology, Topology]:
+    def split(
+        topology: Topology,
+        split_edges: Dict[Edge, float],
+        add_missing_elements_to_topology: None | Label = None,
+    ) -> Tuple[Topology, Topology]:
         Split._validate_split_edges(split_edges)
 
         topology_a = Topology()
@@ -20,6 +30,11 @@ def split(topology: Topology, split_edges: Dict[Edge, float]) -> Tuple[Topology,
         new_end_nodes = Split._split_edges(topology, split_edges)
         node_labels, edge_labels, signal_labels = Split._label_elements(topology, new_end_nodes)
 
+        if add_missing_elements_to_topology is not None:
+            Split._assign_missing_elements_to_label(
+                topology, node_labels, edge_labels, signal_labels, add_missing_elements_to_topology
+            )
+
         # Add nodes, edges and signals to destination topologies.
         def _add_elements_to_topology(
             _element_label_matching, _topology_a_method, _topology_b_method
@@ -165,12 +180,41 @@ def _dfs(_start_node: Node, _label):
 
         if not new_end_nodes:
             raise ValueError("No new end nodes found. Split not possible")
-        any_pair = list(new_end_nodes.values())[0]
-        _dfs(any_pair[0], Label.A_Topology)
-        _dfs(any_pair[1], Label.B_Topology)
+
+        for end_node_pair in new_end_nodes.values():
+            node_a = end_node_pair[0]
+            node_b = end_node_pair[1]
+            if node_a not in node_labels and node_b not in node_labels:
+                _dfs(node_a, Label.A_Topology)
+                _dfs(node_b, Label.B_Topology)
+            elif node_a in node_labels and node_b in node_labels:
+                if node_labels[node_a] == node_labels[node_b]:
+                    raise ValueError("Split edges do not fully split. Split not possible.")
+            elif node_a in node_labels:
+                _dfs(node_b, Label.get_opposite_label(node_labels[node_a]))
+            elif node_b in node_labels:
+                _dfs(node_a, Label.get_opposite_label(node_labels[node_b]))
 
         return node_labels, edge_labels, signal_labels
 
+    @staticmethod
+    def _assign_missing_elements_to_label(
+        topology: Topology,
+        node_labels: Dict[Node, Label],
+        edge_labels: Dict[Edge, Label],
+        signal_labels: Dict[Signal, Label],
+        label: Label,
+    ):
+        for node in topology.nodes.values():
+            if node not in node_labels:
+                node_labels[node] = label
+        for edge in topology.edges.values():
+            if edge not in edge_labels:
+                edge_labels[edge] = label
+        for signal in topology.signals.values():
+            if signal not in signal_labels:
+                signal_labels[signal] = label
+
     @staticmethod
     def _validate_for_data_loss(
         topology: Topology,