diff --git a/server/Dockerfile b/server/Dockerfile
new file mode 100644
index 0000000..6002dc4
--- /dev/null
+++ b/server/Dockerfile
@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt "numpy<2.0"
+COPY . .
+ENV MOULIN_TOKEN=moulin-2026
+EXPOSE 8211
+CMD ["uvicorn","app:app","--host","0.0.0.0","--port","8211"]
diff --git a/server/README.md b/server/README.md
new file mode 100644
index 0000000..c2d9bad
--- /dev/null
+++ b/server/README.md
@@ -0,0 +1,66 @@
+# moulin-mapper server
+
+## Lancement local
+
+```bash
+cd server/
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+
+uvicorn app:app --host 0.0.0.0 --port 8211
+```
+
+GUI accessible sur : http://localhost:8211/
+
+## Variables d'environnement
+
+| Variable | Défaut | Description |
+|----------|--------|-------------|
+| `MOULIN_TOKEN` | `moulin-2026` | Token authentification ingest WS |
+
+## Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `GET /` | GUI live (HTML statique) |
+| `WS /ws/ingest?token=…` | Reçoit le flux JSONL du client ROV/sim |
+| `WS /ws/live` | Navigateur s'abonne aux mises à jour temps réel |
+| `POST /session/reset` | Remet la session à zéro (form: token) |
+| `GET /healthz` | Santé + compteurs |
+| `GET /cloud.ply` | Export nuage 3D courant |
+
+## Déploiement derrière Caddy (préfixe `/moulin-live/`)
+
+Exemple Caddyfile :
+```
+handle /moulin-live/* {
+ uri strip_prefix /moulin-live
+ reverse_proxy localhost:8211
+}
+```
+
+**Important** : la GUI construit les URLs WS depuis `window.location.pathname`,
+donc le préfixe de déploiement est automatiquement inclus.
+Ne PAS utiliser d'URLs en dur dans le code client.
+
+## Lancer le client stream (sur le PC de Flag)
+
+```bash
+cd client/
+pip install -r requirements.txt
+
+# Simulation rapide (test)
+python stream_client.py \
+ --file ../../data/sim/run_L.jsonl \
+ --url wss://laboratoire.freeboxos.fr/moulin-live/ws/ingest \
+ --token moulin-2026 \
+ --speed 0
+
+# Temps réel
+python stream_client.py \
+ --file ../../data/sim/run_L.jsonl \
+ --url wss://laboratoire.freeboxos.fr/moulin-live/ws/ingest \
+ --token moulin-2026 \
+ --speed 1.0
+```
diff --git a/server/app.py b/server/app.py
new file mode 100644
index 0000000..de11801
--- /dev/null
+++ b/server/app.py
@@ -0,0 +1,228 @@
+"""
+app.py — Serveur FastAPI moulin-mapper.
+
+Lance avec : uvicorn app:app --host 0.0.0.0 --port 8211
+Déployé derrière préfixe /moulin-live/ via reverse-proxy Caddy.
+"""
+
+import asyncio
+import json
+import os
+import time
+from typing import Set
+
+import numpy as np
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Form, Request
+from fastapi.responses import HTMLResponse, PlainTextResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from slam_incremental import IncrementalSLAM
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+TOKEN = os.environ.get("MOULIN_TOKEN", "moulin-2026")
+
+# ---------------------------------------------------------------------------
+# État global de session
+# ---------------------------------------------------------------------------
+
+slam = IncrementalSLAM()
+session_records: list = [] # tous les enregistrements bruts reçus
+session_start_time: float = time.time()
+debit_window: list = [] # timestamps récents pour calcul débit
+
+# Clients /ws/live connectés
+live_clients: Set[WebSocket] = set()
+
+# ---------------------------------------------------------------------------
+# App FastAPI (root_path vide — le préfixe est géré par Caddy côté client)
+# ---------------------------------------------------------------------------
+
+app = FastAPI(title="moulin-mapper live")
+
+
+# ---------------------------------------------------------------------------
+# Broadcast aux clients /ws/live
+# ---------------------------------------------------------------------------
+
+async def broadcast(payload: dict) -> None:
+ if not live_clients:
+ return
+ msg = json.dumps(payload)
+ dead = set()
+ for ws in list(live_clients):
+ try:
+ await ws.send_text(msg)
+ except Exception:
+ dead.add(ws)
+ live_clients.difference_update(dead)
+
+
+# ---------------------------------------------------------------------------
+# WS /ws/ingest — reçoit le flux du client ROV/sim
+# ---------------------------------------------------------------------------
+
+@app.websocket("/ws/ingest")
+async def ws_ingest(websocket: WebSocket, token: str = ""):
+ if token != TOKEN:
+ await websocket.close(code=4001)
+ return
+
+ await websocket.accept()
+ try:
+ while True:
+ raw = await websocket.receive_text()
+ try:
+ data = json.loads(raw)
+ except json.JSONDecodeError:
+ continue
+
+ # Accepte un seul record ou une liste
+ records = data if isinstance(data, list) else [data]
+
+ sweep_completed = False
+ for rec in records:
+ session_records.append(rec)
+ debit_window.append(time.time())
+ # Nettoie la fenêtre (5 secondes)
+ cutoff = time.time() - 5.0
+ while debit_window and debit_window[0] < cutoff:
+ debit_window.pop(0)
+
+ completed = slam.add_record(rec)
+ if completed:
+ sweep_completed = True
+
+ if sweep_completed:
+ delta = slam.get_sweep_delta()
+ delta["debit"] = len(debit_window) / 5.0
+ await broadcast(delta)
+
+ except WebSocketDisconnect:
+ pass
+ except Exception as e:
+ print(f"[ingest] erreur: {e}")
+
+
+# ---------------------------------------------------------------------------
+# WS /ws/live — navigateur s'abonne
+# ---------------------------------------------------------------------------
+
+@app.websocket("/ws/live")
+async def ws_live(websocket: WebSocket):
+ await websocket.accept()
+ live_clients.add(websocket)
+
+ # Envoie l'état complet courant dès la connexion
+ try:
+ snapshot = slam.get_state_snapshot()
+ snapshot["debit"] = len(debit_window) / 5.0
+ await websocket.send_text(json.dumps(snapshot))
+
+ # Garde la connexion ouverte jusqu'à déconnexion
+ while True:
+ try:
+ # ping keepalive (pas de timeout natif FastAPI WS)
+ await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+ except asyncio.TimeoutError:
+ await websocket.send_text(json.dumps({"type": "ping"}))
+ except WebSocketDisconnect:
+ pass
+ except Exception:
+ pass
+ finally:
+ live_clients.discard(websocket)
+
+
+# ---------------------------------------------------------------------------
+# POST /session/reset
+# ---------------------------------------------------------------------------
+
+@app.post("/session/reset")
+async def session_reset(token: str = Form(...)):
+ if token != TOKEN:
+ raise HTTPException(status_code=403, detail="Token invalide")
+ slam.reset()
+ session_records.clear()
+ debit_window.clear()
+ await broadcast({"type": "reset"})
+ return {"status": "ok"}
+
+
+# ---------------------------------------------------------------------------
+# GET /healthz
+# ---------------------------------------------------------------------------
+
+@app.get("/healthz")
+async def healthz():
+ return {
+ "status": "ok",
+ "records": slam.records_count,
+ "sweeps": slam.sweeps_done,
+ "map_points": len(slam.imap),
+ "loop_closures": slam.loop_closures,
+ "live_clients": len(live_clients),
+ }
+
+
+# ---------------------------------------------------------------------------
+# GET /cloud.ply — export nuage 3D (contour extrudé altitude/depth)
+# ---------------------------------------------------------------------------
+
+@app.get("/cloud.ply")
+async def cloud_ply():
+ map_arr = slam.imap.get_array()
+ if len(map_arr) == 0:
+ raise HTTPException(status_code=204, detail="Carte vide")
+
+ # Extrude les points 2D sur l'intervalle [depth - altitude, depth]
+ # Utilise les dernières valeurs connues depuis les enregistrements
+ depth = 1.5
+ altitude = 0.5
+ if session_records:
+ last = session_records[-1]
+ depth = last.get("depth", 1.5)
+ altitude = last.get("altitude", 0.5)
+
+ z_top = -depth + altitude # fond (proche du bas)
+ z_bot = -depth # surface de l'eau (z=0)
+
+ pts_3d = []
+ for pt in map_arr:
+ pts_3d.append((pt[0], pt[1], z_top))
+ pts_3d.append((pt[0], pt[1], z_bot))
+
+ lines = [
+ "ply",
+ "format ascii 1.0",
+ f"element vertex {len(pts_3d)}",
+ "property float x",
+ "property float y",
+ "property float z",
+ "end_header",
+ ]
+ for p in pts_3d:
+ lines.append(f"{p[0]:.4f} {p[1]:.4f} {p[2]:.4f}")
+
+ content = "\n".join(lines) + "\n"
+ from fastapi.responses import Response
+ return Response(
+ content=content,
+ media_type="application/octet-stream",
+ headers={"Content-Disposition": "attachment; filename=moulin_cloud.ply"},
+ )
+
+
+# ---------------------------------------------------------------------------
+# Fichiers statiques + page principale
+# ---------------------------------------------------------------------------
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+ static_path = os.path.join(os.path.dirname(__file__), "static", "index.html")
+ with open(static_path, "r", encoding="utf-8") as f:
+ return f.read()
+
+app.mount("/static", StaticFiles(directory=os.path.join(os.path.dirname(__file__), "static")), name="static")
diff --git a/server/client/README.md b/server/client/README.md
new file mode 100644
index 0000000..bb60d0f
--- /dev/null
+++ b/server/client/README.md
@@ -0,0 +1,46 @@
+# moulin-mapper — client stream
+
+## Prérequis
+
+```bash
+pip install -r requirements.txt
+```
+
+## Commande (simulation rapide)
+
+```bash
+python stream_client.py \
+ --file ../data/sim/run_L.jsonl \
+ --url wss://laboratoire.freeboxos.fr/moulin-live/ws/ingest \
+ --token moulin-2026 \
+ --speed 0
+```
+
+## Commande temps réel
+
+```bash
+python stream_client.py \
+ --file ../data/sim/run_L.jsonl \
+ --url wss://laboratoire.freeboxos.fr/moulin-live/ws/ingest \
+ --token moulin-2026 \
+ --speed 1.0
+```
+
+## Bridge ROV (futur)
+
+```bash
+rov_bridge | python stream_client.py \
+ --stdin \
+ --url wss://laboratoire.freeboxos.fr/moulin-live/ws/ingest \
+ --token moulin-2026
+```
+
+## Options
+
+| Option | Défaut | Description |
+|--------|--------|-------------|
+| `--file FILE` | — | Fichier JSONL à envoyer |
+| `--stdin` | — | Lit depuis stdin (bridge ROV) |
+| `--url URL` | `ws://127.0.0.1:8211/ws/ingest` | URL WebSocket du serveur |
+| `--token TOKEN` | `moulin-2026` | Token d'authentification |
+| `--speed FLOAT` | `1.0` | 0=max, 1=temps réel, 2=2× plus vite |
diff --git a/server/client/requirements.txt b/server/client/requirements.txt
new file mode 100644
index 0000000..31b5e2f
--- /dev/null
+++ b/server/client/requirements.txt
@@ -0,0 +1 @@
+websockets>=12.0
diff --git a/server/client/stream_client.py b/server/client/stream_client.py
new file mode 100644
index 0000000..b864593
--- /dev/null
+++ b/server/client/stream_client.py
@@ -0,0 +1,102 @@
+"""
+stream_client.py — Envoie un flux JSONL vers le serveur moulin-mapper.
+
+Usage:
+ python stream_client.py --file run_L.jsonl --url ws://127.0.0.1:8211/ws/ingest --token moulin-2026 --speed 1.0
+
+ --speed 0 : aussi vite que possible (pas de délai)
+ --speed 1 : temps réel (deltas de t respectés)
+ --stdin : lit depuis stdin au lieu d'un fichier (bridge ROV)
+"""
+
+import argparse
+import json
+import sys
+import time
+import asyncio
+
+try:
+ import websockets
+except ImportError:
+ print("Installe d'abord : pip install websockets")
+ sys.exit(1)
+
+
+async def stream(url: str, token: str, lines, speed: float):
+ # Ajoute le token comme query param
+ sep = "&" if "?" in url else "?"
+ full_url = f"{url}{sep}token={token}"
+
+ t_prev = None
+ sent = 0
+ t_file_prev = None
+
+ print(f"[moulin-stream] connexion → {full_url}")
+
+ while True:
+ try:
+ async with websockets.connect(full_url, ping_interval=20, ping_timeout=30) as ws:
+ print("[moulin-stream] connecté")
+ for line in lines:
+ line = line.strip()
+ if not line:
+ continue
+ try:
+ rec = json.loads(line)
+ except json.JSONDecodeError:
+ continue
+
+ t_rec = rec.get("t", 0.0)
+
+ # Timing
+ if speed > 0 and t_file_prev is not None:
+ dt_file = t_rec - t_file_prev
+ if dt_file > 0:
+ await asyncio.sleep(dt_file / speed)
+
+ t_file_prev = t_rec
+
+ await ws.send(json.dumps(rec))
+ sent += 1
+
+ if sent % 100 == 0:
+ print(f"\r[moulin-stream] {sent} lignes envoyées, t={t_rec:.1f}s", end="", flush=True)
+
+ print(f"\n[moulin-stream] terminé — {sent} enregistrements envoyés")
+ return
+
+ except (websockets.exceptions.ConnectionClosed,
+ ConnectionRefusedError,
+ OSError) as e:
+ print(f"\n[moulin-stream] connexion perdue ({e}), reconnexion dans 3s…")
+ await asyncio.sleep(3.0)
+ # Redémarre depuis le début si on a perdu la connexion
+ # (les données sont déjà lues depuis un itérateur — on ne peut pas rembobiner stdin)
+ print("[moulin-stream] AVERTISSEMENT: relance depuis le début du fichier")
+ break
+
+
+def main():
+ parser = argparse.ArgumentParser(description="Stream JSONL vers moulin-mapper")
+ src = parser.add_mutually_exclusive_group(required=True)
+ src.add_argument("--file", help="Fichier JSONL à envoyer")
+ src.add_argument("--stdin", action="store_true", help="Lit depuis stdin")
+ parser.add_argument("--url", default="ws://127.0.0.1:8211/ws/ingest",
+ help="URL WebSocket du serveur (ex: wss://lab.freeboxos.fr/moulin-live/ws/ingest)")
+ parser.add_argument("--token", default="moulin-2026", help="Token d'authentification")
+ parser.add_argument("--speed", type=float, default=1.0,
+ help="Multiplicateur de vitesse (0=max, 1=temps réel, 2=2×)")
+ args = parser.parse_args()
+
+ if args.file:
+ with open(args.file, "r") as f:
+ lines = f.readlines()
+ print(f"[moulin-stream] fichier: {args.file} ({len(lines)} lignes)")
+ else:
+ lines = sys.stdin
+
+ asyncio.run(stream(args.url, args.token, lines, args.speed))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/server/requirements.txt b/server/requirements.txt
new file mode 100644
index 0000000..33b979e
--- /dev/null
+++ b/server/requirements.txt
@@ -0,0 +1,6 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.30.0
+numpy>=1.24.0
+scipy>=1.11.0
+websockets>=12.0
+python-multipart>=0.0.9
diff --git a/server/room.py b/server/room.py
new file mode 100644
index 0000000..73006a4
--- /dev/null
+++ b/server/room.py
@@ -0,0 +1,86 @@
+"""
+room.py — Géométrie chambre de moulin + raycast 2D. Copie standalone.
+"""
+
+import numpy as np
+from typing import Optional, List, Tuple
+
+ROOM_POLYGON = np.array([
+ [0.0, 0.0],
+ [8.0, 0.0],
+ [8.0, 5.0],
+ [3.0, 5.0],
+ [3.0, 8.0],
+ [0.0, 8.0],
+], dtype=float)
+
+NICHE_WALLS = np.array([
+ [[0.0, 4.0], [3.0, 4.0]],
+ [[0.0, 2.0], [3.0, 2.0]],
+], dtype=float)
+
+
+def _polygon_to_segments(poly: np.ndarray) -> List[Tuple[np.ndarray, np.ndarray]]:
+ segs = []
+ n = len(poly)
+ for i in range(n):
+ segs.append((poly[i], poly[(i + 1) % n]))
+ return segs
+
+
+def get_all_segments() -> List[Tuple[np.ndarray, np.ndarray]]:
+ segs = _polygon_to_segments(ROOM_POLYGON)
+ for wall in NICHE_WALLS:
+ segs.append((wall[0], wall[1]))
+ return segs
+
+
+_ALL_SEGMENTS = get_all_segments()
+
+
+def _ray_segment_intersect(
+ origin: np.ndarray,
+ direction: np.ndarray,
+ p0: np.ndarray,
+ p1: np.ndarray,
+) -> Optional[float]:
+ dx = direction[0]
+ dy = direction[1]
+ ex = p1[0] - p0[0]
+ ey = p1[1] - p0[1]
+ denom = -dx * ey + ex * dy
+ if abs(denom) < 1e-12:
+ return None
+ bx = p0[0] - origin[0]
+ by = p0[1] - origin[1]
+ t = (-bx * ey + ex * by) / denom
+ u = (dx * by - bx * dy) / denom
+ if t >= 0.0 and 0.0 <= u <= 1.0:
+ return t
+ return None
+
+
+def range_to_walls(
+ x: float,
+ y: float,
+ bearing_world_deg: float,
+ max_range: float = 30.0,
+) -> Optional[float]:
+ bearing_rad = np.deg2rad(bearing_world_deg)
+ direction = np.array([np.sin(bearing_rad), np.cos(bearing_rad)], dtype=float)
+ origin = np.array([x, y], dtype=float)
+ min_t = None
+ for p0, p1 in _ALL_SEGMENTS:
+ t = _ray_segment_intersect(origin, direction, p0, p1)
+ if t is not None and t > 1e-6:
+ if min_t is None or t < min_t:
+ min_t = t
+ if min_t is not None and min_t <= max_range:
+ return min_t
+ return None
+
+
+def get_room_bounds() -> Tuple[float, float, float, float]:
+ pts = ROOM_POLYGON
+ return float(pts[:, 0].min()), float(pts[:, 0].max()), \
+ float(pts[:, 1].min()), float(pts[:, 1].max())
diff --git a/server/slam_incremental.py b/server/slam_incremental.py
new file mode 100644
index 0000000..5821392
--- /dev/null
+++ b/server/slam_incremental.py
@@ -0,0 +1,400 @@
+"""
+slam_incremental.py — SLAM incrémental alimenté enregistrement par enregistrement.
+
+Adapté depuis pipeline/slam.py pour une utilisation serveur (pas de batch).
+Appel: une seule méthode add_record(rec) par message reçu.
+Quand un sweep est complété → ICP + fermeture de boucle auto.
+"""
+
+import numpy as np
+from scipy.spatial import cKDTree
+from typing import List, Optional, Tuple, Dict
+
+# ---------------------------------------------------------------------------
+# Dead-reckoning
+# ---------------------------------------------------------------------------
+
+class DeadReckoning:
+ def __init__(self, alpha_magneto: float = 0.3, tau: float = 2.0):
+ self.x = 0.0
+ self.y = 0.0
+ self.h_gyro = 0.0
+ self.heading_deg = 0.0
+ self.vf = 0.0
+ self.vl = 0.0
+ self.t_prev = None
+ self.alpha = alpha_magneto
+ self.tau = tau
+
+ def reset(self):
+ self.x = 0.0
+ self.y = 0.0
+ self.h_gyro = 0.0
+ self.heading_deg = 0.0
+ self.vf = 0.0
+ self.vl = 0.0
+ self.t_prev = None
+
+ def update(self, t: float, heading_deg: float,
+ ax: float, ay: float, gz: float,
+ vf: float = None, vl: float = 0.0) -> Tuple[float, float, float]:
+ if self.t_prev is None:
+ self.t_prev = t
+ self.h_gyro = heading_deg
+ self.heading_deg = heading_deg
+ return self.x, self.y, self.heading_deg
+
+ dt = t - self.t_prev
+ if dt <= 0:
+ return self.x, self.y, self.heading_deg
+ self.t_prev = t
+
+ self.h_gyro = (self.h_gyro + np.rad2deg(gz) * dt) % 360
+ dh = ((heading_deg - self.h_gyro + 180) % 360) - 180
+ self.h_gyro = (self.h_gyro + self.alpha * dh) % 360
+ self.heading_deg = self.h_gyro
+
+ if vf is not None:
+ self.vf = vf
+ self.vl = vl
+ else:
+ decay = np.exp(-dt / self.tau)
+ self.vf = self.vf * decay + ax * dt
+ self.vl = 0.0
+
+ h_rad = np.deg2rad(self.heading_deg)
+ vx = self.vf * np.sin(h_rad) - self.vl * np.cos(h_rad)
+ vy = self.vf * np.cos(h_rad) + self.vl * np.sin(h_rad)
+ self.x += vx * dt
+ self.y += vy * dt
+ return self.x, self.y, self.heading_deg
+
+
+# ---------------------------------------------------------------------------
+# Accumulation de sweep
+# ---------------------------------------------------------------------------
+
+class SweepAccumulator:
+ def __init__(self):
+ self.current_sweep: List[Dict] = []
+ self.last_angle = None
+ self.sweeps_done = 0
+
+ def reset(self):
+ self.current_sweep = []
+ self.last_angle = None
+ self.sweeps_done = 0
+
+ def add_beam(self, angle_deg: float, distance: float,
+ pose: Tuple[float, float, float]) -> Optional[List[Dict]]:
+ beam = {"angle_deg": angle_deg, "distance": distance, "pose": pose}
+
+ if (self.last_angle is not None
+ and self.last_angle > 180
+ and angle_deg < 90):
+ completed = self.current_sweep.copy()
+ self.current_sweep = [beam]
+ self.last_angle = angle_deg
+ self.sweeps_done += 1
+ if len(completed) >= 20:
+ return completed
+ return None
+
+ self.current_sweep.append(beam)
+ self.last_angle = angle_deg
+ return None
+
+
+def sweep_to_world_points(sweep: List[Dict]) -> np.ndarray:
+ points = []
+ for beam in sweep:
+ d = beam["distance"]
+ if d <= 0.01:
+ continue
+ angle_rel = beam["angle_deg"]
+ px, py, hdg = beam["pose"]
+ angle_world = (hdg + angle_rel) % 360.0
+ a_rad = np.deg2rad(angle_world)
+ wx = px + d * np.sin(a_rad)
+ wy = py + d * np.cos(a_rad)
+ points.append([wx, wy])
+ if not points:
+ return np.zeros((0, 2))
+ return np.array(points)
+
+
+# ---------------------------------------------------------------------------
+# ICP 2D
+# ---------------------------------------------------------------------------
+
+def icp_2d(
+ source_pts: np.ndarray,
+ map_pts: np.ndarray,
+ max_iter: int = 20,
+ tol: float = 1e-4,
+ max_dist: float = 0.5,
+) -> Tuple[float, float, float, bool]:
+ if len(source_pts) < 5 or len(map_pts) < 5:
+ return 0.0, 0.0, 0.0, False
+
+ src = source_pts.copy()
+ tree = cKDTree(map_pts)
+ dx_total = 0.0
+ dy_total = 0.0
+ dtheta_total = 0.0
+
+ for _ in range(max_iter):
+ dists, idxs = tree.query(src, k=1, workers=-1)
+ mask = dists < max_dist
+ if mask.sum() < 5:
+ return dx_total, dy_total, dtheta_total, False
+
+ src_m = src[mask]
+ dst_m = map_pts[idxs[mask]]
+ c_src = src_m.mean(axis=0)
+ c_dst = dst_m.mean(axis=0)
+ A = src_m - c_src
+ B = dst_m - c_dst
+ H = A.T @ B
+ U, S, Vt = np.linalg.svd(H)
+ R = Vt.T @ U.T
+ if np.linalg.det(R) < 0:
+ Vt[-1, :] *= -1
+ R = Vt.T @ U.T
+ t = c_dst - R @ c_src
+ src = (R @ src.T).T + t
+ dx_total += t[0]
+ dy_total += t[1]
+ dtheta_total += np.arctan2(R[1, 0], R[0, 0])
+ if np.abs(t).max() < tol and abs(np.arctan2(R[1, 0], R[0, 0])) < tol:
+ return dx_total, dy_total, dtheta_total, True
+
+ return dx_total, dy_total, dtheta_total, True
+
+
+# ---------------------------------------------------------------------------
+# Carte incrémentale
+# ---------------------------------------------------------------------------
+
+class IncrementalMap:
+ def __init__(self, voxel_size: float = 0.05):
+ self.points: List[np.ndarray] = []
+ self.voxel_size = voxel_size
+ self._voxel_set = set()
+
+ def reset(self):
+ self.points = []
+ self._voxel_set = set()
+
+ def add_points(self, pts: np.ndarray) -> int:
+ """Retourne le nombre de nouveaux points ajoutés."""
+ added = 0
+ for pt in pts:
+ key = (int(pt[0] / self.voxel_size), int(pt[1] / self.voxel_size))
+ if key not in self._voxel_set:
+ self._voxel_set.add(key)
+ self.points.append(pt)
+ added += 1
+ return added
+
+ def get_array(self) -> np.ndarray:
+ if not self.points:
+ return np.zeros((0, 2))
+ return np.array(self.points)
+
+ def __len__(self):
+ return len(self.points)
+
+
+# ---------------------------------------------------------------------------
+# Fermeture de boucle
+# ---------------------------------------------------------------------------
+
+class LoopClosureDetector:
+ def __init__(self, min_time: float = 15.0, dist_thresh: float = 0.8):
+ self.min_time = min_time
+ self.dist_thresh = dist_thresh
+ self.history: List[Tuple[float, float, float, int]] = []
+
+ def reset(self):
+ self.history = []
+
+ def add_pose(self, t: float, x: float, y: float, sweep_idx: int) -> None:
+ self.history.append((t, x, y, sweep_idx))
+
+ def check(self, t: float, x: float, y: float) -> Optional[int]:
+ for (t_old, x_old, y_old, idx_old) in self.history:
+ if t - t_old < self.min_time:
+ continue
+ dist = np.sqrt((x - x_old)**2 + (y - y_old)**2)
+ if dist < self.dist_thresh:
+ return idx_old
+ return None
+
+
+# ---------------------------------------------------------------------------
+# Orchestrateur SLAM incrémental
+# ---------------------------------------------------------------------------
+
+class IncrementalSLAM:
+ """
+ Reçoit les enregistrements un par un via add_record().
+ Après chaque sweep complet → ICP + fermeture de boucle.
+ Expose: pose_dr, pose_corrected, map, trajectory, loop_closures.
+ """
+
+ def __init__(self):
+ self.dr = DeadReckoning()
+ self.sweep_acc = SweepAccumulator()
+ self.imap = IncrementalMap()
+ self.lcd = LoopClosureDetector()
+
+ # Pose courante (x, y, heading_deg)
+ self.pose_dr = (0.0, 0.0, 0.0)
+ self.pose_corrected = (0.0, 0.0, 0.0)
+
+ # Trajectoire : liste de (t, x, y, h) — corrigée
+ self.trajectory: List[Tuple[float, float, float, float]] = []
+
+ # Stats
+ self.records_count = 0
+ self.sweeps_done = 0
+ self.loop_closures = 0
+ self.last_t = 0.0
+
+ # Points ajoutés au dernier sweep (pour delta live)
+ self._last_new_points: np.ndarray = np.zeros((0, 2))
+
+ def reset(self):
+ self.dr.reset()
+ self.sweep_acc.reset()
+ self.imap.reset()
+ self.lcd.reset()
+ self.pose_dr = (0.0, 0.0, 0.0)
+ self.pose_corrected = (0.0, 0.0, 0.0)
+ self.trajectory = []
+ self.records_count = 0
+ self.sweeps_done = 0
+ self.loop_closures = 0
+ self.last_t = 0.0
+ self._last_new_points = np.zeros((0, 2))
+
+ def add_record(self, rec: dict) -> bool:
+ """
+ Traite un enregistrement. Retourne True si un sweep vient d'être complété
+ (le client /ws/live recevra alors un delta).
+ """
+ t = rec["t"]
+ self.records_count += 1
+ self.last_t = t
+
+ # DR
+ x, y, h = self.dr.update(
+ t=t,
+ heading_deg=rec["heading"],
+ ax=rec["ax"],
+ ay=rec["ay"],
+ gz=rec["gz"],
+ vf=rec.get("vf"),
+ vl=rec.get("vl", 0.0),
+ )
+ self.pose_dr = (x, y, h)
+
+ # Sweep accumulation
+ sweep = self.sweep_acc.add_beam(
+ angle_deg=rec["ping360_angle"],
+ distance=rec["ping360_distance"],
+ pose=(x, y, h),
+ )
+
+ if sweep is None:
+ return False
+
+ # --- Sweep complet ---
+ self.sweeps_done = self.sweep_acc.sweeps_done
+ new_pts = sweep_to_world_points(sweep)
+
+ # ICP si la carte n'est pas vide
+ map_arr = self.imap.get_array()
+ dx_icp = dy_icp = dtheta_icp = 0.0
+ if len(map_arr) >= 5 and len(new_pts) >= 5:
+ dx_icp, dy_icp, dtheta_icp, _ = icp_2d(new_pts, map_arr)
+ # Appliquer correction ICP à la pose courante
+ x_c = x + dx_icp
+ y_c = y + dy_icp
+ h_c = (h + np.rad2deg(dtheta_icp)) % 360
+ self.pose_corrected = (x_c, y_c, h_c)
+ # Recalculer les points corrigés pour la carte
+ corrected_sweep = [
+ {
+ "angle_deg": b["angle_deg"],
+ "distance": b["distance"],
+ "pose": (
+ b["pose"][0] + dx_icp,
+ b["pose"][1] + dy_icp,
+ b["pose"][2] + np.rad2deg(dtheta_icp),
+ )
+ }
+ for b in sweep
+ ]
+ map_pts_new = sweep_to_world_points(corrected_sweep)
+ else:
+ self.pose_corrected = (x, y, h)
+ map_pts_new = new_pts
+
+ # Ajouter les points à la carte
+ added = self.imap.add_points(map_pts_new)
+ self._last_new_points = map_pts_new if added > 0 else np.zeros((0, 2))
+
+ # Trajectoire
+ xc, yc, hc = self.pose_corrected
+ self.trajectory.append((t, xc, yc, hc))
+
+ # Fermeture de boucle
+ loop_old_idx = self.lcd.check(t, xc, yc)
+ if loop_old_idx is not None:
+ self.loop_closures += 1
+ # Redistribution linéaire correction sur dernières poses
+ n_loop = len(self.trajectory) - loop_old_idx
+ if n_loop > 1:
+ corr = np.array([
+ self.trajectory[loop_old_idx][1] - xc,
+ self.trajectory[loop_old_idx][2] - yc,
+ ])
+ for i in range(loop_old_idx, len(self.trajectory)):
+ alpha = (i - loop_old_idx) / n_loop
+ tt, xx, yy, hh = self.trajectory[i]
+ self.trajectory[i] = (tt, xx + alpha * corr[0], yy + alpha * corr[1], hh)
+
+ self.lcd.add_pose(t, xc, yc, len(self.trajectory) - 1)
+
+ return True
+
+ def get_state_snapshot(self) -> dict:
+ """Retourne l'état complet (pour connexion initiale /ws/live)."""
+ map_arr = self.imap.get_array()
+ return {
+ "type": "snapshot",
+ "records": self.records_count,
+ "sweeps": self.sweeps_done,
+ "loop_closures": self.loop_closures,
+ "last_t": self.last_t,
+ "pose_dr": list(self.pose_dr),
+ "pose_corrected": list(self.pose_corrected),
+ "map_points": map_arr.tolist(),
+ "trajectory": [list(p) for p in self.trajectory],
+ }
+
+ def get_sweep_delta(self) -> dict:
+ """Retourne le delta après un sweep (nouveaux points + pose actuelle)."""
+ return {
+ "type": "delta",
+ "records": self.records_count,
+ "sweeps": self.sweeps_done,
+ "loop_closures": self.loop_closures,
+ "last_t": self.last_t,
+ "pose_dr": list(self.pose_dr),
+ "pose_corrected": list(self.pose_corrected),
+ "new_map_points": self._last_new_points.tolist(),
+ "trajectory_tail": [list(p) for p in self.trajectory[-5:]],
+ }
diff --git a/server/static/index.html b/server/static/index.html
new file mode 100644
index 0000000..98779fa
--- /dev/null
+++ b/server/static/index.html
@@ -0,0 +1,487 @@
+
+
+
+
+
+Moulin Mapper — Live
+
+
+
+
+
+ MOULIN MAPPER
+
+ Déconnecté
+
+
+
+
+
+
+
+
+