Merge pull request #15 from scaleapi/nisse-data-loader5

Nisse data loader5

Author: nisseknudsen

README.md

@@ -50,35 +50,26 @@ seq002 = dataset['002']
 
 #### Loading
 The devkit will automatically search the sequence directory for available sensor and meta data and prepare the path for a loading step. At this point no point clouds or images have been loaded into memory.
-To execute the loading of sensor and meta data into memory, we simply call the `load()` method on the sequence object. This will load all available sensor and meta data. If only specific sensors or meta data is required, there are more specific methods available.
+To execute the loading of sensor and meta data into memory, we simply call the `load()` method on the sequence object. This will load all available sensor and meta data. If only specific sensors or meta data is required, there are more specific methods available which can also be chained to each other.
 ```python
 seq002.load()
 
 # OR
 
-seq002.load_lidar()
-seq002.load_camera()
-seq002.load_gps_poses()
-seq002.load_timestamps()
-seq002.load_cuboids()
-```
-
-Since not everybody might want to work with full sampling rate, each of the `load()` methods accept a _3-tuple_ which serves as a slicing information. In the following example, we want every second frame between frame 10 and frame 50 loaded. It is equivalent to slicing a python array using `my_array[10:50:2]`.
-```python
-seq002.load((10, 50, 2))
+seq002.load_lidar().load_cuboids()
 ```
 
 #### Data Access
 
 ##### LiDAR
 The LiDAR point clouds are stored as [pandas.DataFrames](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html#pandas.DataFrame) and therefore allow to leverage their extensive API for data manipulation. This includes the simple return as a [numpy.ndarray](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html).
 ```python
-pc0 = seq002.lidar.data[0]
+pc0 = seq002.lidar[0]
 print(pc0.columns) # Index(['x', 'y', 'z', 'i', 't', 'd'], dtype='object')
 
-pc0_np = seq002.lidar.data[0].to_numpy()
+pc0_np = seq002.lidar[0].to_numpy()
 # OR
-pc0_np = seq002.lidar.data[0].values
+pc0_np = seq002.lidar[0].values
 ```
 
 ##### Cameras
@@ -89,7 +80,7 @@ print(seq002.camera.keys()) # ['front_camera', 'left_camera', 'back_camera', 'r
 Each camera name has its recordings loaded as [Pillow Image](https://pillow.readthedocs.io/en/stable/reference/Image.html) object, and can be accessed via normal list slicing. In the following example, we select the first image from the front camera and display it using the Pillow library in Python.
 ```python
 front_camera = seq002.camera['front_camera']
-img0 = front_camera.data[0]
+img0 = front_camera[0]
 img0.show()
 ```
 Afterwards the extensive Pillow Image API can be used for image manipulation, conversion or export.
@@ -101,18 +92,18 @@ In addition to the sensor data, the loaded data set also contains the following
 
 These can be directly accessed through the known list slicing operations, and read in their dict format. For example, the following example shows how to get the GPS coordinates of the vehicle on the first frame.
 ```python
-pose0 = seq002.gps_poses.data[0]
+pose0 = seq002.gps[0]
 lat0 = pose0['lat']
 long0 = pose0['long']
 ```
 
 #### Annotations
 
 The LiDAR Cuboid annotations are also stored inside the sequence object as a [pandas.DataFrames](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html#pandas.DataFrame) for each timestamp.
-The position coordinates (`positin.x`,`position.y`,`position.z`) are located at the center of a cuboid. `dimensions.x` is the width of the cuboid from left to right, `dimensions.y` is the length of the cuboid from front to back and `dimensions.z` is the height of the cuboid from top to bottom.
+The position coordinates (`position.x`,`position.y`,`position.z`) are located at the center of a cuboid. `dimensions.x` is the width of the cuboid from left to right, `dimensions.y` is the length of the cuboid from front to back and `dimensions.z` is the height of the cuboid from top to bottom.
 
 ```python
-cuboids0 = seq002.cuboids.data[0]
+cuboids0 = seq002.cuboids[0]
 print(cuboids0.columns) # Index(['uuid', 'label', 'yaw', 'stationary', 'camera_used', 'position.x', 'position.y', 'position.z', 'dimensions.x', 'dimensions.y', 'dimensions.z', 'attributes.Object Motion', 'attributes.Rider Status', 'attributes.Pedestrian Behavior', 'attributes.Pedestrian Age'], dtype='object')
 ```
 

python/pandaset/annotations.py

@@ -1,4 +1,5 @@
 import glob
+
 import pandas as pd
 
 
@@ -9,6 +10,9 @@ def __init__(self, directory):
  self.data = None
  self._load_data_structure()
 
+ def __getitem__(self, item):
+ return self.data[item]
+
  def _load_data_structure(self):
  self._data_structure = sorted(glob.glob(f'{self._directory}/*.pkl.gz'))
 

python/pandaset/dataset.py

@@ -1,5 +1,5 @@
-from .utils import subdirectories
 from .sequence import Sequence
+from .utils import subdirectories
 
 
 class DataSet:

python/pandaset/meta.py

@@ -1,46 +1,40 @@
-import os.path
 import json
+import os.path
 
 
-class GPSPoses:
- def __init__(self, directory):
+class Meta:
+ def __init__(self, directory, filename):
  self._directory = directory
  self._data_structure = None
  self.data = None
  self._load_data_structure()
 
+ def __getitem__(self, item):
+ return self.data[item]
+
+ def load(self):
+ self._load_data()
+
  def _load_data_structure(self):
- meta_file = f'{self._directory}/gps_poses.json'
+ meta_file = f'{self._directory}/{self.filename}'
  if os.path.isfile(meta_file):
  self._data_structure = meta_file
 
- def load_data(self, sl):
+ def _load_data(self):
  self.data = []
  with open(self._data_structure, 'r') as f:
  file_data = json.load(f)
- for entry in file_data[sl]:
+ for entry in file_data:
  self.data.append(
  entry
  )
 
 
-class Timestamps:
+class GPS(Meta):
  def __init__(self, directory):
- self._directory = directory
- self._data_structure = None
- self.data = None
- self._load_data_structure()
+ Meta.__init__(self, directory, 'gps.json')
 
- def _load_data_structure(self):
- meta_file = f'{self._directory}/timestamps.json'
- if os.path.isfile(meta_file):
- self._data_structure = meta_file
 
- def load_data(self, sl):
- self.data = []
- with open(self._data_structure, 'r') as f:
- file_data = json.load(f)
- for entry in file_data[sl]:
- self.data.append(
- entry
- )
+class Timestamps(Meta):
+ def __init__(self, directory):
+ Meta.__init__(self, directory, 'timestamps.json')

python/pandaset/sensors.py

@@ -1,105 +1,83 @@
 import glob
+import json
+import os.path
+
 import pandas as pd
 from PIL import Image
-import os.path
-import json
 
 
-class Lidar:
- def __init__(self, directory):
+class Sensor:
+ def __init__(self, directory, data_file_extension):
  self._directory = directory
+ self._data_file_extension = data_file_extension
  self._data_structure = None
  self.data = None
- self._pose_structure = None
+ self._poses_structure = None
  self.poses = None
  self._timestamps_structure = None
  self.timestamps = None
  self._load_data_structure()
 
+ def __getitem__(self, item):
+ return self.data[item]
+
  def _load_data_structure(self):
- self._data_structure = sorted(glob.glob(f'{self._directory}/*.pkl.gz'))
+ self._data_structure = sorted(glob.glob(f'{self._directory}/*.{self._data_file_extension}'))
 
- positions_file = f'{self._directory}/positions.json'
- if os.path.isfile(positions_file):
- self._pose_structure = positions_file
+ poses_file = f'{self._directory}/poses.json'
+ if os.path.isfile(poses_file):
+ self._poses_structure = poses_file
 
  timestamps_file = f'{self._directory}/timestamps.json'
  if os.path.isfile(timestamps_file):
  self._timestamps_structure = timestamps_file
 
- def load_data(self, sl):
+ def load(self):
+ self._load_data()
+ self._load_poses()
+ self._load_timestamps()
+
+ def _load_data(self):
  self.data = []
- for fp in self._data_structure[sl]:
+ for fp in self._data_structure:
  self.data.append(
- pd.read_pickle(fp)
+ self._load_data_file(fp)
  )
- self.load_positions(sl)
- self.load_timestamps(sl)
 
- def load_positions(self, sl):
+ def _load_poses(self):
  self.poses = []
- with open(self._pose_structure, 'r') as f:
+ with open(self._poses_structure, 'r') as f:
  file_data = json.load(f)
- for entry in file_data[sl]:
+ for entry in file_data:
  self.poses.append(
  entry
  )
 
- def load_timestamps(self, sl):
+ def _load_timestamps(self):
  self.timestamps = []
  with open(self._timestamps_structure, 'r') as f:
  file_data = json.load(f)
- for entry in file_data[sl]:
+ for entry in file_data:
  self.timestamps.append(
  entry
  )
 
+ def _load_data_file(self, fp):
+ return None
 
-class Camera:
- def __init__(self, directory):
- self._directory = directory
- self._data_structure = None
- self.data = None
- self._pose_structure = None
- self.poses = None
- self._timestamps_structure = None
- self.timestamps = None
- self._load_data_structure()
 
- def _load_data_structure(self):
- self._data_structure = sorted(glob.glob(f'{self._directory}/*.jpg'))
+class Lidar(Sensor):
 
- positions_file = f'{self._directory}/positions.json'
- if os.path.isfile(positions_file):
- self._pose_structure = positions_file
+ def __init__(self, directory):
+ Sensor.__init__(self, directory, 'pkl.gz')
 
- timestamps_file = f'{self._directory}/timestamps.json'
- if os.path.isfile(timestamps_file):
- self._timestamps_structure = timestamps_file
+ def _load_data_file(self, fp):
+ return pd.read_pickle(fp)
 
- def load_data(self, sl):
- self.data = []
- for fp in self._data_structure[sl]:
- self.data.append(
- Image.open(fp)
- )
- self.load_positions(sl)
- self.load_timestamps(sl)
 
- def load_positions(self, sl):
- self.poses = []
- with open(self._pose_structure, 'r') as f:
- file_data = json.load(f)
- for entry in file_data[sl]:
- self.poses.append(
- entry
- )
+class Camera(Sensor):
+ def __init__(self, directory):
+ Sensor.__init__(self, directory, 'jpg')
 
- def load_timestamps(self, sl):
- self.timestamps = []
- with open(self._timestamps_structure, 'r') as f:
- file_data = json.load(f)
- for entry in file_data[sl]:
- self.timestamps.append(
- entry
- )
+ def _load_data_file(self, fp):
+ return Image.open(fp)

python/pandaset/sequence.py

@@ -1,7 +1,7 @@
 from .utils import subdirectories
 from .sensors import Lidar
 from .sensors import Camera
-from .meta import GPSPoses
+from .meta import GPS
 from .meta import Timestamps
 from .annotations import Cuboids
 
@@ -11,7 +11,7 @@ def __init__(self, directory):
  self._directory = directory
  self.lidar = None
  self.camera = None
- self.gps_poses = None
+ self.gps = None
  self.timestamps = None
  self.cuboids = None
  self._load_data_structure()
@@ -29,33 +29,38 @@ def _load_data_structure(self):
  camera_name = cd.split('/')[-1]
  self.camera[camera_name] = Camera(cd)
  if dd.endswith('meta'):
- self.gps_poses = GPSPoses(dd)
+ self.gps = GPS(dd)
  self.timestamps = Timestamps(dd)
  if dd.endswith('annotations'):
  annotation_directories = subdirectories(dd)
  for ad in annotation_directories:
  if ad.endswith('cuboids'):
  self.cuboids = Cuboids(ad)
 
- def load(self, sl=(None, None, None)):
- self.load_lidar(sl)
- self.load_camera(sl)
- self.load_gps_poses(sl)
- self.load_timestamps(sl)
- self.load_cuboids(sl)
+ def load(self):
+ self.load_lidar()
+ self.load_camera()
+ self.load_gps()
+ self.load_timestamps()
+ self.load_cuboids()
 
- def load_lidar(self, sl=(None, None, None)):
- self.lidar.load_data(slice(*sl))
+ def load_lidar(self):
+ self.lidar.load()
+ return self
 
- def load_camera(self, sl=(None, None, None)):
- for c in self.camera.values():
- c.load_data(slice(*sl))
+ def load_camera(self):
+ for cam in self.camera.values():
+ cam.load()
+ return self
 
- def load_gps_poses(self, sl=(None, None, None)):
- self.gps_poses.load_data(slice(*sl))
+ def load_gps(self):
+ self.gps.load()
+ return self
 
- def load_timestamps(self, sl=(None, None, None)):
- self.timestamps.load_data(slice(*sl))
+ def load_timestamps(self):
+ self.timestamps.load()
+ return self
 
- def load_cuboids(self, sl=(None, None, None)):
- self.cuboids.load_data(slice(*sl))
+ def load_cuboids(self):
+ self.cuboids.load()
+ return self

python/pandaset/utils.py

@@ -3,8 +3,3 @@
 
 def subdirectories(directory):
  return [d.path for d in os.scandir(directory) if d.is_dir()]
-
-'''
-def relative_paths(full_paths, base_path):
- return [os.path.relpath(fp, base_path) for fp in full_paths]
-'''