various scripts updates. Fixed a bug in transportation mapping

data/train_set/.task_statistics.npz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0007deb4883cf7e34289d1ae3c3fc768d6a8edfbb7c7fbd9599f7e7727b7ad03
-size 17770
+oid sha256:fd711dff3ed71c2d1c3d4821c81615ed07551a35526e2044f0c5f5182091f378
+size 19190

scripts/dronescapes_viewer/dronescapes_representations.py

@@ -0,0 +1,37 @@
+import sys
+from pathlib import Path
+from vre.representations.cv_representations import (
+    DepthRepresentation, NormalsRepresentation, SemanticRepresentation, ColorRepresentation, HSVRepresentation,
+    EdgesRepresentation, OpticalFlowRepresentation)
+from vre.representations import Representation
+sys.path.append(str(Path(__file__).parents[1] / "semantic_mapper"))
+from semantic_mapper import get_new_semantic_mapped_tasks
+
+def get_gt_tasks() -> dict[str, Representation]:
+    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]]
+    classes_8 = ["land", "forest", "residential", "road", "little-objects", "water", "sky", "hill"]
+    tasks = [
+        SemanticRepresentation("semantic_segprop8", classes=classes_8, color_map=color_map),
+        DepthRepresentation("depth_sfm_manual202204", min_depth=0, max_depth=300),
+        NormalsRepresentation("camera_normals_sfm_manual202204"),
+    ]
+    return {t.name: t for t in tasks}
+
+def get_other_tasks() -> dict[str, Representation]:
+    tasks = [
+        rgb := ColorRepresentation("rgb"),
+        # HSVRepresentation("hsv", [rgb]),
+        # DepthRepresentation("depth_dpt", min_depth=0, max_depth=1),
+        # EdgesRepresentation("edges_dexined"),
+        OpticalFlowRepresentation("opticalflow_rife"),
+        DepthRepresentation("depth_marigold", min_depth=0, max_depth=1),
+        NormalsRepresentation("normals_svd(depth_marigold)")
+    ]
+    return {t.name: t for t in tasks}
+
+dronescapes_task_types = {
+    **get_new_semantic_mapped_tasks(),
+    **get_other_tasks(),
+    **get_gt_tasks()
+}

scripts/dronescapes_viewer/dronescapes_viewer.py

@@ -0,0 +1,35 @@
+import sys
+import os
+os.environ["STATS_PBAR"] = "1"
+os.environ["VRE_LOGLEVEL"] = "0"
+from pathlib import Path
+sys.path.append(Path.cwd().parent.__str__())
+from pprint import pprint
+import random
+from vre.readers.multitask_dataset import MultiTaskDataset#, MultiTaskItem
+#from vre.representations import build_representations_from_cfg, add_external_representations, Representation, ReprOut
+from vre.utils import MemoryData, reorder_dict
+from omegaconf import OmegaConf
+import numpy as np
+import torch as tr
+from media_processing_lib.collage_maker import collage_fn
+from media_processing_lib.image import image_add_title, image_write
+import matplotlib.pyplot as plt
+
+from dronescapes_representations import dronescapes_task_types
+
+data_path = "../../data/test_set"
+# data_path = "../vre_dronescapes/atanasie_DJI_0652_full"
+# config_path = "../vre_dronescapes/cfg.yaml"
+# external_path = "../vre_dronescapes/semantic_mapper.py:get_new_semantic_mapped_tasks"
+stats_path = "../../data/train_set/.task_statistics.npz"
+# cfg = OmegaConf.to_container(OmegaConf.load(config_path), resolve=True)
+# representations = build_representations_from_cfg(cfg)
+# representations = add_external_representations(representations, external_path, cfg)
+reader = MultiTaskDataset(data_path, task_names=list(dronescapes_task_types),
+                          task_types=dronescapes_task_types, handle_missing_data="fill_nan",
+                          normalization="min_max", cache_task_stats=True, batch_size_stats=100,
+                          statistics=np.load(stats_path, allow_pickle=True)["arr_0"].item())
+print(reader)
+print("== Shapes ==")
+pprint(reader.data_shape)

scripts/semantic_mapper/semantic_mapper.py

@@ -349,7 +349,8 @@ def get_new_semantic_mapped_tasks(tasks_subset: list[str] | None = None) -> dict
         },
         {
             "others": [c for c in coco_classes if c not in
-                       (cls := ["bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat"])],
+                       (cls := ["bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat",
+                                "road", "railroad", "pavement-merged"])],
             "transportation": cls,
         },
         {

scripts/world_normals_analysis/convert_w2c.py

@@ -0,0 +1,60 @@
+from argparse import ArgumentParser, Namespace
+from pathlib import Path
+from multiprocessing import Pool
+import shutil
+import glob
+from tqdm import tqdm
+from loggez import loggez_logger as logger
+import numpy as np
+
+def w2c(x: np.ndarray, cm: np.ndarray) -> np.ndarray:
+    x1 = (x - 0.5) * 2 # [0:1] -> [-1: 1]
+    x2 = x1 @ np.linalg.inv(cm) # [-1: 1] -> [-1: 1]
+    return x2.clip(-1, 1)
+
+def load(path: Path) -> np.ndarray:
+    return np.load(path, allow_pickle=True)["arr_0"]
+
+def do_one(args: tuple[Path, Path, Path]):
+    in_path, cm_path, out_path = args
+    in_np, cm_np = load(in_path), load(cm_path)
+    out_np = w2c(in_np.astype(np.float32), cm_np).astype(in_np.dtype)
+    np.savez_compressed(out_path, out_np)
+
+def get_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("in_dir", type=Path)
+    parser.add_argument("camera_parameters_dir", type=Path)
+    parser.add_argument("--out_dir", "-o", type=Path, required=True)
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--n_workers", type=int, default=0)
+    args = parser.parse_args()
+    assert not args.out_dir.exists() or args.overwrite, f"'{args.out_dir}' exists. Use --overwrite"
+
+    return args
+
+def main(args: Namespace):
+    logger.info(f"- In dir: '{args.in_dir}'")
+    logger.info(f"- Camera Parameters dir: '{args.camera_parameters_dir}'")
+    logger.info(f"- Out dir: '{args.camera_parameters_dir}'")
+    in_paths = list(map(Path, glob.glob(f"{args.in_dir}/**/*.npz", recursive=True)))
+    out_paths = [args.out_dir / in_path.name for in_path in in_paths]
+    assert len(in_paths) > 0, (args.in_dir, in_paths)
+    logger.info(f"npz files found: {len(in_paths)}")
+    shutil.rmtree(args.out_dir, ignore_errors=True)
+    Path(args.out_dir).mkdir()
+
+    cm_paths = []
+    for path in in_paths:
+        path_split = path.stem.split("_")
+        scene, scene_ix = "_".join(path_split[0:-1]), path_split[-1]
+        cm_path = Path(args.camera_parameters_dir) / scene / f"cameraRotationMatrices/{scene_ix:0>6}.npz"
+        assert cm_path.exists(), (path, cm_path)
+        cm_paths.append(cm_path)
+    logger.info("Found all camera matrices paths")
+
+    map_fn = map if args.n_workers == 0 else Pool(args.n_workers).imap
+    list(map_fn(do_one, tqdm(zip(in_paths, cm_paths, out_paths), total=len(in_paths))))
+
+if __name__ == "__main__":
+    main(get_args())

scripts/world_normals_analysis/world_to_camera_normals.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -12,12 +12,7 @@
     "os.environ[\"VRE_LOGLEVEL\"] = \"0\"\n",
     "from pathlib import Path\n",
     "sys.path.append(Path.cwd().parent.__str__())\n",
-    "from pprint import pprint\n",
-    "import random\n",
-    "from vre.readers.multitask_dataset import MultiTaskDataset, MultiTaskItem\n",
-    "from vre.representations import build_representations_from_cfg, add_external_representations, Representation, ReprOut\n",
     "from vre.utils import MemoryData, reorder_dict, lo, FakeVideo\n",
-    "from omegaconf import OmegaConf\n",
     "import numpy as np\n",
     "import torch as tr\n",
     "from media_processing_lib.collage_maker import collage_fn\n",
@@ -66,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -83,15 +78,15 @@
     }
    ],
    "source": [
-    "# scene = \"atanasie_DJI_0652_full\"\n",
-    "scene = \"herculane_DJI_0021_full\"\n",
-    "marigolds_path = f\"../vre_dronescapes/{scene}/normals_svd(depth_marigold)/npz\"\n",
-    "cms_path = f\"../raw_data/camera_matrices/{scene}/cameraRotationMatrices\"\n",
-    "# buildings_path = f\"../vre_dronescapes/{scene}/buildings/npz\"\n",
-    "normals_path = \"../data\"\n",
+    "scene = \"atanasie_DJI_0652_full\"\n",
+    "# scene = \"herculane_DJI_0021_full\"\n",
+    "marigolds_path = f\"../../vre_dronescapes/{scene}/normals_svd(depth_marigold)/npz\"\n",
+    "cms_path = f\"../../raw_data/camera_matrices/{scene}/cameraRotationMatrices\"\n",
+    "buildings_path = f\"../../vre_dronescapes/{scene}/buildings/npz\"\n",
+    "normals_path = \"../../data\"\n",
     "\n",
     "marigold_data = natsorted(Path(marigolds_path).iterdir(), key=lambda p: p.name)\n",
-    "# buildings_data = natsorted(Path(buildings_path).iterdir(), key=lambda p: p.name)\n",
+    "buildings_data = natsorted(Path(buildings_path).iterdir(), key=lambda p: p.name)\n",
     "cms_data = natsorted(Path(cms_path).iterdir(), key=lambda p: p.name)\n",
     "\n",
     "normals_all = list(map(Path, glob.glob(f\"{normals_path}/**/normals_sfm_manual202204/**/{scene}*.npz\", recursive=True)))\n",
@@ -269,16 +264,16 @@
     "    imgs = [*imgs, C_collage]\n",
     "    titles, diffs = [*titles, f\"inv + permute axis {comb}\"], [*diffs, C_diff]\n",
     "\n",
-    "# display(pd.DataFrame(diffs, index=titles, columns=ixs).sum(1).to_frame().fillna(0).sort_values(0))\n",
-    "# sorted_ixs = np.argsort(pd.DataFrame(diffs, index=titles, columns=ixs).sum(1)).values\n",
-    "# imgs, titles = [imgs[ix] for ix in sorted_ixs], [titles[ix] for ix in sorted_ixs]\n",
-    "# collage = collage_fn(imgs, rows_cols=(len(imgs), 1), titles=titles, size_px=25, pad_to_max=False)\n",
-    "# display(Image.fromarray(collage))\n"
+    "display(pd.DataFrame(diffs, index=titles, columns=ixs).sum(1).to_frame().fillna(0).sort_values(0))\n",
+    "sorted_ixs = np.argsort(pd.DataFrame(diffs, index=titles, columns=ixs).sum(1)).values\n",
+    "imgs, titles = [imgs[ix] for ix in sorted_ixs], [titles[ix] for ix in sorted_ixs]\n",
+    "collage = collage_fn(imgs, rows_cols=(len(imgs), 1), titles=titles, size_px=25, pad_to_max=False)\n",
+    "display(Image.fromarray(collage))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -313,7 +308,7 @@
     "print(frames.shape)\n",
     "video = FakeVideo(frames, fps=10)\n",
     "print(video)\n",
-    "video.write(\"herculane.mp4\")"
+    "video.write(\"atanasie.mp4\")"
    ]
   },
   {