Change priority computing.

Now we check levels first, than layers and only after that figure
priority.

Author: enzet

doc/author.svg

@@ -152,7 +152,6 @@ def main(id_: str | None) -> None:
                 SCHEME,
                 label_mode=LabelMode.NO,
                 zoom_level=15.7,
-                ignore_level_matching=True,
             ),
         )
 
@@ -169,9 +168,7 @@ def main(id_: str | None) -> None:
         draw_around_point(
             np.array((55.751, 37.628)),
             "trees",
-            MapConfiguration(
-                SCHEME, label_mode=LabelMode(LabelMode.ALL), zoom_level=18.1
-            ),
+            MapConfiguration(SCHEME, zoom_level=18.1, level="overground"),
             get=BoundingBox(37.624, 55.749, 37.633, 55.753),
         )
 

doc/colors.svg

@@ -458,6 +458,16 @@ def __init__(
         if "layer" in tags:
             self.layer = float(tags["layer"])
 
+        self.level: float = 0.0
+        if "level" in tags:
+            try:
+                levels = [
+                    float(x) for x in tags["level"].replace(",", ".").split(";")
+                ]
+                self.level = min(levels)
+            except ValueError:
+                pass
+
         self.placement_offset: float = 0.0
         self.is_transition: bool = False
 
@@ -710,6 +720,12 @@ def __init__(
         self.max_layer: float = max(
             connection[0].layer for connection in connections
         )
+        self.min_level: float = min(
+            connection[0].level for connection in connections
+        )
+        self.max_level: float = max(
+            connection[0].level for connection in connections
+        )
         self.scale: float = self.road_1.scale
         self.flinger: Flinger = flinger
 
@@ -888,10 +904,16 @@ def append(self, road: Road) -> None:
 
     def draw_simple(self, svg: Drawing) -> None:
         """Draw roads as styled figures, usually lines with outlines."""
-        for road in sorted(self.roads, key=lambda x: x.matcher.priority):
+        for road in sorted(
+            self.roads,
+            key=lambda x: (x.level, x.layer, x.matcher.priority),
+        ):
             road.draw(svg, is_border=True)
 
-        for road in sorted(self.roads, key=lambda x: x.matcher.priority):
+        for road in sorted(
+            self.roads,
+            key=lambda x: (x.level, x.layer, x.matcher.priority),
+        ):
             road.draw(svg, is_border=False)
 
     def draw_lanes(
@@ -901,14 +923,17 @@ def draw_lanes(
         if not self.roads:
             return
 
-        layered_roads: dict[float, list[Road]] = {}
-        layered_connectors: dict[float, list[Connector]] = {}
+        level_layer = tuple[float, float]
+
+        layered_roads: dict[level_layer, list[Road]] = {}
+        layered_connectors: dict[level_layer, list[Connector]] = {}
 
         for road in self.roads:
+            key: level_layer = (road.level, road.layer)
             if not road.is_transition:
-                if road.layer not in layered_roads:
-                    layered_roads[road.layer] = []
-                layered_roads[road.layer].append(road)
+                if key not in layered_roads:
+                    layered_roads[key] = []
+                layered_roads[key].append(road)
             else:
                 connections = [
                     [
@@ -922,9 +947,9 @@ def draw_lanes(
                     connector: Connector = ComplexConnector(
                         [connections[0][0], connections[1][0]], flinger
                     )
-                    if road.layer not in layered_connectors:
-                        layered_connectors[road.layer] = []
-                    layered_connectors[road.layer].append(connector)
+                    if key not in layered_connectors:
+                        layered_connectors[key] = []
+                    layered_connectors[key].append(connector)
 
         for connected in self.nodes.values():
             if len(connected) <= 1:
@@ -948,27 +973,41 @@ def draw_lanes(
                 # `SimpleIntersection(connected, flinger, scale)` here.
                 continue
 
-            if connector.min_layer not in layered_connectors:
-                layered_connectors[connector.min_layer] = []
-            layered_connectors[connector.min_layer].append(connector)
+            min_key: level_layer = (
+                connector.min_level,
+                connector.min_layer,
+            )
+            if min_key not in layered_connectors:
+                layered_connectors[min_key] = []
+            layered_connectors[min_key].append(connector)
 
-            if connector.max_layer not in layered_connectors:
-                layered_connectors[connector.max_layer] = []
-            layered_connectors[connector.max_layer].append(connector)
+            max_key: level_layer = (
+                connector.max_level,
+                connector.max_layer,
+            )
+            if max_key not in layered_connectors:
+                layered_connectors[max_key] = []
+            layered_connectors[max_key].append(connector)
 
-        for layer in sorted(layered_roads.keys()):
+        for level_layer_key in sorted(layered_roads.keys()):
             roads: list[Road] = sorted(
-                layered_roads[layer], key=lambda x: x.matcher.priority
+                layered_roads[level_layer_key],
+                key=lambda x: x.matcher.priority,
+            )
+            connectors: list[Connector] | None = layered_connectors.get(
+                level_layer_key
             )
-            connectors: list[Connector] | None = layered_connectors.get(layer)
 
             # Draw borders.
 
             for road in roads:
                 road.draw(svg, is_border=True)
             if connectors:
                 for connector in connectors:
-                    if connector.min_layer == layer:
+                    if (
+                        connector.min_level,
+                        connector.min_layer,
+                    ) == level_layer_key:
                         connector.draw_border(svg)
 
             # Draw inner parts.
@@ -977,7 +1016,10 @@ def draw_lanes(
                 road.draw(svg, is_border=False)
             if connectors:
                 for connector in connectors:
-                    if connector.max_layer == layer:
+                    if (
+                        connector.max_level,
+                        connector.max_layer,
+                    ) == level_layer_key:
                         connector.draw(svg)
 
             # Draw lane separators.

doc/time.svg

@@ -118,10 +118,26 @@ def get_path(
 
         return path
 
+    def get_level(self) -> float:
+        """Get figure level value or 0 if it is not specified.
+
+        For multi-value levels (e.g. "0;1"), return the minimum value.
+        """
+        if "level" in self.tags:
+            try:
+                levels: list[float] = [
+                    float(x)
+                    for x in self.tags["level"].replace(",", ".").split(";")
+                ]
+                return min(levels)
+            except ValueError:
+                return 0.0
+        return 0.0
+
     def get_layer(self) -> float:
         """Get figure layer value or 0 if it is not specified.
 
-        TODO: support values separated by "," or ";".
+        TODO(enzet): support values separated by "," or ";".
         """
         try:
             if "layer" in self.tags:
@@ -131,10 +147,17 @@ def get_layer(self) -> float:
         return 0.0
 
     def __lt__(self, other: StyledFigure) -> bool:
-        """Compare figures based on priority and layer."""
+        """Compare figures based on level, layer, and priority."""
+
+        # First, check level.
+        if self.get_level() != other.get_level():
+            return self.get_level() < other.get_level()
+
+        # Then, check layer.
         if self.get_layer() != other.get_layer():
             return self.get_layer() < other.get_layer()
 
+        # Then, check priority.
         return self.line_style.priority < other.line_style.priority
 
 

doc/trees.svg

@@ -302,7 +302,7 @@ def from_structure(
                 else:
                     way_matcher.style[key] = value
 
-        priority = structure.get("priority", 0.0)
+        priority: float = structure.get("priority", 0.0)
         way_matcher.priority = scheme.get_value(priority)
         way_matcher.parallel_offset = structure.get("parallel_offset", 0.0)