Splasher V1.0

Splasher is a labeled for 3d point cloud to a 2d grid!

README.md

@@ -0,0 +1,51 @@
+# Splasher
+
+Outil de **labélisation** dont le cœur est générique : on lui donne un *dataset
+synchrone* — à chaque instant, un **pack de canaux nommés** (nuage de points 3D,
+image caméra, pose, …) — et on labélise soit une **grille 2D vue-de-dessus (BEV)**,
+soit directement les **points 3D**, soit les deux.
+
+Premier cas d'usage : la **traversabilité**. Mais rien n'est câblé en dur : pas de
+schéma de classes imposé, pas de sémantique monde imposée, et **aucune dépendance
+obligatoire à un format de dataset**. apairo n'est qu'un adaptateur d'entrée optionnel.
+
+## Idée
+
+- Plusieurs canaux synchronisés, affichés comme références : on se balade librement
+  dans le nuage 3D, on regarde les images caméra.
+- On choisit les **canaux** à afficher (dock *Canaux* : montrer/masquer chaque nuage
+  ou caméra disponible dans la source — plusieurs caméras et nuages possibles).
+- On **dessine la grille de carrés** (vue de dessus) : son étendue et la taille de
+  chaque carré, créée explicitement via **« Nouvelle grille »**. L'annulation (undo)
+  est **par frame**.
+- On **sélectionne un rectangle** à la souris sur cette vue de dessus. Selon la cible :
+  - **Grid** : remplit les carrés couverts de la classe active (sortie = raster d'IDs).
+  - **Points** : assigne la classe aux points 3D dans le rectangle (sortie = labels par point).
+- Mode **Sélection** (façon bureau) : tracer un rectangle sélectionne des cellules
+  (**Shift** = ajouter, sélections non contiguës possibles), puis on **applique** la classe
+  à toute la sélection d'un coup. Changer de grille demande **confirmation** si une
+  labélisation existe déjà.
+- **Cumul** : on peut cumuler ±N frames **recalées par leurs poses** dans le repère du
+  frame courant (nuage plus dense pour mieux labéliser). La grille et les labels restent
+  **par frame** : un coup de pinceau sur le nuage cumulé est **décumulé** vers chaque
+  frame source. (Nécessite un canal `POSE`.)
+
+## Installation
+
+```bash
+cd ~/dev/splasher
+uv sync                 # cœur seul (numpy + Qt)
+uv sync --extra apairo  # + adaptateur apairo (optionnel)
+```
+
+## Démo (zéro donnée externe)
+
+```bash
+uv run python examples/demo_arraysource.py
+```
+
+## Entrée
+
+Le cœur consomme une `Source` : `__len__`, `__getitem__(i) -> Frame`, `channels()`.
+`ArraySource` en construit une depuis des tableaux numpy en mémoire. `ApairoSource`
+(extra `apairo`) enveloppe tout dataset apairo synchrone.

examples/demo_arraysource.py

@@ -0,0 +1,10 @@
+"""Lance Splasher sur une source synthétique — aucune donnée externe requise.
+
+    uv run python examples/demo_arraysource.py
+"""
+
+from splasher import launch
+from splasher.demo import make_demo_source
+
+if __name__ == "__main__":
+    launch(make_demo_source(), title="Splasher — démo")

pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "splasher"
+version = "0.1.0"
+description = "Labélisation : canaux synchronisés (nuages 3D, images) -> grille 2D BEV ou labels par point"
+readme = "README.md"
+authors = [{ name = "Augustin Bresset", email = "augustin.bresset@gmail.com" }]
+requires-python = ">=3.11"
+dependencies = [
+    "numpy",
+    "pyqtgraph",
+    "PySide6",
+    "PyOpenGL",
+]
+
+# apairo n'est qu'UN adaptateur d'entrée optionnel — le cœur n'en dépend pas.
+[project.optional-dependencies]
+apairo = [
+    "apairo @ git+https://github.com/apairo-robotics/apairo.git",
+    "PyYAML",
+]
+
+[project.scripts]
+splasher = "splasher.cli:main"
+
+[dependency-groups]
+dev = ["pytest"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["splasher"]
+
+[tool.hatch.metadata]
+allow-direct-references = true

splasher/__init__.py

@@ -0,0 +1,33 @@
+"""Splasher — labélisation de canaux synchronisés vers une grille 2D BEV ou des labels par point.
+
+Le cœur (`splasher.core`) ne dépend que de numpy et reste importable sans toolkit UI.
+L'UI (PySide6/pyqtgraph) n'est chargée qu'au moment de `launch()`.
+"""
+
+from __future__ import annotations
+
+from .core.source import ChannelKind, ChannelSpec, Frame, Source, channels_of_kind
+from .core.array_source import ArraySource
+from .core.grid import Grid, grid_from_points
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ChannelKind",
+    "ChannelSpec",
+    "Frame",
+    "Source",
+    "channels_of_kind",
+    "ArraySource",
+    "Grid",
+    "grid_from_points",
+    "launch",
+    "__version__",
+]
+
+
+def launch(*args, **kwargs):
+    """Ouvre la fenêtre Splasher sur une `Source`. Importe l'UI paresseusement."""
+    from .ui.app import launch as _launch
+
+    return _launch(*args, **kwargs)

splasher/adapters/__init__.py

@@ -0,0 +1 @@
+"""Adaptateurs d'entrée optionnels (apairo, …). Aucun n'est requis par le cœur."""

splasher/adapters/apairo_source.py

@@ -0,0 +1,72 @@
+"""Adaptateur **optionnel** : un dataset apairo synchrone -> `Source` Splasher.
+
+apairo n'est pas importé au niveau module : seul `from_path` le charge. La classe
+fonctionne en duck-typing sur n'importe quel objet façon apairo
+(`is_synchronous`, `keys`, `__len__`, `__getitem__` -> objet avec `.data`/`.timestamp`).
+Installer via l'extra : `uv sync --extra apairo`.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from ..core.source import ChannelKind, ChannelSpec, Frame
+
+
+def _kind_of(arr: np.ndarray) -> ChannelKind:
+    """Devine le `ChannelKind` d'un canal apairo d'après la forme du tableau."""
+    if arr.ndim == 3 and arr.shape[2] in (1, 3, 4):
+        return ChannelKind.IMAGE
+    if arr.shape in ((4, 4), (3, 4)) or arr.shape == (7,):
+        return ChannelKind.POSE
+    if arr.ndim == 2 and arr.shape[1] >= 3:
+        return ChannelKind.POINTCLOUD
+    return ChannelKind.SCALAR  # ex. labels (N,)
+
+
+class ApairoSource:
+    """Enveloppe un dataset apairo **synchrone** en `Source`."""
+
+    def __init__(self, dataset, keys: list[str] | None = None) -> None:
+        if not getattr(dataset, "is_synchronous", False):
+            raise ValueError(
+                "ApairoSource requiert un dataset apairo synchrone — "
+                "appelez ds.synchronize(reference=..., tolerance=...) d'abord."
+            )
+        self._ds = dataset
+        self._keys = list(keys) if keys is not None else list(dataset.keys)
+        self._specs = self._classify()
+
+    def _classify(self) -> list[ChannelSpec]:
+        sample = self._ds[0]
+        specs = []
+        for k in self._keys:
+            arr = np.asarray(sample.data[k])
+            specs.append(ChannelSpec(k, _kind_of(arr), arr.dtype, tuple(arr.shape)))
+        return specs
+
+    def __len__(self) -> int:
+        return len(self._ds)
+
+    def __getitem__(self, index: int) -> Frame:
+        s = self._ds[index]
+        channels = {k: np.asarray(s.data[k]) for k in self._keys if k in s.data}
+        return Frame(channels=channels, timestamp=getattr(s, "timestamp", None))
+
+    def channels(self) -> list[ChannelSpec]:
+        return list(self._specs)
+
+    @classmethod
+    def from_path(cls, path: str, *, keys: list[str] | None = None,
+                  reference: str | None = None, tolerance: float = 0.1) -> "ApairoSource":
+        """Ouvre un `RawDataset` apairo et le synchronise si besoin."""
+        import apairo  # import paresseux — l'extra `apairo` doit être installé
+
+        ds = apairo.RawDataset(path, keys=keys) if keys else apairo.RawDataset(path)
+        if not ds.is_synchronous:
+            if reference is None:
+                raise ValueError(
+                    "dataset asynchrone : précisez reference=<canal> pour la synchronisation."
+                )
+            ds = ds.synchronize(reference=reference, tolerance=tolerance)
+        return cls(ds, keys=keys)

splasher/cli.py

@@ -0,0 +1,38 @@
+"""CLI Splasher.
+
+    splasher demo                      # source synthétique (zéro donnée externe)
+    splasher <chemin> --adapter apairo # via l'adaptateur apairo (extra optionnel)
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="splasher", description=__doc__)
+    parser.add_argument("path", nargs="?", help="chemin du dataset, ou 'demo'")
+    parser.add_argument("--adapter", choices=["apairo"], help="adaptateur d'entrée")
+    args = parser.parse_args(argv)
+
+    from . import launch
+
+    if args.path in (None, "demo"):
+        from .demo import make_demo_source
+
+        launch(make_demo_source(), title="Splasher — démo")
+        return 0
+
+    if args.adapter == "apairo":
+        from .adapters.apairo_source import ApairoSource
+
+        launch(ApairoSource.from_path(args.path), title=f"Splasher — {args.path}")
+        return 0
+
+    parser.error("précise un --adapter (ex. --adapter apairo) ou utilise 'demo'")
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

splasher/core/__init__.py

@@ -0,0 +1 @@
+"""Cœur de Splasher : protocole d'entrée, grille, projection, cibles de labels. numpy uniquement."""

splasher/core/accumulate.py

@@ -0,0 +1,91 @@
+"""Cumul de frames par registration des poses, avec traçabilité pour le décumul.
+
+On accumule une fenêtre de frames **dans le repère du frame de référence** (le frame
+courant) : chaque frame `j` est ramené par `inv(pose_ref) @ pose_j`. Chaque point
+accumulé garde :
+- `frame_id` : frame source,
+- `chan_id`  : indice du canal nuage source (dans `cloud_keys`),
+- `point_id` : indice du point dans **la concaténation complète** des canaux nuage de
+  ce frame (ordre = `cloud_keys`), fixe quelle que soit la visibilité des canaux.
+
+Cela permet de **décumuler** des labels peints sur le nuage cumulé vers chaque frame
+d'origine, et de **filtrer par canal** sans jamais désaligner les labels points
+(qui restent dimensionnés sur la concaténation complète).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from .poses import invert, pose_to_matrix, transform_points
+
+
+@dataclass
+class Accumulation:
+    points: np.ndarray          # (M, 3+) dans le repère de référence
+    frame_id: np.ndarray        # (M,) frame source
+    chan_id: np.ndarray         # (M,) indice de canal nuage source
+    point_id: np.ndarray        # (M,) indice dans la concaténation complète du frame
+    counts: dict[int, int] = field(default_factory=dict)  # frame -> nb total de points
+
+    @property
+    def xy(self) -> np.ndarray:
+        return self.points[:, :2]
+
+    def visible_mask(self, visible_chan_indices) -> np.ndarray:
+        """Masque des points dont le canal est dans `visible_chan_indices`."""
+        if len(self.chan_id) == 0:
+            return np.zeros(0, dtype=bool)
+        return np.isin(self.chan_id, np.asarray(list(visible_chan_indices), dtype=np.int64))
+
+
+def window_indices(ref_idx: int, radius: int, n_frames: int) -> list[int]:
+    """Fenêtre `[ref-radius, ref+radius]` bornée à `[0, n_frames)`."""
+    lo = max(0, ref_idx - radius)
+    hi = min(n_frames, ref_idx + radius + 1)
+    return list(range(lo, hi))
+
+
+def accumulate(source, ref_idx: int, indices: list[int], cloud_keys: list[str],
+               pose_key: str | None = None) -> Accumulation:
+    """Accumule `indices` dans le repère de `ref_idx`. `pose_key=None` -> identité."""
+    p_ref_inv = None
+    if pose_key is not None:
+        p_ref_inv = invert(pose_to_matrix(source[ref_idx].channels[pose_key]))
+
+    pts, fids, cids, pids = [], [], [], []
+    counts: dict[int, int] = {}
+    for j in indices:
+        frame = source[j]
+        if pose_key is not None and j != ref_idx:
+            T = p_ref_inv @ pose_to_matrix(frame.channels[pose_key])
+        else:
+            T = None  # identité (frame de référence, ou pas de pose)
+
+        offset = 0
+        for ci, key in enumerate(cloud_keys):
+            p = frame.channels.get(key)
+            if p is None or len(p) == 0:
+                continue
+            q = np.asarray(p, dtype=np.float64).copy() if T is None else transform_points(p, T)
+            m = len(p)
+            pts.append(q)
+            fids.append(np.full(m, j, dtype=np.int64))
+            cids.append(np.full(m, ci, dtype=np.int64))
+            pids.append(offset + np.arange(m, dtype=np.int64))
+            offset += m
+        counts[j] = offset
+
+    if pts:
+        return Accumulation(
+            np.concatenate(pts, axis=0),
+            np.concatenate(fids),
+            np.concatenate(cids),
+            np.concatenate(pids),
+            counts,
+        )
+    return Accumulation(
+        np.zeros((0, 3)), np.zeros(0, np.int64), np.zeros(0, np.int64), np.zeros(0, np.int64), counts
+    )

splasher/core/array_source.py

@@ -0,0 +1,55 @@
+"""`ArraySource` — une `Source` construite depuis des tableaux numpy en mémoire.
+
+C'est l'entrée par défaut, sans aucune dépendance : utile pour les démos, les
+tests, et tout pipeline qui produit déjà des arrays. Aucune I/O cachée.
+"""
+
+from __future__ import annotations
+
+from typing import Mapping, Sequence
+
+import numpy as np
+
+from .source import ChannelSpec, Frame, Source
+
+
+class ArraySource(Source):
+    """Source synchrone en mémoire.
+
+    Parameters
+    ----------
+    specs:
+        Description des canaux (`ChannelSpec`). L'ordre est conservé.
+    frames:
+        Une séquence de dicts `{nom_canal: np.ndarray}`, un par pas de temps.
+    timestamps:
+        Optionnel ; horodatages par frame. `None` (défaut) = synchrone.
+    """
+
+    def __init__(
+        self,
+        specs: Sequence[ChannelSpec],
+        frames: Sequence[Mapping[str, np.ndarray]],
+        timestamps: Sequence[float] | None = None,
+    ) -> None:
+        self._specs = list(specs)
+        self._frames = [dict(f) for f in frames]
+        if timestamps is not None and len(timestamps) != len(self._frames):
+            raise ValueError("timestamps doit avoir la même longueur que frames")
+        self._timestamps = None if timestamps is None else [float(t) for t in timestamps]
+
+        names = {s.name for s in self._specs}
+        for i, fr in enumerate(self._frames):
+            missing = names - set(fr.keys())
+            if missing:
+                raise ValueError(f"frame {i}: canaux manquants {sorted(missing)}")
+
+    def __len__(self) -> int:
+        return len(self._frames)
+
+    def __getitem__(self, index: int) -> Frame:
+        ts = None if self._timestamps is None else self._timestamps[index]
+        return Frame(channels=dict(self._frames[index]), timestamp=ts)
+
+    def channels(self) -> list[ChannelSpec]:
+        return list(self._specs)

splasher/core/colormap.py

@@ -0,0 +1,51 @@
+"""Petit colormap viridis numpy-pur (pas de matplotlib) : valeurs -> RGBA float [0,1]."""
+
+from __future__ import annotations
+
+import numpy as np
+
+# Ancres viridis approximées (0 -> 1).
+_VIRIDIS = (
+    np.array(
+        [
+            [68, 1, 84],
+            [59, 82, 139],
+            [33, 145, 140],
+            [94, 201, 98],
+            [253, 231, 37],
+        ],
+        dtype=np.float32,
+    )
+    / 255.0
+)
+
+
+def colormap(values, *, vmin: float | None = None, vmax: float | None = None,
+             alpha: float = 1.0, lut: np.ndarray = _VIRIDIS) -> np.ndarray:
+    """Mappe `values` (1D) vers un tableau RGBA `(N, 4)` float32 dans [0, 1].
+
+    `vmin`/`vmax` par défaut = min/max finis des valeurs.
+    """
+    v = np.asarray(values, dtype=np.float32).ravel()
+    finite = np.isfinite(v)
+    if vmin is None:
+        vmin = float(v[finite].min()) if finite.any() else 0.0
+    if vmax is None:
+        vmax = float(v[finite].max()) if finite.any() else 1.0
+    if vmax <= vmin:
+        vmax = vmin + 1.0
+
+    t = np.clip((v - vmin) / (vmax - vmin), 0.0, 1.0)
+    t = np.where(finite, t, 0.0)
+
+    n = len(lut) - 1
+    pos = t * n
+    lo = np.floor(pos).astype(np.intp)
+    hi = np.minimum(lo + 1, n)
+    frac = (pos - lo)[:, None]
+    rgb = lut[lo] * (1.0 - frac) + lut[hi] * frac
+
+    out = np.empty((v.shape[0], 4), dtype=np.float32)
+    out[:, :3] = rgb
+    out[:, 3] = alpha
+    return out

splasher/core/grid.py

@@ -0,0 +1,111 @@
+"""`Grid` — la grille de carrés vue-de-dessus (BEV), définie en unités monde.
+
+C'est la première chose qu'on conçoit : une étendue monde `(xmin..xmax, ymin..ymax)`
+et la taille d'un carré `cell_size` (mètres). On en déduit `cols × rows`. La grille
+fournit le mapping monde <-> cellule, un raster vide, et les segments de lignes pour
+l'affichage.
+
+Conventions :
+- `j` (colonne) indexe `x` : `j = floor((x - xmin) / cell_size)`
+- `i` (ligne)   indexe `y` : `i = floor((y - ymin) / cell_size)`
+- un raster a la forme `(rows, cols)`, indexé `raster[i, j]`
+- l'origine `(xmin, ymin)` est en bas-gauche, `y` vers le haut.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Grid:
+    xmin: float
+    xmax: float
+    ymin: float
+    ymax: float
+    cell_size: float
+
+    def __post_init__(self) -> None:
+        if self.cell_size <= 0:
+            raise ValueError("cell_size doit être > 0")
+        if self.xmax <= self.xmin or self.ymax <= self.ymin:
+            raise ValueError("étendue invalide (xmax > xmin et ymax > ymin requis)")
+
+    # --- dimensions -------------------------------------------------------
+    @property
+    def cols(self) -> int:
+        return max(1, math.ceil((self.xmax - self.xmin) / self.cell_size))
+
+    @property
+    def rows(self) -> int:
+        return max(1, math.ceil((self.ymax - self.ymin) / self.cell_size))
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return (self.rows, self.cols)
+
+    @property
+    def width(self) -> float:
+        """Largeur réelle couverte par les carrés (cols * cell_size)."""
+        return self.cols * self.cell_size
+
+    @property
+    def height(self) -> float:
+        return self.rows * self.cell_size
+
+    @property
+    def extent(self) -> tuple[float, float, float, float]:
+        return (self.xmin, self.xmax, self.ymin, self.ymax)
+
+    # --- mapping monde <-> cellule ---------------------------------------
+    def world_to_cell(self, xy: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """`xy` (N, 2) -> (`ij` (N, 2) int [ligne, colonne], `valid` (N,) bool)."""
+        xy = np.asarray(xy, dtype=np.float64).reshape(-1, 2)
+        j = np.floor((xy[:, 0] - self.xmin) / self.cell_size).astype(np.intp)
+        i = np.floor((xy[:, 1] - self.ymin) / self.cell_size).astype(np.intp)
+        valid = (j >= 0) & (j < self.cols) & (i >= 0) & (i < self.rows)
+        return np.stack([i, j], axis=1), valid
+
+    def cell_to_world(self, i: int, j: int) -> tuple[float, float]:
+        """Centre monde de la cellule `(i, j)`."""
+        x = self.xmin + (j + 0.5) * self.cell_size
+        y = self.ymin + (i + 0.5) * self.cell_size
+        return (x, y)
+
+    def empty_raster(self, fill: int = 0, dtype=np.int32) -> np.ndarray:
+        return np.full((self.rows, self.cols), fill, dtype=dtype)
+
+    # --- affichage --------------------------------------------------------
+    def image_rect(self) -> tuple[float, float, float, float]:
+        """`(x, y, w, h)` pour positionner un `ImageItem (rows, cols)` en coords monde."""
+        return (self.xmin, self.ymin, self.width, self.height)
+
+    def line_segments(self) -> tuple[np.ndarray, np.ndarray]:
+        """Segments des lignes de la grille pour un tracé `connect='pairs'`."""
+        x0, y0 = self.xmin, self.ymin
+        x1, y1 = self.xmin + self.width, self.ymin + self.height
+        vx = self.xmin + self.cell_size * np.arange(self.cols + 1)
+        hy = self.ymin + self.cell_size * np.arange(self.rows + 1)
+
+        xs_v = np.repeat(vx, 2)
+        ys_v = np.tile([y0, y1], self.cols + 1)
+        xs_h = np.tile([x0, x1], self.rows + 1)
+        ys_h = np.repeat(hy, 2)
+
+        xs = np.concatenate([xs_v, xs_h]).astype(np.float64)
+        ys = np.concatenate([ys_v, ys_h]).astype(np.float64)
+        return xs, ys
+
+
+def grid_from_points(xy: np.ndarray, cell_size: float = 1.0,
+                     margin: float = 2.0) -> Grid:
+    """Grille par défaut englobant un nuage de points top-down `xy` (N, 2)."""
+    xy = np.asarray(xy, dtype=np.float64).reshape(-1, 2)
+    if len(xy) == 0:
+        return Grid(-10.0, 10.0, -10.0, 10.0, cell_size)
+    lo = np.floor(xy.min(axis=0) - margin)
+    hi = np.ceil(xy.max(axis=0) + margin)
+    return Grid(float(lo[0]), float(hi[0]), float(lo[1]), float(hi[1]), cell_size)

splasher/core/io.py

@@ -0,0 +1,101 @@
+"""Sauvegarde/chargement d'une session de labels — fichiers autonomes.
+
+Format sur disque (dossier de sortie) :
+
+    session.json          # grille (étendue, cell_size) + jeu de classes
+    grid/frame_00007.npy  # raster d'ids (rows, cols), un par sample labélisé
+    grid/frame_00007.png  # même raster colorisé (aperçu, y vers le haut)
+    grid/global.npy       # raster global (si labélisé)
+    points/frame_00007.npy# labels (N,) int64 par frame (segmentation)
+
+Les `.npy`/`.json` n'utilisent que numpy + stdlib. Le `.png` (aperçu) passe par Qt
+si disponible, sinon il est simplement omis.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+
+from .grid import Grid
+from .labels import LabelSet
+
+
+def _save_png(path: Path, rgba: np.ndarray) -> bool:
+    try:
+        from PySide6.QtGui import QImage
+    except Exception:
+        return False
+    arr = np.ascontiguousarray(np.flipud(rgba).astype(np.uint8))  # y vers le haut à l'écran
+    h, w = arr.shape[:2]
+    img = QImage(arr.data, w, h, 4 * w, QImage.Format_RGBA8888)
+    return bool(img.copy().save(str(path)))
+
+
+def save_session(out_dir, *, grid: Grid, labelset: LabelSet,
+                 grid_target=None, point_target=None) -> Path:
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    meta = {
+        "grid": {
+            "xmin": grid.xmin, "xmax": grid.xmax,
+            "ymin": grid.ymin, "ymax": grid.ymax,
+            "cell_size": grid.cell_size, "rows": grid.rows, "cols": grid.cols,
+        },
+        "labels": labelset.to_dict(),
+    }
+    (out / "session.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False))
+
+    if grid_target is not None:
+        gd = out / "grid"
+        gd.mkdir(exist_ok=True)
+        for fi, raster in grid_target.rasters().items():
+            np.save(gd / f"frame_{fi:05d}.npy", raster)
+            _save_png(gd / f"frame_{fi:05d}.png", labelset.colorize(raster, alpha=255))
+        glob = grid_target.global_raster()
+        if (glob != labelset.ignore_id).any():
+            np.save(gd / "global.npy", glob)
+            _save_png(gd / "global.png", labelset.colorize(glob, alpha=255))
+
+    if point_target is not None:
+        pd = out / "points"
+        pd.mkdir(exist_ok=True)
+        for fi, lab in point_target.all_labels().items():
+            np.save(pd / f"frame_{fi:05d}.npy", lab)
+
+    return out
+
+
+def _frame_idx(path: Path) -> int:
+    return int(path.stem.split("_")[1])
+
+
+def load_session(out_dir) -> dict:
+    """Renvoie `{grid, labelset, grid_labels: {i: raster}, point_labels: {i: (N,)}}`."""
+    out = Path(out_dir)
+    meta = json.loads((out / "session.json").read_text())
+    g = meta["grid"]
+    grid = Grid(g["xmin"], g["xmax"], g["ymin"], g["ymax"], g["cell_size"])
+    labelset = LabelSet.from_dict(meta["labels"])
+
+    grid_labels: dict[int, np.ndarray] = {}
+    gd = out / "grid"
+    if gd.is_dir():
+        for p in sorted(gd.glob("frame_*.npy")):
+            grid_labels[_frame_idx(p)] = np.load(p)
+
+    point_labels: dict[int, np.ndarray] = {}
+    pd = out / "points"
+    if pd.is_dir():
+        for p in sorted(pd.glob("frame_*.npy")):
+            point_labels[_frame_idx(p)] = np.load(p)
+
+    return {
+        "grid": grid,
+        "labelset": labelset,
+        "grid_labels": grid_labels,
+        "point_labels": point_labels,
+    }

splasher/core/labels.py

@@ -0,0 +1,96 @@
+"""`LabelSet` — l'ensemble des classes de labélisation (id, nom, couleur).
+
+Générique : aucune classe n'est imposée. Un défaut « traversabilité » est fourni,
+mais on peut charger/sauver n'importe quel jeu de classes en JSON.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+RGB = tuple[int, int, int]
+
+
+@dataclass(frozen=True)
+class LabelClass:
+    id: int
+    name: str
+    color: RGB
+
+
+class LabelSet:
+    def __init__(self, classes: list[LabelClass], ignore_id: int = 0) -> None:
+        self.classes = list(classes)
+        self.ignore_id = ignore_id
+        self._by_id = {c.id: c for c in self.classes}
+
+    @property
+    def max_id(self) -> int:
+        return max((c.id for c in self.classes), default=0)
+
+    @property
+    def paintable(self) -> list[LabelClass]:
+        """Classes assignables (toutes sauf `ignore`)."""
+        return [c for c in self.classes if c.id != self.ignore_id]
+
+    def color_of(self, class_id: int) -> RGB:
+        c = self._by_id.get(class_id)
+        return c.color if c else (0, 0, 0)
+
+    def name_of(self, class_id: int) -> str:
+        c = self._by_id.get(class_id)
+        return c.name if c else str(class_id)
+
+    def lut(self, alpha: int = 255, max_id: int | None = None) -> np.ndarray:
+        """LUT RGBA `(K, 4)` uint8 indexée par id. `ignore_id` -> alpha 0."""
+        top = self.max_id if max_id is None else max(max_id, self.max_id)
+        lut = np.zeros((top + 1, 4), dtype=np.uint8)
+        for c in self.classes:
+            if c.id == self.ignore_id or c.id < 0 or c.id > top:
+                continue
+            lut[c.id, :3] = c.color
+            lut[c.id, 3] = alpha
+        return lut
+
+    def colorize(self, raster: np.ndarray, alpha: int = 255) -> np.ndarray:
+        """Raster d'ids `(rows, cols)` -> image RGBA `(rows, cols, 4)` uint8."""
+        max_id = int(raster.max()) if raster.size else 0
+        return self.lut(alpha=alpha, max_id=max_id)[raster]
+
+    # --- (dé)sérialisation ------------------------------------------------
+    def to_dict(self) -> dict:
+        return {
+            "ignore_id": self.ignore_id,
+            "classes": [
+                {"id": c.id, "name": c.name, "color": list(c.color)} for c in self.classes
+            ],
+        }
+
+    def save(self, path: str | Path) -> None:
+        Path(path).write_text(json.dumps(self.to_dict(), indent=2, ensure_ascii=False))
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "LabelSet":
+        classes = [LabelClass(c["id"], c["name"], tuple(c["color"])) for c in d["classes"]]
+        return cls(classes, ignore_id=d.get("ignore_id", 0))
+
+    @classmethod
+    def load(cls, path: str | Path) -> "LabelSet":
+        return cls.from_dict(json.loads(Path(path).read_text()))
+
+    @classmethod
+    def default(cls) -> "LabelSet":
+        """Jeu par défaut orienté traversabilité (modifiable / remplaçable)."""
+        return cls(
+            [
+                LabelClass(0, "non labélisé", (0, 0, 0)),
+                LabelClass(1, "traversable", (60, 200, 70)),
+                LabelClass(2, "obstacle", (220, 50, 45)),
+                LabelClass(3, "incertain", (235, 170, 30)),
+            ],
+            ignore_id=0,
+        )

splasher/core/poses.py

@@ -0,0 +1,60 @@
+"""Poses rigides : conversion en matrice 4x4, inversion, transformation de points.
+
+Réimplémenté ici (≈30 lignes) pour ne pas dépendre d'apairo_visu / Open3D.
+Formats acceptés : `(4, 4)`, `(3, 4)`, ou vecteur `(7,)` `[x, y, z, qx, qy, qz, qw]`.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def _quat_to_R(q: np.ndarray) -> np.ndarray:
+    x, y, z, w = q
+    n = x * x + y * y + z * z + w * w
+    if n < 1e-12:
+        return np.eye(3)
+    s = 2.0 / n
+    return np.array(
+        [
+            [1 - s * (y * y + z * z), s * (x * y - z * w), s * (x * z + y * w)],
+            [s * (x * y + z * w), 1 - s * (x * x + z * z), s * (y * z - x * w)],
+            [s * (x * z - y * w), s * (y * z + x * w), 1 - s * (x * x + y * y)],
+        ]
+    )
+
+
+def pose_to_matrix(pose: np.ndarray) -> np.ndarray:
+    """Normalise une pose en matrice homogène `(4, 4)` float64."""
+    pose = np.asarray(pose, dtype=np.float64)
+    if pose.shape == (4, 4):
+        return pose.copy()
+    if pose.shape == (3, 4):
+        T = np.eye(4)
+        T[:3, :4] = pose
+        return T
+    if pose.shape == (7,):
+        T = np.eye(4)
+        T[:3, :3] = _quat_to_R(pose[3:])
+        T[:3, 3] = pose[:3]
+        return T
+    raise ValueError(f"forme de pose non supportée : {pose.shape}")
+
+
+def invert(T: np.ndarray) -> np.ndarray:
+    """Inverse d'une transformation rigide `(4, 4)`."""
+    R = T[:3, :3]
+    t = T[:3, 3]
+    Ti = np.eye(4)
+    Ti[:3, :3] = R.T
+    Ti[:3, 3] = -R.T @ t
+    return Ti
+
+
+def transform_points(points: np.ndarray, T: np.ndarray) -> np.ndarray:
+    """Applique `T` aux colonnes xyz de `points` (N, 3+) ; les colonnes en plus sont conservées."""
+    if len(points) == 0:
+        return points.copy()
+    out = np.asarray(points, dtype=np.float64).copy()
+    out[:, :3] = points[:, :3] @ T[:3, :3].T + T[:3, 3]
+    return out

splasher/core/projection.py

@@ -0,0 +1,86 @@
+"""Projection BEV : nuage de points -> cellules de la grille, et sélection par rectangle.
+
+Tout est vectorisé numpy. Sert :
+- la sous-couche de la vue de dessus (densité / hauteur par cellule),
+- la cible Grid (cellules couvertes par un rectangle),
+- la cible Points + le surlignage (masque des points dans un rectangle).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .colormap import colormap
+from .grid import Grid
+
+Rect = tuple[float, float, float, float]  # (x0, y0, x1, y1) en coords monde
+
+
+def points_to_cells(xy: np.ndarray, grid: Grid):
+    """Raccourci vers `grid.world_to_cell` : `xy` (N, 2) -> (`ij` (N, 2), `valid`)."""
+    return grid.world_to_cell(xy)
+
+
+def _reduce_per_cell(points: np.ndarray, grid: Grid, op: str) -> np.ndarray:
+    """Réduit une grandeur par cellule. `op` = 'max_z' ou 'count'. Cellules vides = NaN."""
+    out = np.full(grid.rows * grid.cols, -np.inf if op == "max_z" else 0.0, dtype=np.float64)
+    if len(points):
+        ij, valid = grid.world_to_cell(points[:, :2])
+        flat = ij[valid, 0] * grid.cols + ij[valid, 1]
+        if op == "max_z":
+            np.maximum.at(out, flat, points[valid, 2])
+        else:
+            np.add.at(out, flat, 1.0)
+    out = out.reshape(grid.shape)
+    if op == "max_z":
+        out[~np.isfinite(out)] = np.nan
+    else:
+        out[out == 0.0] = np.nan
+    return out
+
+
+def bev_max_height(points: np.ndarray, grid: Grid) -> np.ndarray:
+    """`(rows, cols)` float : hauteur max (z) par cellule, NaN si vide."""
+    return _reduce_per_cell(points, grid, "max_z")
+
+
+def bev_count(points: np.ndarray, grid: Grid) -> np.ndarray:
+    """`(rows, cols)` float : nombre de points par cellule, NaN si vide."""
+    return _reduce_per_cell(points, grid, "count")
+
+
+def bev_image(scalar_field: np.ndarray, *, alpha: int = 210) -> np.ndarray:
+    """Colorise un champ `(rows, cols)` (NaN = transparent) en RGBA uint8 `(rows, cols, 4)`."""
+    rows, cols = scalar_field.shape
+    rgba = np.zeros((rows, cols, 4), dtype=np.uint8)
+    filled = np.isfinite(scalar_field)
+    if filled.any():
+        colors = colormap(scalar_field[filled])
+        rgba[filled, :3] = (colors[:, :3] * 255).astype(np.uint8)
+        rgba[filled, 3] = alpha
+    return rgba
+
+
+def cells_in_rect(rect: Rect, grid: Grid) -> tuple[slice, slice]:
+    """Cellules (lignes, colonnes) couvertes par un rectangle monde -> slices `(i, j)`."""
+    x0, y0, x1, y1 = rect
+    x0, x1 = sorted((x0, x1))
+    y0, y1 = sorted((y0, y1))
+    j0 = int(np.clip(np.floor((x0 - grid.xmin) / grid.cell_size), 0, grid.cols))
+    j1 = int(np.clip(np.ceil((x1 - grid.xmin) / grid.cell_size), 0, grid.cols))
+    i0 = int(np.clip(np.floor((y0 - grid.ymin) / grid.cell_size), 0, grid.rows))
+    i1 = int(np.clip(np.ceil((y1 - grid.ymin) / grid.cell_size), 0, grid.rows))
+    return slice(i0, i1), slice(j0, j1)
+
+
+def points_in_rect(xy: np.ndarray, rect: Rect) -> np.ndarray:
+    """Masque booléen `(N,)` des points dont `(x, y)` tombe dans le rectangle monde."""
+    if xy is None or len(xy) == 0:
+        return np.zeros(0, dtype=bool)
+    x0, y0, x1, y1 = rect
+    x0, x1 = sorted((x0, x1))
+    y0, y1 = sorted((y0, y1))
+    xy = np.asarray(xy)
+    return (
+        (xy[:, 0] >= x0) & (xy[:, 0] <= x1) & (xy[:, 1] >= y0) & (xy[:, 1] <= y1)
+    )

splasher/core/source.py

@@ -0,0 +1,75 @@
+"""Protocole d'entrée de Splasher — le point central de la généricité.
+
+Une `Source` est un *dataset synchrone* : à chaque index temporel, elle rend un
+`Frame` = un pack de canaux nommés (tableaux numpy), chacun typé par un
+`ChannelKind`. C'est tout ce que l'outil exige. apairo, des fichiers, des arrays
+en mémoire… ne sont que des manières de produire une `Source`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Iterable, Protocol, runtime_checkable
+
+import numpy as np
+
+
+class ChannelKind(Enum):
+    """Nature d'un canal — pilote la vue qui l'affiche et la manière de le labéliser."""
+
+    POINTCLOUD = "pointcloud"  # (N, 3) ou (N, 3+C) : [x, y, z, ...]
+    IMAGE = "image"  # (H, W) ou (H, W, C) uint8
+    POSE = "pose"  # (4, 4) ou (7,) [x,y,z, qx,qy,qz,qw] : placement monde
+    SCALAR = "scalar"  # autre tableau (réservé / extensible)
+
+    def __repr__(self) -> str:  # affichage compact
+        return f"ChannelKind.{self.name}"
+
+
+@dataclass(frozen=True)
+class ChannelSpec:
+    """Métadonnées d'un canal. `shape` peut contenir des `None` pour les dims variables."""
+
+    name: str
+    kind: ChannelKind
+    dtype: np.dtype | None = None
+    shape: tuple[int | None, ...] | None = None
+
+
+@dataclass
+class Frame:
+    """Un pas de temps synchronisé : tous les canaux à un même instant."""
+
+    channels: dict[str, np.ndarray]
+    timestamp: float | None = None  # None = synchrone (convention apairo)
+
+    def __getitem__(self, key: str) -> np.ndarray:
+        return self.channels[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.channels
+
+    def keys(self):
+        return self.channels.keys()
+
+
+@runtime_checkable
+class Source(Protocol):
+    """Dataset synchrone : longueur, accès indexé à un `Frame`, et description des canaux."""
+
+    def __len__(self) -> int: ...
+
+    def __getitem__(self, index: int) -> Frame: ...
+
+    def channels(self) -> list[ChannelSpec]: ...
+
+
+def channels_of_kind(source_or_specs, kind: ChannelKind) -> list[str]:
+    """Noms des canaux d'un `ChannelKind` donné, depuis une `Source` ou une liste de specs."""
+    specs: Iterable[ChannelSpec]
+    if hasattr(source_or_specs, "channels"):
+        specs = source_or_specs.channels()
+    else:
+        specs = source_or_specs
+    return [s.name for s in specs if s.kind == kind]

splasher/core/target.py

@@ -0,0 +1,169 @@
+"""Cibles de labélisation : ce que produit la sélection d'un rectangle.
+
+- `GridTarget`  : raster d'ids par sample — sortie « grille telle quelle ».
+- `PointTarget` : labels `(N,)` par frame (segmentation du nuage).
+
+**Historique par frame** : chaque frame possède sa propre pile d'annulation. `undo`
+prend le frame courant et n'annule que sa dernière action. Un coup de pinceau cumulé
+(décumulé sur plusieurs frames) est enregistré, de façon atomique, sous le frame de
+référence où il a été peint.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+import numpy as np
+
+from .grid import Grid
+from .projection import Rect, cells_in_rect, points_in_rect
+
+
+class LabelTarget(Protocol):
+    name: str
+
+    def undo(self, frame_idx: int): ...
+
+
+class GridTarget:
+    """Rasters d'ids par sample (+ un raster global). Cible « grille »."""
+
+    name = "grid"
+
+    def __init__(self, grid: Grid, ignore_id: int = 0) -> None:
+        self.grid = grid
+        self.ignore_id = ignore_id
+        self._rasters: dict[int, np.ndarray] = {}
+        self._global = grid.empty_raster(ignore_id)
+        self._undo: dict[int, list] = {}
+
+    def raster(self, frame_idx: int, scope: str = "sample") -> np.ndarray:
+        if scope == "global":
+            return self._global
+        r = self._rasters.get(frame_idx)
+        if r is None:
+            r = self.grid.empty_raster(self.ignore_id)
+            self._rasters[frame_idx] = r
+        return r
+
+    def has(self, frame_idx: int, scope: str = "sample") -> bool:
+        return scope == "global" or frame_idx in self._rasters
+
+    def rasters(self) -> dict[int, np.ndarray]:
+        return self._rasters
+
+    def global_raster(self) -> np.ndarray:
+        return self._global
+
+    def load_rasters(self, rasters: dict[int, np.ndarray], global_raster=None) -> None:
+        self._rasters = {int(k): np.asarray(v) for k, v in rasters.items()}
+        if global_raster is not None:
+            self._global = np.asarray(global_raster)
+        self._undo.clear()
+
+    def apply(self, frame_idx: int, rect: Rect, class_id: int, scope: str = "sample") -> bool:
+        si, sj = cells_in_rect(rect, self.grid)
+        if si.start >= si.stop or sj.start >= sj.stop:
+            return False
+        return self._set(frame_idx, (si, sj), class_id, scope)
+
+    def apply_mask(self, frame_idx: int, mask: np.ndarray, class_id: int,
+                   scope: str = "sample") -> bool:
+        """Peint un masque booléen de cellules `(rows, cols)` (sélection)."""
+        if mask is None or not mask.any():
+            return False
+        return self._set(frame_idx, mask, class_id, scope)
+
+    def _set(self, frame_idx: int, sel, class_id: int, scope: str) -> bool:
+        target = self.raster(frame_idx, scope)
+        self._undo.setdefault(frame_idx, []).append((scope, sel, target[sel].copy()))
+        target[sel] = class_id
+        return True
+
+    def clear(self, frame_idx: int, scope: str = "sample") -> None:
+        target = self.raster(frame_idx, scope)
+        self._undo.setdefault(frame_idx, []).append((scope, (slice(None), slice(None)), target.copy()))
+        target[:] = self.ignore_id
+
+    def undo(self, frame_idx: int):
+        stack = self._undo.get(frame_idx)
+        if not stack:
+            return None
+        scope, sel, prev = stack.pop()
+        self.raster(frame_idx, scope)[sel] = prev
+        return scope, frame_idx
+
+
+class PointTarget:
+    """Labels `(N,) int64` par frame. Cible « points » (segmentation du nuage).
+
+    Les labels sont dimensionnés sur la **concaténation complète** des canaux nuage du
+    frame (ordre fixe), donc indépendants de la visibilité des canaux.
+    """
+
+    name = "points"
+
+    def __init__(self, ignore_id: int = 0) -> None:
+        self.ignore_id = ignore_id
+        self._labels: dict[int, np.ndarray] = {}
+        self._undo: dict[int, list] = {}
+
+    def has(self, frame_idx: int) -> bool:
+        return frame_idx in self._labels
+
+    def labels(self, frame_idx: int, n: int | None = None) -> np.ndarray | None:
+        lab = self._labels.get(frame_idx)
+        if (lab is None or (n is not None and len(lab) != n)) and n is not None:
+            lab = np.full(n, self.ignore_id, dtype=np.int64)
+            self._labels[frame_idx] = lab
+        return lab
+
+    def all_labels(self) -> dict[int, np.ndarray]:
+        return self._labels
+
+    def load_labels(self, labels: dict[int, np.ndarray]) -> None:
+        self._labels = {int(k): np.asarray(v, dtype=np.int64) for k, v in labels.items()}
+        self._undo.clear()
+
+    def apply(self, frame_idx: int, rect: Rect, class_id: int, xy: np.ndarray) -> bool:
+        mask = points_in_rect(xy, rect)
+        if not mask.any():
+            return False
+        lab = self.labels(frame_idx, len(xy))
+        self._undo.setdefault(frame_idx, []).append([(frame_idx, mask, lab[mask].copy())])
+        lab[mask] = class_id
+        return True
+
+    def apply_scatter(self, ref_frame: int, frame_to_sel: dict[int, tuple[np.ndarray, int]],
+                      class_id: int) -> bool:
+        """Assigne `class_id` à des points répartis sur plusieurs frames (décumul).
+
+        `frame_to_sel` : `{frame_idx: (indices, n_points_du_frame)}`. L'opération est
+        enregistrée de façon atomique sous `ref_frame` (le frame courant).
+        """
+        changes: list[tuple] = []
+        for frame_idx, (indices, n) in frame_to_sel.items():
+            if len(indices) == 0:
+                continue
+            lab = self.labels(frame_idx, n)
+            changes.append((frame_idx, indices, lab[indices].copy()))
+            lab[indices] = class_id
+        if not changes:
+            return False
+        self._undo.setdefault(ref_frame, []).append(changes)
+        return True
+
+    def clear(self, frame_idx: int, xy: np.ndarray | None = None) -> None:
+        lab = self._labels.get(frame_idx)
+        if lab is None:
+            return
+        self._undo.setdefault(frame_idx, []).append([(frame_idx, slice(None), lab.copy())])
+        lab[:] = self.ignore_id
+
+    def undo(self, frame_idx: int):
+        stack = self._undo.get(frame_idx)
+        if not stack:
+            return None
+        for f, sel, prev in stack.pop():
+            self._labels[f][sel] = prev
+        return self.name, frame_idx

splasher/demo.py

@@ -0,0 +1,95 @@
+"""Source synthétique multi-canaux pour démos/tests — aucune donnée externe.
+
+Scène « conduite » : l'ego avance en +x. Canaux fournis :
+- `lidar`        : sol bruité + obstacles (nuage dense),
+- `lidar_haut`   : points en hauteur au-dessus des obstacles (nuage épars, distinct),
+- `camera_avant` / `camera_arriere` : deux images factices,
+- `pose`         : matrice 4x4 par frame (pour le cumul).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .core.array_source import ArraySource
+from .core.source import ChannelKind, ChannelSpec
+
+
+def _make_image(h: int, w: int, t: int, n_frames: int, *, rear: bool = False) -> np.ndarray:
+    img = np.empty((h, w, 3), dtype=np.uint8)
+    horizon = h // 2
+    img[:horizon] = (140, 110, 90) if rear else (90, 120, 200)  # ciel (teinte différente derrière)
+    img[horizon:] = (70, 110, 70)
+    for r in range(horizon, h):
+        frac = (r - horizon) / max(1, h - horizon)
+        half = int((0.05 + 0.45 * frac) * w)
+        c = w // 2
+        img[r, max(0, c - half):min(w, c + half)] = (60, 60, 64)
+    # « obstacle » mobile (sens inverse derrière)
+    prog = t / max(1, n_frames - 1)
+    bx = int((1 - prog if rear else prog) * (w - 50))
+    img[horizon - 30:horizon + 10, bx:bx + 40] = (80, 150, 210) if rear else (210, 80, 60)
+    return img
+
+
+def make_demo_source(n_frames: int = 40, seed: int = 0) -> ArraySource:
+    rng = np.random.default_rng(seed)
+    h, w = 200, 360
+    speed = 1.2
+
+    n_obs = 9
+    obs_x = rng.uniform(8.0, 70.0, n_obs)
+    obs_y = rng.uniform(-12.0, 12.0, n_obs)
+    obs_r = rng.uniform(0.6, 1.8, n_obs)
+    obs_h = rng.uniform(1.0, 3.0, n_obs)
+
+    specs = [
+        ChannelSpec("lidar", ChannelKind.POINTCLOUD, np.dtype("float32"), (None, 4)),
+        ChannelSpec("lidar_haut", ChannelKind.POINTCLOUD, np.dtype("float32"), (None, 4)),
+        ChannelSpec("camera_avant", ChannelKind.IMAGE, np.dtype("uint8"), (h, w, 3)),
+        ChannelSpec("camera_arriere", ChannelKind.IMAGE, np.dtype("uint8"), (h, w, 3)),
+        ChannelSpec("pose", ChannelKind.POSE, np.dtype("float32"), (4, 4)),
+    ]
+
+    frames: list[dict[str, np.ndarray]] = []
+    for t in range(n_frames):
+        ex = speed * t
+
+        ng = 14000
+        gx = rng.uniform(1.0, 40.0, ng)
+        gy = rng.uniform(-20.0, 20.0, ng)
+        gz = rng.normal(0.0, 0.03, ng)
+        ground = [np.stack([gx, gy, gz, rng.uniform(0.1, 0.3, ng)], axis=1)]
+        high = []
+
+        for k in range(n_obs):
+            xr = obs_x[k] - ex
+            if 0.0 < xr < 40.0:
+                m = 500
+                px = xr + rng.normal(0.0, obs_r[k], m)
+                py = obs_y[k] + rng.normal(0.0, obs_r[k], m)
+                pz = rng.uniform(0.0, obs_h[k], m)
+                ground.append(np.stack([px, py, pz, rng.uniform(0.6, 1.0, m)], axis=1))
+                # nuage "haut" : points épars au-dessus de l'obstacle
+                mh = 80
+                hx = xr + rng.normal(0.0, obs_r[k] * 0.5, mh)
+                hy = obs_y[k] + rng.normal(0.0, obs_r[k] * 0.5, mh)
+                hz = obs_h[k] + rng.uniform(1.0, 3.0, mh)
+                high.append(np.stack([hx, hy, hz, rng.uniform(0.2, 0.5, mh)], axis=1))
+
+        lidar = np.concatenate(ground, axis=0).astype(np.float32)
+        lidar_haut = (np.concatenate(high, axis=0) if high
+                      else np.zeros((0, 4))).astype(np.float32)
+
+        pose = np.eye(4, dtype=np.float32)
+        pose[0, 3] = ex
+
+        frames.append({
+            "lidar": lidar,
+            "lidar_haut": lidar_haut,
+            "camera_avant": _make_image(h, w, t, n_frames),
+            "camera_arriere": _make_image(h, w, t, n_frames, rear=True),
+            "pose": pose,
+        })
+
+    return ArraySource(specs, frames)

splasher/ui/__init__.py

@@ -0,0 +1 @@
+"""UI Splasher (PySide6 + pyqtgraph). Importée paresseusement par `splasher.launch`."""

splasher/ui/app.py

@@ -0,0 +1,33 @@
+"""Point d'entrée UI : `launch(source)`."""
+
+from __future__ import annotations
+
+import sys
+
+import pyqtgraph as pg
+from PySide6 import QtWidgets
+
+from ..core.source import Source
+from .main_window import MainWindow
+
+
+def launch(source: Source, *, labels=None, title: str = "Splasher", block: bool = True):
+    """Ouvre la fenêtre Splasher sur `source`.
+
+    `labels` : un `LabelSet` optionnel (défaut = `LabelSet.default()`).
+    Réutilise une `QApplication` existante si présente. Si `block` et qu'aucune
+    boucle n'est active, lance `app.exec()`. Renvoie la fenêtre.
+    """
+    pg.setConfigOptions(imageAxisOrder="row-major", antialias=False)
+
+    app = QtWidgets.QApplication.instance()
+    owns_app = app is None
+    if owns_app:
+        app = QtWidgets.QApplication(sys.argv[:1])
+
+    window = MainWindow(source, title=title, labelset=labels)
+    window.show()
+
+    if block and owns_app:
+        app.exec()
+    return window

splasher/ui/channel_manager.py

@@ -0,0 +1,55 @@
+"""Gestionnaire de canaux : afficher/masquer les canaux disponibles de la `Source`.
+
+Liste tous les canaux (nuages, caméras, poses…). Les nuages et les images sont
+cochables (afficher/masquer la vue correspondante). Les poses/scalaires sont listés
+pour information (non cochables).
+"""
+
+from __future__ import annotations
+
+from PySide6 import QtCore, QtWidgets
+
+from ..core.source import ChannelKind, ChannelSpec
+
+_KIND_LABEL = {
+    ChannelKind.POINTCLOUD: "nuage",
+    ChannelKind.IMAGE: "caméra",
+    ChannelKind.POSE: "pose",
+    ChannelKind.SCALAR: "scalaire",
+}
+
+
+class ChannelManager(QtWidgets.QWidget):
+    visibilityChanged = QtCore.Signal()
+
+    def __init__(self, specs: list[ChannelSpec]) -> None:
+        super().__init__()
+        self._boxes: dict[str, QtWidgets.QCheckBox] = {}
+        self._kind: dict[str, ChannelKind] = {}
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(6, 4, 6, 4)
+        layout.setSpacing(2)
+
+        for spec in specs:
+            self._kind[spec.name] = spec.kind
+            toggleable = spec.kind in (ChannelKind.POINTCLOUD, ChannelKind.IMAGE)
+            row = QtWidgets.QCheckBox(f"{spec.name}  ·  {_KIND_LABEL.get(spec.kind, '?')}")
+            row.setChecked(toggleable)
+            row.setEnabled(toggleable)
+            if toggleable:
+                row.toggled.connect(lambda _checked: self.visibilityChanged.emit())
+            self._boxes[spec.name] = row
+            layout.addWidget(row)
+
+        layout.addStretch(1)
+
+    def _visible_of_kind(self, kind: ChannelKind) -> set[str]:
+        return {name for name, box in self._boxes.items()
+                if self._kind[name] == kind and box.isChecked()}
+
+    def visible_clouds(self) -> set[str]:
+        return self._visible_of_kind(ChannelKind.POINTCLOUD)
+
+    def visible_images(self) -> set[str]:
+        return self._visible_of_kind(ChannelKind.IMAGE)

splasher/ui/cloud_view.py

@@ -0,0 +1,52 @@
+"""Vue 3D du/des nuage(s) de points : navigation libre (orbit/pan/zoom)."""
+
+from __future__ import annotations
+
+import numpy as np
+import pyqtgraph.opengl as gl
+
+from ..core.colormap import colormap
+
+
+class CloudView(gl.GLViewWidget):
+    """Affiche un ou plusieurs nuages nommés. Couleur par hauteur (z) par défaut."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setBackgroundColor("#101014")
+        self.setCameraPosition(distance=60.0, elevation=30.0, azimuth=-60.0)
+
+        grid = gl.GLGridItem()
+        grid.setSize(x=100, y=100)
+        grid.setSpacing(x=5, y=5)
+        grid.setColor((255, 255, 255, 40))
+        self.addItem(grid)
+        self._grid = grid
+
+        self._scatters: dict[str, gl.GLScatterPlotItem] = {}
+
+    def set_cloud(self, name: str, points: np.ndarray, colors: np.ndarray | None = None,
+                  size: float = 2.0) -> None:
+        """Met à jour (ou crée) le nuage `name`. `points` (N, 3+), `colors` (N, 4) RGBA [0,1]."""
+        if points is None or len(points) == 0:
+            if name in self._scatters:
+                self._scatters[name].setData(pos=np.zeros((0, 3), np.float32))
+            return
+
+        xyz = np.ascontiguousarray(points[:, :3], dtype=np.float32)
+        if colors is None:
+            colors = colormap(xyz[:, 2])
+
+        item = self._scatters.get(name)
+        if item is None:
+            item = gl.GLScatterPlotItem(pxMode=True)
+            # 'opaque' (et non l'additif par défaut) : les couleurs ne saturent pas
+            # vers le blanc quand des dizaines de milliers de points se superposent (cumul).
+            item.setGLOptions("opaque")
+            self.addItem(item)
+            self._scatters[name] = item
+        item.setData(pos=xyz, color=colors, size=size)
+
+    def clear_clouds(self) -> None:
+        for item in self._scatters.values():
+            item.setData(pos=np.zeros((0, 3), np.float32))

splasher/ui/grid_designer.py

@@ -0,0 +1,103 @@
+"""Panneau de conception de la grille : étendue monde + taille de carré.
+
+Deux temps, pour que ce soit clair :
+- éditer les champs met à jour l'**aperçu** des lignes (`previewChanged`) et l'affichage
+  `cols × rows`, sans rien effacer ;
+- le bouton **« Nouvelle grille »** crée/applique la grille (`newGridRequested`), ce qui
+  **réinitialise** les rasters de grille (ils sont liés à la géométrie).
+"""
+
+from __future__ import annotations
+
+from PySide6 import QtCore, QtWidgets
+
+from ..core.grid import Grid
+
+
+def _spin(value, lo, hi, step, decimals) -> QtWidgets.QDoubleSpinBox:
+    sb = QtWidgets.QDoubleSpinBox()
+    sb.setRange(lo, hi)
+    sb.setSingleStep(step)
+    sb.setDecimals(decimals)
+    sb.setValue(value)
+    return sb
+
+
+class GridDesigner(QtWidgets.QWidget):
+    previewChanged = QtCore.Signal(object)     # Grid (aperçu, n'efface rien)
+    newGridRequested = QtCore.Signal(object)   # Grid (création/commit)
+
+    def __init__(self, grid: Grid) -> None:
+        super().__init__()
+        self._committed = grid
+
+        self._xmin = _spin(grid.xmin, -2000, 2000, 1.0, 1)
+        self._xmax = _spin(grid.xmax, -2000, 2000, 1.0, 1)
+        self._ymin = _spin(grid.ymin, -2000, 2000, 1.0, 1)
+        self._ymax = _spin(grid.ymax, -2000, 2000, 1.0, 1)
+        self._cell = _spin(grid.cell_size, 0.05, 100.0, 0.5, 2)
+
+        form = QtWidgets.QFormLayout()
+        form.addRow("x min", self._xmin)
+        form.addRow("x max", self._xmax)
+        form.addRow("y min", self._ymin)
+        form.addRow("y max", self._ymax)
+        form.addRow("taille carré (m)", self._cell)
+
+        self._dims = QtWidgets.QLabel()
+        self._dims.setStyleSheet("color:#9cf; font-weight:bold;")
+
+        self._btn = QtWidgets.QPushButton("➕ Nouvelle grille")
+        self._btn.setToolTip("Créer/appliquer la grille à cette taille (réinitialise la grille labélisée)")
+        self._btn.clicked.connect(self._on_commit)
+
+        root = QtWidgets.QVBoxLayout(self)
+        root.addLayout(form)
+        root.addWidget(self._dims)
+        root.addWidget(self._btn)
+        root.addStretch(1)
+
+        for sb in (self._xmin, self._xmax, self._ymin, self._ymax, self._cell):
+            sb.valueChanged.connect(self._on_edit)
+
+        self._update_dims(grid)
+
+    def committed_grid(self) -> Grid:
+        return self._committed
+
+    def set_grid(self, grid: Grid) -> None:
+        """Recale les champs sur `grid` sans rien émettre (ex. après chargement)."""
+        self._committed = grid
+        for sb, val in ((self._xmin, grid.xmin), (self._xmax, grid.xmax),
+                        (self._ymin, grid.ymin), (self._ymax, grid.ymax), (self._cell, grid.cell_size)):
+            sb.blockSignals(True)
+            sb.setValue(val)
+            sb.blockSignals(False)
+        self._update_dims(grid)
+
+    def _build(self) -> Grid | None:
+        try:
+            return Grid(self._xmin.value(), self._xmax.value(),
+                        self._ymin.value(), self._ymax.value(), self._cell.value())
+        except ValueError:
+            return None
+
+    def _update_dims(self, grid: Grid) -> None:
+        self._dims.setText(f"{grid.cols} × {grid.rows} carrés  ({grid.cols * grid.rows} cellules)")
+
+    def _on_edit(self) -> None:
+        grid = self._build()
+        if grid is None:
+            self._dims.setText("étendue invalide")
+            self._btn.setEnabled(False)
+            return
+        self._btn.setEnabled(True)
+        self._update_dims(grid)
+        self.previewChanged.emit(grid)
+
+    def _on_commit(self) -> None:
+        grid = self._build()
+        if grid is None:
+            return
+        self._committed = grid
+        self.newGridRequested.emit(grid)

splasher/ui/grid_view.py

@@ -0,0 +1,124 @@
+"""Vue de dessus (BEV) : grille de carrés, sous-couche densité, raster de labels,
+et sélection par rectangle (rubber-band) pour peindre.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pyqtgraph as pg
+from PySide6 import QtCore, QtWidgets
+
+from ..core.grid import Grid
+
+
+class _PaintViewBox(pg.ViewBox):
+    """ViewBox avec un mode « peindre » : clic-glisser gauche dessine un rectangle."""
+
+    rectDrawn = QtCore.Signal(object)  # (x0, y0, x1, y1) en coords monde
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._paint = True
+        self._preview = QtWidgets.QGraphicsRectItem()
+        self._preview.setPen(pg.mkPen(255, 213, 74, width=1))
+        self._preview.setBrush(pg.mkBrush(255, 213, 74, 50))
+        self._preview.setZValue(50)
+        self._preview.hide()
+        self.addItem(self._preview, ignoreBounds=True)
+
+    def set_paint_mode(self, on: bool) -> None:
+        self._paint = on
+
+    def mouseDragEvent(self, ev, axis=None):
+        if self._paint and ev.button() == QtCore.Qt.LeftButton:
+            ev.accept()
+            p0 = self.mapSceneToView(ev.buttonDownScenePos())
+            p1 = self.mapSceneToView(ev.scenePos())
+            x0, y0, x1, y1 = p0.x(), p0.y(), p1.x(), p1.y()
+            self._preview.setRect(min(x0, x1), min(y0, y1), abs(x1 - x0), abs(y1 - y0))
+            self._preview.show()
+            if ev.isFinish():
+                self._preview.hide()
+                self.rectDrawn.emit((x0, y0, x1, y1))
+        else:
+            super().mouseDragEvent(ev, axis)
+
+
+class GridView(QtWidgets.QWidget):
+    rectDrawn = QtCore.Signal(object)
+
+    def __init__(self) -> None:
+        super().__init__()
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self._glw = pg.GraphicsLayoutWidget()
+        layout.addWidget(self._glw)
+        self._vb = _PaintViewBox()
+        self._vb.setAspectLocked(True)  # carrés vraiment carrés, y vers le haut
+        self._vb.setBackgroundColor("#0c0c10")
+        self._glw.addItem(self._vb)
+        self._vb.rectDrawn.connect(self.rectDrawn)
+
+        self._under = pg.ImageItem()       # densité/hauteur BEV (M2)
+        self._under.setZValue(-10)
+        self._labels = pg.ImageItem()      # raster de labels colorisé (M3)
+        self._labels.setZValue(-5)
+        self._sel = pg.ImageItem()         # surbrillance de la sélection (mode select)
+        self._sel.setZValue(8)
+        self._pts = pg.ScatterPlotItem(    # points top-down (référence)
+            size=2, pen=None, brush=pg.mkBrush(170, 175, 205, 70), pxMode=True
+        )
+        self._grid_lines = pg.PlotCurveItem(pen=pg.mkPen(120, 125, 150, 140, width=1))
+        self._grid_lines.setZValue(5)
+        for item in (self._under, self._labels, self._pts, self._grid_lines, self._sel):
+            self._vb.addItem(item)
+
+        self._grid: Grid | None = None
+
+    # ------------------------------------------------------------------ API
+    def set_paint_mode(self, on: bool) -> None:
+        self._vb.set_paint_mode(on)
+
+    def set_grid(self, grid: Grid, autorange: bool = True) -> None:
+        self._grid = grid
+        xs, ys = grid.line_segments()
+        self._grid_lines.setData(xs, ys, connect="pairs")
+        if autorange:
+            self._vb.setRange(
+                xRange=(grid.xmin, grid.xmin + grid.width),
+                yRange=(grid.ymin, grid.ymin + grid.height),
+                padding=0.03,
+            )
+
+    def set_topdown_points(self, xy: np.ndarray | None, max_points: int = 12000) -> None:
+        if xy is None or len(xy) == 0:
+            self._pts.setData(x=[], y=[])
+            return
+        xy = np.asarray(xy)
+        if len(xy) > max_points:
+            xy = xy[np.linspace(0, len(xy) - 1, max_points).astype(int)]
+        self._pts.setData(x=xy[:, 0], y=xy[:, 1])
+
+    def set_underlay(self, image: np.ndarray | None, grid: Grid) -> None:
+        self._set_raster(self._under, image, grid, levels=(0, 255))
+
+    def set_labels(self, image: np.ndarray | None, grid: Grid) -> None:
+        self._set_raster(self._labels, image, grid, levels=(0, 255))
+
+    def set_selection(self, mask: np.ndarray | None, grid: Grid) -> None:
+        """Surligne les cellules sélectionnées (`mask` booléen `(rows, cols)`)."""
+        if mask is None or not mask.any():
+            self._sel.clear()
+            return
+        rgba = np.zeros((grid.rows, grid.cols, 4), dtype=np.uint8)
+        rgba[mask] = (90, 200, 255, 110)  # cyan translucide
+        self._set_raster(self._sel, rgba, grid, levels=(0, 255))
+
+    def _set_raster(self, item: pg.ImageItem, image, grid: Grid, levels) -> None:
+        if image is None:
+            item.clear()
+            return
+        item.setImage(image, autoLevels=False, levels=levels)
+        x, y, w, h = grid.image_rect()
+        item.setRect(QtCore.QRectF(x, y, w, h))