Yaramo 2

interlocking/interlockingcontroller/flankprotectioncontroller.py

@@ -1,6 +1,6 @@
 from .signalcontroller import SignalController
 from interlocking.model import Route, Point, OccupancyState, Signal
-from yaramo.model import SignalDirection, NodeConnectionDirection
+from yaramo.model import SignalDirection, EdgeConnectionDirection
 import logging
 
 
@@ -93,14 +93,14 @@ def _get_flank_protection_elements_of_point(self,
                     if node_b.uuid == _point.yaramo_node.uuid:
                         other_point = _point
 
-                if other_point is not None and other_point.is_point:
+                if other_point is not None and other_point.yaramo_node.is_point():
                     connection_direction = other_point.get_connection_direction_of_track(flank_protection_track)
-                    if connection_direction == NodeConnectionDirection.Spitze:
+                    if connection_direction == EdgeConnectionDirection.Spitze:
                         point_results[other_point] = None
                         signal_results, sub_point_results = self._get_flank_protection_elements_of_point(other_point, None)
                         point_results = point_results | sub_point_results
-                    elif connection_direction == NodeConnectionDirection.Links:
+                    elif connection_direction == EdgeConnectionDirection.Links:
                         point_results[other_point] = "right"
-                    elif connection_direction == NodeConnectionDirection.Rechts:
+                    elif connection_direction == EdgeConnectionDirection.Rechts:
                         point_results[other_point] = "left"
         return signal_results, point_results

interlocking/interlockingcontroller/overlapcontroller.py

@@ -57,7 +57,7 @@ async def reserve_points_of_overlap(self, overlap, route, train_id: str):
                 logging.info(f"--- Set point {point.point_id} to reserved (overlap)")
                 point.state = OccupancyState.RESERVED_OVERLAP
                 point.used_by.add(train_id)
-                if point.is_point:
+                if point.yaramo_node.is_point():
                     # Get necessary orientation
                     points_tracks = [point.head, point.left, point.right]
                     found_tracks = []

interlocking/model/point.py

@@ -1,4 +1,4 @@
-from yaramo.model import NodeConnectionDirection
+from yaramo.model import EdgeConnectionDirection
 from .occupancystate import OccupancyState
 from .track import Track
 
@@ -15,25 +15,19 @@ def __init__(self, yaramo_node):
         self.head = None
         self.left = None
         self.right = None
-        self.is_point = True
 
     def connect_track(self, track):
-        if len(self.yaramo_node.connected_nodes) == 1:
+        if not self.yaramo_node.is_point():
             self.head = track
-            self.is_point = False
             return
 
-        other_node = track.right_point.yaramo_node
-        if other_node.uuid == self.yaramo_node.uuid:
-            other_node = track.left_point.yaramo_node
+        connection_direction = self.yaramo_node.get_anschluss_for_edge(track.yaramo_edge)
 
-        connection_direction = self.yaramo_node.get_anschluss_of_other(other_node)
-
-        if connection_direction == NodeConnectionDirection.Spitze:
+        if connection_direction == EdgeConnectionDirection.Spitze:
             self.head = track
-        elif connection_direction == NodeConnectionDirection.Links:
+        elif connection_direction == EdgeConnectionDirection.Links:
             self.left = track
-        elif connection_direction == NodeConnectionDirection.Rechts:
+        elif connection_direction == EdgeConnectionDirection.Rechts:
             self.right = track
 
         #connection_directions = self.yaramo_node.get_anschluss_of_other(other_node)
@@ -59,7 +53,7 @@ def is_track_connected(self, track):
         return track.base_track_id in all_base_ids
 
     def does_point_connect_tracks(self, track_1, track_2):
-        if not self.is_point:
+        if not self.yaramo_node.is_point():
             return False
         if track_1 is None or track_2 is None:
             return False
@@ -84,17 +78,17 @@ def get_necessary_orientation(self, track_1, track_2):
             return "right"
         raise ValueError("None of the given edges is the head edge, orientation not possible")
 
-    def get_connection_direction_of_track(self, track: Track) -> NodeConnectionDirection:
+    def get_connection_direction_of_track(self, track: Track) -> EdgeConnectionDirection:
         if self.head.base_track_id == track.base_track_id:
-            return NodeConnectionDirection.Spitze
+            return EdgeConnectionDirection.Spitze
         if self.left.base_track_id == track.base_track_id:
-            return NodeConnectionDirection.Links
+            return EdgeConnectionDirection.Links
         if self.right.base_track_id == track.base_track_id:
-            return NodeConnectionDirection.Rechts
+            return EdgeConnectionDirection.Rechts
         raise ValueError("Given track is not connected to node")
 
     def get_possible_successors(self, track):
-        if not self.is_point:
+        if not self.yaramo_node.is_point():
             return []
         if self.head.base_track_id == track.base_track_id:
             return [self.left, self.right]