Add road lines to argoverse map. Change road line types to argoverse convention

Author: DanielDauner

d123/dataset/conversion/map/opendrive/opendrive_map_conversion.py

@@ -358,19 +358,19 @@ def _extract_road_line_df(
         if str(lane_row.right_lane_id) in ["nan", "None"]:
             # This is a boundary lane, e.g. a border or sidewalk
             ids.append(running_id)
-            road_line_types.append(int(RoadLineType.SOLID_SINGLE_WHITE))
+            road_line_types.append(int(RoadLineType.SOLID_WHITE))
             geometries.append(lane_row.right_boundary)
             running_id += 1
         else:
             # This is a regular lane
             ids.append(running_id)
-            road_line_types.append(int(RoadLineType.BROKEN_SINGLE_WHITE))
+            road_line_types.append(int(RoadLineType.DASHED_WHITE))
             geometries.append(lane_row.right_boundary)
             running_id += 1
         if str(lane_row.left_lane_id) in ["nan", "None"]:
             # This is a boundary lane, e.g. a border or sidewalk
             ids.append(running_id)
-            road_line_types.append(int(RoadLineType.SOLID_SINGLE_WHITE))
+            road_line_types.append(int(RoadLineType.DASHED_WHITE))
             geometries.append(lane_row.left_boundary)
             running_id += 1
 

d123/dataset/dataset_specific/av2/av2_constants.py

@@ -1,6 +1,7 @@
 from d123.common.datatypes.detection.detection_types import DetectionType
 from d123.common.datatypes.sensor.camera import CameraType
 from d123.common.utils.enums import SerialIntEnum
+from d123.dataset.maps.map_datatypes import RoadLineType
 
 
 class AV2SensorBoxDetectionType(SerialIntEnum):
@@ -85,3 +86,22 @@ class AV2SensorBoxDetectionType(SerialIntEnum):
     "stereo_front_left": CameraType.CAM_STEREO_L,
     "stereo_front_right": CameraType.CAM_STEREO_R,
 }
+
+
+AV2_ROAD_LINE_TYPE_MAPPING = {
+    "NONE": RoadLineType.NONE,
+    "UNKNOWN": RoadLineType.UNKNOWN,
+    "DASH_SOLID_YELLOW": RoadLineType.DASH_SOLID_YELLOW,
+    "DASH_SOLID_WHITE": RoadLineType.DASH_SOLID_WHITE,
+    "DASHED_WHITE": RoadLineType.DASHED_WHITE,
+    "DASHED_YELLOW": RoadLineType.DASHED_YELLOW,
+    "DOUBLE_SOLID_YELLOW": RoadLineType.DOUBLE_SOLID_YELLOW,
+    "DOUBLE_SOLID_WHITE": RoadLineType.DOUBLE_SOLID_WHITE,
+    "DOUBLE_DASH_YELLOW": RoadLineType.DOUBLE_DASH_YELLOW,
+    "DOUBLE_DASH_WHITE": RoadLineType.DOUBLE_DASH_WHITE,
+    "SOLID_YELLOW": RoadLineType.SOLID_YELLOW,
+    "SOLID_WHITE": RoadLineType.SOLID_WHITE,
+    "SOLID_DASH_WHITE": RoadLineType.SOLID_DASH_WHITE,
+    "SOLID_DASH_YELLOW": RoadLineType.SOLID_DASH_YELLOW,
+    "SOLID_BLUE": RoadLineType.SOLID_BLUE,
+}

d123/dataset/dataset_specific/av2/av2_map_conversion.py

@@ -1,3 +1,4 @@
+import warnings
 from pathlib import Path
 from typing import Any, Dict, Final, List
 
@@ -16,11 +17,16 @@
 from d123.dataset.conversion.map.road_edge.road_edge_3d_utils import (
     get_road_edges_3d_from_generic_drivable_area_df,
 )
-from d123.dataset.maps.map_datatypes import MapLayer, RoadEdgeType, RoadLineType
-
-# TODO:
-# - TODO
-LANE_GROUP_MARK_TYPES = ["DASHED_WHITE", "DOUBLE_DASH_WHITE", "DASH_SOLID_WHITE", "SOLID_DASH_WHITE", "SOLID_WHITE"]
+from d123.dataset.dataset_specific.av2.av2_constants import AV2_ROAD_LINE_TYPE_MAPPING
+from d123.dataset.maps.map_datatypes import MapLayer, RoadEdgeType
+
+LANE_GROUP_MARK_TYPES: List[str] = [
+    "DASHED_WHITE",
+    "DOUBLE_DASH_WHITE",
+    "DASH_SOLID_WHITE",
+    "SOLID_DASH_WHITE",
+    "SOLID_WHITE",
+]
 MAX_ROAD_EDGE_LENGTH: Final[float] = 100.0  # TODO: Add to config
 
 
@@ -73,29 +79,27 @@ def _extract_polyline(data: List[Dict[str, float]], close: bool = False) -> Poly
     lane_group_dict = _extract_lane_group_dict(log_map_archive["lane_segments"])
     intersection_dict = _extract_intersection_dict(log_map_archive["lane_segments"], lane_group_dict)
 
-    lane_df = get_lane_df(log_map_archive["lane_segments"])
-    lane_group_df = get_lane_group_df(lane_group_dict)
-    intersection_df = get_intersections_df(intersection_dict)
-    crosswalk_df = get_crosswalk_df(log_map_archive["pedestrian_crossings"])
-    walkway_df = get_empty_gdf()  # NOTE: AV2 does not provide walkways, so we create an empty DataFrame.
-    carpark_df = get_empty_gdf()  # NOTE: AV2 does not provide carparks, so we create an empty DataFrame.
-    generic_drivable_df = get_generic_drivable_df(drivable_areas)
-    road_edge_df = get_road_edge_df(generic_drivable_df)
-    # road_line_df = get_empty_gdf()
+    dataframes: Dict[MapLayer, gpd.GeoDataFrame] = {}
+
+    dataframes[MapLayer.LANE] = get_lane_df(log_map_archive["lane_segments"])
+    dataframes[MapLayer.LANE_GROUP] = get_lane_group_df(lane_group_dict)
+    dataframes[MapLayer.INTERSECTION] = get_intersections_df(intersection_dict)
+    dataframes[MapLayer.CROSSWALK] = get_crosswalk_df(log_map_archive["pedestrian_crossings"])
+    dataframes[MapLayer.GENERIC_DRIVABLE] = get_generic_drivable_df(drivable_areas)
+    dataframes[MapLayer.ROAD_EDGE] = get_road_edge_df(dataframes[MapLayer.GENERIC_DRIVABLE])
+    dataframes[MapLayer.ROAD_LINE] = get_road_line_df(log_map_archive["lane_segments"])
+    # NOTE: AV2 does not provide walkways or carparks, so we create an empty DataFrame.
+    dataframes[MapLayer.WALKWAY] = get_empty_gdf()
+    dataframes[MapLayer.CARPARK] = get_empty_gdf()
 
     map_file_path.unlink(missing_ok=True)
     if not map_file_path.parent.exists():
         map_file_path.parent.mkdir(parents=True, exist_ok=True)
 
-    lane_df.to_file(map_file_path, layer=MapLayer.LANE.serialize(), driver="GPKG")
-    lane_group_df.to_file(map_file_path, layer=MapLayer.LANE_GROUP.serialize(), driver="GPKG", mode="a")
-    intersection_df.to_file(map_file_path, layer=MapLayer.INTERSECTION.serialize(), driver="GPKG", mode="a")
-    crosswalk_df.to_file(map_file_path, layer=MapLayer.CROSSWALK.serialize(), driver="GPKG", mode="a")
-    walkway_df.to_file(map_file_path, layer=MapLayer.WALKWAY.serialize(), driver="GPKG", mode="a")
-    carpark_df.to_file(map_file_path, layer=MapLayer.CARPARK.serialize(), driver="GPKG", mode="a")
-    generic_drivable_df.to_file(map_file_path, layer=MapLayer.GENERIC_DRIVABLE.serialize(), driver="GPKG", mode="a")
-    road_edge_df.to_file(map_file_path, layer=MapLayer.ROAD_EDGE.serialize(), driver="GPKG", mode="a")
-    # road_line_df.to_file(map_file_path, layer=MapLayer.ROAD_LINE.serialize(), driver="GPKG", mode="a")
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", message="'crs' was not provided")
+        for layer, gdf in dataframes.items():
+            gdf.to_file(map_file_path, layer=layer.serialize(), driver="GPKG", mode="a")
 
 
 def get_empty_gdf() -> gpd.GeoDataFrame:
@@ -151,10 +155,7 @@ def _get_centerline_from_boundaries(
             left_boundary=lane_dict["left_lane_boundary"],
             right_boundary=lane_dict["right_lane_boundary"],
         )
-        lane_speed_limit_mps = None
-
-        # ids.append(lane_id)
-        # lane_types.append(lanes_type[lane_id])
+        lane_speed_limit_mps = None  # TODO: Consider using geo reference to retrieve speed limits.
         lane_group_ids.append(lane_id)
         speed_limits_mps.append(lane_speed_limit_mps)
         predecessor_ids.append(lane_dict["predecessors"])
@@ -313,18 +314,28 @@ def get_road_edge_df(generic_drivable_area_df: gpd.GeoDataFrame) -> gpd.GeoDataF
     return gpd.GeoDataFrame(pd.DataFrame({"id": ids, "road_edge_type": road_edge_types}), geometry=geometries)
 
 
-def get_road_line_df(
-    road_lines: Dict[int, npt.NDArray[np.float64]], road_lines_type: Dict[int, RoadLineType]
-) -> gpd.GeoDataFrame:
-    ids = list(road_lines.keys())
-    geometries = [Polyline3D.from_array(road_edge).linestring for road_edge in road_lines.values()]
+def get_road_line_df(lanes: Dict[int, Any]) -> gpd.GeoDataFrame:
 
-    data = pd.DataFrame(
-        {
-            "id": ids,
-            "road_line_type": [int(road_line_type) for road_line_type in road_lines_type.values()],
-        }
-    )
+    # TODO @DanielDauner: Allow lanes to reference road line dataframe.
+
+    ids = []
+    road_lines_type = []
+    geometries = []
+
+    running_id = 0
+    for lane in lanes.values():
+        for side in ["left", "right"]:
+            # NOTE: We currently ignore lane markings that are NONE in the AV2 dataset.
+            # TODO: Review if the road line system should be changed in the future.
+            if lane[f"{side}_lane_mark_type"] == "NONE":
+                continue
+
+            ids.append(running_id)
+            road_lines_type.append(AV2_ROAD_LINE_TYPE_MAPPING[lane[f"{side}_lane_mark_type"]])
+            geometries.append(lane[f"{side}_lane_boundary"].linestring)
+            running_id += 1
+
+    data = pd.DataFrame({"id": ids, "road_line_type": road_lines_type})
     gdf = gpd.GeoDataFrame(data, geometry=geometries)
     return gdf
 

d123/dataset/dataset_specific/nuplan/nuplan_map_conversion.py

@@ -53,8 +53,9 @@
 MAX_ROAD_EDGE_LENGTH = 100.0  # meters, used to filter out very long road edges
 
 NUPLAN_ROAD_LINE_CONVERSION = {
-    0: RoadLineType.BROKEN_SINGLE_WHITE,
-    2: RoadLineType.SOLID_SINGLE_WHITE,
+    0: RoadLineType.DASHED_WHITE,
+    2: RoadLineType.SOLID_WHITE,
+    3: RoadLineType.UNKNOWN,
 }
 
 
@@ -443,9 +444,6 @@ def _extract_road_line_dataframe(self) -> gpd.GeoDataFrame:
         geometries = []
 
         for idx in range(len(boundary_types)):
-            # NOTE @DanielDauner: We ignore boundaries of nuPlan-type, which are on intersections.
-            if boundary_types[idx] not in NUPLAN_ROAD_LINE_CONVERSION.keys():
-                continue
             ids.append(fids[idx])
             road_line_types.append(int(NUPLAN_ROAD_LINE_CONVERSION[boundary_types[idx]]))
             geometries.append(boundaries[idx])

d123/dataset/dataset_specific/wopd/waymo_map_utils/wopd_map_utils.py

@@ -20,18 +20,17 @@
 # - Implement speed bumps
 # - Implement driveways with a different semantic type if needed
 # - Implement intersections and lane group logic
-# - Handle lane type, e.g. TYPE_UNDEFINED = 0; TYPE_FREEWAY = 1; TYPE_SURFACE_STREET = 2; TYPE_BIKE_LANE = 3;
 
 WAYMO_ROAD_LINE_CONVERSION = {
-    0: RoadLineType.UNKNOWN,
-    1: RoadLineType.BROKEN_SINGLE_WHITE,
-    2: RoadLineType.SOLID_SINGLE_WHITE,
-    3: RoadLineType.SOLID_DOUBLE_WHITE,
-    4: RoadLineType.BROKEN_SINGLE_YELLOW,
-    5: RoadLineType.BROKEN_DOUBLE_YELLOW,
-    6: RoadLineType.SOLID_SINGLE_YELLOW,
-    7: RoadLineType.SOLID_DOUBLE_YELLOW,
-    8: RoadLineType.PASSING_DOUBLE_YELLOW,
+    0: RoadLineType.UNKNOWN,  # aka. UNKNOWN
+    1: RoadLineType.DASHED_WHITE,  # aka. BROKEN_SINGLE_WHITE
+    2: RoadLineType.SOLID_WHITE,  # aka. SOLID_SINGLE_WHITE
+    3: RoadLineType.DOUBLE_SOLID_WHITE,  # aka. SOLID_DOUBLE_WHITE
+    4: RoadLineType.DASHED_YELLOW,  # aka. BROKEN_SINGLE_YELLOW
+    5: RoadLineType.DOUBLE_DASH_YELLOW,  # aka. BROKEN_DOUBLE_YELLOW
+    6: RoadLineType.SOLID_YELLOW,  # aka. SOLID_SINGLE_YELLOW
+    7: RoadLineType.DOUBLE_SOLID_YELLOW,  # aka. SOLID_DOUBLE_YELLOW
+    8: RoadLineType.DOUBLE_DASH_YELLOW,  # aka. PASSING_DOUBLE_YELLOW
 }
 
 WAYMO_ROAD_EDGE_CONVERSION = {

d123/dataset/maps/map_datatypes.py

@@ -25,7 +25,6 @@ class MapLayer(SerialIntEnum):
 class LaneType(SerialIntEnum):
     """
     Enum for LaneType.
-    NOTE: We use the lane types from Waymo.
     https://github.com/waymo-research/waymo-open-dataset/blob/99a4cb3ff07e2fe06c2ce73da001f850f628e45a/src/waymo_open_dataset/protos/map.proto#L147
     """
 
@@ -55,12 +54,18 @@ class RoadLineType(SerialIntEnum):
     https://github.com/waymo-research/waymo-open-dataset/blob/master/src/waymo_open_dataset/protos/map.proto#L208
     """
 
-    UNKNOWN = 0
-    BROKEN_SINGLE_WHITE = 1
-    SOLID_SINGLE_WHITE = 2
-    SOLID_DOUBLE_WHITE = 3
-    BROKEN_SINGLE_YELLOW = 4
-    BROKEN_DOUBLE_YELLOW = 5
-    SOLID_SINGLE_YELLOW = 6
-    SOLID_DOUBLE_YELLOW = 7
-    PASSING_DOUBLE_YELLOW = 8
+    NONE = 0
+    UNKNOWN = 1
+    DASH_SOLID_YELLOW = 2
+    DASH_SOLID_WHITE = 3
+    DASHED_WHITE = 4
+    DASHED_YELLOW = 5
+    DOUBLE_SOLID_YELLOW = 6
+    DOUBLE_SOLID_WHITE = 7
+    DOUBLE_DASH_YELLOW = 8
+    DOUBLE_DASH_WHITE = 9
+    SOLID_YELLOW = 10
+    SOLID_WHITE = 11
+    SOLID_DASH_WHITE = 12
+    SOLID_DASH_YELLOW = 13
+    SOLID_BLUE = 14

notebooks/av2/delete_me_map.ipynb

@@ -43,7 +43,10 @@
    "id": "2",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "for lane_segment_id, lane_segment_dict in log_map_archive[\"lane_segments\"].items():\n",
+    "    print(f\"Lane Segment ID: {lane_segment_id}\")"
+   ]
   },
   {
    "cell_type": "code",

notebooks/viz/bev_matplotlib.ipynb

@@ -210,8 +210,8 @@
     "    box_detections = scene.get_box_detections_at_iteration(iteration)\n",
     "\n",
     "    point_2d = ego_vehicle_state.bounding_box.center.state_se2.point_2d\n",
-    "    add_debug_map_on_ax(ax, scene.map_api, point_2d, radius=radius, route_lane_group_ids=None)\n",
-    "    # add_default_map_on_ax(ax, scene.map_api, point_2d, radius=radius, route_lane_group_ids=None)\n",
+    "    # add_debug_map_on_ax(ax, scene.map_api, point_2d, radius=radius, route_lane_group_ids=None)\n",
+    "    add_default_map_on_ax(ax, scene.map_api, point_2d, radius=radius, route_lane_group_ids=None)\n",
     "    # add_traffic_lights_to_ax(ax, traffic_light_detections, scene.map_api)\n",
     "\n",
     "    add_box_detections_to_ax(ax, box_detections)\n",
@@ -238,7 +238,7 @@
     "\n",
     "scene_index = 9\n",
     "iteration = 99\n",
-    "fig, ax = plot_scene_at_iteration(scenes[scene_index], iteration=iteration, radius=100)\n",
+    "fig, ax = plot_scene_at_iteration(scenes[scene_index], iteration=iteration, radius=30)\n",
     "plt.show()\n",
     "\n",
     "# camera = scenes[scene_index].get_camera_at_iteration(\n",