almost done

dronescapes_reader/dronescapes_representations.py

@@ -93,37 +93,56 @@ class SemanticRepresentation(NpzRepresentation):
             new_images[x_argmax == i] = self.color_map[i]
         return new_images
 
-# class SemanticMapper(SemanticRepresentation):
-#     """Maps one or more semantic segmentations to a final one + a merge fn. Copy-pasta from VRE"""
-#     def __init__(*args, original_classes: list[list[str]], mapping: list[dict[str, list[str]]],
-#                  color_map: list[tuple[int, int, int]],
-#                  merge_fn: Callable[[list[np.ndarray]], np.ndarray] | None = None, **kwargs):
-#         super().__init__(*args, classes=list(mapping[0].keys()), color_map=color_map, **kwargs)
-#         assert len(self.dependencies) >= 1, "No dependencies provided. Need at least one semantic segmentation to map."
-#         assert isinstance(mapping, list), type(mapping)
-#         assert len(mapping) == (B := len(self.dependencies)), (len(mapping), B)
-#         assert (A := len(original_classes)) == len(self.dependencies), (A, B)
-#         assert all(m.keys() == mapping[0].keys() for m in mapping), [list(m.keys()) for m in mapping]
-#         assert len(color_map) == len(mapping[0].keys()), (len(color_map), len(mapping[0].keys()))
-#         self.original_classes = original_classes
-#         self.mapping = mapping
-
-#     def _make_one(self, semantic_dep_data: np.ndarray, mapping: dict[str, list[str]],
-#                   original_classes: list[str]) -> np.ndarray:
-#         assert semantic_dep_data.dtype in (np.uint8, np.uint16), semantic_dep_data.dtype
-#         mapping_ix = {list(mapping.keys()).index(k): [original_classes.index(_v)
-#                                                       for _v in v] for k, v in mapping.items()}
-#         flat_mapping = {}
-#         for k, v in mapping_ix.items():
-#             for _v in v:
-#                 flat_mapping[_v] = k
-#         mapped_data = np.vectorize(flat_mapping.get)(semantic_dep_data).astype(np.uint8)
-#         return mapped_data
-
+class SemanticMapper(SemanticRepresentation):
+    """Maps one or more semantic segmentations to a final one + a merge fn. Copy-pasta from VRE"""
+    def __init__(self, *args, original_classes: list[list[str]], mapping: list[dict[str, list[str]]],
+                 color_map: list[tuple[int, int, int]],
+                 merge_fn: Callable[[list[np.ndarray]], np.ndarray] | None = None, **kwargs):
+        super().__init__(*args, classes=list(mapping[0].keys()), color_map=color_map, **kwargs)
+        assert len(self.dependencies) >= 1, "No dependencies provided. Need at least one semantic segmentation to map."
+        assert isinstance(mapping, list), type(mapping)
+        assert len(mapping) == (B := len(self.dependencies)), (len(mapping), B)
+        assert (A := len(original_classes)) == len(self.dependencies), (A, B)
+        assert all(m.keys() == mapping[0].keys() for m in mapping), [list(m.keys()) for m in mapping]
+        assert len(color_map) == len(mapping[0].keys()), (len(color_map), len(mapping[0].keys()))
+        self.original_classes = original_classes
+        self.mapping = mapping
+        self.merge_fn = merge_fn if merge_fn is not None else SemanticMapper._default_merge_fn
+
+    @staticmethod
+    def _default_merge_fn(dep_data: list[np.ndarray]) -> np.ndarray:
+        if len(dep_data) > 1:
+            raise ValueError(f"default_merge_fn doesnt' work with >1 dependencies: {len(dep_data)}")
+        return dep_data[0]
+
+    def _make_one(self, path: Path, mapping: dict[str, list[str]],
+                  original_classes: list[str]) -> np.ndarray:
+        semantic_dep_data: np.ndarray = NpzRepresentation.load_from_disk(self, path).numpy()
+        semantic_dep_data = semantic_dep_data.argmax(-1) if len(semantic_dep_data.shape) == 3 else semantic_dep_data
+        assert len(semantic_dep_data.shape) == 2, f"Only argmaxed data supported, got: {semantic_dep_data.shape}"
+        assert semantic_dep_data.dtype in (np.uint8, np.uint16), semantic_dep_data.dtype
+        mapping_ix = {list(mapping.keys()).index(k): [original_classes.index(_v)
+                                                      for _v in v] for k, v in mapping.items()}
+        flat_mapping = {}
+        for k, v in mapping_ix.items():
+            for _v in v:
+                flat_mapping[_v] = k
+        mapped_data = np.vectorize(flat_mapping.get)(semantic_dep_data).astype(np.uint8)
+        return mapped_data
     
-
-_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]]
+    def load_from_disk(self, path: Path | list[Path]):
+        # note: assuming SemanticRepresentation for all deps. TODO: generic deps.
+        paths = [path] if isinstance(path, Path) else path
+        assert len(paths) == len(self.dependencies), (len(path), len(self.dependencies))
+        individual_semantics = []
+        for path, mapping, original_classes in zip(paths, self.mapping, self.original_classes):
+            individual_semantics.append(self._make_one(path, mapping, original_classes))
+        res = self.merge_fn(individual_semantics)
+        res_torch = F.one_hot(tr.from_numpy(res).long(), num_classes=self.n_classes).float()
+        return res_torch
+
+color_map_8classes = [[0, 255, 0], [0, 127, 0], [255, 255, 0], [255, 255, 255],
+                      [255, 0, 0], [0, 0, 255], [0, 255, 255], [127, 127, 63]]
 coco_classes = ["person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
                 "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
                 "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
@@ -184,24 +203,41 @@ mapillary_color_map = [[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 1
                        [0, 60, 100], [0, 0, 142], [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
                        [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10]]
 
-dronescapes_task_types = { # some pre-baked representations
-    "rgb": RGBRepresentation("rgb"),
-    "hsv": HSVRepresentation("hsv", dependencies=["rgb"]),
-    "edges_dexined": EdgesRepresentation("edges_dexined"),
-    "edges_gb": EdgesRepresentation("edges_gb"),
-    "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),
-    "depth_ufo": DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
-    "depth_marigold": DepthRepresentation("depth_marigold", min_depth=0, max_depth=1),
-    "normals_sfm_manual202204": NormalsRepresentation("normals_sfm_manual202204"),
-    "opticalflow_rife": OpticalFlowRepresentation("opticalflow_rife"),
-    "semantic_segprop8": SemanticRepresentation("semantic_segprop8", classes=8, color_map=_color_map),
-    "semantic_mask2former_swin_mapillary_converted":
-        SemanticRepresentation("semantic_mask2former_swin_mapillary_converted", classes=8, color_map=_color_map),
-    "semantic_mask2former_coco_47429163_0":
-        SemanticRepresentation("semantic_mask2former_coco_47429163_0", classes=coco_classes, color_map=coco_color_map),
-    "semantic_mask2former_mapillary_49189528_0":
-        SemanticRepresentation("semantic_mask2former_mapillary_49189528_0", classes=mapillary_classes,
-                               color_map=mapillary_color_map),
-    "softseg_gb": NpzRepresentation("softseg_gb", 3),
-}
+m2f_mapillary_to_8_classes = {
+        "land": ["Terrain", "Sand", "Snow"],
+        "forest": ["Vegetation"],
+        "residential": ["Building", "Utility Pole", "Pole", "Fence", "Wall", "Manhole", "Street Light", "Curb",
+                        "Guard Rail", "Caravan", "Junction Box", "Traffic Sign (Front)", "Billboard", "Banner",
+                        "Mailbox", "Traffic Sign (Back)", "Bench", "Fire Hydrant", "Trash Can", "CCTV Camera",
+                        "Traffic Light", "Barrier", "Rail Track", "Phone Booth", "Curb Cut", "Traffic Sign Frame",
+                        "Bike Rack"],
+        "road": ["Road", "Lane Marking - General", "Sidewalk", "Bridge", "Other Vehicle", "Motorcyclist", "Pothole",
+                 "Catch Basin", "Car Mount", "Tunnel", "Parking", "Service Lane", "Lane Marking - Crosswalk",
+                 "Pedestrian Area", "On Rails", "Bike Lane", "Crosswalk - Plain"],
+        "little-objects": ["Car", "Person", "Truck", "Boat", "Wheeled Slow", "Trailer", "Ground Animal", "Bicycle",
+                           "Motorcycle", "Bird", "Bus", "Ego Vehicle", "Bicyclist", "Other Rider"],
+        "water": ["Water"],
+        "sky": ["Sky"],
+        "hill": ["Mountain"]
+    }
+
+tasks = [ # some pre-baked representations
+    RGBRepresentation("rgb"),
+    HSVRepresentation("hsv", dependencies=["rgb"]),
+    EdgesRepresentation("edges_dexined"),
+    EdgesRepresentation("edges_gb"),
+    DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),
+    DepthRepresentation("depth_sfm_manual202204", min_depth=0, max_depth=300),
+    DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
+    DepthRepresentation("depth_marigold", min_depth=0, max_depth=1),
+    NormalsRepresentation("normals_sfm_manual202204"),
+    OpticalFlowRepresentation("opticalflow_rife"),
+    SemanticRepresentation("semantic_segprop8", classes=8, color_map=color_map_8classes),
+    SemanticMapper("semantic_mask2former_swin_mapillary_converted", original_classes=[mapillary_classes],
+                   mapping=[m2f_mapillary_to_8_classes], color_map=color_map_8classes),
+    SemanticRepresentation("semantic_mask2former_coco_47429163_0", classes=coco_classes, color_map=coco_color_map),
+    SemanticRepresentation("semantic_mask2former_mapillary_49189528_0", classes=mapillary_classes,
+                            color_map=mapillary_color_map),
+    NpzRepresentation("softseg_gb", 3),
+]
+dronescapes_task_types: dict[str, NpzRepresentation] = {task.name: task for task in tasks}

dronescapes_reader/multitask_dataset.py

@@ -41,7 +41,6 @@ class MultiTaskDataset(Dataset):
       - 'drop': Drop the data point if any of the representations is missing.
       - 'fill_{none,zero,nan}': Fill the missing data with Nones, zeros or NaNs.
     - files_suffix: What suffix to look for when creating the dataset. Valid values: 'npy' or 'npz'.
-    - files_per_repr_overwrites: A dictionay {src: target} that maps one task to another's data (i.e. {'hsv': 'rgb'})
     - cache_task_stats: If set to True, the statistics will be cached at '{path}/.task_statistics.npz'. Can be enabled
     using the environmental variable STATS_CACHE=1. Defaults to False.
     - batch_size_stats: Controls the batch size during statistics computation. Can be enabled by environmental variable
@@ -211,7 +210,8 @@ 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, task_types: dict[str, NpzRepresentation], task_names: list[str] | None) -> BuildDatasetTuple:
+    def _build_dataset(self, task_types: dict[str, NpzRepresentation],
+                       task_names: list[str] | None) -> BuildDatasetTuple:
         logger.debug(f"Building dataset from: '{self.path}'")
         all_npz_files = self._get_all_npz_files()
         all_files: dict[str, dict[str, str]] = {k: {_v.name: _v for _v in v} for k, v in all_npz_files.items()}

scripts/dronescapes_viewer.py

@@ -11,9 +11,8 @@ import random
 def main():
     assert len(sys.argv) == 2, f"Usage ./dronescapes_viewer.py /path/to/dataset"
     reader = MultiTaskDataset(sys.argv[1], task_names=list(dronescapes_task_types.keys()),
-                          task_types=dronescapes_task_types,
-                          handle_missing_data="fill_nan",
-                          normalization="min_max", cache_task_stats=True)
+                              task_types=dronescapes_task_types, handle_missing_data="fill_nan",
+                              normalization="min_max", cache_task_stats=True)
     print(reader)
 
     print("== Shapes ==")