updated notebook and added basic dronescapes representations

dronescapes_reader/__init__.py

@@ -1,2 +1,3 @@
 """init file"""
 from .multitask_dataset import MultiTaskDataset
+from .dronescapes_representations import DepthRepresentation, OpticalFlowRepresentation, SemanticRepresentation

dronescapes_reader/dronescapes_representations.py

@@ -0,0 +1,53 @@
+"""Dronescapes representations -- adds various loading/writing/image showing capabilities to dronescapes tasks"""
+from pathlib import Path
+import numpy as np
+import torch as tr
+import flow_vis
+from overrides import overrides
+from matplotlib.cm import hot # pylint: disable=no-name-in-module
+from .multitask_dataset import NpzRepresentation
+
+class DepthRepresentation(NpzRepresentation):
+    """DepthRepresentation. Implements depth task-specific stuff, like hotmap."""
+    def __init__(self, *args, min_depth: float, max_depth: float, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_depth = min_depth
+        self.max_depth = max_depth
+
+    @overrides
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        x = x.numpy()
+        x = np.clip(x, self.min_depth, self.max_depth)
+        x = np.nan_to_num((x - x.min()) / (x.max() - x.min()), 0)
+        y = hot(x)[..., 0:3]
+        y = np.uint8(y * 255)
+        return y
+
+class OpticalFlowRepresentation(NpzRepresentation):
+    """OpticalFlowRepresentation. Implements depth task-specific stuff, like using flow_vis."""
+    @overrides
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        return flow_vis.flow_to_color(x.numpy())
+
+class SemanticRepresentation(NpzRepresentation):
+    """SemanticRepresentation. Implements depth task-specific stuff, like using flow_vis."""
+    def __init__(self, *args, classes: int | list[str], color_map: list[tuple[int, int, int]], **kwargs):
+        super().__init__(*args, **kwargs)
+        self.classes = list(range(classes)) if isinstance(classes, int) else classes
+        self.n_classes = len(self.classes)
+        self.color_map = color_map
+        assert len(color_map) == self.n_classes, (color_map, self.n_classes)
+
+    @overrides
+    def load_from_disk(self, path: Path) -> tr.Tensor:
+        res = super().load_from_disk(path)
+        assert len(res.shape) == 2, f"Only argmaxed data supported, got: {res.shape}"
+        return res
+
+    @overrides
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        new_images = np.zeros((*x.shape, 3), dtype=np.uint8)
+        x = x.numpy()
+        for i in range(self.n_classes):
+            new_images[x == i] = self.color_map[i]
+        return new_images

dronescapes_reader/multitask_dataset.py

@@ -109,7 +109,13 @@ class MultiTaskDataset(Dataset):
         """
         if self._tasks is not None:
             return self._tasks
-        self._tasks = [self.task_types[task_name](task_name) for task_name in self.task_names]
+        self._tasks = []
+        for task_name in self.task_names:
+            t = self.task_types[task_name]
+            if not isinstance(t, NpzRepresentation):
+                t = t(task_name)
+            self._tasks.append(t)
+        assert all(t.name == t_n for t, t_n in zip(self._tasks, self.task_names)), (self._task_names, self._tasks)
         return self._tasks
 
     def collate_fn(self, items: list[MultiTaskItem]) -> MultiTaskItem:
@@ -122,7 +128,7 @@ class MultiTaskDataset(Dataset):
         res = {k: tr.zeros(len(items), *self.data_shape[k]).float() for k in self.task_names} # float32 always
         for i in range(len(items)):
             for k in self.task_names:
-                res[k][i] = items[i][0][k] if items[i][0][k] is not None else 0
+                res[k][i] = items[i][0][k] if items[i][0][k] is not None else float("nan")
         return res, items_name, self.task_names
 
     # Private methods

scripts/dronescapes_viewer.py

@@ -1,14 +1,24 @@
 #!/usr/bin/env python3
 import sys
 from pathlib import Path
-sys.path.append(Path.cwd().parent.__str__())
-from dronescapes_reader import MultiTaskDataset
+sys.path.append(Path(__file__).parents[1].__str__())
+from functools import partial
+from dronescapes_reader import MultiTaskDataset, DepthRepresentation, OpticalFlowRepresentation, SemanticRepresentation
 from pprint import pprint
 from torch.utils.data import DataLoader
 import random
 
 def main():
-    reader = MultiTaskDataset(Path(sys.argv[1]), handle_missing_data="fill_none")
+    sema_repr = partial(SemanticRepresentation, classes=8, color_map=[[0, 255, 0], [0, 127, 0], [255, 255, 0],
+                                                                    [255, 255, 255], [255, 0, 0], [0, 0, 255],
+                                                                    [0, 255, 255], [127, 127, 63]])
+    reader = MultiTaskDataset(sys.argv[1], handle_missing_data="fill_none",
+                            task_types={"depth_dpt": DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),
+                                        "depth_sfm_manual202204": DepthRepresentation("depth_sfm_manual202204",
+                                                                                        min_depth=0, max_depth=300),
+                                        "opticalflow_rife": OpticalFlowRepresentation,
+                                        "semantic_segprop8": sema_repr,
+                                        "semantic_mask2former_swin_mapillary_converted": sema_repr})
     print(reader)
 
     print("== Shapes ==")