reconstruct3d 0.1.0__tar.gz → 0.1.2__tar.gz

reconstruct3d-0.1.2/.dockerignore

@@ -0,0 +1,18 @@
+# Mantener el contexto de build liviano. node_modules se reinstala dentro de la
+# imagen; outputs/data/jobs y artefactos son regenerables o pesados.
+.git
+**/__pycache__
+**/*.pyc
+.venv
+node_modules
+frontend/node_modules
+frontend/dist
+outputs
+data
+backend/jobs
+backend/jobs.db
+reconstruct3d/cgal_mesh/build
+dist
+*.ply
+*.npy
+*.pkl

{reconstruct3d-0.1.0 → reconstruct3d-0.1.2}/.gitignore

@@ -30,4 +30,4 @@ outputs/
 
 # OS noise
 .DS_Store
-Thumbs.db
+Thumbs.db

{reconstruct3d-0.1.0 → reconstruct3d-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reconstruct3d
-Version: 0.1.0
+Version: 0.1.2
 Summary: Pipeline offline de reconstrucción 3D desde video monocular: Structure-from-Motion incremental + Bundle Adjustment + densificación MVS + mallado CGAL, con front-ends de features intercambiables (SIFT, ORB, SuperPoint+LightGlue).
 Project-URL: Homepage, https://github.com/FernandoUs/Template-SLAM
 Project-URL: Repository, https://github.com/FernandoUs/Template-SLAM

reconstruct3d-0.1.2/backend/.gitignore

@@ -0,0 +1,2 @@
+jobs/
+jobs.db

reconstruct3d-0.1.2/backend/Dockerfile

@@ -0,0 +1,27 @@
+# Backend FastAPI de la demo. Instala la librería reconstruct3d con el extra
+# 'api' y sirve uvicorn en :8000. Contexto de build = raíz del repo.
+FROM python:3.12-slim
+
+# Dependencias nativas de OpenCV (libGL/glib) que opencv-contrib-python necesita
+# en runtime. Sin esto, importar cv2 falla con "libGL.so.1 not found".
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgl1 \
+        libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# hatch-vcs deriva la versión del tag git, pero aquí no copiamos .git. Le damos
+# una versión fija de build para que la instalación no falle (es una imagen de
+# demo, no el paquete publicado en PyPI).
+ENV SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0
+
+# Instalar solo la librería + backend. Copiamos lo mínimo para aprovechar caché.
+COPY pyproject.toml README.md ./
+COPY reconstruct3d ./reconstruct3d
+RUN pip install --no-cache-dir ".[api]"
+
+COPY backend ./backend
+
+EXPOSE 8000
+CMD ["uvicorn", "backend.app:app", "--host", "0.0.0.0", "--port", "8000"]

{reconstruct3d-0.1.0 → reconstruct3d-0.1.2}/backend/app.py

@@ -26,6 +26,8 @@ from fastapi.responses import FileResponse
 
 from reconstruct3d import Pipeline, ALL_STAGES
 
+from backend import store
+
 HERE = os.path.dirname(os.path.abspath(__file__))
 JOBS_DIR = os.path.join(HERE, "jobs")
 os.makedirs(JOBS_DIR, exist_ok=True)
@@ -38,8 +40,12 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Un job a la vez: la reconstrucción es intensiva en CPU/memoria.
-_executor = ThreadPoolExecutor(max_workers=1)
+# Procesamiento en paralelo/background: varios jobs a la vez. La reconstrucción
+# es intensiva en CPU/memoria, así que el número de jobs concurrentes es acotado
+# y configurable por env (R3D_MAX_WORKERS). Los que excedan el cupo quedan en
+# cola ("queued") y arrancan cuando se libere un worker.
+_MAX_WORKERS = max(1, int(os.environ.get("R3D_MAX_WORKERS", "2")))
+_executor = ThreadPoolExecutor(max_workers=_MAX_WORKERS)
 _lock = threading.Lock()
 
 
@@ -47,19 +53,23 @@ _lock = threading.Lock()
 class Job:
     id: str
     stages: List[str]
+    name: str = ""                  # nombre del video subido (para mostrar en la UI)
     status: str = "queued"          # queued | running | done | error
     current: Optional[str] = None
     progress: float = 0.0
+    detail: str = ""                # avance fino de la etapa actual (p.ej. "densificando 213/379")
     events: List[dict] = field(default_factory=list)
     artifacts: Dict[str, str] = field(default_factory=dict)  # stage -> filename
     error: Optional[str] = None
     out_dir: str = ""
     created: float = field(default_factory=time.time)
+    last_save: float = 0.0          # para throttlear escrituras a SQLite en eventos 'progress'
 
     def public(self) -> dict:
         return {
-            "id": self.id, "status": self.status, "stages": self.stages,
-            "current": self.current, "progress": round(self.progress, 3),
+            "id": self.id, "name": self.name, "status": self.status,
+            "stages": self.stages, "current": self.current,
+            "progress": round(self.progress, 3), "detail": self.detail,
             "events": self.events[-200:], "artifacts": self.artifacts,
             "error": self.error, "created": self.created,
         }
@@ -68,22 +78,65 @@ class Job:
 JOBS: Dict[str, Job] = {}
 
 
+def _load_jobs_from_db():
+    """Restaura los jobs persistidos al arrancar el backend.
+
+    Los jobs que quedaron 'running'/'queued' al apagarse el servidor ya no tienen
+    hilo vivo: se marcan como interrumpidos (no se reanudan automáticamente)."""
+    for d in store.load_all():
+        job = Job(
+            id=d["id"], stages=d["stages"], name=d["name"] or "",
+            status=d["status"], current=d["current"], progress=d["progress"],
+            events=d["events"], artifacts=d["artifacts"], error=d["error"],
+            out_dir=d["out_dir"], created=d["created"] or time.time(),
+        )
+        if job.status in ("running", "queued"):
+            job.status = "error"
+            job.current = None
+            job.error = "interrumpido por reinicio del servidor"
+            store.save(job)
+        JOBS[job.id] = job
+
+
+_load_jobs_from_db()
+
+
 def _record_event(job: Job, ev: dict):
     """Callback on_event de la Pipeline: actualiza estado y progreso del job."""
     with _lock:
-        job.events.append(ev)
         stage, status = ev.get("stage"), ev.get("status")
+        ntotal = max(1, len(job.stages))
+
+        # Eventos de avance fino DENTRO de una etapa (no se guardan en el log para
+        # no inundarlo): mueven la barra de forma continua y la persistencia a
+        # SQLite se throttlea a ~1/s para no martillar el disco.
+        if status == "progress":
+            job.detail = ev.get("message", "")
+            if stage in job.stages and "frac" in ev:
+                base = job.stages.index(stage) / ntotal
+                job.progress = base + float(ev["frac"]) / ntotal
+            now = time.time()
+            if now - job.last_save >= 1.0:
+                job.last_save = now
+                store.save(job)
+            return
+
+        # Eventos de frontera de etapa (start/done): sí van al log.
+        job.events.append(ev)
         if status == "start" and stage in job.stages:
             job.current = stage
+            job.detail = ""
         done = sum(1 for e in job.events
                    if e.get("status") == "done" and e.get("stage") in job.stages)
-        job.progress = done / max(1, len(job.stages))
+        job.progress = done / ntotal
+        store.save(job)  # refleja el avance en SQLite (sobrevive reinicios)
 
 
 def _run_job(job: Job, video_path: str, frontend: str, camera, jobs: int,
              config: dict):
     with _lock:
         job.status = "running"
+        store.save(job)
     try:
         pipe = Pipeline(job.out_dir, frontend=frontend, camera=camera, jobs=jobs,
                         on_event=lambda ev: _record_event(job, ev))
@@ -93,10 +146,12 @@ def _run_job(job: Job, video_path: str, frontend: str, camera, jobs: int,
             job.status = "done"
             job.current = None
             job.progress = 1.0
+            store.save(job)
     except Exception as e:  # noqa: BLE001
         with _lock:
             job.status = "error"
             job.error = str(e)
+            store.save(job)
 
 
 @app.get("/api/health")
@@ -130,12 +185,23 @@ async def create_job(
     with open(video_path, "wb") as f:
         shutil.copyfileobj(video.file, f)
 
-    job = Job(id=job_id, stages=stages, out_dir=out_dir)
+    # Calibración: camera puede ser None (defaults), "auto" (intrínsecos derivados
+    # de la resolución del propio video, sin tablero), o un dict de intrínsecos.
+    camera = cfg.get("camera")
+    if camera == "auto":
+        from reconstruct3d.calibrate import auto_intrinsics
+        fm = float(cfg.get("focal_mult", 1.2))
+        camera = auto_intrinsics(video_path, focal_mult=fm)
+        print(f"[job {job_id}] calibración automática: {camera['_auto']}")
+
+    job = Job(id=job_id, stages=stages, out_dir=out_dir,
+              name=video.filename or f"input{suffix}")
     JOBS[job_id] = job
+    store.save(job)
 
     _executor.submit(
         _run_job, job, video_path,
-        cfg.get("frontend", "sift"), cfg.get("camera"), int(cfg.get("jobs", 0)),
+        cfg.get("frontend", "sift"), camera, int(cfg.get("jobs", 0)),
         cfg.get("config", {}),
     )
     return {"job_id": job_id, "stages": stages}
@@ -170,6 +236,7 @@ def get_artifact(job_id: str, name: str):
 @app.delete("/api/jobs/{job_id}")
 def delete_job(job_id: str):
     job = JOBS.pop(job_id, None)
+    store.delete(job_id)
     if job and os.path.isdir(job.out_dir):
         shutil.rmtree(job.out_dir, ignore_errors=True)
     return {"deleted": bool(job)}

reconstruct3d-0.1.2/backend/store.py

@@ -0,0 +1,87 @@
+"""Persistencia de jobs en SQLite.
+
+Los jobs viven en memoria mientras corren, pero se reflejan en una base SQLite
+para sobrevivir reinicios del backend. Guardamos el estado completo (incluidos
+eventos y artefactos) como columnas, serializando las listas/dicts a JSON.
+
+La conexión es única y compartida entre los hilos de los workers
+(`check_same_thread=False`), protegida por un lock propio.
+"""
+import json
+import os
+import sqlite3
+import threading
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+DB_PATH = os.environ.get("R3D_DB", os.path.join(_HERE, "jobs.db"))
+
+_conn = sqlite3.connect(DB_PATH, check_same_thread=False)
+_conn.row_factory = sqlite3.Row
+_conn.execute(
+    """
+    CREATE TABLE IF NOT EXISTS jobs (
+        id        TEXT PRIMARY KEY,
+        name      TEXT,
+        status    TEXT,
+        current   TEXT,
+        progress  REAL,
+        stages    TEXT,   -- JSON
+        events    TEXT,   -- JSON
+        artifacts TEXT,   -- JSON
+        error     TEXT,
+        out_dir   TEXT,
+        created   REAL
+    )
+    """
+)
+_conn.commit()
+_lock = threading.Lock()
+
+
+def save(job) -> None:
+    """Inserta o actualiza un job (upsert por id)."""
+    with _lock:
+        _conn.execute(
+            """
+            INSERT INTO jobs
+                (id, name, status, current, progress, stages, events,
+                 artifacts, error, out_dir, created)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                name=excluded.name, status=excluded.status,
+                current=excluded.current, progress=excluded.progress,
+                stages=excluded.stages, events=excluded.events,
+                artifacts=excluded.artifacts, error=excluded.error,
+                out_dir=excluded.out_dir, created=excluded.created
+            """,
+            (
+                job.id, job.name, job.status, job.current, job.progress,
+                json.dumps(job.stages), json.dumps(job.events),
+                json.dumps(job.artifacts), job.error, job.out_dir, job.created,
+            ),
+        )
+        _conn.commit()
+
+
+def delete(job_id: str) -> None:
+    with _lock:
+        _conn.execute("DELETE FROM jobs WHERE id = ?", (job_id,))
+        _conn.commit()
+
+
+def load_all() -> list[dict]:
+    """Devuelve todos los jobs guardados como dicts (listas/dicts ya deserializados)."""
+    with _lock:
+        rows = _conn.execute("SELECT * FROM jobs ORDER BY created").fetchall()
+    out = []
+    for r in rows:
+        out.append({
+            "id": r["id"], "name": r["name"], "status": r["status"],
+            "current": r["current"], "progress": r["progress"] or 0.0,
+            "stages": json.loads(r["stages"] or "[]"),
+            "events": json.loads(r["events"] or "[]"),
+            "artifacts": json.loads(r["artifacts"] or "{}"),
+            "error": r["error"], "out_dir": r["out_dir"] or "",
+            "created": r["created"],
+        })
+    return out

reconstruct3d-0.1.2/config/default.yaml

@@ -0,0 +1,37 @@
+# TEMPLATE-SLAM default configuration.
+#
+# Every magic number that used to live in the four scripts now lives here.
+# Override on the CLI with --config <path/to/other.yaml>.
+
+camera:
+  fx: 696.08
+  fy: 696.08
+  cx: 393.11
+  cy: 238.94
+  # Brown-Conrady (k1, k2, p1, p2, k3).
+  distortion: [0.3092, -0.7429, 0.0021, -0.0149, 0.6486]
+
+frontend:
+  extractor: SIFT          # SIFT (only one implemented for now)
+  matcher: BruteForce
+  ratio: 0.75              # Lowe's ratio test
+
+extraction:
+  frame_skip: 5            # process 1 of every N frames from the video
+  window: 3                # pairwise E-matrix neighborhood radius (frames)
+  min_matches: 5           # below this, skip the pair
+
+geometry:
+  essential:
+    prob: 0.999
+    threshold: 1.0         # px
+  pnp:
+    reprojection_error: 5.0
+    min_obs: 15            # need at least N 3D<->2D matches before solving PnP
+    min_inliers: 20        # accept the pose only if RANSAC keeps >= N inliers
+
+io:
+  database_path: outputs/sfm_data.pkl
+  map_state_path: outputs/map_state.npy
+  initial_cloud_path: outputs/init_cloud.ply
+  tracked_cloud_path: outputs/tracked_cloud.ply

reconstruct3d-0.1.2/config/iphone.yaml

@@ -0,0 +1,45 @@
+# iPhone — calibración promediada (estimada vía FOV + checkerboard).
+# Fuente: config/iPhoneavg.yaml (formato ORB-SLAM3), convertido al
+# layout que espera template_slam.
+#
+# Resolución del video al que corresponde: 540 x 960 (portrait).
+# Si tu video tiene OTRA resolución, hay que re-calibrar o escalar
+# fx, fy, cx, cy proporcionalmente.
+
+camera:
+  fx: 750.6
+  fy: 750.6
+  cx: 229.3
+  cy: 435.1
+  # Distorsión en 0 — la calibración "real" estaba sobreajustada,
+  # así que en la versión promedio se desactivó.
+  distortion: [0.0, 0.0, 0.0, 0.0, 0.0]
+
+frontend:
+  extractor: SIFT
+  matcher: BruteForce
+  ratio: 0.75
+
+extraction:
+  # Para videos de iPhone (24 fps, mucho movimiento de mano) conviene
+  # un salto más alto que el default. Súbelo a 15-20 si sigue lento.
+  frame_skip: 20
+  window: 3
+  min_matches: 5
+
+geometry:
+  essential:
+    prob: 0.999
+    threshold: 1.0
+  pnp:
+    reprojection_error: 5.0
+    min_obs: 15
+    min_inliers: 20
+
+# Rutas namespaced con prefijo 'iphone_' para no pisar las salidas
+# del default.yaml si corres ambas calibraciones en paralelo.
+io:
+  database_path: outputs/iphone_sfm_data.pkl
+  map_state_path: outputs/iphone_map_state.npy
+  initial_cloud_path: outputs/iphone_init_cloud.ply
+  tracked_cloud_path: outputs/iphone_tracked_cloud.ply

reconstruct3d-0.1.2/data/README.md

@@ -0,0 +1,23 @@
+# `data/` — Videos de entrada
+
+Pon aquí los videos que quieras procesar con el pipeline. La carpeta
+está en `.gitignore`, así que los archivos no se suben al repo (los
+videos suelen pesar demasiado para git).
+
+## Uso
+
+```bash
+python apps/extract_features.py --video data/mi_video.mp4
+python apps/initialize_map.py
+python apps/track.py
+python apps/view.py            --video data/mi_video.mp4
+```
+
+## Convención sugerida
+
+* Un video por archivo, nombre descriptivo (`utec_aula.mp4`,
+  `iphone_calle.mp4`, ...).
+* Si tienes varias cámaras con calibraciones distintas, crea un YAML
+  por cámara en `config/` (p. ej. `config/utec.yaml`, `config/iphone.yaml`)
+  y pásalo con `--config` en los cuatro pasos del pipeline.
+

reconstruct3d-0.1.2/docker-compose.yml

@@ -0,0 +1,39 @@
+# Demo completa con un solo comando:
+#
+#     docker compose up --build
+#
+# Frontend:  http://localhost:5173   (UI; sus llamadas /api van al backend)
+# Backend:   http://localhost:8000   (API FastAPI; /api/health para probar)
+#
+# Para apagar:  docker compose down
+
+services:
+  backend:
+    build:
+      context: .
+      dockerfile: backend/Dockerfile
+    ports:
+      - "8000:8000"
+    volumes:
+      # Código montado para hot-reload en desarrollo.
+      - ./backend:/app/backend
+      - ./reconstruct3d:/app/reconstruct3d
+      # Los jobs (videos subidos + nubes generadas) persisten en el host.
+      - ./backend/jobs:/app/backend/jobs
+    command: uvicorn backend.app:app --host 0.0.0.0 --port 8000 --reload
+
+  frontend:
+    build:
+      context: .
+      dockerfile: frontend/Dockerfile
+    ports:
+      - "5173:5173"
+    environment:
+      # Dentro de la red de Compose el backend es alcanzable por su nombre.
+      VITE_PROXY_TARGET: http://backend:8000
+    volumes:
+      # Código montado para hot-reload; node_modules se queda el del contenedor.
+      - ./frontend:/app
+      - /app/node_modules
+    depends_on:
+      - backend

reconstruct3d-0.1.2/examples/ejemplo_uso.py

@@ -0,0 +1,58 @@
+"""Ejemplo mínimo de uso de reconstruct3d como librería instalada.
+
+Sirve para verificar que el paquete se instaló bien y funciona "en cualquier lado":
+
+    pip install reconstruct3d        # (cuando esté publicado en PyPI)
+    python ejemplo_uso.py ruta/a/tu/video.mp4
+
+O sin video, solo para comprobar que la importación funciona:
+
+    python ejemplo_uso.py --check
+"""
+import sys
+
+import reconstruct3d
+from reconstruct3d import Pipeline
+
+
+def check():
+    """Comprueba que el paquete importa y muestra qué hay disponible."""
+    print(f"reconstruct3d {reconstruct3d.__version__} importado correctamente ✅")
+    print("Etapas disponibles:", reconstruct3d.ALL_STAGES)
+    print("Front-ends: sift (default), orb, spglue (requiere extra 'spglue')")
+
+
+def reconstruir(video: str):
+    """Corre la reconstrucción end-to-end sobre un video y reporta progreso."""
+
+    def on_event(ev):
+        # ev = {stage, status, message, ...}
+        print(f"[{ev['stage']:>8}] {ev['status']:<5} {ev.get('message', '')}")
+
+    pipe = Pipeline(
+        out_dir="outputs/ejemplo",   # carpeta donde se escriben los artefactos
+        frontend="sift",             # 'sift' | 'orb' | 'spglue'
+        camera=None,                 # o "camera.json" con tus intrínsecos
+        jobs=0,                      # 0 = auto (paraleliza extract/dense)
+        on_event=on_event,
+    )
+
+    # Etapas: extract -> init -> track -> ba -> dense -> mesh.
+    # Quita 'dense'/'mesh' si quieres algo más rápido (nube rala).
+    pipe.run(
+        video,
+        stages=["extract", "init", "track", "ba"],
+        config={"extract": {"k_skip": 15, "m_window": 4}},
+    )
+
+    print("\nArtefactos generados:")
+    for nombre, ruta in pipe.artifacts().items():
+        print(f"  {nombre}: {ruta}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2 or sys.argv[1] in ("--check", "-h", "--help"):
+        check()
+        print("\nUso: python ejemplo_uso.py ruta/a/video.mp4")
+    else:
+        reconstruir(sys.argv[1])

reconstruct3d-0.1.2/frontend/Dockerfile

@@ -0,0 +1,14 @@
+# Frontend Vite + React en modo desarrollo (hot reload). El proxy /api se
+# redirige al backend vía VITE_PROXY_TARGET (lo fija docker-compose).
+FROM node:20-slim
+
+WORKDIR /app
+
+# Instalar deps primero para cachear la capa de node_modules.
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm install
+
+COPY frontend ./
+
+EXPOSE 5173
+CMD ["npm", "run", "dev", "--", "--host", "0.0.0.0"]

reconstruct3d-0.1.2/frontend/jsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}