diff --git a/README.md b/README.md index b02f5c3f..68860008 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ Welcome to the devkit of the [nuScenes](https://www.nuscenes.org) dataset. - [Dataset download](#dataset-download) - [Devkit setup](#devkit-setup) - [Getting started](#getting-started) +- [Frequently asked questions](#frequently-asked-questions) - [Setting up a new virtual environment](#setting-up-a-new-virtual-environment) ## Changelog @@ -57,11 +58,13 @@ In case you want to avoid downloading and setting up the data, you can also take Github](https://github.com/nutonomy/nuscenes-devkit/blob/master/python-sdk/tutorial.ipynb). To learn more about the dataset, go to [nuScenes.org](https://www.nuscenes.org) or take a look at the [database schema](https://github.com/nutonomy/nuscenes-devkit/blob/master/schema.md) and [annotator instructions](https://github.com/nutonomy/nuscenes-devkit/blob/master/instructions.md). ## Frequently asked questions -- *How come some objects visible in the camera images are not annotated?* In the [annotator instructions](https://github.com/nutonomy/nuscenes-devkit/blob/master/instructions.md) we specify that an object should only be annotated if it is covered by at least one LIDAR point. This is done to have precise location annotations, speedup the annotation process and remove faraway objects. +1) *How come some objects visible in the camera images are not annotated?* In the [annotator instructions](https://github.com/nutonomy/nuscenes-devkit/blob/master/instructions.md) we specify that an object should only be annotated if it is covered by at least one LIDAR point. This is done to have precise location annotations, speedup the annotation process and remove faraway objects. -- *I have found an incorrect annotation. Can you correct it?* Please make sure that the annotation is indeed incorrect according to the [annotator instructions](https://github.com/nutonomy/nuscenes-devkit/blob/master/instructions.md). Then send an email to nuScenes@nutonomy.com. +2) *I have found an incorrect annotation. Can you correct it?* Please make sure that the annotation is indeed incorrect according to the [annotator instructions](https://github.com/nutonomy/nuscenes-devkit/blob/master/instructions.md). Then send an email to nuScenes@nutonomy.com. -- *How can I use the RADAR data?* We recently [added features to parse and visualize RADAR point-clouds](https://github.com/nutonomy/nuscenes-devkit/pull/6). More visualization tools will follow. +3) *How can I use the RADAR data?* We recently [added features to parse and visualize RADAR point-clouds](https://github.com/nutonomy/nuscenes-devkit/pull/6). More visualization tools will follow. + +4) *Why are there less sample pointclouds than samples?* See [this issue](https://github.com/nutonomy/nuscenes-devkit/issues/8). Scenes 169 and 170 overlap and going forward we will remove scene 169. ## Setting up a new virtual environment diff --git a/python-sdk/export/export_egoposes_on_map.py b/python-sdk/export/export_egoposes_on_map.py new file mode 100644 index 00000000..8b876e16 --- /dev/null +++ b/python-sdk/export/export_egoposes_on_map.py @@ -0,0 +1,24 @@ +""" +Exports an image for each map location with all the ego poses drawn on the map. +""" +import os + +import matplotlib.pyplot as plt +import numpy as np + +from nuscenes_utils.nuscenes import NuScenes + +# Load NuScenes class +nusc = NuScenes() +locations = np.unique([l['location'] for l in nusc.log]) + +# Create output directory +out_dir = os.path.expanduser('~/nuscenes-visualization/map-poses') +if not os.path.isdir(out_dir): + os.makedirs(out_dir) + +for location in locations: + nusc.render_egoposes_on_map(log_location=location) + out_path = os.path.join(out_dir, 'egoposes-%s.png' % location) + plt.tight_layout() + plt.savefig(out_path) \ No newline at end of file diff --git a/python-sdk/examples/export_pointclouds_as_obj.py b/python-sdk/export/export_pointclouds_as_obj.py similarity index 82% rename from python-sdk/examples/export_pointclouds_as_obj.py rename to python-sdk/export/export_pointclouds_as_obj.py index 43befb90..a2c0974f 100644 --- a/python-sdk/examples/export_pointclouds_as_obj.py +++ b/python-sdk/export/export_pointclouds_as_obj.py @@ -1,3 +1,8 @@ +""" +Export fused point clouds of a scene to a Wavefront OBJ file. +This point-cloud can be viewed in your favorite 3D rendering tool, e.g. Meshlab or Maya. +""" + import os import os.path as osp import argparse @@ -10,22 +15,19 @@ from nuscenes_utils.data_classes import PointCloud from nuscenes_utils.geometry_utils import view_points -from nuscenes_utils.nuscenes import NuScenes, NuScenesExplorer +from nuscenes_utils.nuscenes import NuScenes -def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_token: str, channel: str='LIDAR_TOP', +def export_scene_pointcloud(nusc: NuScenes, out_path: str, scene_token: str, channel: str='LIDAR_TOP', min_dist: float=3.0, max_dist: float=30.0, verbose: bool=True) -> None: """ - Export fused point clouds of a scene to a Wavefront OBJ file. - This point-cloud can be viewed in your favorite 3D rendering tool, e.g. Meshlab or Maya. - :param explorer: NuScenesExplorer instance. + :param nusc: NuScenes instance. :param out_path: Output path to write the point-cloud to. :param scene_token: Unique identifier of scene to render. :param channel: Channel to render. :param min_dist: Minimum distance to ego vehicle below which points are dropped. :param max_dist: Maximum distance to ego vehicle above which points are dropped. :param verbose: Whether to print messages to stdout. - :return: """ # Check inputs. @@ -35,15 +37,15 @@ def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_tok assert channel in valid_channels, 'Input channel {} not valid.'.format(channel) # Get records from DB. - scene_rec = explorer.nusc.get('scene', scene_token) - start_sample_rec = explorer.nusc.get('sample', scene_rec['first_sample_token']) - sd_rec = explorer.nusc.get('sample_data', start_sample_rec['data'][channel]) + scene_rec = nusc.get('scene', scene_token) + start_sample_rec = nusc.get('sample', scene_rec['first_sample_token']) + sd_rec = nusc.get('sample_data', start_sample_rec['data'][channel]) # Make list of frames cur_sd_rec = sd_rec sd_tokens = [] while cur_sd_rec['next'] != '': - cur_sd_rec = explorer.nusc.get('sample_data', cur_sd_rec['next']) + cur_sd_rec = nusc.get('sample_data', cur_sd_rec['next']) sd_tokens.append(cur_sd_rec['token']) # Write point-cloud. @@ -53,11 +55,11 @@ def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_tok for sd_token in tqdm(sd_tokens): if verbose: print('Processing {}'.format(sd_rec['filename'])) - sc_rec = explorer.nusc.get('sample_data', sd_token) - sample_rec = explorer.nusc.get('sample', sc_rec['sample_token']) + sc_rec = nusc.get('sample_data', sd_token) + sample_rec = nusc.get('sample', sc_rec['sample_token']) lidar_token = sd_rec['token'] - lidar_rec = explorer.nusc.get('sample_data', lidar_token) - pc = PointCloud.from_file(osp.join(explorer.nusc.dataroot, lidar_rec['filename'])) + lidar_rec = nusc.get('sample_data', lidar_token) + pc = PointCloud.from_file(osp.join(nusc.dataroot, lidar_rec['filename'])) # Get point cloud colors. coloring = np.ones((3, pc.points.shape[1])) * -1 @@ -68,7 +70,7 @@ def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_tok # Points live in their own reference frame. So they need to be transformed via global to the image plane. # First step: transform the point cloud to the ego vehicle frame for the timestamp of the sweep. - cs_record = explorer.nusc.get('calibrated_sensor', lidar_rec['calibrated_sensor_token']) + cs_record = nusc.get('calibrated_sensor', lidar_rec['calibrated_sensor_token']) pc.rotate(Quaternion(cs_record['rotation']).rotation_matrix) pc.translate(np.array(cs_record['translation'])) @@ -81,7 +83,7 @@ def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_tok print('Distance filter: Keeping %d of %d points...' % (keep.sum(), len(keep))) # Second step: transform to the global frame. - poserecord = explorer.nusc.get('ego_pose', lidar_rec['ego_pose_token']) + poserecord = nusc.get('ego_pose', lidar_rec['ego_pose_token']) pc.rotate(Quaternion(poserecord['rotation']).rotation_matrix) pc.translate(np.array(poserecord['translation'])) @@ -94,13 +96,14 @@ def export_scene_pointcloud(explorer: NuScenesExplorer, out_path: str, scene_tok f.write("v {v[0]:.8f} {v[1]:.8f} {v[2]:.8f} {c[0]:.4f} {c[1]:.4f} {c[2]:.4f}\n".format(v=v, c=c/255.0)) if not sd_rec['next'] == "": - sd_rec = explorer.nusc.get('sample_data', sd_rec['next']) + sd_rec = nusc.get('sample_data', sd_rec['next']) -def pointcloud_color_from_image(nusc, pointsensor_token: str, camera_token: str) -> Tuple[np.array, np.array]: +def pointcloud_color_from_image(nusc: NuScenes, pointsensor_token: str, camera_token: str) -> Tuple[np.array, np.array]: """ Given a point sensor (lidar/radar) token and camera sample_data token, load point-cloud and map it to the image plane, then retrieve the colors of the closest image pixels. + :param nusc: NuScenes instance. :param pointsensor_token: Lidar/radar sample_data token. :param camera_token: Camera sample data token. :return (coloring , mask ). Returns the colors for n points that reproject into the @@ -165,10 +168,10 @@ def pointcloud_color_from_image(nusc, pointsensor_token: str, camera_token: str) parser = argparse.ArgumentParser(description='Export a scene in Wavefront point cloud format.', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--scene', default='scene-0061', type=str, help='Name of a scene, e.g. scene-0061') - parser.add_argument('--out_dir', default='', type=str, help='Output folder') + parser.add_argument('--out_dir', default='~/nuscenes-visualization/pointclouds', type=str, help='Output folder') parser.add_argument('--verbose', default=0, type=int, help='Whether to print outputs to stdout') args = parser.parse_args() - out_dir = args.out_dir + out_dir = os.path.expanduser(args.out_dir) scene_name = args.scene verbose = bool(args.verbose) @@ -188,4 +191,4 @@ def pointcloud_color_from_image(nusc, pointsensor_token: str, camera_token: str) scene_tokens = [s['token'] for s in nusc.scene if s['name'] == scene_name] assert len(scene_tokens) == 1, 'Error: Invalid scene %s' % scene_name - export_scene_pointcloud(nusc.explorer, out_path, scene_tokens[0], channel='LIDAR_TOP', verbose=verbose) + export_scene_pointcloud(nusc, out_path, scene_tokens[0], channel='LIDAR_TOP', verbose=verbose) diff --git a/python-sdk/export/export_scene_videos.py b/python-sdk/export/export_scene_videos.py new file mode 100644 index 00000000..cf1c353c --- /dev/null +++ b/python-sdk/export/export_scene_videos.py @@ -0,0 +1,23 @@ +""" +Exports a video of each scene (with annotations) to disk. +""" +import os + +from nuscenes_utils.nuscenes import NuScenes + +# Load NuScenes class +nusc = NuScenes() +scene_tokens = [s['token'] for s in nusc.scene] + +# Create output directory +out_dir = os.path.expanduser('~/nuscenes-visualization/scene-videos') +if not os.path.isdir(out_dir): + os.makedirs(out_dir) + +# Write videos to disk +for scene_token in scene_tokens: + scene = nusc.get('scene', scene_token) + print('Writing scene %s' % scene['name']) + out_path = os.path.join(out_dir, scene['name']) + '.avi' + if not os.path.exists(out_path): + nusc.render_scene(scene['token'], out_path=out_path) \ No newline at end of file diff --git a/python-sdk/nuscenes_utils/data_classes.py b/python-sdk/nuscenes_utils/data_classes.py index 65d9857c..549110af 100644 --- a/python-sdk/nuscenes_utils/data_classes.py +++ b/python-sdk/nuscenes_utils/data_classes.py @@ -3,27 +3,29 @@ # Licensed under the Creative Commons [see licence.txt] from __future__ import annotations - import struct +from typing import Tuple, List import cv2 import numpy as np from pyquaternion import Quaternion +from matplotlib.axes import Axes from nuscenes_utils.geometry_utils import view_points class PointCloud: - def __init__(self, points): + def __init__(self, points: np.ndarray): """ Class for manipulating and viewing point clouds. :param points: . Input point cloud matrix. """ + assert points.shape[0] == 4, 'Error: Pointcloud points must have format: 4 x n' self.points = points @staticmethod - def load_numpy_bin(file_name): + def load_numpy_bin(file_name: str) -> np.ndarray: """ Loads LIDAR data from binary numpy format. Data is stored as (x, y, z, intensity, ring index). :param file_name: The path of the pointcloud file. @@ -34,14 +36,15 @@ def load_numpy_bin(file_name): return points.T @staticmethod - def load_pcd_bin(file_name): + def load_pcd_bin(file_name: str) -> np.ndarray: """ Loads RADAR data from a Point Cloud Data file to a list of lists (=points) and meta data. Example of the header fields: # .PCD v0.7 - Point Cloud Data file format VERSION 0.7 - FIELDS x y z dyn_prop id rcs vx vy vx_comp vy_comp is_quality_valid ambig_state x_rms y_rms invalid_state pdh0 vx_rms vy_rms + FIELDS x y z dyn_prop id rcs vx vy vx_comp vy_comp is_quality_valid ambig_state x_rms y_rms invalid_state pdh0 + vx_rms vy_rms SIZE 4 4 4 1 2 4 4 4 4 4 1 1 1 1 1 1 1 1 TYPE F F F I I F F F F F I I I I I I I I COUNT 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 @@ -111,11 +114,10 @@ def load_pcd_bin(file_name): return points @classmethod - def from_file(cls, file_name): + def from_file(cls, file_name: str) -> PointCloud: """ Instantiate from a .pcl, .pdc, .npy, or .bin file. - :param file_name: . Path of the pointcloud file on disk. - :return: . + :param file_name: Path of the pointcloud file on disk. """ if file_name.endswith('.bin'): @@ -127,27 +129,25 @@ def from_file(cls, file_name): return cls(points) - def nbr_points(self): + def nbr_points(self) -> int: """ Returns the number of points. - :return: . Number of points. + :return: Number of points. """ return self.points.shape[1] - def subsample(self, ratio): + def subsample(self, ratio: float) -> None: """ Sub-samples the pointcloud. - :param ratio: . Fraction to keep. - :return: . + :param ratio: Fraction to keep. """ selected_ind = np.random.choice(np.arange(0, self.nbr_points()), size=int(self.nbr_points() * ratio)) self.points = self.points[:, selected_ind] - def remove_close(self, radius): + def remove_close(self, radius: float) -> None: """ Removes point too close within a certain radius from origin. - :param radius: . - :return: . + :param radius: Radius below which points are removed. """ x_filt = np.abs(self.points[0, :]) < radius @@ -155,85 +155,82 @@ def remove_close(self, radius): not_close = np.logical_not(np.logical_and(x_filt, y_filt)) self.points = self.points[:, not_close] - def translate(self, x): + def translate(self, x: np.ndarray) -> None: """ Applies a translation to the point cloud. :param x: . Translation in x, y, z. - :return: . """ for i in range(3): self.points[i, :] = self.points[i, :] + x[i] - def rotate(self, rot_matrix): + def rotate(self, rot_matrix: np.ndarray) -> None: """ Applies a rotation. :param rot_matrix: . Rotation matrix. - :return: . """ self.points[:3, :] = np.dot(rot_matrix, self.points[:3, :]) - def transform(self, transf_matrix): + def transform(self, transf_matrix: np.ndarray) -> None: """ Applies a homogeneous transform. :param transf_matrix: . Homogenous transformation matrix. - :return: . """ self.points[:3, :] = transf_matrix.dot(np.vstack((self.points[:3, :], np.ones(self.nbr_points()))))[:3, :] - def render_height(self, ax, view=np.eye(4), x_lim=(-20, 20), y_lim=(-20, 20), marker_size=1): + def render_height(self, ax: Axes, view: np.ndarray=np.eye(4), x_lim: Tuple=(-20, 20), y_lim: Tuple=(-20, 20), + marker_size: float=1) -> None: """ Very simple method that applies a transformation and then scatter plots the points colored by height (z-value). - :param ax: . Axes on which to render the points. + :param ax: Axes on which to render the points. :param view: . Defines an arbitrary projection (n <= 4). - :param x_lim: (min , max ). - :param y_lim: (min , max ). - :param marker_size: . Marker size. - :return: . + :param x_lim: (min , max ). x range for plotting. + :param y_lim: (min , max ). y range for plotting. + :param marker_size: Marker size. """ self._render_helper(2, ax, view, x_lim, y_lim, marker_size) - def render_intensity(self, ax, view=np.eye(4), x_lim=(-20, 20), y_lim=(-20, 20), marker_size=1): + def render_intensity(self, ax: Axes, view: np.ndarray=np.eye(4), x_lim: Tuple=(-20, 20), y_lim: Tuple=(-20, 20), + marker_size: float=1) -> None: """ Very simple method that applies a transformation and then scatter plots the points colored by intensity. - :param ax: . Axes on which to render the points. + :param ax: Axes on which to render the points. :param view: . Defines an arbitrary projection (n <= 4). :param x_lim: (min , max ). :param y_lim: (min , max ). - :param marker_size: . Marker size. - :return: . + :param marker_size: Marker size. """ self._render_helper(3, ax, view, x_lim, y_lim, marker_size) - def _render_helper(self, color_channel, ax, view, x_lim, y_lim, marker_size): + def _render_helper(self, color_channel: int, ax: Axes, view: np.ndarray, x_lim: Tuple, y_lim: Tuple, + marker_size: float) -> None: """ Helper function for rendering. - :param color_channel: . - :param ax: . Axes on which to render the points. + :param color_channel: Point channel to use as color. + :param ax: Axes on which to render the points. :param view: . Defines an arbitrary projection (n <= 4). :param x_lim: (min , max ). :param y_lim: (min , max ). - :param marker_size: . Marker size. - :return: . + :param marker_size: Marker size. """ points = view_points(self.points[:3, :], view, normalize=False) ax.scatter(points[0, :], points[1, :], c=self.points[color_channel, :], s=marker_size) - ax.set_xlim(x_lim) - ax.set_ylim(y_lim) + ax.set_xlim(left=x_lim[0], right=x_lim[1]) + ax.set_ylim(left=y_lim[0], right=y_lim[1]) class Box: """ Simple data class representing a 3d box including, label, score and velocity. """ - def __init__(self, center, size, orientation, label=np.nan, score=np.nan, velocity=(np.nan, np.nan, np.nan), - name=None): + def __init__(self, center: List[float], size: List[float], orientation: Quaternion, label: int=np.nan, + score: float=np.nan, velocity: Tuple=(np.nan, np.nan, np.nan), name: str=None): """ - :param center: [: 3]. Center of box given as x, y, z. - :param size: [: 3]. Size of box in width, length, height. - :param orientation: . Box orientation. - :param label: . Integer label, optional. - :param score: . Classification score, optional. - :param velocity: [: 3]. Box velocity in x, y, z direction. - :param name: . Box name, optional. Can be used e.g. for denote category name. + :param center: Center of box given as x, y, z. + :param size: Size of box in width, length, height. + :param orientation: Box orientation. + :param label: Integer label, optional. + :param score: Classification score, optional. + :param velocity: Box velocity in x, y, z direction. + :param name: Box name, optional. Can be used e.g. for denote category name. """ assert not np.any(np.isnan(center)) assert not np.any(np.isnan(size)) @@ -269,55 +266,35 @@ def __repr__(self): self.wlh[1], self.wlh[2], self.orientation.axis[0], self.orientation.axis[1], self.orientation.axis[2], self.orientation.degrees, self.orientation.radians, self.velocity[0], self.velocity[1], self.velocity[2], self.name) - - def encode(self): - """ - Encodes the box instance to a JSON-friendly vector representation. - :return: [: 16]. List of floats encoding the box. - """ - return self.center.tolist() + self.wlh.tolist() + self.orientation.elements.tolist() + [ - self.label] + [self.score] + self.velocity.tolist() + [self.name] - - @classmethod - def decode(cls, data): - """ - Instantiates a Box instance from encoded vector representation. - :param data: [: 16]. Output from encode. - :return: . - """ - return Box(data[0:3], data[3:6], Quaternion(data[6:10]), label=data[10], score=data[11], velocity=data[12:15], - name=data[15]) - + @property def rotation_matrix(self) -> np.ndarray: """ Return a rotation matrix. - :return: . + :return: . The box's rotation matrix. """ return self.orientation.rotation_matrix - def translate(self, x): + def translate(self, x: np.ndarray) -> None: """ Applies a translation. :param x: . Translation in x, y, z direction. - :return: . """ self.center += x - def rotate(self, quaternion: Quaternion): + def rotate(self, quaternion: Quaternion) -> None: """ Rotates box. - :param quaternion: . Rotation to apply. - :return: . + :param quaternion: Rotation to apply. """ self.center = np.dot(quaternion.rotation_matrix, self.center) self.orientation = quaternion * self.orientation self.velocity = np.dot(quaternion.rotation_matrix, self.velocity) - def corners(self, wlh_factor: float=1.0): + def corners(self, wlh_factor: float=1.0) -> np.ndarray: """ Returns the bounding box corners. - :param wlh_factor: . Multiply w, l, h by a factor to inflate or deflate the box. + :param wlh_factor: Multiply w, l, h by a factor to scale the box. :return: . First four corners are the ones facing forward. The last four are the ones facing backwards. """ @@ -340,22 +317,23 @@ def corners(self, wlh_factor: float=1.0): return corners - def bottom_corners(self): + def bottom_corners(self) -> np.ndarray: """ Returns the four bottom corners. :return: . Bottom corners. First two face forward, last two face backwards. """ return self.corners()[:, [2, 3, 7, 6]] - def render(self, axis, view=np.eye(3), normalize=False, colors=('b', 'r', 'k'), linewidth=2): + def render(self, axis: Axes, view: np.ndarray=np.eye(3), normalize: bool=False, colors: Tuple=('b', 'r', 'k'), + linewidth: float=2): """ Renders the box in the provided Matplotlib axis. - :param axis: . Axis onto which the box should be drawn. + :param axis: Axis onto which the box should be drawn. :param view: . Define a projection in needed (e.g. for drawing projection in an image). - :param normalize: . Whether to normalize the remaining coordinate. + :param normalize: Whether to normalize the remaining coordinate. :param colors: (: 3). Valid Matplotlib colors ( or normalized RGB tuple) for front, back and sides. - :param linewidth: . Width in pixel of the box sides. + :param linewidth: Width in pixel of the box sides. """ corners = view_points(self.corners(), view, normalize=normalize)[:2, :] @@ -381,16 +359,15 @@ def draw_rect(selected_corners, color): [center_bottom[1], center_bottom_forward[1]], color=colors[0], linewidth=linewidth) - def render_cv2(self, im, view=np.eye(3), normalize=False, - colors=((0, 0, 255), (255, 0, 0), (155, 155, 155)), linewidth=2): + def render_cv2(self, im: np.ndarray, view: np.ndarray=np.eye(3), normalize: bool=False, + colors: Tuple=((0, 0, 255), (255, 0, 0), (155, 155, 155)), linewidth: float=2.0) -> None: """ Renders box using opencv2. :param im: . Image array. Channels are in BGR order. - :param view: . Define a projection in needed (e.g. for drawing projection in an image). - :param normalize: . Whether to normalize the remaining coordinate. + :param view: . Define a projection if needed (e.g. for drawing projection in an image). + :param normalize: Whether to normalize the remaining coordinate. :param colors: ((R, G, B), (R, G, B), (R, G, B)). Colors for front, side & rear. - :param linewidth: . Linewidth for plot. - :return: + :param linewidth: Linewidth for plot. """ corners = view_points(self.corners(), view, normalize=normalize)[:2, :] diff --git a/python-sdk/nuscenes_utils/geometry_utils.py b/python-sdk/nuscenes_utils/geometry_utils.py index e7957156..8eaaa1da 100644 --- a/python-sdk/nuscenes_utils/geometry_utils.py +++ b/python-sdk/nuscenes_utils/geometry_utils.py @@ -3,44 +3,44 @@ # Licensed under the Creative Commons [see licence.txt] from __future__ import annotations - -import numpy as np +from typing import Tuple import math from enum import IntEnum +import numpy as np + class BoxVisibility(IntEnum): """ Enumerates the various level of box visibility in an image """ ALL = 0 # Requires all corners are inside the image. ANY = 1 # Requires at least one corner visible in the image. NONE = 2 # Requires no corners to be inside, i.e. box can be fully outside the image. - IN_FRONT = 3 # Requires all corners to be 1 meter front of the camera AND at least one corner be visible in image. -def quaternion_slerp(q0, q1, fraction): +def quaternion_slerp(q0: np.ndarray, q1: np.ndarray, fraction: float) -> np.ndarray: """ Does interpolation between two quaternions. This code is modified from https://www.lfd.uci.edu/~gohlke/code/transformations.py.html :param q0: . First quaternion. :param q1: . Second quaternion. - :param fraction: . Interpolation fraction between 0 and 1. + :param fraction: Interpolation fraction between 0 and 1. :return: . Interpolated quaternion. """ - _EPS = np.finfo(float).eps * 4.0 + eps = np.finfo(float).eps * 4.0 if fraction == 0.0: return q0 elif fraction == 1.0: return q1 d = np.dot(q0, q1) - if abs(abs(d) - 1.0) < _EPS: + if abs(abs(d) - 1.0) < eps: return q0 if d < 0.0: # invert rotation d = -d np.negative(q1, q1) angle = math.acos(d) - if abs(angle) < _EPS: + if abs(angle) < eps: return q0 is_in = 1.0 / math.sin(angle) q0 *= math.sin((1.0 - fraction) * angle) * is_in @@ -49,7 +49,7 @@ def quaternion_slerp(q0, q1, fraction): return q0 -def view_points(points, view, normalize): +def view_points(points: np.ndarray, view: np.ndarray, normalize: bool) -> np.ndarray: """ This is a helper class that maps 3d points to a 2d plane. It can be used to implement both perspective and orthographic projections. It first applies the dot product between the points and the view. By convention, @@ -64,7 +64,7 @@ def view_points(points, view, normalize): :param points: Matrix of points, where each point (x, y, z) is along each column. :param view: . Defines an arbitrary projection (n <= 4). The projection should be such that the corners are projected onto the first 2 axis. - :param normalize: . Whether to normalize the remaining coordinate (along the third axis). + :param normalize: Whether to normalize the remaining coordinate (along the third axis). :return: . Mapped point. If normalize=False, the third coordinate is the height. """ @@ -88,14 +88,14 @@ def view_points(points, view, normalize): return points -def box_in_image(box, intrinsic, imsize, vis_level=BoxVisibility.IN_FRONT): +def box_in_image(box, intrinsic: np.ndarray, imsize: Tuple[int], vis_level: int=BoxVisibility.ANY) -> bool: """ Check if a box is visible inside an image without accounting for occlusions. - :param box: . + :param box: The box to be checked. :param intrinsic: . Intrinsic camera matrix. :param imsize: (width , height ). - :param vis_level: . One of the enumerations of . - :return . True if visibility condition is satisfied. + :param vis_level: One of the enumerations of . + :return True if visibility condition is satisfied. """ corners_3d = box.corners() @@ -106,15 +106,13 @@ def box_in_image(box, intrinsic, imsize, vis_level=BoxVisibility.IN_FRONT): visible = np.logical_and(visible, corners_img[1, :] > 0) visible = np.logical_and(visible, corners_3d[2, :] > 1) - in_front = corners_3d[2, :] > 1 # True if a corner is at least 1 meter in front of camera. + in_front = corners_3d[2, :] > 0.1 # True if a corner is at least 0.1 meter in front of the camera. if vis_level == BoxVisibility.ALL: - return all(visible) + return all(visible) and all(in_front) elif vis_level == BoxVisibility.ANY: - return any(visible) + return any(visible) and all(in_front) elif vis_level == BoxVisibility.NONE: return True - elif vis_level == BoxVisibility.IN_FRONT: - return any(visible) and all(in_front) else: raise ValueError("vis_level: {} not valid".format(vis_level)) diff --git a/python-sdk/nuscenes_utils/map_mask.py b/python-sdk/nuscenes_utils/map_mask.py index a2ad4f3c..6043afbf 100644 --- a/python-sdk/nuscenes_utils/map_mask.py +++ b/python-sdk/nuscenes_utils/map_mask.py @@ -3,19 +3,20 @@ # Licensed under the Creative Commons [see licence.txt] import os.path as osp +from typing import Tuple import numpy as np import cv2 class MapMask: - def __init__(self, img_file, precision=0.1, foreground=255, background=0): + def __init__(self, img_file: str, precision: float=0.1, foreground: int=255, background: int=0): """ Init a map mask object that contains the semantic prior (drivable surface and sidewalks) mask. - :param img_file: . File path to map png file. - :param precision: . Precision in meters. - :param foreground: . Foreground value. - :param background: . Background value. + :param img_file: File path to map png file. + :param precision: Precision in meters. + :param foreground: Foreground value. + :param background: Background value. """ assert osp.exists(img_file), 'map mask {} does not exist'.format(img_file) self.img_file = img_file @@ -27,10 +28,10 @@ def __init__(self, img_file, precision=0.1, foreground=255, background=0): self._transf_matrix = None # Transformation matrix from global coords to map coords. (lazy load). @property - def mask(self): + def mask(self) -> np.ndarray: """ Create binary mask from the png file. - :return: . + :return: . The binary mask. """ if self._mask is None: img = cv2.imread(self.img_file, cv2.IMREAD_GRAYSCALE) @@ -41,10 +42,10 @@ def mask(self): return self._mask @property - def transform_matrix(self): + def transform_matrix(self) -> np.ndarray: """ Generate transform matrix for this map mask. - :return: . + :return: . The transformation matrix. """ if self._transf_matrix is None: mask_shape = self.mask.shape @@ -54,10 +55,10 @@ def transform_matrix(self): return self._transf_matrix @property - def distance_mask(self): + def distance_mask(self) -> np.ndarray: """ Generate distance mask from self.mask which is the original mask from the png file. - :return: . + :return: . The distance mask. """ if self._distance_mask is None: # distance to nearest foreground in mask @@ -66,20 +67,19 @@ def distance_mask(self): return self._distance_mask - def export_to_png(self, filename='mask.png'): + def export_to_png(self, filename: str='mask.png') -> None: """ Export mask to png file. - :param filename: . Path to the png file. - :return: . + :param filename: Path to the png file. """ cv2.imwrite(filename=filename, img=self.mask) - def is_on_mask(self, x, y): + def is_on_mask(self, x: float, y: float) -> bool: """ Determine whether a point is on the semantic_prior mask. - :param x: . Global x. - :param y: . Global y. - :return: . + :param x: Global x. + :param y: Global y. + :return: Whether the points is on the mask. """ px, py = self.get_pixel(x, y) @@ -89,12 +89,12 @@ def is_on_mask(self, x, y): return self.mask[py, px] == self.foreground - def dist_to_mask(self, x, y): + def dist_to_mask(self, x: float, y:float) -> float: """ Get the distance of a point to the nearest foreground in perception GT semantic prior mask (dilated). - :param x: . Global x. - :param y: . Global y. - :return: . Distance to nearest foreground, if not in distance mask, return -1. + :param x: Global x. + :param y: Global y. + :return: Distance to nearest foreground, if not in distance mask, return -1. """ px, py = self.get_pixel(x, y) @@ -103,11 +103,11 @@ def dist_to_mask(self, x, y): return self.distance_mask[py, px] - def get_pixel(self, x, y): + def get_pixel(self, x: float, y: float) -> Tuple[int]: """ Get the image coordinates given a x-y point. - :param x: . Global x. - :param y: . Global y. + :param x: Global x. + :param y: Global y. :return: (px , py ). Pixel coordinates in map. """ px, py = int(x / self.precision), self.mask.shape[0] - int(y / self.precision) diff --git a/python-sdk/nuscenes_utils/nuscenes.py b/python-sdk/nuscenes_utils/nuscenes.py index 84c9d521..b2f5e6d2 100644 --- a/python-sdk/nuscenes_utils/nuscenes.py +++ b/python-sdk/nuscenes_utils/nuscenes.py @@ -17,6 +17,8 @@ from PIL import Image from matplotlib.axes import Axes from pyquaternion import Quaternion +import sklearn.metrics +from tqdm import tqdm from nuscenes_utils.map_mask import MapMask from nuscenes_utils.data_classes import PointCloud, Box @@ -189,7 +191,7 @@ def get_sample_data_path(self, sample_data_token: str) -> str: sd_record = self.get('sample_data', sample_data_token) return osp.join(self.dataroot, sd_record['filename']) - def get_sample_data(self, sample_data_token, box_vis_level=BoxVisibility.IN_FRONT, selected_anntokens=None) -> \ + def get_sample_data(self, sample_data_token, box_vis_level=BoxVisibility.ANY, selected_anntokens=None) -> \ Tuple[str, List[Box], np.array]: """ Returns the data path as well as all annotations related to that sample_data. @@ -322,15 +324,15 @@ def render_pointcloud_in_image(self, sample_token: str, dot_size: int=5, points self.explorer.render_pointcloud_in_image(sample_token, dot_size, pointsensor_channel=pointsensor_channel, camera_channel=camera_channel) - def render_sample(self, sample_token: str, box_vis_level: BoxVisibility=BoxVisibility.IN_FRONT) -> None: + def render_sample(self, sample_token: str, box_vis_level: BoxVisibility=BoxVisibility.ANY) -> None: self.explorer.render_sample(sample_token, box_vis_level) - def render_sample_data(self, sample_data_token: str, with_anns: bool=True, box_vis_level: BoxVisibility=3, - axes_limit: float=40, ax: Axes=None) -> None: + def render_sample_data(self, sample_data_token: str, with_anns: bool=True, + box_vis_level: BoxVisibility=BoxVisibility.ANY, axes_limit: float=40, ax: Axes=None) -> None: self.explorer.render_sample_data(sample_data_token, with_anns, box_vis_level, axes_limit, ax) def render_annotation(self, sample_annotation_token: str, margin: float=10, view: np.ndarray=np.eye(4), - box_vis_level: BoxVisibility=3) -> None: + box_vis_level: BoxVisibility=BoxVisibility.ANY) -> None: self.explorer.render_annotation(sample_annotation_token, margin, view, box_vis_level) def render_instance(self, instance_token: str) -> None: @@ -340,11 +342,11 @@ def render_scene(self, scene_token: str, freq: float=10, imsize: Tuple[float, fl out_path : str=None) -> None: self.explorer.render_scene(scene_token, freq, imsize, out_path) - def render_scene_channel(self, scene_token: str, channel: str='CAM_FRONT', imsize: Tuple[float, float] = (640, 360)): + def render_scene_channel(self, scene_token: str, channel: str='CAM_FRONT', imsize: Tuple[float, float]=(640, 360)): self.explorer.render_scene_channel(scene_token, channel=channel, imsize=imsize) - def render_scene_on_map(self, scene_token: str) -> None: - self.explorer.render_scene_on_map(scene_token) + def render_egoposes_on_map(self, log_location: str, scene_tokens: List=None, demo_ss_factor: float=2.0) -> None: + self.explorer.render_egoposes_on_map(log_location, scene_tokens, demo_ss_factor) class NuScenesExplorer: @@ -517,7 +519,7 @@ def render_pointcloud_in_image(self, sample_token: str, dot_size: int=5, pointse plt.scatter(points[0, :], points[1, :], c=coloring, s=dot_size) plt.axis('off') - def render_sample(self, token: str, box_vis_level: BoxVisibility=BoxVisibility.IN_FRONT) -> None: + def render_sample(self, token: str, box_vis_level: BoxVisibility=BoxVisibility.ANY) -> None: """ Render all LIDAR and camera sample_data in sample along with annotations. :param token: Sample token. @@ -541,8 +543,8 @@ def render_sample(self, token: str, box_vis_level: BoxVisibility=BoxVisibility.I axes.flatten()[-1].axis('off') plt.tight_layout() - def render_sample_data(self, sample_data_token: str, with_anns: bool=True, box_vis_level: BoxVisibility=3, - axes_limit: float=40, ax: Axes=None) -> None: + def render_sample_data(self, sample_data_token: str, with_anns: bool=True, + box_vis_level: BoxVisibility=BoxVisibility.ANY, axes_limit: float=40, ax: Axes=None) -> None: """ Render sample data onto axis. :param sample_data_token: Sample_data token. @@ -590,7 +592,7 @@ def render_sample_data(self, sample_data_token: str, with_anns: bool=True, box_v ax.set_aspect('equal') def render_annotation(self, anntoken: str, margin: float=10, view: np.ndarray=np.eye(4), - box_vis_level: BoxVisibility=3) -> None: + box_vis_level: BoxVisibility=BoxVisibility.ANY) -> None: """ Render selected annotation. :param anntoken: Sample_annotation token. @@ -728,7 +730,7 @@ def render_scene(self, scene_token: str, freq: float=10, imsize: Tuple[float, fl # Get annotations and params from DB. impath, boxes, camera_intrinsic = self.nusc.get_sample_data(sd_rec['token'], - box_vis_level=BoxVisibility.IN_FRONT) + box_vis_level=BoxVisibility.ANY) # Load and render if not osp.exists(impath): @@ -795,7 +797,7 @@ def render_scene_channel(self, scene_token: str, channel: str='CAM_FRONT', imsiz # Get data from DB impath, boxes, camera_intrinsic = self.nusc.get_sample_data(sd_rec['token'], - box_vis_level=BoxVisibility.IN_FRONT) + box_vis_level=BoxVisibility.ANY) # Load and render if not osp.exists(impath): @@ -824,56 +826,72 @@ def render_scene_channel(self, scene_token: str, channel: str='CAM_FRONT', imsiz cv2.destroyAllWindows() - def render_scene_on_map(self, scene_token: str) -> None: + def render_egoposes_on_map(self, log_location: str, scene_tokens: List=None, demo_ss_factor: float=2.0) \ + -> None: """ - Renders the ego poses for a scene on the map. Also counts the number of ego poses that were on the - semantic prior area (drivable surface + sidewalks). - :param scene_token: Unique identifier of scene to render. + Renders ego poses a the map. These can be filtered by location or scene. + :param log_location: Name of the location, e.g. "singapore-onenorth", "boston-seaport". + :param scene_tokens: Optional list of scene tokens. + :param demo_ss_factor: Subsampling factor for rendering the map. """ - _, axes = plt.subplots(1, 1, figsize=(10, 10)) + # Settings + close_dist = 100 + pixel_to_meter = 0.1 + ignore_logfiles = ['n008-2018-05-21-11-06-59-0400'] # Exclude older logs with incompatible maps - on_drivable_cnt = 0 + # Get logs by location + log_tokens = [l['token'] for l in self.nusc.log if l['location'] == log_location + and l['logfile'] not in ignore_logfiles] + assert len(log_tokens) > 0 - # Get records from NuScenes database. - scene_record = self.nusc.get('scene', scene_token) - log_record = self.nusc.get('log', scene_record['log_token']) - map_record = self.nusc.get('map', log_record['map_token']) + # Filter scenes + scene_tokens_location = [e['token'] for e in self.nusc.scene if e['log_token'] in log_tokens] + if scene_tokens is not None: + scene_tokens_location = [t for t in scene_tokens_location if t in scene_tokens] + if len(scene_tokens_location) == 0: + print('Warning: Found 0 valid scenes for location %s!' % log_location) - # map_record['mask'].mask holds a MapMask instance that we need below. - map_mask = map_record['mask'] + map_poses = [] - # Now draw the map mask + for scene_token in tqdm(scene_tokens_location): - # For the purpose of this demo, subsample the mask by a factor of 25. - demo_ss_factor = 25.0 - mask = Image.fromarray(map_mask.mask) - axes.imshow(mask.resize((int(mask.size[0]/demo_ss_factor), int(mask.size[1]/demo_ss_factor)), - resample=Image.NEAREST)) - title = '{}'.format(scene_record['name']) - axes.set_title(title) + # Get records from the database. + scene_record = self.nusc.get('scene', scene_token) + log_record = self.nusc.get('log', scene_record['log_token']) + map_record = self.nusc.get('map', log_record['map_token']) + map_mask = map_record['mask'] - # For each sample in the scene, plot the ego pose. - sample_tokens = self.nusc.field2token('sample', 'scene_token', scene_token) - for sample_token in sample_tokens: - sample_record = self.nusc.get('sample', sample_token) + # For each sample in the scene, store the ego pose. + sample_tokens = self.nusc.field2token('sample', 'scene_token', scene_token) + for sample_token in sample_tokens: + sample_record = self.nusc.get('sample', sample_token) - # Poses are associated with the sample_data. Here we use the LIDAR_TOP sample_data. - sample_data_record = self.nusc.get('sample_data', sample_record['data']['LIDAR_TOP']) + # Poses are associated with the sample_data. Here we use the lidar sample_data. + sample_data_record = self.nusc.get('sample_data', sample_record['data']['LIDAR_TOP']) + pose_record = self.nusc.get('ego_pose', sample_data_record['ego_pose_token']) - pose_record = self.nusc.get('ego_pose', sample_data_record['ego_pose_token']) + # Recover the ego pose. A 1 is added at the end to make it homogenous coordinates. + pose = np.array(pose_record['translation'] + [1]) - # Recover the ego pose. A 1 is added at the end to make it homogenous coordinates. - pose = np.array(pose_record['translation'] + [1]) + # Calculate the pose on the map. + map_pose = np.dot(map_mask.transform_matrix, pose) + map_pose = map_pose[:2] + map_poses.append(map_pose) - # Calculate the pose on the map. - map_pose = np.dot(map_mask.transform_matrix, pose) + # Compute number of close ego poses. + map_poses = np.vstack(map_poses) + dists = sklearn.metrics.pairwise.euclidean_distances(map_poses * pixel_to_meter) + close_poses = np.sum(dists < close_dist, axis=0) - # Plot - axes.plot(map_pose[0] / demo_ss_factor, map_pose[1] / demo_ss_factor, 'b.') - - # Check if outside semantic prior area. - on_drivable_cnt += map_mask.is_on_mask(pose[0], pose[1]) - - print('For scene {}, {} ego poses ({:.1f}%) were on the semantic prior area'.format( - scene_record['name'], on_drivable_cnt, 100*on_drivable_cnt/len(sample_tokens))) + # Plot. + _, ax = plt.subplots(1, 1, figsize=(10, 10)) + mask = Image.fromarray(map_mask.mask) + ax.imshow(mask.resize((int(mask.size[0] / demo_ss_factor), int(mask.size[1] / demo_ss_factor)), resample=Image.NEAREST)) + title = 'Number of ego poses within {}m in {}'.format(close_dist, log_location) + ax.set_title(title, color='w') + sc = ax.scatter(map_poses[:, 0] / demo_ss_factor, map_poses[:, 1] / demo_ss_factor, s=10, c=close_poses) + color_bar = plt.colorbar(sc, fraction=0.025, pad=0.04) + plt.rcParams['figure.facecolor'] = 'black' + color_bar_ticklabels = plt.getp(color_bar.ax.axes, 'yticklabels') + plt.setp(color_bar_ticklabels, color='w') \ No newline at end of file diff --git a/python-sdk/tutorial.ipynb b/python-sdk/tutorial.ipynb index 0dd71307..beaa0d1a 100644 --- a/python-sdk/tutorial.ipynb +++ b/python-sdk/tutorial.ipynb @@ -37,10 +37,10 @@ "304715 sample_data,\n", "99952 sample_annotation,\n", "12 map,\n", - "Done loading in 4.3 seconds.\n", + "Done loading in 2.8 seconds.\n", "======\n", "Reverse indexing ...\n", - "Done reverse indexing in 1.3 seconds.\n", + "Done reverse indexing in 0.7 seconds.\n", "======\n" ] } @@ -814,7 +814,7 @@ "# These lines are commented as they run more smoothly from the command line. \n", "\n", "# Let's grab scene 0043, it is nice and dense.\n", - "my_scene_token = nusc.field2token('scene', 'name', 'scene-0043')[0]\n", + "# my_scene_token = nusc.field2token('scene', 'name', 'scene-0043')[0] # UNCOMMENT\n", "# nusc.render_scene_channel(my_scene_token, 'CAM_FRONT') # UNCOMMENT" ] }, @@ -831,21 +831,21 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "For scene scene-0043, 39 ego poses (100.0%) were on the semantic prior area\n" + "100%|██████████| 79/79 [00:13<00:00, 5.82it/s]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -855,8 +855,8 @@ } ], "source": [ - "# Finally, we can also see where on the map this scene was captured:\n", - "nusc.render_scene_on_map(my_scene_token)" + "# Finally, let us visualize all scenes on the map for a particular location\n", + "nusc.render_egoposes_on_map(log_location='singapore-onenorth')" ] }, { @@ -864,9 +864,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "" - ] + "source": [] } ], "metadata": { @@ -878,7 +876,7 @@ "language_info": { "codemirror_mode": { "name": "ipython", - "version": 3.0 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", @@ -889,5 +887,5 @@ } }, "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file + "nbformat_minor": 1 +} diff --git a/requirements.txt b/requirements.txt index 90ec6585..87706878 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,5 @@ numpy==1.14.5 opencv-python==3.4.2.17 Pillow==5.2.0 pyquaternion==0.9.2 +scikit-learn==0.19.2 tqdm==4.25.0 diff --git a/schema.md b/schema.md index d52469f4..84955309 100644 --- a/schema.md +++ b/schema.md @@ -18,7 +18,7 @@ attribute --------- An attribute is a property of an instance that can change while the category remains the same. - Example: vehicle pose, and whether or not a bicycle has a rider. + Example: a vehicle being parked/stopped/moving, and whether or not a bicycle has a rider. ``` attribute { "token": -- Unique record identifier. @@ -65,27 +65,26 @@ sensor { calibrated_sensor --------- -Definition of a particular sensor as calibrated on a particular vehicle. All extrinsic parameters are +Definition of a particular sensor (lidar/radar/camera) as calibrated on a particular vehicle. All extrinsic parameters are given with respect to the ego vehicle body frame. ``` calibrated_sensor { "token": -- Unique record identifier. "sensor_token": -- Foreign key pointing to the sensor type. "translation": [3] -- Coordinate system origin: x, y, z. - "rotation": [4] -- Coordinate system orientation in quaternions. - "camera_intrinsic": [3, 3] -- Intrinsic camera calibration matrix. - "camera_distortion": [*] -- Distortion per convention of the CalTech camera calibration toolbox. Can be 5-10 coefficients. + "rotation": [4] -- Coordinate system orientation as quaternion: w, x, y, z. + "camera_intrinsic": [3, 3] -- Intrinsic camera calibration + rectification matrix. Empty for sensors that are not cameras. } ``` ego_pose --------- -Ego vehicle pose at a particular timestamp. Given with respect to global coordinate system. +Ego vehicle pose at a particular timestamp. Given with respect to global coordinate system of the log's map. ``` ego_pose { "token": -- Unique record identifier. "translation": [3] -- Coordinate system origin: x, y, z. - "rotation": [4] -- Coordinate system orientation in quaternions. + "rotation": [4] -- Coordinate system orientation as quaternion: w, x, y, z. "timestamp": -- Unix time stamp. } ``` @@ -135,7 +134,7 @@ sample { sample_data --------- -A sensor data e.g. image, point cloud, radar return. For sample_data with is_key_frame=True, the time-stamps +A sensor data e.g. image, point cloud or radar return. For sample_data with is_key_frame=True, the time-stamps should be very close to the sample it points to. For non key-frames the sample_data points to the sample that follows closest in time. ``` @@ -157,8 +156,8 @@ sample_data { sample_annotation --------- -A geometry defining the position of an object seen in a sample. All location data is given with respect -to the world coordinate system. +A bounding box defining the position of an object seen in a sample. All location data is given with respect +to the global coordinate system. ``` sample_annotation { "token": -- Unique record identifier. @@ -168,7 +167,7 @@ sample_annotation { "visibility_token": -- Foreign key. Visibility may also change over time. "translation": [3] -- Bounding box location as center_x, center_y, center_z. "size": [3] -- Bounding box size as width, length, height. - "rotation": [4] -- Bounding box orientation in quaternions. + "rotation": [4] -- Bounding box orientation as quaternion: w, x, y, z. "next": -- Foreign key. Sample annotation from the same object instance that follows this in time. Empty if this is the last annotation for this object. "prev": -- Foreign key. Sample annotation from the same object instance that precedes this in time. Empty if this is the first annotation for this object. } @@ -176,12 +175,12 @@ sample_annotation { map --------- -Map data that is stored as binary semantic masks from a top-down view. +Map data that is stored as binary semantic masks from a top-down view. As the maps are updated regularly, there may be multiple versions for the same location. In that case the ego_poses of logs with different maps cannot be compared. ``` map { "token": -- Unique record identifier. "log_token": -- Foreign key. - "category": -- Map category, e.g. semantic_prior for drivable surface and sidewalk + "category": -- Map category, currently only semantic_prior for drivable surface and sidewalk "filename": -- Relative path to the file with the map mask. } ```