files_per_repr_overwrites and and hsv support. Other backports too (opticalflow/ndims)

dronescapes_reader/__init__.py

@@ -1,20 +1,22 @@
 """init file"""
 from .multitask_dataset import MultiTaskDataset, NpzRepresentation
 from .dronescapes_representations import DepthRepresentation, OpticalFlowRepresentation, SemanticRepresentation, \
-    ColorRepresentation, EdgesRepresentation
+    ColorRepresentation, EdgesRepresentation, NormalsRepresentation, HSVRepresentation
 
 _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]]
 _m2f_name = "semantic_mask2former_swin_mapillary_converted"
 dronescapes_task_types = { # some pre-baked representations
-    "rgb": ColorRepresentation("rgb"),
-    "edges_dexined": ColorRepresentation("edges_dexined"),
+    "rgb": ColorRepresentation("rgb", 3),
+    "hsv": HSVRepresentation("hsv", 3),
+    "edges_dexined": ColorRepresentation("edges_dexined", 1),
     "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),
+    "normals_sfm_manual202204": NormalsRepresentation("normals_sfm_manual202204"),
     "depth_ufo": DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
     "opticalflow_rife": OpticalFlowRepresentation,
     "semantic_segprop8": SemanticRepresentation("semantic_segprop8", classes=8, color_map=_color_map),
     _m2f_name: SemanticRepresentation(_m2f_name, classes=8, color_map=_color_map),
-    "softseg_gb": ColorRepresentation("softseg_gb"),
+    "softseg_gb": ColorRepresentation("softseg_gb", 3),
     "edges_gb": EdgesRepresentation("edges_gb"),
 }

dronescapes_reader/dronescapes_representations.py

@@ -4,28 +4,58 @@ from pathlib import Path
 import numpy as np
 import torch as tr
 import flow_vis
+from skimage.color import rgb2hsv, hsv2rgb
 from overrides import overrides
 from matplotlib.cm import hot # pylint: disable=no-name-in-module
 from .multitask_dataset import NpzRepresentation
 from torch.nn import functional as F
 
 class ColorRepresentation(NpzRepresentation):
+    def __init__(self, name: str, n_channels: int):
+        super().__init__(name)
+        self._n_channels = n_channels
+
+    @overrides
     def load_from_disk(self, path: Path) -> tr.Tensor:
         res = super().load_from_disk(path)
         return res.float() / 255
 
+    @overrides
     def save_to_disk(self, data: tr.Tensor, path: Path):
         return super().save_to_disk((data * 255).byte(), path)
 
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return self._n_channels
+
+class HSVRepresentation(ColorRepresentation):
+    @overrides
+    def load_from_disk(self, path: Path) -> tr.Tensor:
+        rgb = NpzRepresentation.load_from_disk(self, path)
+        return tr.from_numpy(rgb2hsv(rgb)).float()
+
+    @overrides
+    def save_to_disk(self, data: tr.Tensor, path: Path):
+        rgb = tr.from_numpy(hsv2rgb(data) * 255).byte()
+        NpzRepresentation.save_to_disk(rgb, path)
+
 class EdgesRepresentation(NpzRepresentation):
+    @overrides
     def load_from_disk(self, path: Path) -> tr.Tensor:
         res = super().load_from_disk(path).float()
         assert len(res.shape) == 3 and res.shape[-1] == 1
         return res
 
+    @overrides
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
         return (x.detach().repeat(1, 1, 3) * 255).cpu().numpy().astype(np.uint8)
 
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return 1
+
 class DepthRepresentation(NpzRepresentation):
     """DepthRepresentation. Implements depth task-specific stuff, like hotmap."""
     def __init__(self, *args, min_depth: float, max_depth: float, **kwargs):
@@ -40,21 +70,38 @@ class DepthRepresentation(NpzRepresentation):
         y: np.ndarray = hot(x)[..., 0:3] * 255
         return y.astype(np.uint8)
 
+    @overrides
     def load_from_disk(self, path: Path) -> tr.Tensor:
         res = super().load_from_disk(path).squeeze().unsqueeze(-1)
         res = res.float().clip(self.min_depth, self.max_depth)
         res = (res - self.min_depth) / (self.max_depth - self.min_depth)
         return res
 
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return 1
+
+class NormalsRepresentation(NpzRepresentation):
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return 3
+
 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.squeeze().nan_to_num(0).detach().cpu().numpy())
 
+    @overrides
     def load_from_disk(self, path: Path) -> tr.Tensor:
-        res = super().load_from_disk(path).float()
-        return res
+        return super().load_from_disk(path).float()
+
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return 2
 
 class SemanticRepresentation(NpzRepresentation):
     """SemanticRepresentation. Implements depth task-specific stuff, like using flow_vis."""
@@ -82,3 +129,8 @@ class SemanticRepresentation(NpzRepresentation):
         for i in range(self.n_classes):
             new_images[x == i] = self.color_map[i]
         return new_images
+
+    @property
+    @overrides
+    def n_channels(self) -> int:
+        return self.n_classes

dronescapes_reader/multitask_dataset.py

@@ -16,6 +16,7 @@ monkey_patch()
 BuildDatasetTuple = Tuple[Dict[str, List[Path]], List[str]]
 MultiTaskItem = Tuple[Dict[str, tr.Tensor], str, List[str]] # [{task: data}, stem(name) | list[stem(name)], [tasks]]
 
+
 class NpzRepresentation:
     """Generic Task with data read from/saved to npz files. Tries to read data as-is from disk and store it as well"""
     def __init__(self, name: str):
@@ -34,15 +35,24 @@ class NpzRepresentation:
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
         """very basic implementation of converting this representation to a viewable image. You should overwrite this"""
         assert isinstance(x, tr.Tensor), type(x)
-        if len(x.shape) == 2: x = x.unsqueeze(-1)
+        if len(x.shape) == 2:
+            x = x.unsqueeze(-1)
         assert len(x.shape) == 3, x.shape # guaranteed to be (H, W, C) at this point
-        if x.shape[-1] != 3: x = x[..., 0:1]
-        if x.shape[-1] == 1: x = x.repeat(1, 1, 3)
+        if x.shape[-1] != 3:
+            x = x[..., 0:1]
+        if x.shape[-1] == 1:
+            x = x.repeat(1, 1, 3)
         x = x.nan_to_num(0).cpu().detach().numpy() # guaranteed to be (H, W, 3) at this point hopefully
         _min, _max = x.min((0, 1), keepdims=True), x.max((0, 1), keepdims=True)
-        if x.dtype != np.uint8: x = np.nan_to_num((x - _min) / (_max - _min) * 255, 0).astype(np.uint8)
+        if x.dtype != np.uint8:
+            x = np.nan_to_num((x - _min) / (_max - _min) * 255, 0).astype(np.uint8)
         return x
 
+    @property
+    def n_channels(self) -> int:
+        """return the number of channels for this representation. Must be updated by each downstream representation"""
+        raise NotImplementedError(f"n_channels is not implemented for {self}")
+
     def __repr__(self):
         return str(self)
 
@@ -70,7 +80,8 @@ class MultiTaskDataset(Dataset):
     """
 
     def __init__(self, path: Path, task_names: list[str] | None = None, handle_missing_data: str = "fill_none",
-                 files_suffix: str = "npz", task_types: dict[str, type] | None = None):
+                 files_suffix: str = "npz", task_types: dict[str, type] | None = None,
+                 files_per_repr_overwrites: dict[str, str] | None = None):
         assert Path(path).exists(), f"Provided path '{path}' doesn't exist!"
         assert handle_missing_data in ("drop", "fill_none", "fill_zero", "fill_nan"), \
             f"Invalid handle_missing_data mode: {handle_missing_data}"
@@ -78,6 +89,7 @@ class MultiTaskDataset(Dataset):
         self.path = Path(path).absolute()
         self.handle_missing_data = handle_missing_data
         self.suffix = files_suffix
+        self.files_per_repr_overwrites = files_per_repr_overwrites
         self.all_files_per_repr = self._get_all_npz_files()
         self.files_per_repr, self.file_names = self._build_dataset() # these are filtered by 'drop' or 'fill_none' logic
         if task_types is None:
@@ -87,6 +99,7 @@ class MultiTaskDataset(Dataset):
         if task_names is None:
             task_names = list(self.files_per_repr.keys())
             logger.debug(f"No explicit tasks provided. Using all of them as read from the paths ({len(task_names)}).")
+        assert all(task in self.files_per_repr for task in task_names), (task_names, self.files_per_repr.keys())
         self.task_types = {k: task_types.get(k, NpzRepresentation) for k in task_names}
         assert all(isinstance(x, str) for x in task_names), tuple(zip(task_names, (type(x) for x in task_names)))
         self.task_names = sorted(task_names)
@@ -164,6 +177,21 @@ class MultiTaskDataset(Dataset):
         assert not any(len(x) == 0 for x in in_files.values()), f"{ [k for k, v in in_files.items() if len(v) == 0] }"
         return in_files
 
+    def _build_dataset(self) -> BuildDatasetTuple:
+        logger.debug(f"Building dataset from: '{self.path}'")
+        if self.handle_missing_data == "drop":
+            files_per_repr, common = self._build_dataset_drop_missing()
+        else:
+            files_per_repr, common = self._build_dataset_fill_missing()
+        if self.files_per_repr_overwrites is not None: # here we match for example 'hsv' to read also from 'rgb' dir
+            for left, right in self.files_per_repr_overwrites.items():
+                if right not in (fpr := files_per_repr):
+                    logger.info(f"Overwrite: {left} => {right} provided, but {right} is not in {fpr.keys()}")
+                    continue
+                assert left not in fpr.keys(), f"Overwrite: {left} => {right}. {left} already exists in {fpr.keys()}"
+                files_per_repr[left] = files_per_repr[right]
+        return files_per_repr, common
+
     def _build_dataset_drop_missing(self) -> BuildDatasetTuple:
         in_files = self.all_files_per_repr
         name_to_node_path = {k: {_v.name: _v for _v in v} for k, v in in_files.items()} # {node: {name: path}}
@@ -195,13 +223,6 @@ class MultiTaskDataset(Dataset):
         assert len(files_per_repr) > 0
         return files_per_repr, all_files
 
-    def _build_dataset(self) -> BuildDatasetTuple:
-        logger.debug(f"Building dataset from: '{self.path}'")
-        if self.handle_missing_data == "drop":
-            return self._build_dataset_drop_missing()
-        else:
-            return self._build_dataset_fill_missing()
-
     # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
 
     def __getitem__(self, index: int | slice | list[int] | tuple) -> MultiTaskItem:

scripts/dronescapes_viewer.py

@@ -8,7 +8,8 @@ from torch.utils.data import DataLoader
 import random
 
 def main():
-    reader = MultiTaskDataset(sys.argv[1], handle_missing_data="fill_none", task_types=dronescapes_task_types)
+    reader = MultiTaskDataset(sys.argv[1], handle_missing_data="fill_none", task_types=dronescapes_task_types,
+                              files_per_repr_overwrites={"hsv": "rgb"})
     print(reader)
 
     print("== Shapes ==")