Add tracks and track types

Author: arneboockmeyer

test/track_test.py

@@ -0,0 +1,20 @@
+import itertools
+
+from yaramo.model import Edge, Node, Track, TrackType
+
+
+def test_edges_in_order():
+    node_a = Node()
+    node_b = Node()
+    node_c = Node()
+    node_d = Node()
+    edge_a = Edge(node_a, node_b)
+    edge_b = Edge(node_b, node_c)
+    edge_c = Edge(node_c, node_d)
+    track = Track(TrackType.Hauptgleis)
+    edge_list = [edge_a, edge_b, edge_c]
+    for permutation in list(itertools.permutations(edge_list)):
+        track.add_edge_section(permutation[0], 0.0, 5.0)
+        track.add_edge_section(permutation[1], 0.0, 5.0)
+        track.add_edge_section(permutation[2], 0.0, 5.0)
+        assert track.get_edges_in_order() == edge_list

yaramo/model.py

@@ -11,4 +11,5 @@
     SignalSystem,
 )
 from yaramo.topology import Topology  # pylint: noqa
+from yaramo.track import Track, TrackType  # pylint: noqa
 from yaramo.trip import Trip  # pylint: noqa

yaramo/track.py

@@ -0,0 +1,74 @@
+from enum import Enum, auto
+from typing import Dict, List, Tuple
+
+from yaramo.base_element import BaseElement
+from yaramo.edge import Edge
+from yaramo.node import Node
+
+
+class TrackType(Enum):
+    Hauptgleis = auto()
+    Durchgehendes_Hauptgleis = auto()
+    Streckengleis = auto()
+    Anschlussgleis = auto()
+    Nebengleis = auto()
+    sonstige = auto()
+
+
+class Track(BaseElement):
+    def __init__(self, track_type, **kwargs):
+        super().__init__(**kwargs)
+        self.track_type: TrackType = track_type
+        self.edge_sections: Dict[Edge, Tuple[float, float]] = {}
+
+    def add_edge_section(self, edge: Edge, section_start: float, section_end: float):
+        self.edge_sections[edge] = (section_start, section_end)
+
+    @property
+    def edges(self) -> List[Edge]:
+        return list(self.edge_sections.keys())
+
+    def get_edges_in_order(self) -> List[Edge]:
+        if len(self.edges) <= 1:
+            return self.edges
+
+        def _count_node_occurrences_in_edges(_node: Node):
+            _count = 0
+            for _edge in self.edges:
+                if _node == _edge.node_a:
+                    _count += 1
+                if _node == _edge.node_b:
+                    _count += 1
+            return _count
+
+        previous_edge: Edge | None = self.edges[0]
+        next_node: Node | None = None
+
+        for edge in self.edges:
+            count_a = _count_node_occurrences_in_edges(edge.node_a)
+            count_b = _count_node_occurrences_in_edges(edge.node_b)
+            if count_a == 1 and count_b == 1:
+                raise ValueError("Edges of Track separated")
+            if count_a == 1 and count_b > 1:
+                previous_edge = edge
+                next_node = edge.node_b
+                break
+            if count_a > 1 and count_b == 1:
+                previous_edge = edge
+                next_node = edge.node_a
+                break
+
+        edges_in_order: List[Edge] = [previous_edge]
+
+        while len(edges_in_order) < len(self.edges):
+            next_edge = None
+            for edge in self.edges:
+                if edge.is_node_connected(next_node) and not edge == previous_edge:
+                    next_edge = edge
+                    break
+
+            edges_in_order.append(next_edge)
+            next_node = next_edge.get_other_node(next_node)
+            previous_edge = next_edge
+
+        return edges_in_order