Delete openscene-v1.1/process_data

openscene-v1.1/process_data/create_nuplan_data_with_vis.py

@@ -1,446 +0,0 @@
-import argparse
-import shutil
-from typing import Dict, List
-
-# import mmcv
-import numpy as np
-from os import listdir
-from os.path import isfile, join
-
-from pyquaternion import Quaternion
-
-import cv2
-
-from tqdm import tqdm
-
-import os
-
-import multiprocessing
-import pickle
-from nuplan.common.actor_state.state_representation import StateSE2
-from nuplan.common.maps.abstract_map import AbstractMap
-from nuplan.common.maps.nuplan_map.map_factory import get_maps_api
-
-from nuplan.database.nuplan_db_orm.nuplandb_wrapper import NuPlanDBWrapper
-from nuplan.database.nuplan_db_orm.lidar import Lidar
-from nuplan.database.nuplan_db.nuplan_scenario_queries import (
-    get_traffic_light_status_for_lidarpc_token_from_db,
-    get_images_from_lidar_tokens,
-    get_cameras,
-)
-from nuplan.planning.scenario_builder.nuplan_db.nuplan_scenario import CameraChannel
-from navsim.common.extraction.driving_command import get_driving_command
-
-from helpers.multiprocess_helper import get_scenes_per_thread
-from helpers.canbus import CanBus
-from helpers.multisweep_helper import obtain_sensor2top
-
-NUPLAN_MAPS_ROOT = os.environ["NUPLAN_MAPS_ROOT"]
-filtered_classes = ["traffic_cone", "barrier", "czone_sign", "generic_object"]
-
-
-def create_nuplan_info(
-    nuplan_db_wrapper: NuPlanDBWrapper, db_names: List[str], args
-):
-    nuplan_sensor_root = args.nuplan_sensor_path
-
-    # get all db files & assign db files for current thread.
-
-
-    scene_dict = {}
-    log_sensors = os.listdir(nuplan_sensor_root)
-
-    # For each sequence...
-    for log_db_name in db_names:
-        log_db = nuplan_db_wrapper.get_log_db(log_db_name)
-        log_name = log_db.log_name
-        log_token = log_db.log.token
-        map_location = log_db.log.location
-        vehicle_name = log_db.log.vehicle_name
-
-        # NOTE: I am unsure why "us-nv-las-vegas-strip" is saved as "las_vegas" in db logs.
-        map_name = map_location if map_location != "las_vegas" else "us-nv-las-vegas-strip"
-        map_api = get_maps_api(NUPLAN_MAPS_ROOT, "nuplan-maps-v1.0", map_name)  # NOTE: lru cached
-
-        log_file = os.path.join(nuplan_db_path, log_db_name + ".db")
-        if log_db_name not in log_sensors:
-            continue
-
-        frame_idx = 0
-
-        # list (sequence) of point clouds (each frame).
-        lidar_pc_list = log_db.lidar_pc
-        lidar_pcs = lidar_pc_list
-
-        # get log cam infos
-        log_cam_infos = {}
-        for cam in get_cameras(log_file, [str(channel.value) for channel in CameraChannel]):
-            intrinsics = np.array(pickle.loads(cam.intrinsic), dtype=np.float32)
-            translation = np.array(pickle.loads(cam.translation), dtype=np.float32)
-            rotation = np.array(pickle.loads(cam.rotation), dtype=np.float32)
-            rotation = Quaternion(rotation).rotation_matrix
-            distortion = np.array(pickle.loads(cam.distortion), dtype=np.float32)
-            c = dict(
-                intrinsic=intrinsics,
-                distortion=distortion,
-                translation=translation,
-                rotation=rotation,
-            )
-            log_cam_infos[cam.token] = c
-
-        # Find the first valid point clouds, with all 8 cameras available.
-        for start_idx in range(0, len(lidar_pcs)):
-            retrieved_images = get_images_from_lidar_tokens(
-                log_file,
-                [lidar_pcs[start_idx].token],
-                [str(channel.value) for channel in CameraChannel],
-            )
-            if len(list(retrieved_images)) == 8:
-                break
-
-        # Find the true LiDAR start_idx with the minimum timestamp difference with CAM_F0.
-        retrieved_images_0 = get_images_from_lidar_tokens(
-            log_file, [lidar_pcs[start_idx].token], ["CAM_F0"]
-        )
-        diff_0 = abs(list(retrieved_images_0)[0].timestamp - lidar_pcs[start_idx].timestamp)
-        retrieved_images_1 = get_images_from_lidar_tokens(
-            log_file, [lidar_pcs[start_idx + 1].token], ["CAM_F0"]
-        )
-        diff_1 = abs(list(retrieved_images_1)[0].timestamp - lidar_pcs[start_idx + 1].timestamp)
-        start_idx = start_idx if diff_0 < diff_1 else start_idx + 1
-
-        # Find key_frames (controled by args.sample_interval)
-        lidar_pc_list = lidar_pc_list[start_idx :: args.sample_interval]
-        index = -1
-        for lidar_pc in tqdm(lidar_pc_list, dynamic_ncols=True):
-            index += 1
-
-            # LiDAR attributes.
-            lidar_pc_token = lidar_pc.token
-            scene_token = lidar_pc.scene_token
-            pc_file_name = lidar_pc.filename
-            next_token = lidar_pc.next_token
-            prev_token = lidar_pc.prev_token
-            lidar_token = lidar_pc.lidar_token
-            time_stamp = lidar_pc.timestamp
-            scene_name = "log-" + lidar_pc.scene.name
-            lidar_boxes = lidar_pc.lidar_boxes
-            roadblock_ids = [
-                str(roadblock_id)
-                for roadblock_id in str(lidar_pc.scene.roadblock_ids).split(" ")
-                if len(roadblock_id) > 0
-            ]
-
-            # Saving configurations.
-            if scene_token not in scene_dict.keys():
-                scene_dict[scene_token] = []
-                frame_idx = 0
-            if frame_idx == 0:
-                scene_dict[scene_token] = []
-
-            can_bus = CanBus(lidar_pc).tensor
-            lidar = log_db.session.query(Lidar).filter(Lidar.token == lidar_token).all()
-            pc_file_path = os.path.join(args.nuplan_sensor_path, pc_file_name)
-
-            if not os.path.exists(pc_file_path):  # some lidar files are missing.
-                # print(pc_file_path)
-                with open("./nofile.log", "a") as f:
-                    f.write(pc_file_path)
-                    f.write("\n")
-                continue
-
-            traffic_lights = []
-            for traffic_light_status in get_traffic_light_status_for_lidarpc_token_from_db(
-                log_file, lidar_pc_token
-            ):
-                lane_connector_id: int = traffic_light_status.lane_connector_id
-                is_red: bool = traffic_light_status.status.value == 2
-                traffic_lights.append((lane_connector_id, is_red))
-
-            ego_pose = StateSE2(
-                lidar_pc.ego_pose.x,
-                lidar_pc.ego_pose.y,
-                lidar_pc.ego_pose.quaternion.yaw_pitch_roll[0],
-            )
-            driving_command = get_driving_command(ego_pose, map_api, roadblock_ids)
-
-            info = {
-                "token": lidar_pc_token,
-                "frame_idx": frame_idx,
-                "timestamp": time_stamp,
-                "log_name": log_name,
-                "log_token": log_token,
-                "scene_name": scene_name,
-                "scene_token": scene_token,
-                "map_location": map_location,
-                "roadblock_ids": roadblock_ids,
-                "vehicle_name": vehicle_name,
-                "can_bus": can_bus,
-                "lidar_path": pc_file_name,  # use the relative path.
-                "lidar2ego_translation": lidar[0].translation_np,
-                "lidar2ego_rotation": [
-                    lidar[0].rotation.w,
-                    lidar[0].rotation.x,
-                    lidar[0].rotation.y,
-                    lidar[0].rotation.z,
-                ],
-                "ego2global_translation": can_bus[:3],
-                "ego2global_rotation": can_bus[3:7],
-                "ego_dynamic_state": [
-                    lidar_pc.ego_pose.vx,
-                    lidar_pc.ego_pose.vy,
-                    lidar_pc.ego_pose.acceleration_x,
-                    lidar_pc.ego_pose.acceleration_y,
-                ],
-                "traffic_lights": traffic_lights,
-                "driving_command": driving_command, 
-                "cams": dict(),
-                "prev_sweep_token": prev_token,
-                "next_sweep_token": next_token,
-                "sweeps": [],
-            }
-            info["sample_prev"] = None
-            info["sample_next"] = None
-            if index > 0:  # find prev.
-                info["sample_prev"] = lidar_pc_list[index - 1].token
-            if index < len(lidar_pc_list) - 1:  # find next.
-                next_key_token = lidar_pc_list[index + 1].token
-                next_key_scene = lidar_pc_list[index + 1].scene_token
-                info["sample_next"] = next_key_token
-            else:
-                next_key_token, next_key_scene = None, None
-
-            if next_key_token == None or next_key_token == "":
-                frame_idx = 0
-            else:
-                if next_key_scene != scene_token:
-                    frame_idx = 0
-                else:
-                    frame_idx += 1
-
-            # Parse lidar2ego translation.
-            l2e_r = info["lidar2ego_rotation"]
-            l2e_t = info["lidar2ego_translation"]
-            e2g_r = info["ego2global_rotation"]
-            e2g_t = info["ego2global_translation"]
-            l2e_r_mat = Quaternion(l2e_r).rotation_matrix
-            e2g_r_mat = Quaternion(e2g_r).rotation_matrix
-
-            # add lidar2global: map point coord in lidar to point coord in the global
-            l2e = np.eye(4)
-            l2e[:3, :3] = l2e_r_mat
-            l2e[:3, -1] = l2e_t
-            e2g = np.eye(4)
-            e2g[:3, :3] = e2g_r_mat
-            e2g[:3, -1] = e2g_t
-            lidar2global = np.dot(e2g, l2e)
-            info["ego2global"] = e2g
-            info["lidar2ego"] = l2e
-            info["lidar2global"] = lidar2global
-
-            # obtain 8 image's information per frame
-            retrieved_images = get_images_from_lidar_tokens(
-                log_file, [lidar_pc.token], [str(channel.value) for channel in CameraChannel]
-            )
-            cams = {}
-            for img in retrieved_images:
-                channel = img.channel
-                filename = img.filename_jpg
-                filepath = os.path.join(args.nuplan_sensor_path, filename)
-                if not os.path.exists(filepath):
-                    frame_str = f"{log_db_name}, {lidar_pc_token}"
-                    tqdm.tqdm.write(f"camera file missing: {frame_str}")
-                    continue
-                cam_info = log_cam_infos[img.camera_token]
-                cams[channel] = dict(
-                    data_path=filename,  # use the relative path.
-                    sensor2lidar_rotation=cam_info["rotation"],
-                    sensor2lidar_translation=cam_info["translation"],
-                    cam_intrinsic=cam_info["intrinsic"],
-                    distortion=cam_info["distortion"],
-                )
-            if len(cams) != 8:
-                frame_str = f"{log_db_name}, {lidar_pc_token}"
-                tqdm.write(f"not all cameras are available: {frame_str}")
-                continue
-            info["cams"] = cams
-
-            # parse sweeps if assigned.
-            sweeps = []
-            tmp_info = info
-            count = 0
-            while len(sweeps) < args.max_sweeps:
-                if tmp_info["prev_sweep_token"] == None:
-                    break
-
-                # Get the previous sweep and update info to previous sweep.
-                sweep = obtain_sensor2top(
-                    tmp_info["prev_sweep_token"], log_db, l2e_t, l2e_r_mat, e2g_t, e2g_r_mat, args
-                )
-
-                # Save sweeps in every sweep_interval.
-                tmp_info = sweep
-                if count == args.sweep_interval:
-                    if os.path.exists(sweep["data_path"]):
-                        sweeps.append(sweep)
-                    count = 0
-                else:
-                    count += 1
-            info["sweeps"] = sweeps
-
-            # Parse 3D object labels.
-            if not args.is_test:
-                if args.filter_instance:
-                    fg_lidar_boxes = [
-                        box for box in lidar_boxes if box.category.name not in filtered_classes
-                    ]
-                else:
-                    fg_lidar_boxes = lidar_boxes
-
-                instance_tokens = [item.token for item in fg_lidar_boxes]
-                track_tokens = [item.track_token for item in fg_lidar_boxes]
-
-                inv_ego_r = lidar_pc.ego_pose.trans_matrix_inv
-                ego_yaw = lidar_pc.ego_pose.quaternion.yaw_pitch_roll[0]
-
-                locs = np.array(
-                    [
-                        np.dot(
-                            inv_ego_r[:3, :3],
-                            (b.translation_np - lidar_pc.ego_pose.translation_np).T,
-                        ).T
-                        for b in fg_lidar_boxes
-                    ]
-                ).reshape(-1, 3)
-                dims = np.array([[b.length, b.width, b.height] for b in fg_lidar_boxes]).reshape(
-                    -1, 3
-                )
-                rots = np.array([b.yaw for b in fg_lidar_boxes]).reshape(-1, 1)
-                rots = rots - ego_yaw
-
-                velocity = np.array([[b.vx, b.vy] for b in fg_lidar_boxes]).reshape(-1, 2)
-                velocity_3d = np.array([[b.vx, b.vy, b.vz] for b in fg_lidar_boxes]).reshape(-1, 3)
-
-                # convert velo from global to lidar: only need the rotation matrix
-                for i in range(len(fg_lidar_boxes)):
-                    velo = np.array([*velocity[i], 0.0])
-                    velo = velo @ np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T
-                    velocity[i] = velo[:2]
-
-                for i in range(len(fg_lidar_boxes)):
-                    velo = velocity_3d[i]
-                    velo = velo @ np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T
-                    velocity_3d[i] = velo
-
-                names = [box.category.name for box in fg_lidar_boxes]
-                names = np.array(names)
-                gt_boxes_nuplan = np.concatenate([locs, dims, rots], axis=1)
-                info["anns"] = dict(
-                    gt_boxes=gt_boxes_nuplan,
-                    gt_names=names,
-                    gt_velocity_3d=velocity_3d.reshape(-1, 3),
-                    instance_tokens=instance_tokens,
-                    track_tokens=track_tokens,
-                )
-            scene_dict[scene_token].append(info)
-        del map_api
-        
-        pkl_file_path = f"{args.out_dir}/{log_name}.pkl"
-        os.makedirs(args.out_dir, exist_ok=True)
-        with open(pkl_file_path, "wb") as f:
-            pickle.dump(dict(scene_dict), f, protocol=pickle.HIGHEST_PROTOCOL)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Train a detector")
-    parser.add_argument(
-        "--thread-num", type=int, default=50, help="number of threads for multi-processing."
-    )
-
-    # directory configurations.
-    parser.add_argument("--nuplan-root-path", help="the path to nuplan root path.")
-    parser.add_argument("--nuplan-db-path", help="the dir saving nuplan db.")
-    parser.add_argument("--nuplan-sensor-path", help="the dir to nuplan sensor data.")
-    parser.add_argument("--nuplan-map-version", help="nuplan mapping dataset version.")
-    parser.add_argument("--nuplan-map-root", help="path to nuplan map data.")
-    parser.add_argument("--out-dir", help="output path.")
-
-    # data configurations.
-    parser.add_argument("--max-sweeps", type=int, default=10, help="number of point cloud sweeps.")
-    parser.add_argument(
-        "--sweep-interval", type=int, default=5, help="interval of point cloud sweeps."
-    )
-    parser.add_argument(
-        "--sample-interval", type=int, default=10, help="interval of key frame samples."
-    )
-    parser.add_argument(
-        "--scene-process-type",
-        type=str,
-        default="skip",
-        help="process type when a scene is processed.",
-    )
-
-    # TODO.
-    parser.add_argument("--save-bev-images", action="store_true", help="XXX")
-    parser.add_argument("--save_surround_images", action="store_true", help="XXX")
-
-    # split.
-    parser.add_argument("--is-test", action="store_true", help="Dealing with Test set data.")
-    parser.add_argument(
-        "--filter-instance", action="store_true", help="Ignore instances in filtered_classes."
-    )
-    parser.add_argument("--split", type=str, default="train", help="Train/Val/Test set.")
-
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == "__main__":
-    args = parse_args()
-
-    nuplan_root_path = args.nuplan_root_path
-    nuplan_db_path = args.nuplan_db_path
-    nuplan_sensor_path = args.nuplan_sensor_path
-    nuplan_map_version = args.nuplan_map_version
-    nuplan_map_root = args.nuplan_map_root
-    out_dir = args.out_dir
-
-    nuplan_db_wrapper = NuPlanDBWrapper(
-        data_root=nuplan_root_path,
-        map_root=nuplan_map_root,
-        db_files=nuplan_db_path,
-        map_version=nuplan_map_version,
-    )
-    
-    nuplan_db_path = args.nuplan_db_path
-    db_names_with_extension = [
-        f for f in listdir(nuplan_db_path) if isfile(join(nuplan_db_path, f))
-    ]
-    db_names = [name[:-3] for name in db_names_with_extension]
-    db_names.sort()
-    
-    print(db_names)
-    
-    db_names_split = np.split(np.array(db_names), args.thread_num)
-    
-
-    manager = multiprocessing.Manager()
-    # return_dict = manager.dict()
-    threads = []
-    for x in range(args.thread_num):
-        t = multiprocessing.Process(
-            target=create_nuplan_info,
-            name=str(x),
-            args=(nuplan_db_wrapper, db_names_split[x], args),
-        )
-        threads.append(t)
-    for thr in threads:
-        thr.start()
-    for thr in threads:
-        if thr.is_alive():
-            thr.join()
-    
-    # pkl_file_path = f"{args.out_dir}/{args.split}.pkl"
-    # os.makedirs(args.out_dir, exist_ok=True)
-    # with open(pkl_file_path, "wb") as f:
-    #     pickle.dump(dict(return_dict), f, protocol=pickle.HIGHEST_PROTOCOL)

openscene-v1.1/process_data/driving_command.py

@@ -1,178 +0,0 @@
-from re import A
-from typing import Dict, List, Tuple
-import warnings
-
-import numpy as np
-import numpy.typing as npt
-
-from shapely.geometry import Point
-
-from nuplan.common.maps.abstract_map import AbstractMap
-from nuplan.common.actor_state.state_representation import StateSE2
-from nuplan.common.maps.maps_datatypes import SemanticMapLayer
-from nuplan.common.maps.abstract_map_objects import (
-    LaneGraphEdgeMapObject,
-    RoadBlockGraphEdgeMapObject,
-)
-
-from navsim.planning.simulation.planner.pdm_planner.utils.route_utils import (
-    route_roadblock_correction,
-)
-from navsim.planning.simulation.planner.pdm_planner.utils.graph_search.dijkstra import (
-    Dijkstra,
-)
-from navsim.planning.simulation.planner.pdm_planner.utils.pdm_path import PDMPath
-from navsim.planning.simulation.planner.pdm_planner.utils.pdm_geometry_utils import (
-    convert_absolute_to_relative_se2_array,
-)
-from navsim.planning.simulation.planner.pdm_planner.utils.pdm_enums import (
-    SE2Index,
-)
-
-# shapely runtime warning
-warnings.filterwarnings("ignore", category=RuntimeWarning)
-
-
-def get_driving_command(
-    ego_pose: StateSE2,
-    map_api: AbstractMap,
-    route_roadblock_ids: List[str],
-    distance: float = 20,
-    lateral_offset: float = 2,
-) -> npt.NDArray[np.int]:
-    """
-    Creates the one-hot (left, forward, right)driving command for the ego vehicle
-    :param ego_pose: (x, y, heading) object for global ego pose
-    :param map_api: nuPlan's map interface
-    :param route_roadblock_ids: roadblock ids of route
-    :param distance: longitudinal distance to interpolate on th centerline, defaults to 10
-    :param lateral_offset: lateral offset for left/right threshold, to defaults to 2
-    :return: numpy one-hot array of driving_command
-    """
-
-    driving_command = np.zeros((3,), dtype=int)  # one-hot: (left, forward, right)
-
-    # If no route available, go straight
-    if len(route_roadblock_ids) == 0:
-        driving_command[1] = 1
-        return driving_command
-
-    # Apply route correction on route_roadblock_ids
-    route_roadblock_dict, _ = get_route_dicts(map_api, route_roadblock_ids)
-    corrected_route_roadblock_ids = route_roadblock_correction(
-        ego_pose, map_api, route_roadblock_dict
-    )
-    route_roadblock_dict, route_lane_dict = get_route_dicts(map_api, corrected_route_roadblock_ids)
-
-    # Find the nearest lane, graph search, and centerline extraction
-    current_lane = get_current_lane(ego_pose, route_lane_dict)
-    discrete_centerline = get_discrete_centerline(
-        current_lane, route_roadblock_dict, route_lane_dict
-    )
-    centerline = PDMPath(discrete_centerline)
-
-    # Interpolate target distance on centerline
-    current_progress = centerline.project(Point(*ego_pose.array))
-    target_progress = current_progress + distance
-
-    current_pose_array, target_pose_array = centerline.interpolate(
-        [current_progress, target_progress], as_array=True
-    )
-    target_pose_array = convert_absolute_to_relative_se2_array(
-        StateSE2(*current_pose_array), target_pose_array[None,...]
-    )[0]
-
-    # Threshold for driving command
-    if target_pose_array[SE2Index.Y] >= lateral_offset:
-        driving_command[0] = 1
-    elif target_pose_array[SE2Index.Y] <= -lateral_offset:
-        driving_command[2] = 1
-    else:
-        driving_command[1] = 1
-
-    # delete some variables for memory management
-    del route_roadblock_dict, route_lane_dict, _, centerline
-    return driving_command
-
-
-def get_route_dicts(
-    map_api: AbstractMap, route_roadblock_ids: List[str]
-) -> Tuple[Dict[str, RoadBlockGraphEdgeMapObject], Dict[str, LaneGraphEdgeMapObject]]:
-    """
-    Loads the roadblock and lane dicts
-    :param map_api: nuPlan's map interface
-    :param route_roadblock_ids: roadblock ids of route
-    :return: tuple of roadblock and lane dicts
-    """
-
-    # remove repeated ids while remaining order in list
-    route_roadblock_ids = list(dict.fromkeys(route_roadblock_ids))
-
-    route_roadblock_dict: Dict[str, RoadBlockGraphEdgeMapObject] = {}
-    route_lane_dict: Dict[str, LaneGraphEdgeMapObject] = {}
-
-    for id_ in route_roadblock_ids:
-        block = map_api.get_map_object(id_, SemanticMapLayer.ROADBLOCK)
-        block = block or map_api.get_map_object(id_, SemanticMapLayer.ROADBLOCK_CONNECTOR)
-        route_roadblock_dict[block.id] = block
-        for lane in block.interior_edges:
-            route_lane_dict[lane.id] = lane
-
-    return route_roadblock_dict, route_lane_dict
-
-
-def get_current_lane(
-    ego_pose: StateSE2, route_lane_dict: Dict[str, LaneGraphEdgeMapObject]
-) -> LaneGraphEdgeMapObject:
-    """
-    Find current lane, either if intersection with ego pose, or by distance.
-    :param ego_pose: (x, y, heading) object for global ego pose
-    :param route_lane_dict: Dictionary of roadblock ids and objects
-    :return: Lane object
-    """
-
-    closest_distance = np.inf
-    starting_lane = None
-    for edge in route_lane_dict.values():
-        if edge.contains_point(ego_pose):
-            starting_lane = edge
-            break
-
-        distance = edge.polygon.distance(Point(*ego_pose.array))
-        if distance < closest_distance:
-            starting_lane = edge
-            closest_distance = distance
-
-    return starting_lane
-
-
-def get_discrete_centerline(
-    current_lane: LaneGraphEdgeMapObject,
-    route_roadblock_dict: Dict[str, RoadBlockGraphEdgeMapObject],
-    route_lane_dict: Dict[str, LaneGraphEdgeMapObject],
-    search_depth: int = 30,
-) -> List[StateSE2]:
-    """
-    Given the current lane, apply graph search, and extract centerline.
-    :param current_lane: Lane object closest to ego
-    :param route_roadblock_dict: Dictionary of roadblock ids and objects
-    :param route_lane_dict: Dictionary of lane ids and objects
-    :param search_depth: max search depth of Dijkstra, defaults to 30
-    :return: List of (x, y, heading) objects
-    """
-
-    roadblocks = list(route_roadblock_dict.values())
-    roadblock_ids = list(route_roadblock_dict.keys())
-
-    # find current roadblock index
-    start_idx = np.argmax(np.array(roadblock_ids) == current_lane.get_roadblock_id())
-    roadblock_window = roadblocks[start_idx : start_idx + search_depth]
-
-    graph_search = Dijkstra(current_lane, list(route_lane_dict.keys()))
-    route_plan, _ = graph_search.search(roadblock_window[-1])
-
-    centerline_discrete_path: List[StateSE2] = []
-    for lane in route_plan:
-        centerline_discrete_path.extend(lane.baseline_path.discrete_path)
-
-    return centerline_discrete_path

openscene-v1.1/process_data/helpers/canbus.py

@@ -1,50 +0,0 @@
-import numpy as np
-
-
-class CanBus:
-    """Wrapper class to convert lidar_can_bus to numpy array"""
-
-    def __init__(self, lidar_pc):
-        self.x = lidar_pc.ego_pose.x
-        self.y = lidar_pc.ego_pose.y
-        self.z = lidar_pc.ego_pose.z
-
-        self.qw = lidar_pc.ego_pose.qw
-        self.qx = lidar_pc.ego_pose.qx
-        self.qy = lidar_pc.ego_pose.qy
-        self.qz = lidar_pc.ego_pose.qz
-
-        self.acceleration_x = lidar_pc.ego_pose.acceleration_x
-        self.acceleration_y = lidar_pc.ego_pose.acceleration_y
-        self.acceleration_z = lidar_pc.ego_pose.acceleration_z
-
-        self.vx = lidar_pc.ego_pose.vx
-        self.vy = lidar_pc.ego_pose.vy
-        self.vz = lidar_pc.ego_pose.vz
-
-        self.angular_rate_x = lidar_pc.ego_pose.angular_rate_x
-        self.angular_rate_y = lidar_pc.ego_pose.angular_rate_y
-        self.angular_rate_z = lidar_pc.ego_pose.angular_rate_z
-
-        self.tensor = np.array(
-            [
-                self.x,
-                self.y,
-                self.z,
-                self.qw,
-                self.qx,
-                self.qy,
-                self.qz,
-                self.acceleration_x,
-                self.acceleration_y,
-                self.acceleration_z,
-                self.vx,
-                self.vy,
-                self.vz,
-                self.angular_rate_x,
-                self.angular_rate_y,
-                self.angular_rate_z,
-                0.0,
-                0.0,
-            ]
-        )

openscene-v1.1/process_data/helpers/multiprocess_helper.py

@@ -1,32 +0,0 @@
-import numpy as np
-import multiprocessing
-
-
-def get_scenes_per_thread(scenes, thread_num):
-    scenes = sorted(scenes)
-    num_tasks = thread_num
-    cur_id = int(multiprocessing.current_process().name)
-
-    num_scene = len(scenes)
-    a = num_scene // num_tasks
-    b = num_scene % num_tasks
-
-    if cur_id == 0:
-        print("num_scene:", num_scene)
-
-    process_num = []
-    for id in range(num_tasks):
-        if id >= b:
-            process_num.append(a)
-        else:
-            process_num.append(a + 1)
-    addsum = np.cumsum(process_num)
-
-    if cur_id == 0:
-        start = 0
-        end = addsum[0]
-    else:
-        start = addsum[cur_id - 1]
-        end = addsum[cur_id]
-
-    return scenes[start:end], start

openscene-v1.1/process_data/helpers/multisweep_helper.py

@@ -1,66 +0,0 @@
-import os
-import numpy as np
-from pyquaternion import Quaternion
-
-from nuplan.database.nuplan_db_orm.lidar_pc import LidarPc
-from nuplan.database.nuplan_db_orm.lidar import Lidar
-
-from navsim.common.extraction.helpers.canbus import CanBus
-
-
-def obtain_sensor2top(lidar_token, log_db, l2e_t, l2e_r_mat, e2g_t, e2g_r_mat, args):
-    """Obtain the info with RT matric from other sensors to Top LiDAR.
-
-    Args:
-        lidar_token (str): Sample data token corresponding to the
-            specific sensor type.
-        log_db: To obtain LiDAR of corresponding token.
-        l2e_t (np.ndarray): Translation from lidar to ego in shape (1, 3).
-        l2e_r_mat (np.ndarray): Rotation matrix from lidar to ego
-            in shape (3, 3).
-        e2g_t (np.ndarray): Translation from ego to global in shape (1, 3).
-        e2g_r_mat (np.ndarray): Rotation matrix from ego to global
-            in shape (3, 3).
-
-    Returns:
-        sweep (dict): Sweep information after transformation.
-    """
-    lidar_pc = log_db.session.query(LidarPc).filter(LidarPc.token == lidar_token).all()
-    lidar_pc = lidar_pc[0]
-    can_bus = CanBus(lidar_pc).tensor
-
-    lidar_sensor = log_db.session.query(Lidar).filter(Lidar.token == lidar_pc.lidar_token).all()
-    lidar_sensor = lidar_sensor[0]
-
-    sweep = {
-        "prev_sweep_token": lidar_pc.prev_token,
-        "data_path": os.path.join(args.nuplan_sensor_path, lidar_pc.filename),
-        "type": lidar_sensor.channel,
-        "sample_data_token": lidar_pc.token,
-        "sensor2ego_translation": lidar_sensor.translation_np,
-        "sensor2ego_rotation": lidar_sensor.quaternion,
-        "ego2global_translation": can_bus[:3],
-        "ego2global_rotation": can_bus[3:7],
-        "timestamp": lidar_pc.timestamp,
-    }
-
-    l2e_r_s = sweep["sensor2ego_rotation"]
-    l2e_t_s = sweep["sensor2ego_translation"]
-    e2g_r_s = sweep["ego2global_rotation"]
-    e2g_t_s = sweep["ego2global_translation"]
-
-    # obtain the RT from sensor to Top LiDAR
-    # sweep->ego->global->ego'->lidar
-    l2e_r_s_mat = Quaternion(l2e_r_s).rotation_matrix
-    e2g_r_s_mat = Quaternion(e2g_r_s).rotation_matrix
-    R = (l2e_r_s_mat.T @ e2g_r_s_mat.T) @ (np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T)
-    T = (l2e_t_s @ e2g_r_s_mat.T + e2g_t_s) @ (
-        np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T
-    )
-    T -= (
-        e2g_t @ (np.linalg.inv(e2g_r_mat).T @ np.linalg.inv(l2e_r_mat).T)
-        + l2e_t @ np.linalg.inv(l2e_r_mat).T
-    )
-    sweep["sensor2lidar_rotation"] = R.T  # points @ R.T + T
-    sweep["sensor2lidar_translation"] = T
-    return sweep

openscene-v1.1/process_data/helpers/transformation.py

@@ -1,138 +0,0 @@
-import numpy as np
-from pyquaternion import Quaternion
-
-from nuplan.database.utils.pointclouds.pointcloud import PointCloud
-
-
-def _load_points(pc_file_name):
-    pc = PointCloud.parse_from_file(pc_file_name).to_pcd_bin2().T
-    return pc
-
-
-def transform_pcs_to_images(
-    pc,
-    cam2lidar_rotation,
-    cam2lidar_translation,
-    cam_intrinsic,
-    img_shape=None,
-    eps=1e-3,
-    return_depth=False,
-):
-    """Transform point clouds from LiDAR coordinates to the camera coordinates.
-
-    Args:
-        pc: a numpy array with shape [-1, 6]
-        cam_infos: dict of camera information.
-    Return:
-        pc_cam: dict of 2d coordinates in corresponding camera space.
-    """
-    pc_xyz = pc[:, :3]
-
-    lidar2cam_r = np.linalg.inv(cam2lidar_rotation)
-    lidar2cam_t = cam2lidar_translation @ lidar2cam_r.T
-    lidar2cam_rt = np.eye(4)
-    lidar2cam_rt[:3, :3] = lidar2cam_r.T
-    lidar2cam_rt[3, :3] = -lidar2cam_t
-
-    viewpad = np.eye(4)
-    viewpad[: cam_intrinsic.shape[0], : cam_intrinsic.shape[1]] = cam_intrinsic
-    lidar2img_rt = viewpad @ lidar2cam_rt.T
-
-    cur_pc_xyz = np.concatenate([pc_xyz, np.ones_like(pc_xyz)[:, :1]], -1)
-    cur_pc_cam = lidar2img_rt @ cur_pc_xyz.T
-    cur_pc_cam = cur_pc_cam.T
-
-    cur_pc_in_fov = cur_pc_cam[:, 2] > eps
-    depth = cur_pc_cam[..., 2:3]
-
-    cur_pc_cam = cur_pc_cam[..., 0:2] / np.maximum(
-        cur_pc_cam[..., 2:3], np.ones_like(cur_pc_cam[..., 2:3]) * eps
-    )
-    if img_shape is not None:
-        img_h, img_w = img_shape
-        cur_pc_in_fov = (
-            cur_pc_in_fov
-            & (cur_pc_cam[:, 0] < (img_w - 1))
-            & (cur_pc_cam[:, 0] > 0)
-            & (cur_pc_cam[:, 1] < (img_h - 1))
-            & (cur_pc_cam[:, 1] > 0)
-        )
-    if return_depth:
-        cur_pc_cam = np.concatenate([cur_pc_cam, depth], axis=-1)
-    return cur_pc_cam, cur_pc_in_fov
-
-
-def transform_cam_to_img(pc_cam, cam_intrinsic, img_shape=None, eps=1e-3, return_depth=False):
-    """Transform point clouds from LiDAR coordinates to the camera coordinates.
-
-    Args:
-        pc: a numpy array with shape [-1, 6]
-        cam_infos: dict of camera information.
-    Return:
-        pc_cam: dict of 2d coordinates in corresponding camera space.
-    """
-    pc_cam = pc_cam[:, :3]
-
-    viewpad = np.eye(4)
-    viewpad[: cam_intrinsic.shape[0], : cam_intrinsic.shape[1]] = cam_intrinsic
-
-    pc_img = np.concatenate([pc_cam, np.ones_like(pc_cam)[:, :1]], -1)
-    pc_img = viewpad @ pc_img.T
-    pc_img = pc_img.T
-
-    cur_pc_in_fov = pc_img[:, 2] > eps
-    depth = pc_img[..., 2:3]
-
-    pc_img = pc_img[..., 0:2] / np.maximum(pc_img[..., 2:3], np.ones_like(pc_img[..., 2:3]) * eps)
-    if img_shape is not None:
-        img_h, img_w = img_shape
-        cur_pc_in_fov = (
-            cur_pc_in_fov
-            & (pc_img[:, 0] < (img_w - 1))
-            & (pc_img[:, 0] > 0)
-            & (pc_img[:, 1] < (img_h - 1))
-            & (pc_img[:, 1] > 0)
-        )
-    if return_depth:
-        pc_img = np.concatenate([pc_img, depth], axis=-1)
-    return pc_img, cur_pc_in_fov
-
-
-def transform_nuplan_boxes_to_cam(box, cam2lidar_rotation, cam2lidar_translation):
-    """Transform point clouds from LiDAR coordinates to the camera coordinates.
-
-    Args:
-        box: a numpy array with shape [-1, 7]
-    """
-    locs, dims, rots = box[:, :3], box[:, 3:6], box[:, 6:]
-    dims_cams = dims[:, [0, 2, 1]]  # l, w, h -> l, h, w
-
-    rots_cam = np.zeros_like(rots)
-    for idx, rot in enumerate(rots):
-        rot = Quaternion(axis=[0, 0, 1], radians=rot)
-        rot = Quaternion(matrix=cam2lidar_rotation).inverse * rot
-        rots_cam[idx] = -rot.yaw_pitch_roll[0]
-
-    lidar2cam_r = np.linalg.inv(cam2lidar_rotation)
-    lidar2cam_t = cam2lidar_translation @ lidar2cam_r.T
-    lidar2cam_rt = np.eye(4)
-    lidar2cam_rt[:3, :3] = lidar2cam_r.T
-    lidar2cam_rt[3, :3] = -lidar2cam_t
-
-    locs_cam = np.concatenate([locs, np.ones_like(locs)[:, :1]], -1)  # -1, 4
-    locs_cam = lidar2cam_rt.T @ locs_cam.T
-    locs_cam = locs_cam.T
-    locs_cam = locs_cam[:, :-1]
-    return np.concatenate([locs_cam, dims_cams, rots_cam], -1)
-
-
-def transform_sweep_pc_to_lidar_top(sweep_pc, sensor2lidar_rotation, sensor2lidar_translation):
-    sweep_xyz = sweep_pc[:, :3]
-    sweep_xyz = np.concatenate([sweep_xyz, np.ones_like(sweep_xyz)[:, :1]], -1)
-
-    sensor2lidar_rt = np.eye(4)
-    sensor2lidar_rt[:3, :3] = sensor2lidar_rotation.T
-    sensor2lidar_rt[3, :3] = sensor2lidar_translation
-
-    sweep_xyz = sweep_xyz @ sensor2lidar_rt
-    return sweep_xyz[:, :3]

openscene-v1.1/process_data/helpers/viz.py

@@ -1,93 +0,0 @@
-import cv2
-import numpy as np
-
-from navsim.common.extraction.helpers import transformation
-
-
-def draw_pcs_on_images(pc, cam_infos, eps=1e-3):
-    for cam_type, cam_info in cam_infos.items():
-        cur_img_path = cam_info["data_path"]
-        cur_img = cv2.imread(cur_img_path)
-        cur_img_h, cur_img_w = cur_img.shape[:2]
-
-        cur_pc_cam, cur_pc_in_fov = transformation.transform_pcs_to_images(
-            pc,
-            cam_info["sensor2lidar_rotation"],
-            cam_info["sensor2lidar_translation"],
-            cam_info["cam_intrinsic"],
-            img_shape=(cur_img_h, cur_img_w),
-            eps=eps,
-        )
-
-        cur_pc_cam = cur_pc_cam[cur_pc_in_fov]
-        for x, y in cur_pc_cam:
-            cv2.circle(cur_img, (int(x), int(y)), 3, (255, 0, 0), 3)
-        cv2.imwrite(f"dbg/{cam_type}.png", cur_img)
-    return None
-
-
-def draw_pcs(points, labels, color_map):
-    """Draw point cloud from BEV
-
-    Args:
-        points: A ndarray with shape as [-1, 3]
-        labels: the label of each point with shape [-1]
-        color_map: color of each label.
-    """
-    import matplotlib.pyplot as plt
-
-    _, ax = plt.subplots(1, 1, figsize=(9, 9))
-    axes_limit = 40
-    # points: LiDAR points with shape [-1, 3]
-    viz_points = points
-    dists = np.sqrt(np.sum(viz_points[:, :2] ** 2, axis=1))
-    colors = np.minimum(1, dists / axes_limit / np.sqrt(2))
-
-    # prepare color_map
-    points_color = color_map[labels] / 255.0  # -1, 3
-
-    point_scale = 0.2
-    scatter = ax.scatter(viz_points[:, 0], viz_points[:, 1], c=points_color, s=point_scale)
-
-    ax.plot(0, 0, "x", color="red")
-    ax.set_xlim(-axes_limit, axes_limit)
-    ax.set_ylim(-axes_limit, axes_limit)
-    ax.axis("off")
-    ax.set_aspect("equal")
-    plt.savefig("dbg/dbg.png", bbox_inches="tight", pad_inches=0, dpi=200)
-
-
-def draw_sweep_pcs(info, sweeps):
-    cur_pc_file = info["lidar_path"]
-    cur_pc = transformation._load_points(cur_pc_file)
-    viz_pcs = [cur_pc[:, :3]]
-    viz_labels = [np.ones_like(cur_pc)[:, 0] * 0.0]
-
-    for idx, sweep in enumerate(sweeps):
-        sweep_pc_file = sweep["data_path"]
-        sweep_pc = transformation._load_points(sweep_pc_file)
-        sweep_pc = transformation.transform_sweep_pc_to_lidar_top(
-            sweep_pc, sweep["sensor2lidar_rotation"], sweep["sensor2lidar_translation"]
-        )
-
-        viz_pcs.append(sweep_pc)
-        viz_labels.append(np.ones_like(sweep_pc)[:, 0] * (idx + 1))
-
-    viz_pcs = np.concatenate(viz_pcs, 0)
-    viz_labels = np.concatenate(viz_labels, 0).astype(np.int)
-    color_map = np.array(
-        [
-            [245, 150, 100],
-            [245, 230, 100],
-            [250, 80, 100],
-            [150, 60, 30],
-            [255, 0, 0],
-            [180, 30, 80],
-            [255, 0, 0],
-            [30, 30, 255],
-            [200, 40, 255],
-            [90, 30, 150],
-        ]
-    )
-    draw_pcs(viz_pcs, viz_labels, color_map)
-    return None

openscene-v1.1/process_data/helpers/viz_box.py

@@ -1,102 +0,0 @@
-import numpy as np
-
-from matplotlib.lines import Line2D
-
-
-def rotz(t):
-    """Rotation about the z-axis."""
-    c = np.cos(t)
-    s = np.sin(t)
-    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
-
-
-def draw_box_and_pc(points, boxes, names=None):
-    import matplotlib.pyplot as plt
-
-    _, ax = plt.subplots(1, 1, figsize=(9, 9))
-    axes_limit = 40
-    # points: LiDAR points with shape [-1, 3]
-    viz_points = points
-    dists = np.sqrt(np.sum(viz_points[:, :2] ** 2, axis=1))
-    colors = np.minimum(1, dists / axes_limit / np.sqrt(2))
-
-    # prepare color_map
-    points_color = np.array([[245, 150, 100]]).reshape(1, 3).repeat(points.shape[0], 0)
-    points_color = points_color / 255.0
-    point_scale = 0.2
-    scatter = ax.scatter(viz_points[:, 0], viz_points[:, 1], c=points_color, s=point_scale)
-
-    ax.plot(0, 0, "x", color="red")
-    ax.set_xlim(-axes_limit, axes_limit)
-    ax.set_ylim(-axes_limit, axes_limit)
-
-    if names is None:
-        draw_box_3d(boxes, ax)
-    else:
-        color_map = {
-            "vehicle": "green",
-            "bicycle": "blue",
-            "pedestrian": "red",
-            "traffic_cone": "darkred",
-            "barrier": "peru",
-            "czone_sign": "pink",
-            "generic_object": "black",
-        }
-        colors = [color_map[name] for name in names]
-        draw_box_3d(boxes, ax, linestyle="--", colors=colors)
-
-    ax.axis("off")
-    ax.set_aspect("equal")
-    plt.savefig("dbg/dbg.png", bbox_inches="tight", pad_inches=0, dpi=200)
-
-
-def draw_box_3d(boxes, ax, linestyle="--", colors="cyan"):
-    for o in range(len(boxes)):
-        color = colors[o]
-        obj = boxes[o]
-        c_x, c_y, c_z, l, w, h, rz = obj[0], obj[1], obj[2], obj[3], obj[4], obj[5], obj[6]
-
-        R = rotz(rz)
-
-        # 3d bounding box corners
-        x_corners = [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2]
-        y_corners = [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2]
-        z_corners = [h, h, h, h, 0, 0, 0, 0]
-
-        # rotate and translate 3d bounding box
-        corners_3d = np.dot(R, np.vstack([x_corners, y_corners, z_corners]))
-
-        corners_3d[0, :] = corners_3d[0, :] + c_x
-        corners_3d[1, :] = corners_3d[1, :] + c_y
-        corners_3d[2, :] = corners_3d[2, :] + c_z
-
-        corners_3d_velo = np.transpose(corners_3d)
-
-        x1, x2, x3, x4 = corners_3d_velo[0:4, 0]
-        y1, y2, y3, y4 = corners_3d_velo[0:4, 1]
-
-        polygon = np.zeros([5, 2], dtype=np.float32)
-        polygon[0, 0] = x1
-        polygon[1, 0] = x2
-        polygon[2, 0] = x3
-        polygon[3, 0] = x4
-        polygon[4, 0] = x1
-
-        polygon[0, 1] = y1
-        polygon[1, 1] = y2
-        polygon[2, 1] = y3
-        polygon[3, 1] = y4
-        polygon[4, 1] = y1
-
-        line1 = [(x1, y1), (x2, y2)]
-        line2 = [(x2, y2), (x3, y3)]
-        line3 = [(x3, y3), (x4, y4)]
-        line4 = [(x4, y4), (x1, y1)]
-        (line1_xs, line1_ys) = zip(*line1)
-        (line2_xs, line2_ys) = zip(*line2)
-        (line3_xs, line3_ys) = zip(*line3)
-        (line4_xs, line4_ys) = zip(*line4)
-        ax.add_line(Line2D(line1_xs, line1_ys, linewidth=1, linestyle=linestyle, color=color))
-        ax.add_line(Line2D(line2_xs, line2_ys, linewidth=1, linestyle=linestyle, color=color))
-        ax.add_line(Line2D(line3_xs, line3_ys, linewidth=1, linestyle=linestyle, color=color))
-        ax.add_line(Line2D(line4_xs, line4_ys, linewidth=1, linestyle=linestyle, color=color))

openscene-v1.1/process_data/helpers/viz_box_2d.py

@@ -1,135 +0,0 @@
-"""
-Visualize 3D boxes in Image space.
-Align the setting in mmdetection3d:
-    * Convert 3D box in nuplan coordinates to camera coordinates.
-    * draw 3D box in camera.
-"""
-
-import cv2
-import numpy as np
-from navsim.common.extraction.helpers import transformation
-
-
-def rotation_3d_in_axis(points, angles, axis=0):
-    """Rotate points by angles according to axis.
-
-    Args:
-        points (torch.Tensor): Points of shape (N, M, 3).
-        angles (torch.Tensor): Vector of angles in shape (N,)
-        axis (int, optional): The axis to be rotated. Defaults to 0.
-
-    Raises:
-        ValueError: when the axis is not in range [0, 1, 2], it will \
-            raise value error.
-
-    Returns:
-        torch.Tensor: Rotated points in shape (N, M, 3)
-    """
-    rot_sin = np.sin(angles)
-    rot_cos = np.cos(angles)
-    ones = np.ones_like(rot_cos)
-    zeros = np.zeros_like(rot_cos)
-    if axis == 1:
-        rot_mat_T = np.stack(
-            [
-                np.stack([rot_cos, zeros, -rot_sin]),
-                np.stack([zeros, ones, zeros]),
-                np.stack([rot_sin, zeros, rot_cos]),
-            ]
-        )
-    elif axis == 2 or axis == -1:
-        rot_mat_T = np.stack(
-            [
-                np.stack([rot_cos, -rot_sin, zeros]),
-                np.stack([rot_sin, rot_cos, zeros]),
-                np.stack([zeros, zeros, ones]),
-            ]
-        )
-    elif axis == 0:
-        rot_mat_T = np.stack(
-            [
-                np.stack([zeros, rot_cos, -rot_sin]),
-                np.stack([zeros, rot_sin, rot_cos]),
-                np.stack([ones, zeros, zeros]),
-            ]
-        )
-    else:
-        raise ValueError(f"axis should in range [0, 1, 2], got {axis}")
-    return np.einsum("aij,jka->aik", points, rot_mat_T)
-
-
-def plot_rect3d_on_img(img, num_rects, rect_corners, color=(0, 255, 0), thickness=1):
-    """Plot the boundary lines of 3D rectangular on 2D images.
-
-    Args:
-        img (numpy.array): The numpy array of image.
-        num_rects (int): Number of 3D rectangulars.
-        rect_corners (numpy.array): Coordinates of the corners of 3D
-            rectangulars. Should be in the shape of [num_rect, 8, 2].
-        color (tuple[int]): The color to draw bboxes. Default: (0, 255, 0).
-        thickness (int, optional): The thickness of bboxes. Default: 1.
-    """
-    line_indices = (
-        (0, 1),
-        (0, 3),
-        (0, 4),
-        (1, 2),
-        (1, 5),
-        (3, 2),
-        (3, 7),
-        (4, 5),
-        (4, 7),
-        (2, 6),
-        (5, 6),
-        (6, 7),
-    )
-    for i in range(num_rects):
-        corners = rect_corners[i].astype(np.int)
-        for start, end in line_indices:
-            cv2.line(
-                img,
-                (corners[start, 0], corners[start, 1]),
-                (corners[end, 0], corners[end, 1]),
-                color,
-                thickness,
-                cv2.LINE_AA,
-            )
-    return img.astype(np.uint8)
-
-
-def draw_boxes_nuplan_on_img(gt_boxes_nuplan, cam_infos, eps=1e-3):
-    for cam_type, cam_info in cam_infos.items():
-        cur_img_path = cam_info["data_path"]
-        cur_img = cv2.imread(cur_img_path)
-        cur_img_h, cur_img_w = cur_img.shape[:2]
-
-        gt_boxes_cams = transformation.transform_nuplan_boxes_to_cam(
-            gt_boxes_nuplan,
-            cam_info["sensor2lidar_rotation"],
-            cam_info["sensor2lidar_translation"],
-        )
-
-        # Then convert gt_boxes_cams to corners.
-        cur_locs, cur_dims, cur_rots = (
-            gt_boxes_cams[:, :3],
-            gt_boxes_cams[:, 3:6],
-            gt_boxes_cams[:, 6:],
-        )
-        corners_norm = np.stack(np.unravel_index(np.arange(8), [2] * 3), axis=1)
-        corners_norm = corners_norm[[0, 1, 3, 2, 4, 5, 7, 6]]
-        corners_norm = corners_norm - np.array([0.5, 0.5, 0.5])
-        corners = cur_dims.reshape([-1, 1, 3]) * corners_norm.reshape([1, 8, 3])
-        corners = rotation_3d_in_axis(corners, cur_rots.squeeze(-1), axis=1)
-        corners += cur_locs.reshape(-1, 1, 3)
-
-        # Then draw project corners to image.
-        corners_img, corners_pc_in_fov = transformation.transform_cam_to_img(
-            corners.reshape(-1, 3), cam_info["cam_intrinsic"], img_shape=(cur_img_h, cur_img_w)
-        )
-        corners_img = corners_img.reshape(-1, 8, 2)
-        corners_pc_in_fov = corners_pc_in_fov.reshape(-1, 8)
-        valid_corners = corners_pc_in_fov.all(-1)
-        corners_img = corners_img[valid_corners]
-        cur_img = plot_rect3d_on_img(cur_img, len(corners_img), corners_img)
-        cv2.imwrite(f"dbg/{cam_type}.png", cur_img)
-    return None

openscene-v1.1/process_data/process.sh

@@ -1,32 +0,0 @@
-# Scripts for processing nuplan data.
-# export PYTHONPATH=/cpfs01/user/yangzetong/code/workshop_codes/nuplan-devkit:${PYTHONPATH}
-
-
-# export NUPLAN_DATA_ROOT="$HOME/nuplan/dataset/"
-# export NUPLAN_MAPS_ROOT="$HOME/nuplan/dataset/maps"
-# export NUPLAN_EXP_ROOT="$HOME/nuplan/exp"
-# export NUPLAN_DEVKIT_ROOT="$HOME/nuplan-devkit/"
-
-# 0. Design nuPlan data path, and output data path.
-NUPLAN_PATH=$HOME/nuplan/dataset/nuplan-v1.1/
-NUPLAN_DB_PATH=$NUPLAN_PATH/splits/mini
-NUPLAN_SENSOR_PATH=${NUPLAN_PATH}/sensor_blobs
-NUPLAN_MAP_VERSION=nuplan-maps-v1.0
-NUPLAN_MAPS_ROOT=${HOME}/nuplan/dataset/maps
-
-OUT_DIR=/home/daniel/navsim_logs/mini
-
-# 1. TODO: Generate train/val pickle.
-python $NAVSIM_DEVKIT_ROOT/navsim/common/extraction/create_nuplan_data_with_vis.py \
-  --nuplan-root-path ${NUPLAN_PATH} \
-  --nuplan-db-path ${NUPLAN_DB_PATH} \
-  --nuplan-sensor-path ${NUPLAN_SENSOR_PATH} \
-  --nuplan-map-version ${NUPLAN_MAP_VERSION} \
-  --nuplan-map-root ${NUPLAN_MAPS_ROOT} \
-  --out-dir ${OUT_DIR} \
-  --split mini \
-  --thread-num 16
-
-# 2. TODO: Extract Data Files from the generated pickle file.
-
-# 3. TODO: Soft-link to some place similar to https://github.com/OpenDriveLab/OpenScene/blob/main/docs/dataset_stats.md#filesystem-hierarchy