wip

scripts/semantic_mapper/semantic_mapper.py

@@ -213,21 +213,21 @@ class BinaryMapper(TaskMapper, NpIORepresentation):
     TaskMapper is the only high level interface that makes sense, so we should focus on keeping that generic and easy.
     """
     def __init__(self, name: str, dependencies: list[Representation], mapping: list[dict[str, list]],
-                 mode: str = "all_agree", load_mode: str = "binary"):
+                 mode: str, load_mode: str = "binary"):
         TaskMapper.__init__(self, name=name, dependencies=dependencies, n_channels=2)
         NpIORepresentation.__init__(self)
-        assert mode in ("all_agree", "at_least_one"), mode
-        assert load_mode in ("one_hot", "binary")
-        assert len(mapping[0]) == 2, mapping
-        assert len(mapping) == len(dependencies), (len(mapping), len(dependencies))
-        assert all(mapping[0].keys() == m.keys() for m in mapping), [m.keys() for m in mapping]
-        self.original_classes = [dep.classes for dep in dependencies]
+        assert mode in ("all_agree", "majority", "majority"), (name, mode)
+        assert load_mode in ("one_hot", "binary"), (name, load_mode)
+        assert len(mapping[0]) == 2, (name, mapping)
+        assert len(mapping) == len(dependencies), (name, len(mapping), len(dependencies))
+        assert all(mapping[0].keys() == m.keys() for m in mapping), (name, [m.keys() for m in mapping])
+        self.original_classes: list[list[str]] = [dep.classes for dep in dependencies]
         self.mapping = mapping
         self.mode = mode
         self.load_mode = load_mode
         self.classes = list(mapping[0].keys())
         self.n_classes = len(self.classes)
-        self.color_map = [[255, 255, 255], [0, 0, 0]]
+        self.color_map = [[0, 0, 0], [255, 255, 255]]
         self.output_dtype = "bool"
 
     @overrides
@@ -250,41 +250,29 @@ class BinaryMapper(TaskMapper, NpIORepresentation):
     def merge_fn(self, dep_data: list[MemoryData]) -> MemoryData:
         dep_data_converted = [semantic_mapper(x.argmax(-1), mapping, oc)
                               for x, mapping, oc in zip(dep_data, self.mapping, self.original_classes)]
-        res_argmax = sum(dep_data_converted) > (0 if self.mode == "all_agree" else 1)
+        if self.mode == "all_agree":
+            res_argmax = sum(dep_data_converted) == len(self.dependencies)
+        elif self.mode == "majority":
+            res_argmax = sum(dep_data_converted) > 0
+        else:
+            res_argmax = sum(dep_data_converted) > len(dep_data_converted) // 2
         return self.disk_to_memory_fmt(res_argmax)
 
 class BuildingsFromM2FDepth(BinaryMapper, NpIORepresentation):
-    def __init__(self, name: str, original_classes: tuple[list[str], list[str]], load_mode: str = "binary"):
-        buildings_mapping = [
-            {
-                "buildings": (cls := ["Building", "Utility Pole", "Pole", "Fence", "Wall"]),
-                "others": [x for x in mapillary_classes if x not in cls],
-            },
-            {
-                "buildings": (cls := ["building-other-merged", "house", "roof"]),
-                "others": [x for x in coco_classes if x not in cls]
-            }
-        ]
-
-        dependencies = [m2f_mapillary, m2f_coco, marigold]
+    def __init__(self, name: str, dependencies: list[Representation], load_mode: str = "binary"):
+        assert len(dependencies) == 2, dependencies
         TaskMapper.__init__(self, name=name, dependencies=dependencies, n_channels=2)
         NpIORepresentation.__init__(self)
-        self.color_map = [[255, 255, 255], [0, 0, 0]]
-        self.original_classes = original_classes
-        self.mapping = buildings_mapping
-        self.classes = list(buildings_mapping[0].keys())
-        self.n_classes = len(self.classes)
+        self.color_map = [[0, 0, 0], [255, 255, 255]]
+        self.classes = ["others", name]
         self.load_mode = load_mode
         self.output_dtype = "bool"
 
     def merge_fn(self, dep_data: list[MemoryData]) -> MemoryData:
-        m2f_mapillary, m2f_coco = dep_data[0].argmax(-1), dep_data[1].argmax(-1)
-        depth = dep_data[2].squeeze()
-        m2f_mapillary_converted = semantic_mapper(m2f_mapillary, self.mapping[0], self.original_classes[0])
-        m2f_coco_converted = semantic_mapper(m2f_coco, self.mapping[1], self.original_classes[1])
+        buildings, depth = dep_data
         thr = 0.3 # np.percentile(depth.numpy(), 0.8)
-        combined = (m2f_mapillary_converted + m2f_coco_converted + (depth > thr)) != 0
-        return self.disk_to_memory_fmt(combined)
+        buildings_depth = buildings * (depth <= thr)
+        return self.disk_to_memory_fmt(buildings_depth)
 
 class SafeLandingAreas(BinaryMapper, NpIORepresentation):
     def __init__(self, name: str, original_classes: tuple[list[str], list[str]], include_semantics: bool = False,
@@ -293,9 +281,9 @@ class SafeLandingAreas(BinaryMapper, NpIORepresentation):
         dependencies = [m2f_mapillary, m2f_coco, marigold, normals_svd_marigold]
         TaskMapper.__init__(self, name, dependencies=dependencies, n_channels=2)
         NpIORepresentation.__init__(self)
-        self.color_map = [[0, 255, 0], [255, 0, 0]]
+        self.color_map = [[255, 0, 0], [0, 255, 0]]
         self.original_classes = original_classes
-        self.classes = ["safe-landing", "unsafe-landing"]
+        self.classes = ["unsafe-landing", "safe-landing"]
         self.n_classes = len(self.classes)
         self.sky_water = sky_water
         self.load_mode = load_mode
@@ -310,107 +298,130 @@ class SafeLandingAreas(BinaryMapper, NpIORepresentation):
             sw = self.sky_water.merge_fn(dep_data)
             sw = sw.argmax(-1) if self.sky_water.load_mode == "one_hot" else sw
             where_safe = (where_safe * sw * (depth < 0.9)).astype(bool)
-        return self.disk_to_memory_fmt(~where_safe)
+        return self.disk_to_memory_fmt(where_safe)
 
 def get_new_semantic_mapped_tasks(tasks_subset: list[str] | None = None) -> dict[str, TaskMapper]:
     """The exported function for VRE!"""
     buildings_mapping = [
         {
-            "buildings": (cls := ["Building", "Utility Pole", "Pole", "Fence", "Wall"]),
-            "others": [x for x in mapillary_classes if x not in cls],
+            "others": [x for x in mapillary_classes if x not in
+                       (cls := ["Building", "Utility Pole", "Pole", "Fence", "Wall"])],
+            "buildings": cls,
         },
         {
-            "buildings": (cls := ["building-other-merged", "house", "roof"]),
-            "others": [x for x in coco_classes if x not in cls]
-        }
-    ]
-
-    living_mapping = [
-        {
-            "living": (cls := ["Person", "Bicyclist", "Motorcyclist", "Other Rider", "Bird", "Ground Animal"]),
-            "others": [c for c in mapillary_classes if c not in cls],
+            "others": [x for x in coco_classes if x not in (cls := ["building-other-merged", "house", "roof"])],
+            "buildings": cls,
         },
         {
-            "living": (cls := ["person", "bird", "cat", "dog", "horse", "sheep", "cow",
-                            "elephant", "bear", "zebra", "giraffe"]),
-            "others": [c for c in coco_classes if c not in cls],
-        }
+            "others": [x for x in mapillary_classes if x not in
+                       (cls := ["Building", "Utility Pole", "Pole", "Fence", "Wall"])],
+            "buildings": cls,
+        },
     ]
 
     sky_and_water_mapping = [
         {
-            "sky-and-water": (cls := ["Sky", "Water"]),
-            "others": [c for c in mapillary_classes if c not in cls],
+            "others": [c for c in mapillary_classes if c not in (cls := ["Sky", "Water"])],
+            "sky-and-water": cls,
         },
         {
-            "sky-and-water": (cls := ["sky-other-merged", "water-other"]),
-            "others": [c for c in coco_classes if c not in cls],
+            "others": [c for c in coco_classes if c not in
+                       (cls := ["sky-other-merged", "water-other", "sea", "river"])],
+            "sky-and-water": cls,
+        },
+        {
+            "others": [c for c in mapillary_classes if c not in (cls := ["Sky", "Water"])],
+            "sky-and-water": cls,
         },
     ]
 
     transportation_mapping = [
         {
-            "transportation": (cls := ["Bike Lane", "Crosswalk - Plain", "Curb Cut", "Parking", "Rail Track",
-                                       "Road", "Service Lane", "Sidewalk", "Bridge", "Tunnel", "Bicyclist",
-                                       "Motorcyclist",
-                                       "Other Rider", "Lane Marking - Crosswalk", "Lane Marking - General",
-                                       "Traffic Light",
-                                       "Traffic Sign (Back)", "Traffic Sign (Front)", "Bicycle", "Boat", "Bus", "Car",
-                                       "Caravan", "Motorcycle", "On Rails", "Other Vehicle", "Trailer", "Truck",
-                                       "Wheeled Slow", "Car Mount", "Ego Vehicle"]),
-            "others": [c for c in mapillary_classes if c not in cls]
+            "others": [c for c in mapillary_classes if c not in
+                       (cls := ["Bike Lane", "Crosswalk - Plain", "Curb Cut", "Parking", "Rail Track", "Road",
+                                "Service Lane", "Sidewalk", "Bridge", "Tunnel", "Bicyclist", "Motorcyclist",
+                                "Other Rider", "Lane Marking - Crosswalk", "Lane Marking - General", "Traffic Light",
+                                "Traffic Sign (Back)", "Traffic Sign (Front)", "Bicycle", "Boat", "Bus", "Car",
+                                "Caravan", "Motorcycle", "On Rails", "Other Vehicle", "Trailer", "Truck",
+                                "Wheeled Slow", "Car Mount", "Ego Vehicle"])],
+            "transportation": cls,
         },
         {
-            "transportation": (cls := ["bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat"]),
-            "others": [c for c in coco_classes if c not in cls]
-        }
+            "others": [c for c in coco_classes if c not in
+                       (cls := ["bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat"])],
+            "transportation": cls,
+        },
+        {
+            "others": [c for c in mapillary_classes if c not in
+                       (cls := ["Bike Lane", "Crosswalk - Plain", "Curb Cut", "Parking", "Rail Track", "Road",
+                                "Service Lane", "Sidewalk", "Bridge", "Tunnel", "Bicyclist", "Motorcyclist",
+                                "Other Rider", "Lane Marking - Crosswalk", "Lane Marking - General", "Traffic Light",
+                                "Traffic Sign (Back)", "Traffic Sign (Front)", "Bicycle", "Boat", "Bus", "Car",
+                                "Caravan", "Motorcycle", "On Rails", "Other Vehicle", "Trailer", "Truck",
+                                "Wheeled Slow", "Car Mount", "Ego Vehicle"])],
+            "transportation": cls,
+        },
     ]
 
     containing_mapping = [
         {
-            "containing": (cls := [
-                "Terrain", "Sand", "Mountain", "Road", "Sidewalk", "Pedestrian Area", "Rail Track", "Parking",
-                "Service Lane", "Bridge", "Water", "Vegetation", "Curb", "Fence", "Wall", "Guard Rail",
-                "Barrier", "Curb Cut", "Snow"
-            ]),
-            "contained": [c for c in mapillary_classes if c not in cls],  # Buildings and constructions will be here
+            "contained": [c for c in mapillary_classes if c not in
+                          (cls := ["Terrain", "Sand", "Mountain", "Road", "Sidewalk", "Pedestrian Area", "Rail Track",
+                                   "Parking", "Service Lane", "Bridge", "Water", "Vegetation", "Curb", "Fence", "Wall",
+                                   "Guard Rail", "Barrier", "Curb Cut", "Snow"])],
+            "containing": cls,
         },
         {
-            "containing": (cls := [
-                "floor-wood", "floor-other-merged", "pavement-merged", "mountain-merged", "sand", "road",
-                "sea", "river", "railroad", "platform", "grass-merged", "snow", "stairs", "tent"
-            ]),
-            "contained": [c for c in coco_classes if c not in cls],  # Buildings and constructions will be here
-        }
+            "contained": [c for c in coco_classes if c not in
+                          (cls := ["floor-wood", "floor-other-merged", "pavement-merged", "mountain-merged", "platform",
+                                   "sand", "road", "sea", "river", "railroad", "grass-merged", "snow", "stairs",
+                                   "tent"])],
+            "containing": cls,
+        },
+        {
+            "contained": [c for c in mapillary_classes if c not in
+                          (cls := ["Terrain", "Sand", "Mountain", "Road", "Sidewalk", "Pedestrian Area", "Rail Track",
+                                   "Parking", "Service Lane", "Bridge", "Water", "Vegetation", "Curb", "Fence", "Wall",
+                                   "Guard Rail", "Barrier", "Curb Cut", "Snow"])],
+            "containing": cls,
+        },
     ]
 
     vegetation_mapping = [
         {
-            "vegetation": (cls := ["Mountain", "Sand", "Sky", "Snow", "Terrain", "Vegetation"]),
-            "others": [x for x in mapillary_classes if x not in cls],
+            "others": [x for x in mapillary_classes if x not in
+                       (cls := ["Mountain", "Sand", "Sky", "Snow", "Terrain", "Vegetation"])],
+            "vegetation": cls,
         },
         {
-            "vegetation": (cls := ["tree-merged", "grass-merged", "dirt-merged", "flower", "potted plant", "river",
-                                "sea", "water-other", "mountain-merged", "rock-merged"]),
-            "others": [x for x in coco_classes if x not in cls],
-        }
+            "others": [x for x in coco_classes if x not in
+                       (cls := ["tree-merged", "grass-merged", "dirt-merged", "flower", "potted plant", "river",
+                                "sea", "water-other", "mountain-merged", "rock-merged"])],
+            "vegetation": cls,
+        },
+        {
+            "others": [x for x in mapillary_classes if x not in
+                       (cls := ["Mountain", "Sand", "Sky", "Snow", "Terrain", "Vegetation"])],
+            "vegetation": cls,
+        },
     ]
 
     available_tasks: list[TaskMapper] = [
         SemanticMask2FormerMapillaryConvertedPaper("semantic_mask2former_swin_mapillary_converted", [m2f_mapillary]),
         SemanticMask2FormerMapillaryConvertedPaper("semantic_mask2former_r50_mapillary_converted", [m2f_r50_mapillary]),
         SemanticMask2FormerCOCOConverted("semantic_mask2former_swin_coco_converted", [m2f_coco]),
-        BinaryMapper("buildings", [m2f_mapillary, m2f_coco], buildings_mapping),
-        BinaryMapper("living-vs-non-living", [m2f_mapillary, m2f_coco], living_mapping),
-        sky_water := BinaryMapper("sky-and-water", [m2f_mapillary, m2f_coco], sky_and_water_mapping,
-                                  mode="at_least_one"),
-        BinaryMapper("transportation", [m2f_mapillary, m2f_coco], transportation_mapping, mode="at_least_one"),
-        BinaryMapper("containing", [m2f_mapillary, m2f_coco], containing_mapping),
-        BinaryMapper("vegetation", [m2f_mapillary, m2f_coco], vegetation_mapping),
-        BuildingsFromM2FDepth("buildings(nearby)", [mapillary_classes, coco_classes]),
+        buildings := BinaryMapper("buildings", [m2f_mapillary, m2f_coco, m2f_r50_mapillary],
+                                  buildings_mapping, mode="majority"),
+        BinaryMapper("sky-and-water", [m2f_mapillary, m2f_coco, m2f_r50_mapillary],
+                     sky_and_water_mapping, mode="majority"),
+        BinaryMapper("transportation", [m2f_mapillary, m2f_coco, m2f_r50_mapillary],
+                     transportation_mapping, mode="majority"),
+        BinaryMapper("containing", [m2f_mapillary, m2f_coco, m2f_r50_mapillary], containing_mapping, mode="majority"),
+        BinaryMapper("vegetation", [m2f_mapillary, m2f_coco, m2f_r50_mapillary], vegetation_mapping, mode="majority"),
+        BuildingsFromM2FDepth("buildings(nearby)", [buildings, marigold]),
         SafeLandingAreas("safe-landing-no-sseg", [mapillary_classes, coco_classes]),
-        SafeLandingAreas("safe-landing-semantics", [mapillary_classes, coco_classes],
-                         include_semantics=True, sky_water=sky_water),
+        # SafeLandingAreas("safe-landing-semantics", [mapillary_classes, coco_classes],
+        #                  include_semantics=True, sky_water=sky_water),
     ]
     if tasks_subset is None:
         return {t.name: t for t in available_tasks}