feat(perception): project recorded results into Rerun

src/k1link/web/app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import shutil
 from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager, suppress
 from pathlib import Path
@@ -13,6 +14,7 @@ from fastapi.staticfiles import StaticFiles
 from pydantic import ValidationError
 
 from k1link import __version__
+from k1link.compute import RecordedPerceptionOverlayStore
 from k1link.sessions import (
     MaterializedRecording,
     RecordedMediaInspector,
@@ -51,6 +53,19 @@ session_recording_materializer = SessionRecordingMaterializer(
 session_recorded_media_inspector = RecordedMediaInspector(
     session_store.data_dir / "recorded-media-preparations"
 )
+_ffmpeg = shutil.which("ffmpeg")
+_ffprobe = shutil.which("ffprobe")
+session_perception_overlay_store = (
+    RecordedPerceptionOverlayStore(
+        jobs_root=REPOSITORY_ROOT / ".runtime" / "compute-jobs",
+        results_root=REPOSITORY_ROOT / ".runtime" / "compute-results",
+        cache_root=session_store.data_dir / "perception-overlays",
+        ffmpeg_path=Path(_ffmpeg),
+        ffprobe_path=Path(_ffprobe),
+    )
+    if _ffmpeg is not None and _ffprobe is not None
+    else None
+)
 
 
 def _prepare_recorded_media_for_launch(
@@ -304,6 +319,7 @@ app.include_router(
         recording_materializer=session_recording_materializer,
         recording_preparation_manager=session_recording_preparation_manager,
         media_inspector=session_recorded_media_inspector,
+        perception_overlay_provider=session_perception_overlay_store,
     )
 )
 

src/k1link/web/session_api.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictBool, field_validator,
 from starlette.concurrency import run_in_threadpool
 from starlette.types import Receive, Scope, Send
 
+from k1link.compute import RecordedPerceptionOverlayError
 from k1link.sessions import (
     RECORDED_MEDIA_MANIFEST_SCHEMA,
     LayoutConflictError,
@@ -102,6 +103,16 @@ class RecordedBlueprintRequest(StrictApiModel):
     point_size: float = Field(default=2.5, strict=True, ge=0.1, le=32.0)
     palette: Literal["turbo", "viridis", "plasma", "grayscale", "custom"] = "turbo"
     custom_color: str = Field(default="#f7f8f4", pattern=r"^#[0-9A-Fa-f]{6}$")
+    active_view: Literal["spatial", "perception", "metrics"] = "spatial"
+
+
+class RecordedPerceptionRequest(StrictApiModel):
+    application_id: Literal["nodedc_mission_core_recorded"]
+    recording_id: str = Field(
+        min_length=1,
+        max_length=128,
+        pattern=r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$",
+    )
 
 
 class SceneSettingsDocument(StrictApiModel):
@@ -233,6 +244,16 @@ class CatalogRefresher(Protocol):
     def __call__(self) -> object: ...
 
 
+class RecordedPerceptionOverlayProvider(Protocol):
+    def render(
+        self,
+        session_id: str,
+        *,
+        application_id: str,
+        recording_id: str,
+    ) -> bytes | None: ...
+
+
 def build_session_router(
     store: SessionStore,
     *,
@@ -241,6 +262,7 @@ def build_session_router(
     recording_materializer: RecordingMaterializer | None = None,
     recording_preparation_manager: SessionRecordingPreparationManager | None = None,
     media_inspector: RecordedMediaInspector | None = None,
+    perception_overlay_provider: RecordedPerceptionOverlayProvider | None = None,
     allow_synchronous_recording_fallback: bool = False,
     replay_action_id: str = DEFAULT_REPLAY_ACTION_ID,
 ) -> APIRouter:
@@ -755,6 +777,7 @@ def build_session_router(
                 ),
                 application_id=RECORDED_APPLICATION_ID,
                 recording_id=request.recording_id,
+                active_view=request.active_view,
             )
         except SessionNotFoundError as exc:
             raise HTTPException(status_code=404, detail=str(exc)) from exc
@@ -780,6 +803,56 @@ def build_session_router(
             },
         )
 
+    @router.post("/api/v1/observation-sessions/{session_id}/perception.rrd")
+    async def get_observation_session_perception(
+        session_id: str,
+        request: RecordedPerceptionRequest,
+    ) -> Response:
+        if perception_overlay_provider is None:
+            return Response(status_code=204, headers={"Cache-Control": "no-store"})
+        try:
+            await run_in_threadpool(
+                _prepare_replay,
+                store,
+                catalog_refresher,
+                session_id,
+                1.0,
+                False,
+                False,
+            )
+            payload = await run_in_threadpool(
+                perception_overlay_provider.render,
+                session_id,
+                application_id=request.application_id,
+                recording_id=request.recording_id,
+            )
+        except SessionNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except (SessionNotReplayableError, SessionIntegrityError) as exc:
+            raise HTTPException(status_code=409, detail=str(exc)) from exc
+        except RecordedPerceptionOverlayError as exc:
+            raise HTTPException(
+                status_code=500,
+                detail="Не удалось подготовить слой распознавания.",
+            ) from exc
+        except ValueError as exc:
+            raise HTTPException(
+                status_code=422,
+                detail="Некорректный идентификатор сессии.",
+            ) from exc
+        if payload is None:
+            return Response(status_code=204, headers={"Cache-Control": "no-store"})
+        return Response(
+            content=payload,
+            media_type="application/vnd.rerun.rrd",
+            headers={
+                "Cache-Control": "private, no-cache, no-transform",
+                "Content-Length": str(len(payload)),
+                "X-Content-Type-Options": "nosniff",
+                "Content-Disposition": 'inline; filename="perception.rrd"',
+            },
+        )
+
     @router.get("/api/v1/observation-sessions/{session_id}/media/{artifact_id}/manifest")
     def get_recorded_media_manifest(
         session_id: str,