dronescapes_reader/dronescapes_representations.py

"""Dronescapes representations -- adds various loading/writing/image showing capabilities to dronescapes tasks"""
from __future__ import annotations
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):
        super().__init__(*args, **kwargs)
        assert 0 <= min_depth < max_depth, (min_depth, max_depth)
        self.min_depth = min_depth
        self.max_depth = max_depth

    @overrides
    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
        x = x.detach().clip(0, 1).squeeze().cpu().numpy()
        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:
        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."""
    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 and self.n_classes > 1, (color_map, self.n_classes)

    @overrides
    def load_from_disk(self, path: Path) -> tr.Tensor:
        res = super().load_from_disk(path)
        if len(res.shape) == 3:
            assert res.shape[-1] == self.n_classes, f"Expected {self.n_classes} (HxWxC), got {res.shape[-1]}"
            res = res.argmax(-1)
        assert len(res.shape) == 2, f"Only argmaxed data supported, got: {res.shape}"
        res = F.one_hot(res.long(), num_classes=self.n_classes).float()
        return res

    @overrides
    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
        x = x.squeeze().nan_to_num(0).detach().argmax(-1).cpu().numpy()
        new_images = np.zeros((*x.shape, 3), dtype=np.uint8)
        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