phase cv 0

2026-03-26 22:22:35 -03:00
parent beb0416280
commit 65814b5b9e
46 changed files with 2962 additions and 268 deletions
--- a/tests/detect/manual/seed_scenario.py
+++ b/tests/detect/manual/seed_scenario.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Seed a scenario checkpoint from a video chunk.
+
+Extracts frames via ffmpeg, uploads to MinIO, creates a StageCheckpoint
+in Postgres marked as a scenario. No pipeline, no Redis, no SSE.
+
+Prerequisites:
+  - Postgres reachable (port-forward or local)
+  - MinIO reachable (port-forward or local)
+
+Usage:
+    # With K8s port-forwards:
+    kubectl port-forward svc/postgres 5432:5432 &
+    kubectl port-forward svc/minio 9000:9000 &
+
+    python tests/detect/manual/seed_scenario.py
+
+    # Custom video:
+    python tests/detect/manual/seed_scenario.py --video media/mpr/out/chunks/.../chunk_0001.mp4
+
+Then open:
+    http://mpr.local.ar/detection/?job=<JOB_ID>&stage=filter_scenes&editor=true
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+import uuid
+
+parser = argparse.ArgumentParser(description="Seed a scenario checkpoint")
+parser.add_argument("--video",
+                    default="media/mpr/out/chunks/95043d50-4df6-4ac8-bbd5-2ba873117c6e/chunk_0000.mp4")
+parser.add_argument("--label", default="chelsea_edges_default",
+                    help="Scenario label for bookmarking")
+parser.add_argument("--fps", type=float, default=2.0, help="Frames per second to extract")
+parser.add_argument("--max-frames", type=int, default=20, help="Max frames to extract")
+parser.add_argument("--db-url",
+                    default=os.environ.get("DATABASE_URL", "postgresql://mpr:mpr@localhost:5432/mpr"))
+parser.add_argument("--s3-url",
+                    default=os.environ.get("S3_ENDPOINT_URL", "http://localhost:9000"))
+args = parser.parse_args()
+
+# Set env before imports
+os.environ["DATABASE_URL"] = args.db_url
+os.environ["S3_ENDPOINT_URL"] = args.s3_url
+os.environ.setdefault("AWS_ACCESS_KEY_ID", "minioadmin")
+os.environ.setdefault("AWS_SECRET_ACCESS_KEY", "minioadmin")
+
+sys.path.insert(0, ".")
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)-7s %(name)s — %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def extract_frames_ffmpeg(video_path: str, fps: float, max_frames: int):
+    """Extract frames using ffmpeg subprocess — no pipeline dependencies."""
+    import subprocess
+    import tempfile
+    from pathlib import Path
+
+    import numpy as np
+    from PIL import Image
+
+    from detect.models import Frame
+
+    tmpdir = tempfile.mkdtemp(prefix="scenario_")
+    pattern = os.path.join(tmpdir, "frame_%04d.jpg")
+
+    cmd = [
+        "ffmpeg", "-i", video_path,
+        "-vf", f"fps={fps}",
+        "-frames:v", str(max_frames),
+        "-q:v", "2",
+        pattern,
+        "-y", "-loglevel", "error",
+    ]
+    subprocess.run(cmd, check=True)
+
+    frames = []
+    for jpg in sorted(Path(tmpdir).glob("frame_*.jpg")):
+        seq = int(jpg.stem.split("_")[1]) - 1  # 0-indexed
+        img = Image.open(jpg).convert("RGB")
+        image_array = np.array(img)
+        frame = Frame(
+            sequence=seq,
+            chunk_id=0,
+            timestamp=seq / fps,
+            image=image_array,
+        )
+        frames.append(frame)
+        jpg.unlink()
+
+    Path(tmpdir).rmdir()
+    return frames
+
+
+def main():
+    job_id = str(uuid.uuid4())
+    video_path = args.video
+
+    if not os.path.exists(video_path):
+        logger.error("Video not found: %s", video_path)
+        sys.exit(1)
+
+    logger.info("Video: %s", video_path)
+    logger.info("Job ID: %s", job_id)
+    logger.info("Label: %s", args.label)
+
+    # Ensure DB tables exist
+    from core.db.connection import create_tables
+    create_tables()
+
+    # Extract frames
+    logger.info("Extracting frames (fps=%.1f, max=%d)...", args.fps, args.max_frames)
+    frames = extract_frames_ffmpeg(video_path, args.fps, args.max_frames)
+    logger.info("Extracted %d frames", len(frames))
+
+    # Upload frames to MinIO
+    from detect.checkpoint.frames import save_frames
+    logger.info("Uploading frames to MinIO...")
+    manifest = save_frames(job_id, frames)
+    logger.info("Uploaded %d frames", len(manifest))
+
+    # Build frame metadata
+    frames_meta = [
+        {
+            "sequence": f.sequence,
+            "chunk_id": f.chunk_id,
+            "timestamp": f.timestamp,
+            "perceptual_hash": "",
+        }
+        for f in frames
+    ]
+
+    # All frames are "filtered" (no scene filter ran)
+    filtered_sequences = [f.sequence for f in frames]
+
+    # Save checkpoint as scenario
+    from core.db.detect import save_stage_checkpoint
+    from detect.checkpoint.frames import CHECKPOINT_PREFIX
+
+    checkpoint = save_stage_checkpoint(
+        job_id=job_id,
+        stage="filter_scenes",
+        stage_index=1,
+        frames_prefix=f"{CHECKPOINT_PREFIX}/{job_id}/frames/",
+        frames_manifest={str(k): v for k, v in manifest.items()},
+        frames_meta=frames_meta,
+        filtered_frame_sequences=filtered_sequences,
+        stage_output_key="",
+        stats={"frames_extracted": len(frames), "frames_after_scene_filter": len(frames)},
+        config_snapshot={},
+        config_overrides={},
+        video_path=video_path,
+        profile_name="soccer_broadcast",
+        is_scenario=True,
+        scenario_label=args.label,
+    )
+
+    logger.info("")
+    logger.info("Scenario created:")
+    logger.info("  ID: %s", checkpoint.id)
+    logger.info("  Job: %s", job_id)
+    logger.info("  Label: %s", args.label)
+    logger.info("  Frames: %d", len(frames))
+    logger.info("")
+    logger.info("Open in editor:")
+    logger.info("  http://mpr.local.ar/detection/?job=%s#/editor/detect_edges", job_id)
+
+
+if __name__ == "__main__":
+    main()