reconstruct3d 0.1.0__py3-none-any.whl

reconstruct3d/cli.py

@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+"""Orquestador del pipeline de reconstrucción 3D (SfM offline + MVS-lite).
+
+Un único punto de entrada que encadena las 6 etapas del pipeline, evitando
+tener que recordar el orden de los scripts y mantener el directorio `--out`
+sincronizado a mano. Cada subcomando reutiliza las funciones de los módulos
+correspondientes (core, init_sfm, track_sfm, bundle_adjust, dense_mvs, viewer).
+
+Uso típico (con uv):
+
+    uv run python pipeline.py all data/mi_video.mp4
+    uv run python pipeline.py all data/mi_video.mp4 --frontend spglue
+
+O etapa por etapa (comparten el mismo directorio de salida):
+
+    uv run python pipeline.py extract data/mi_video.mp4
+    uv run python pipeline.py init
+    uv run python pipeline.py track
+    uv run python pipeline.py ba
+    uv run python pipeline.py dense data/mi_video.mp4
+    uv run python pipeline.py view data/mi_video.mp4
+
+El directorio de salida por defecto es `outputs/<frontend>/` (p.ej.
+`outputs/sift/`). Todas las etapas leen/escriben ahí: sfm_data.pkl,
+map_state.npy, init_cloud.ply, tracked_cloud.ply, dense_cloud.ply.
+"""
+import argparse
+import os
+import sys
+
+from reconstruct3d.core import DEFAULT_FRONTEND, _FRONTEND_REGISTRY
+
+FRONTENDS = sorted(_FRONTEND_REGISTRY)
+
+
+def default_out(frontend):
+    return os.path.join("outputs", frontend)
+
+
+def _resolve_out(args):
+    """Directorio de salida: --out explícito o outputs/<frontend>/."""
+    out = getattr(args, "out", None) or default_out(args.frontend)
+    os.makedirs(out, exist_ok=True)
+    return out
+
+
+def _banner(stage):
+    print(f"\n{'=' * 70}\n[ETAPA] {stage}\n{'=' * 70}")
+
+
+def _resolve_camera(args):
+    """Resuelve los intrínsecos para `extract` con esta prioridad:
+      1. --calibrate VIDEO  -> calibra ahora y escribe camera.json.
+      2. --camera FILE      -> carga ese JSON.
+      3. ./camera.json      -> lo usa si existe (auto).
+      4. video de calibración detectado (data/calib/, data/, *calib*) -> calibra.
+      5. defaults de CameraConfig (iPhone @ 540x960) si no hay nada.
+    Devuelve una CameraConfig o None (None = usar defaults en process_core).
+    """
+    from reconstruct3d.core import CameraConfig
+    from reconstruct3d import calibrate
+    board = getattr(args, "board", (9, 6))
+    square = getattr(args, "square", 0.025)
+    cam_json = getattr(args, "camera", None)
+    calib_video = getattr(args, "calibrate", None)
+
+    if calib_video:
+        out_json = cam_json or calibrate.DEFAULT_CAMERA_JSON
+        print(f"[*] Calibrando intrínsecos desde '{calib_video}' -> {out_json}")
+        calibrate.run_calibration(calib_video, board=board, square_size=square, out=out_json)
+        return CameraConfig.from_json(out_json)
+
+    if cam_json:
+        print(f"[*] Cámara: {cam_json}")
+        return CameraConfig.from_json(cam_json)
+
+    if os.path.exists(calibrate.DEFAULT_CAMERA_JSON):
+        print(f"[*] Cámara: {calibrate.DEFAULT_CAMERA_JSON} (auto-detectado)")
+        return CameraConfig.from_json(calibrate.DEFAULT_CAMERA_JSON)
+
+    src = calibrate.find_calibration_source()
+    if src:
+        print(f"[*] Video de calibración detectado ('{src}'); calibrando automáticamente...")
+        calibrate.run_calibration(src, board=board, square_size=square,
+                                  out=calibrate.DEFAULT_CAMERA_JSON)
+        return CameraConfig.from_json(calibrate.DEFAULT_CAMERA_JSON)
+
+    print("[*] Sin camera.json ni video de calibración; usando intrínsecos por defecto. "
+          "Pasa --camera o --calibrate para tu dispositivo.")
+    return None
+
+
+# --------------------------------------------------------------------------- #
+# Subcomandos                                                                  #
+# --------------------------------------------------------------------------- #
+def cmd_calibrate(args):
+    """Calibra K desde un video de tablero y escribe/crea camera.json."""
+    from reconstruct3d import calibrate
+    _banner(f"calibrate  ->  {args.out}")
+    calibrate.run_calibration(
+        args.video, board=args.board, square_size=args.square,
+        k_skip=args.k_skip, max_views=args.max_views,
+        interactive=args.interactive, out=args.out,
+    )
+    return args.out
+
+
+def cmd_extract(args):
+    """Etapa 1: extracción de features + matrices esenciales -> sfm_data.pkl."""
+    import pandas as pd
+    from reconstruct3d.core import process_core
+
+    out = _resolve_out(args)
+    _banner(f"1/extract  ({args.frontend})  ->  {out}")
+    camera = _resolve_camera(args)
+    db = process_core(
+        args.video, out, frontend_name=args.frontend,
+        k_skip=args.k_skip, m_window=args.m_window,
+        max_seconds=args.max_seconds, start_seconds=args.start_seconds,
+        camera=camera, reuse_db=not args.force, jobs=getattr(args, "jobs", 0),
+    )
+    if db.pairwise:
+        df = pd.DataFrame(db.pairwise).sort_values("inliers", ascending=False)
+        print(f"\nFrontend usado: {db.frontend_name}")
+        print("Top candidatos (más inliers):\n",
+              df[["frame_i", "frame_j", "inliers", "matches"]].head())
+    return out
+
+
+def cmd_init(args):
+    """Etapa 2: triangulación del par semilla -> map_state.npy + init_cloud.ply."""
+    from reconstruct3d.init_sfm import init_reconstruction
+
+    out = _resolve_out(args)
+    _banner(f"2/init  ->  {out}")
+    init_reconstruction(out)
+    return out
+
+
+def cmd_track(args):
+    """Etapa 3: registro incremental PnP + BA local + fusión -> tracked_cloud.ply."""
+    from reconstruct3d.track_sfm import track_frames
+
+    out = _resolve_out(args)
+    _banner(f"3/track  ->  {out}")
+    track_frames(
+        out, m_window=args.m_window, min_angle=args.min_angle,
+        local_ba=not args.no_local_ba, ba_every=args.ba_every,
+        fuse=not args.no_fuse,
+    )
+    return out
+
+
+def cmd_ba(args):
+    """Etapa 4 (opcional): Bundle Adjustment global -> reescribe el mapa."""
+    from reconstruct3d.bundle_adjust import run_bundle_adjustment
+
+    out = _resolve_out(args)
+    _banner(f"4/ba (global)  ->  {out}")
+    run_bundle_adjustment(out, max_reproj_err=args.max_reproj, max_nfev=args.max_nfev)
+    return out
+
+
+def cmd_dense(args):
+    """Etapa 5: densificación MVS-lite -> dense_cloud.ply."""
+    from reconstruct3d.dense_mvs import run_dense
+
+    out = _resolve_out(args)
+    _banner(f"5/dense  ->  {out}")
+    steps = tuple(int(s) for s in str(args.neighbor_steps).split(",") if s.strip())
+    run_dense(
+        out, args.video, neighbor_steps=steps, min_views=args.min_views,
+        num_disp=args.num_disp, block=args.block, voxel=args.voxel,
+        jobs=getattr(args, "jobs", 0),
+    )
+    return out
+
+
+def cmd_mesh(args):
+    """Etapa 6: mallado de la nube densa con CGAL -> mesh.ply."""
+    from reconstruct3d import mesh
+    # Nube de entrada: posicional `cloud`, o --input, o <out>/dense_cloud.ply.
+    cloud = getattr(args, "cloud", None) or getattr(args, "input", None)
+    if cloud:
+        # Sin --out explícito, mesh.ply va a la carpeta de la nube indicada.
+        out = args.out or os.path.dirname(os.path.abspath(cloud)) or "."
+        os.makedirs(out, exist_ok=True)
+    else:
+        out = _resolve_out(args)
+    _banner(f"6/mesh ({args.method})  ->  {out}")
+    mesh.run_mesh(
+        out, input_ply=cloud, method=args.method, outlier_pct=args.outlier_pct,
+        simplify=args.simplify, smooth=args.smooth, mesh_smooth=args.mesh_smooth,
+        min_component=args.min_component, afront_radius=args.afront_radius,
+        poisson_spacing_mult=args.poisson_spacing_mult, rebuild=args.rebuild,
+    )
+    return out
+
+
+def cmd_view(args):
+    """Etapa 7: visor POV interactivo sobre el mapa reconstruido."""
+    from reconstruct3d import viewer
+    out = _resolve_out(args)
+    _banner(f"7/view  ->  {out}")
+    viewer.main(args.video, out)
+    return out
+
+
+def cmd_chunked(args):
+    """Reconstrucción por chunks con solape + fusión de nubes (videos largos)."""
+    from reconstruct3d import chunked
+    out = _resolve_out(args)
+    _banner(f"chunked  ({args.frontend})  ->  {out}")
+    camera = _resolve_camera(args)
+    chunked.run_chunked(
+        args.video, out, frontend_name=args.frontend, k_skip=args.k_skip, m_window=args.m_window,
+        chunk=args.chunk, overlap=args.overlap, min_angle=args.min_angle,
+        local_ba=not args.no_local_ba, ba_every=args.ba_every, fuse=not args.no_fuse,
+        ba=args.ba, ba_max_nfev=args.ba_max_nfev, chunk_jobs=args.chunk_jobs,
+        inner_jobs=args.inner_jobs, camera=camera, min_overlap=args.min_overlap, voxel=args.voxel,
+    )
+    return out
+
+
+def cmd_all(args):
+    """Pipeline completo: extract -> init -> track -> [ba] -> [dense] -> [mesh] -> [view]."""
+    cmd_extract(args)
+    cmd_init(args)
+    cmd_track(args)
+    if not args.no_ba:
+        cmd_ba(args)
+    if not args.no_dense:
+        cmd_dense(args)
+    if not args.no_mesh and not args.no_dense:
+        try:
+            cmd_mesh(args)
+        except Exception as e:  # noqa: BLE001 - el mallado depende de CGAL nativo
+            print(f"[!] Mallado omitido ({e}). Instala CGAL o corre `mesh` aparte.")
+    out = _resolve_out(args)
+    print(f"\n{'=' * 70}\n[OK] Pipeline completo. Artefactos en: {out}/")
+    for name in ("init_cloud.ply", "tracked_cloud.ply", "dense_cloud.ply", "mesh.ply"):
+        p = os.path.join(out, name)
+        mark = "✓" if os.path.exists(p) else "·"
+        print(f"   [{mark}] {p}")
+    print("=" * 70)
+    if args.view:
+        cmd_view(args)
+
+
+# --------------------------------------------------------------------------- #
+# Argumentos                                                                   #
+# --------------------------------------------------------------------------- #
+def _add_common(p, needs_video=True):
+    if needs_video:
+        p.add_argument("video", help="Ruta al video de entrada (mp4/MOV).")
+    p.add_argument("--frontend", choices=FRONTENDS, default=DEFAULT_FRONTEND,
+                   help=f"Detector+matcher (default: {DEFAULT_FRONTEND}). "
+                        "'sift', 'orb', 'spglue'=SuperPoint+LightGlue (requiere torch).")
+    p.add_argument("--out", default=None,
+                   help="Directorio de salida (default: outputs/<frontend>/).")
+
+
+def _board_arg(s):
+    """'9x6' -> (9, 6)."""
+    parts = str(s).lower().replace("×", "x").split("x")
+    if len(parts) != 2:
+        raise argparse.ArgumentTypeError(f"Tablero inválido: '{s}'. Usa COLSxROWS, p.ej. 9x6.")
+    return int(parts[0]), int(parts[1])
+
+
+def _add_camera_opts(p):
+    """Opciones de cámara/calibración compartidas por extract y all."""
+    p.add_argument("--camera", default=None,
+                   help="JSON con intrínsecos del dispositivo (ver camera.example.json). "
+                        "Si se omite, se auto-detecta camera.json o un video *calib*.")
+    p.add_argument("--calibrate", default=None, metavar="VIDEO_TABLERO",
+                   help="Calibrar K desde este video de tablero antes de extraer (escribe camera.json).")
+    p.add_argument("--board", type=_board_arg, default=(9, 6),
+                   help="Esquinas internas COLSxROWS del tablero de calibración (default 9x6).")
+    p.add_argument("--square", type=float, default=0.025,
+                   help="Lado del cuadrado en metros para calibración (default 0.025).")
+    p.add_argument("--jobs", type=int, default=0,
+                   help="Hilos para extracción/matching (0=auto=nº de CPUs; 1=secuencial).")
+
+
+def _add_mesh_opts(p):
+    """Opciones de mallado CGAL, compartidas por `mesh` y `all`."""
+    p.add_argument("--method", choices=["afront", "poisson"], default="afront",
+                   help="afront=interpola puntos, conserva color, bordes abiertos (default). "
+                        "poisson=superficie suave/cerrada, tolera ruido.")
+    p.add_argument("--outlier-pct", type=float, default=2.0, help="%% de outliers a eliminar (0=off).")
+    p.add_argument("--simplify", type=float, default=0.0,
+                   help="Celda de grid simplify (0=auto~2x spacing; <0=sin simplificar).")
+    p.add_argument("--smooth", type=int, default=0, help="Vecinos de jet smooth de PUNTOS (0=off).")
+    p.add_argument("--mesh-smooth", type=int, default=2,
+                   help="Iteraciones de suavizado tangencial de la MALLA (default 2; 0=off).")
+    p.add_argument("--min-component", type=float, default=0.002,
+                   help="Elimina componentes < FRAC*caras (islas de ruido) (default 0.002; 0=off).")
+    p.add_argument("--afront-radius", type=float, default=5.0, help="Longitud máx. de arista (x spacing).")
+    p.add_argument("--poisson-spacing-mult", type=float, default=1.0, help="Multiplicador de spacing para Poisson.")
+    p.add_argument("--rebuild", action="store_true", help="Recompilar el binario CGAL.")
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        description="Pipeline de reconstrucción 3D (SfM offline + densificación MVS).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # --- calibrate ---
+    pc = sub.add_parser("calibrate", help="Calibrar K desde un video de tablero -> camera.json.")
+    pc.add_argument("video", help="Video del patrón de ajedrez (mp4/MOV/avi).")
+    pc.add_argument("--board", type=_board_arg, default=(9, 6), help="Esquinas internas COLSxROWS (default 9x6).")
+    pc.add_argument("--square", type=float, default=0.025, help="Lado del cuadrado en metros (default 0.025).")
+    pc.add_argument("--k-skip", type=int, default=10, help="Revisar 1 de cada k frames (default 10).")
+    pc.add_argument("--max-views", type=int, default=40, help="Máx. vistas a usar (default 40).")
+    pc.add_argument("--interactive", action="store_true", help="Aceptar cada vista a mano (ventana OpenCV).")
+    pc.add_argument("--out", default="camera.json", help="Ruta de salida (default camera.json).")
+    pc.set_defaults(func=cmd_calibrate)
+
+    # --- extract ---
+    pe = sub.add_parser("extract", help="Etapa 1: features + matrices esenciales.")
+    _add_common(pe)
+    pe.add_argument("--k-skip", type=int, default=5, help="Procesa 1 de cada k frames (default 5).")
+    pe.add_argument("--m-window", type=int, default=3, help="Ventana de pares ±m vecinos (default 3).")
+    pe.add_argument("--max-seconds", type=float, default=None, help="Procesar hasta el segundo N.")
+    pe.add_argument("--start-seconds", type=float, default=0.0, help="Empezar desde el segundo N.")
+    pe.add_argument("--force", action="store_true", help="Re-extraer aunque exista sfm_data.pkl.")
+    _add_camera_opts(pe)
+    pe.set_defaults(func=cmd_extract)
+
+    # --- init ---
+    pi = sub.add_parser("init", help="Etapa 2: triangular par semilla.")
+    _add_common(pi, needs_video=False)
+    pi.set_defaults(func=cmd_init)
+
+    # --- track ---
+    pt = sub.add_parser("track", help="Etapa 3: registro incremental + BA local.")
+    _add_common(pt, needs_video=False)
+    pt.add_argument("--m-window", type=int, default=3, help="Ventana PnP ±m frames extraídos (default 3).")
+    pt.add_argument("--min-angle", type=float, default=1.5, help="Ángulo mínimo de triangulación (grados).")
+    pt.add_argument("--no-local-ba", action="store_true", help="Desactiva BA local por ventana.")
+    pt.add_argument("--ba-every", type=int, default=1, help="BA local cada N cámaras (default 1).")
+    pt.add_argument("--no-fuse", action="store_true", help="Desactiva la fusión de puntos duplicados.")
+    pt.set_defaults(func=cmd_track)
+
+    # --- ba ---
+    pb = sub.add_parser("ba", help="Etapa 4: Bundle Adjustment global (opcional).")
+    _add_common(pb, needs_video=False)
+    pb.add_argument("--max-reproj", type=float, default=4.0, help="Descartar puntos con reproj > px (default 4).")
+    pb.add_argument("--max-nfev", type=int, default=300, help="Máx. evaluaciones del optimizador (default 300).")
+    pb.set_defaults(func=cmd_ba)
+
+    # --- dense ---
+    pd_ = sub.add_parser("dense", help="Etapa 5: densificación MVS-lite.")
+    _add_common(pd_)
+    pd_.add_argument("--neighbor-steps", default="1,2", help="Offsets de vecinos (default '1,2').")
+    pd_.add_argument("--min-views", type=int, default=2, help="Puntos confirmados por >=N pares (default 2).")
+    pd_.add_argument("--num-disp", type=int, default=128, help="numDisparities SGBM (múltiplo de 16).")
+    pd_.add_argument("--block", type=int, default=5, help="blockSize SGBM (impar, default 5).")
+    pd_.add_argument("--voxel", type=float, default=0.0, help="Tamaño de vóxel (0 = automático).")
+    pd_.add_argument("--jobs", type=int, default=0,
+                     help="Hilos para densificar pares (0=auto=nº de CPUs; 1=secuencial).")
+    pd_.set_defaults(func=cmd_dense)
+
+    # --- mesh ---
+    pm = sub.add_parser("mesh", help="Etapa 6: mallado de la nube densa con CGAL.")
+    pm.add_argument("cloud", nargs="?", default=None,
+                    help="Ruta al .ply de entrada (p.ej. outputs/sift/dense_cloud.ply). "
+                         "Si se omite, usa <out>/dense_cloud.ply.")
+    _add_common(pm, needs_video=False)
+    pm.add_argument("--input", default=None,
+                    help="Alternativa a la ruta posicional para la nube de entrada.")
+    _add_mesh_opts(pm)
+    pm.set_defaults(func=cmd_mesh)
+
+    # --- chunked ---
+    pk = sub.add_parser("chunked", help="Reconstrucción por chunks con solape + fusión (videos largos).")
+    _add_common(pk)
+    pk.add_argument("--camera", default=None, help="JSON de intrínsecos (auto-detecta si se omite).")
+    pk.add_argument("--calibrate", default=None, metavar="VIDEO_TABLERO",
+                    help="Calibrar K desde este video de tablero antes de reconstruir.")
+    pk.add_argument("--board", type=_board_arg, default=(9, 6), help="Tablero COLSxROWS (default 9x6).")
+    pk.add_argument("--square", type=float, default=0.025, help="Lado del cuadrado en metros (default 0.025).")
+    pk.add_argument("--k-skip", type=int, default=5, help="1 de cada k frames (default 5).")
+    pk.add_argument("--m-window", type=int, default=3, help="Ventana de pares/PnP (default 3).")
+    pk.add_argument("--chunk", type=int, default=80, help="Frames muestreados por chunk (default 80).")
+    pk.add_argument("--overlap", type=int, default=20, help="Frames muestreados de solape (default 20).")
+    pk.add_argument("--min-angle", type=float, default=1.5, help="Ángulo mín. de triangulación.")
+    pk.add_argument("--no-local-ba", action="store_true", help="Desactiva BA local en cada chunk.")
+    pk.add_argument("--ba-every", type=int, default=1)
+    pk.add_argument("--no-fuse", action="store_true")
+    pk.add_argument("--ba", action="store_true", help="BA global por chunk antes de fusionar.")
+    pk.add_argument("--ba-max-nfev", type=int, default=200)
+    pk.add_argument("--chunk-jobs", type=int, default=0,
+                    help="Chunks en paralelo (procesos; 0=auto, 1=secuencial).")
+    pk.add_argument("--inner-jobs", type=int, default=1,
+                    help="Hilos de extracción/matching dentro de cada chunk (default 1).")
+    pk.add_argument("--min-overlap", type=int, default=4,
+                    help="Frames de solape mínimos para alinear un chunk (default 4).")
+    pk.add_argument("--voxel", type=float, default=0.0, help="Vóxel de dedup del merge (0=auto).")
+    pk.set_defaults(func=cmd_chunked)
+
+    # --- view ---
+    pv = sub.add_parser("view", help="Etapa 6: visor POV interactivo.")
+    _add_common(pv)
+    pv.set_defaults(func=cmd_view)
+
+    # --- all ---
+    pa = sub.add_parser("all", help="Pipeline completo (extract->init->track->ba->dense).")
+    _add_common(pa)
+    # Subconjunto de flags útiles para el modo end-to-end.
+    pa.add_argument("--k-skip", type=int, default=5)
+    pa.add_argument("--m-window", type=int, default=3)
+    pa.add_argument("--max-seconds", type=float, default=None)
+    pa.add_argument("--start-seconds", type=float, default=0.0)
+    pa.add_argument("--force", action="store_true", help="Re-extraer features desde cero.")
+    _add_camera_opts(pa)
+    pa.add_argument("--min-angle", type=float, default=1.5)
+    pa.add_argument("--no-local-ba", action="store_true")
+    pa.add_argument("--ba-every", type=int, default=1)
+    pa.add_argument("--no-fuse", action="store_true")
+    pa.add_argument("--max-reproj", type=float, default=4.0)
+    pa.add_argument("--max-nfev", type=int, default=300)
+    pa.add_argument("--neighbor-steps", default="1,2")
+    pa.add_argument("--min-views", type=int, default=2)
+    pa.add_argument("--num-disp", type=int, default=128)
+    pa.add_argument("--block", type=int, default=5)
+    pa.add_argument("--voxel", type=float, default=0.0)
+    pa.add_argument("--no-ba", action="store_true", help="Saltar el BA global.")
+    pa.add_argument("--no-dense", action="store_true", help="Saltar la densificación.")
+    pa.add_argument("--no-mesh", action="store_true", help="Saltar el mallado CGAL.")
+    pa.add_argument("--input", default=None, help=argparse.SUPPRESS)  # solo para reusar cmd_mesh
+    _add_mesh_opts(pa)
+    pa.add_argument("--view", action="store_true", help="Abrir el visor al terminar.")
+    pa.set_defaults(func=cmd_all)
+
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()