reverse3d 0.9.0__tar.gz → 0.11.0__tar.gz

{reverse3d-0.9.0/reverse3d.egg-info → reverse3d-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.9.0
+Version: 0.11.0
 Summary: AI-agent-ready toolkit for 3D reverse engineering: image analysis, photogrammetry, mesh repair, primitive fitting and headless rendering.
 Author-email: Voxel Enterprise <info@voxel.lat>
 Maintainer-email: Voxel Enterprise <info@voxel.lat>
@@ -32,6 +32,7 @@ License-File: NOTICE
 Requires-Dist: numpy>=1.26
 Requires-Dist: scipy>=1.11
 Requires-Dist: scikit-image>=0.22
+Requires-Dist: xatlas>=0.0.9
 Requires-Dist: opencv-python-headless>=4.9
 Requires-Dist: pillow>=10.3
 Requires-Dist: pillow-heif>=1.1
@@ -96,6 +97,7 @@ Desarrollado por **[Voxel Enterprise](https://voxel.lat)**
 - [💰 Ahorro de tokens](#-ahorro-de-tokens)
 - [🔌 Sin internet (modo offline)](#-sin-internet-modo-offline)
 - [🤖 Piloto automático](#-piloto-automático)
+- [🧠 Reverse3D Core (motor exclusivo)](#-reverse3d-core-motor-exclusivo)
 - [Capacidades](#capacidades)
 - [Herramientas externas opcionales](#herramientas-externas-opcionales)
 - [Referencia de la CLI](#referencia-de-la-cli)
@@ -219,7 +221,7 @@ Cada archivo modificado se **respalda antes** (`*.reverse3d-backup-<fecha>`). So
 | `--lite` | `-Lite` | Todo, con la IA local en la CPU (PyTorch CPU, ~250 MB en vez de ~2.5 GB) |
 | `--minimal` | `-Minimal` | Núcleo + MCP + IA local, sin herramientas externas |
 | `--no-tools` | `-NoTools` | No instalar Blender ni COLMAP |
-| *(en todos los modos)* | *(en todos los modos)* | **La IA local se instala y se descarga siempre** (clasificador, segmentación y profundidad, unos 750 MB) para que todo funcione sin internet |
+| *(en todos los modos)* | *(en todos los modos)* | **La IA local se instala y se descarga siempre** (clasificador, segmentación, profundidad y puntos con IA, unos 800 MB) para que todo funcione sin internet |
 | `--no-auto-approve` | `-NoAutoApprove` | Que los agentes pregunten antes de cada herramienta |
 | `--with recon,depth` | `-With recon,depth` | Extras a elección |
 | `--device auto\|cpu\|gpu` | `-Device …` | Dispositivo por defecto |
@@ -358,7 +360,7 @@ reverse3d config set verbosity full     # si alguna vez necesitas el detalle com
 
 ## 🔌 Sin internet (modo offline)
 
-reverse3d **funciona sin conexión**. Todo el cálculo es local (OpenCV, COLMAP, Open3D, trimesh, Blender). Lo único que se descarga es el modelo de IA de profundidad, y **el instalador lo deja descargado**.
+reverse3d **funciona sin conexión**. Todo el cálculo es local (OpenCV, COLMAP, Open3D, trimesh, Blender). Lo único que se descarga son los modelos de IA local (sujeto, recorte, profundidad y los puntos ALIKED + LightGlue), y **el instalador los deja descargados**.
 
 - **Cambio automático:** si el equipo no detecta internet, reverse3d pasa solo a modo offline. No tienes que hacer nada.
 - **Comprobar:** `reverse3d offline status` dice si hay conexión y qué funciona sin ella. `reverse3d doctor` lo incluye en su informe.
@@ -407,6 +409,23 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 
 ---
 
+## 🧠 Reverse3D Core (motor exclusivo)
+
+**Reverse3D Core** es el motor de reconstrucción propio de Voxel Enterprise. Es **propietario** (no forma parte de este repositorio de código abierto) y viene **incluido en reverse3d Studio**, que lo instala solo.
+
+- **Cuando está instalado**, reverse3d lo usa automáticamente para fusionar las siluetas de los objetos. Aprende qué fotos son fiables, así que un brillo, un mal recorte o una foto mal ubicada **ya no borran el objeto**, y cada foto extra suma precisión.
+- **Sin él**, reverse3d funciona igual con su método abierto.
+- **Comprobarlo:** `reverse3d doctor` muestra `core: {available: true, version: …}`. El informe de cada trabajo indica qué motor se usó (`details.silhouette.engine`).
+
+| Prueba interna (objeto de geometría conocida) | Método abierto | Reverse3D Core |
+|---|---|---|
+| Recortes perfectos | 0,943 | 0,941 |
+| 15 % de recortes defectuosos | 0,000 (pierde el objeto) | **0,921** |
+
+*(Coincidencia volumétrica, IoU: 1 = idéntico.)*
+
+---
+
 ## Capacidades
 
 | Área | Qué hace | Tecnología |
@@ -416,6 +435,8 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 | 🧱 **Plano → pieza** | Extrusión de contornos a sólido 3D con escala real | Shapely + trimesh |
 | 📷 **Fotogrametría** | Fotos → SfM → MVS denso → nube → malla | COLMAP + Open3D |
 | 🌊 **Profundidad con IA** | Una foto → mapa de profundidad → relieve 2.5D | Depth Anything V2 |
+| 🎨 **Texturas** | Textura fotográfica 2048² desde las propias fotos (UV, visibilidad, sin costuras) en `model.glb` | xatlas + OpenCV |
+| 🧠 **Puntos con IA** | Rescate automático de capturas difíciles con puntos y emparejamiento aprendidos | ALIKED + LightGlue (ONNX) |
 | 🛠️ **Reparación de mallas** | Limpieza, restos sueltos, agujeros, normales, Taubin, decimación, alineación OBB/PCA, escala | trimesh |
 | 📏 **Metrología** | Cotas AABB/OBB, área, volumen, centro de masa, estanqueidad | trimesh |
 | 📐 **Primitivas** | Planos, cilindros y esferas con RANSAC (radios, ejes, normales) | NumPy |

{reverse3d-0.9.0 → reverse3d-0.11.0}/README.md

@@ -28,6 +28,7 @@ Desarrollado por **[Voxel Enterprise](https://voxel.lat)**
 - [💰 Ahorro de tokens](#-ahorro-de-tokens)
 - [🔌 Sin internet (modo offline)](#-sin-internet-modo-offline)
 - [🤖 Piloto automático](#-piloto-automático)
+- [🧠 Reverse3D Core (motor exclusivo)](#-reverse3d-core-motor-exclusivo)
 - [Capacidades](#capacidades)
 - [Herramientas externas opcionales](#herramientas-externas-opcionales)
 - [Referencia de la CLI](#referencia-de-la-cli)
@@ -151,7 +152,7 @@ Cada archivo modificado se **respalda antes** (`*.reverse3d-backup-<fecha>`). So
 | `--lite` | `-Lite` | Todo, con la IA local en la CPU (PyTorch CPU, ~250 MB en vez de ~2.5 GB) |
 | `--minimal` | `-Minimal` | Núcleo + MCP + IA local, sin herramientas externas |
 | `--no-tools` | `-NoTools` | No instalar Blender ni COLMAP |
-| *(en todos los modos)* | *(en todos los modos)* | **La IA local se instala y se descarga siempre** (clasificador, segmentación y profundidad, unos 750 MB) para que todo funcione sin internet |
+| *(en todos los modos)* | *(en todos los modos)* | **La IA local se instala y se descarga siempre** (clasificador, segmentación, profundidad y puntos con IA, unos 800 MB) para que todo funcione sin internet |
 | `--no-auto-approve` | `-NoAutoApprove` | Que los agentes pregunten antes de cada herramienta |
 | `--with recon,depth` | `-With recon,depth` | Extras a elección |
 | `--device auto\|cpu\|gpu` | `-Device …` | Dispositivo por defecto |
@@ -290,7 +291,7 @@ reverse3d config set verbosity full     # si alguna vez necesitas el detalle com
 
 ## 🔌 Sin internet (modo offline)
 
-reverse3d **funciona sin conexión**. Todo el cálculo es local (OpenCV, COLMAP, Open3D, trimesh, Blender). Lo único que se descarga es el modelo de IA de profundidad, y **el instalador lo deja descargado**.
+reverse3d **funciona sin conexión**. Todo el cálculo es local (OpenCV, COLMAP, Open3D, trimesh, Blender). Lo único que se descarga son los modelos de IA local (sujeto, recorte, profundidad y los puntos ALIKED + LightGlue), y **el instalador los deja descargados**.
 
 - **Cambio automático:** si el equipo no detecta internet, reverse3d pasa solo a modo offline. No tienes que hacer nada.
 - **Comprobar:** `reverse3d offline status` dice si hay conexión y qué funciona sin ella. `reverse3d doctor` lo incluye en su informe.
@@ -339,6 +340,23 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 
 ---
 
+## 🧠 Reverse3D Core (motor exclusivo)
+
+**Reverse3D Core** es el motor de reconstrucción propio de Voxel Enterprise. Es **propietario** (no forma parte de este repositorio de código abierto) y viene **incluido en reverse3d Studio**, que lo instala solo.
+
+- **Cuando está instalado**, reverse3d lo usa automáticamente para fusionar las siluetas de los objetos. Aprende qué fotos son fiables, así que un brillo, un mal recorte o una foto mal ubicada **ya no borran el objeto**, y cada foto extra suma precisión.
+- **Sin él**, reverse3d funciona igual con su método abierto.
+- **Comprobarlo:** `reverse3d doctor` muestra `core: {available: true, version: …}`. El informe de cada trabajo indica qué motor se usó (`details.silhouette.engine`).
+
+| Prueba interna (objeto de geometría conocida) | Método abierto | Reverse3D Core |
+|---|---|---|
+| Recortes perfectos | 0,943 | 0,941 |
+| 15 % de recortes defectuosos | 0,000 (pierde el objeto) | **0,921** |
+
+*(Coincidencia volumétrica, IoU: 1 = idéntico.)*
+
+---
+
 ## Capacidades
 
 | Área | Qué hace | Tecnología |
@@ -348,6 +366,8 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 | 🧱 **Plano → pieza** | Extrusión de contornos a sólido 3D con escala real | Shapely + trimesh |
 | 📷 **Fotogrametría** | Fotos → SfM → MVS denso → nube → malla | COLMAP + Open3D |
 | 🌊 **Profundidad con IA** | Una foto → mapa de profundidad → relieve 2.5D | Depth Anything V2 |
+| 🎨 **Texturas** | Textura fotográfica 2048² desde las propias fotos (UV, visibilidad, sin costuras) en `model.glb` | xatlas + OpenCV |
+| 🧠 **Puntos con IA** | Rescate automático de capturas difíciles con puntos y emparejamiento aprendidos | ALIKED + LightGlue (ONNX) |
 | 🛠️ **Reparación de mallas** | Limpieza, restos sueltos, agujeros, normales, Taubin, decimación, alineación OBB/PCA, escala | trimesh |
 | 📏 **Metrología** | Cotas AABB/OBB, área, volumen, centro de masa, estanqueidad | trimesh |
 | 📐 **Primitivas** | Planos, cilindros y esferas con RANSAC (radios, ejes, normales) | NumPy |

{reverse3d-0.9.0 → reverse3d-0.11.0}/pyproject.toml

@@ -40,6 +40,7 @@ dependencies = [
     "numpy>=1.26",
     "scipy>=1.11",
     "scikit-image>=0.22",
+    "xatlas>=0.0.9",
     "opencv-python-headless>=4.9",
     "pillow>=10.3",
     "pillow-heif>=1.1",

reverse3d-0.11.0/reverse3d/_version.py

@@ -0,0 +1 @@
+__version__ = "0.11.0"

{reverse3d-0.9.0 → reverse3d-0.11.0}/reverse3d/doctor.py

@@ -41,6 +41,16 @@ def _package_version(dist: str) -> str | None:
         return "installed"
 
 
+def core_status() -> dict[str, object]:
+    """Whether reverse3d-core, the proprietary reconstruction engine, is active."""
+    from reverse3d.reconstruction.silhouette import core_engine
+
+    core = core_engine()
+    if core is None:
+        return {"available": False, "hint": "Included in reverse3d Studio."}
+    return {"available": True, "version": str(getattr(core, "__version__", "?"))}
+
+
 def environment_report(settings: Settings, *, include_offline: bool = True) -> dict[str, object]:
     """Return a JSON-serialisable description of the runtime environment.
 
@@ -70,6 +80,8 @@ def environment_report(settings: Settings, *, include_offline: bool = True) -> d
         "reverse3d": __version__,
         "author": f"{AUTHOR} ({AUTHOR_URL})",
         "official_source": OFFICIAL_REPOSITORY,
+        # Voxel Enterprise's proprietary engine (bundled with reverse3d Studio).
+        "core": core_status(),
         "python": sys.version.split()[0],
         "platform": platform.platform(),
         "workspace": str(settings.workspace),

{reverse3d-0.9.0 → reverse3d-0.11.0}/reverse3d/offline.py

@@ -59,6 +59,55 @@ MODEL_REVISIONS: dict[str, str] = {
 }
 
 
+#: Learned feature models COLMAP runs through ONNX (ALIKED, BSD-3; LightGlue,
+#: Apache-2.0): (download URL, pinned SHA-256). Used to rescue hard photo sets.
+COLMAP_MODELS: dict[str, tuple[str, str]] = {
+    "aliked-n16rot.onnx": (
+        "https://github.com/colmap/colmap/releases/download/3.13.0/aliked-n16rot.onnx",
+        "39c423d0a6f03d39ec89d3d1d61853765c2fb6a8b8381376c703e5758778a547",
+    ),
+    "aliked-lightglue.onnx": (
+        "https://github.com/colmap/colmap/releases/download/3.13.0/aliked-lightglue.onnx",
+        "b9a5de7204648b18a8cf5dcac819f9d30de1a5961ef03756803c8b86c2dceb8d",
+    ),
+}
+
+
+def colmap_model_path(name: str) -> Path | None:
+    """Local copy of a COLMAP ONNX model, if downloaded (filesystem check only)."""
+    path = models_dir() / "colmap" / name
+    return path if path.is_file() else None
+
+
+def download_colmap_models() -> dict[str, str]:
+    """Download the learned-feature models, verifying their pinned SHA-256."""
+    import hashlib
+    import urllib.request
+
+    status: dict[str, str] = {}
+    folder = models_dir() / "colmap"
+    folder.mkdir(parents=True, exist_ok=True)
+    for name, (url, sha) in COLMAP_MODELS.items():
+        target = folder / name
+        if target.is_file() and hashlib.sha256(target.read_bytes()).hexdigest() == sha:
+            status[name] = "ready"
+            continue
+        try:
+            with urllib.request.urlopen(url, timeout=120) as response:  # noqa: S310  # nosec B310 - pinned https URL, SHA-256 checked
+                data = response.read()
+        except Exception as exc:  # network errors come in many shapes
+            status[name] = f"failed ({exc.__class__.__name__})"
+            continue
+        if hashlib.sha256(data).hexdigest() != sha:
+            status[name] = "failed (checksum mismatch)"
+            continue
+        tmp = target.with_suffix(".part")
+        tmp.write_bytes(data)
+        tmp.replace(target)
+        status[name] = "downloaded"
+    return status
+
+
 def models_dir() -> Path:
     """Folder that holds the downloaded AI models (``~/.reverse3d/models``)."""
     return home_dir() / "models"
@@ -263,6 +312,15 @@ def prepare(settings: Settings, *, include_non_commercial: bool = False) -> dict
             }
         )
 
+    if online or all(colmap_model_path(n) for n in COLMAP_MODELS):
+        for name, state in download_colmap_models().items():
+            results.append({"model": f"colmap/{name}", "status": state.split(" ")[0]})
+    else:
+        results += [
+            {"model": f"colmap/{n}", "status": "missing", "detail": "No internet connection."}
+            for n in COLMAP_MODELS
+            if not colmap_model_path(n)
+        ]
     ready = all(r["status"] in ("ready", "downloaded") for r in results)
     return {
         "ready": ready,
@@ -294,6 +352,7 @@ def offline_status(settings: Settings) -> dict[str, Any]:
         "ai_segmentation": DEFAULT_SEGMENTER,
         "ai_depth": _default_model(),
     }
+    features_ready = all(colmap_model_path(n) for n in COLMAP_MODELS)
     on_disk = {key: local_model_path(model) is not None for key, model in ai_models.items()}
     internet = None if settings.offline != "auto" else has_internet()
 
@@ -310,6 +369,7 @@ def offline_status(settings: Settings) -> dict[str, Any]:
             key: {"available": depth_installed, "offline": depth_installed and on_disk[key]}
             for key in ai_models
         },
+        "ai_features": {"available": True, "offline": features_ready},
     }
     missing = []
     names = {
@@ -321,6 +381,11 @@ def offline_status(settings: Settings) -> dict[str, Any]:
         missing.append(
             "AI depth model not downloaded yet: run `reverse3d offline prepare` while online."
         )
+    if not features_ready:
+        missing.append(
+            "AI feature models (ALIKED + LightGlue) not downloaded yet: "
+            "run `reverse3d offline prepare` while online."
+        )
     for key in ("ai_subject", "ai_segmentation"):
         if depth_installed and not on_disk[key]:
             missing.append(

{reverse3d-0.9.0 → reverse3d-0.11.0}/reverse3d/recipes.py

@@ -36,6 +36,7 @@ from reverse3d.config import Settings
 from reverse3d.errors import (
     CaptureQualityError,
     DependencyMissingError,
+    ExternalToolError,
     InputValidationError,
     ProcessingError,
     Reverse3DError,
@@ -161,7 +162,7 @@ def _clean(
             import trimesh
 
             glb = dst.with_name("model.glb")
-            trimesh.load(color_ply, process=False, force="mesh").export(glb)
+            _export_glb(trimesh.load(color_ply, process=False, force="mesh"), glb)
             run.outputs["model_color"] = str(color_ply)
             run.outputs["model_glb"] = str(glb)
         except Exception as exc:  # colour is a bonus: never fail the model for it
@@ -169,6 +170,27 @@ def _clean(
     return report.after
 
 
+# SIFT features per photo when COLMAP only places the cameras.
+_CAMERA_FEATURES = 4096
+
+# Exhaustive matching stays practical for object captures up to this size.
+_OBJECT_EXHAUSTIVE_LIMIT = 400
+
+
+def _export_glb(mesh: Any, path: Path) -> None:
+    """Write a GLB that stands up in any viewer: glTF is Y-up, our models are Z-up.
+
+    The geometry keeps its Z-up coordinates and a root node rotates it, so
+    Blender, game engines and web viewers show it upright.
+    """
+    import trimesh
+
+    scene = trimesh.Scene()
+    up = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
+    scene.add_geometry(mesh, node_name="model", transform=up)
+    scene.export(path)
+
+
 def _has_vertex_colors(path: Path) -> bool:
     import trimesh
 
@@ -253,6 +275,30 @@ _DEFAULT_LOOK = {
 }
 
 
+def _texture(run: _Run, model: Path, photo: Any, to_world: list[list[float]], scale: float) -> None:
+    """Bake a photo texture onto the final model: model.glb gets real detail."""
+    try:
+        import trimesh
+
+        from reverse3d.reconstruction.texture import bake_texture
+
+        mesh: Any = trimesh.load(model, process=False, force="mesh")
+        # The cleaned model is the carved hull scaled by ``scale``.
+        world = np.asarray(to_world) @ np.diag([1 / scale, 1 / scale, 1 / scale, 1.0])
+        textured = run.step(
+            "texture",
+            lambda: bake_texture(
+                mesh, Path(photo.images_dir), Path(photo.sparse_text_dir), to_world=world
+            ),
+        )
+        glb = model.with_name("model.glb")
+        _export_glb(textured, glb)
+        run.outputs["model_glb"] = str(glb)
+        run.details["texture"] = {"size": 2048, "faces": len(textured.faces)}
+    except Exception as exc:  # the texture is a bonus: never fail the model for it
+        logger.info("Texture skipped: %s", exc)
+
+
 def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.reconstruction.photogrammetry import (
         PhotogrammetryOptions,
@@ -303,27 +349,51 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     # and the shape is carved from the silhouettes, which also works on plain,
     # white or glossy surfaces. Open scenes keep classic dense reconstruction.
     silhouette = scene in ("object", "character")
-
-    def photogrammetry(classic: bool) -> PhotogrammetryResult:
+    # An object is shot in several rings plus close-ups, never in one ordered
+    # sequence: match every photo with every other so all of them join one model
+    # (sequential matching split a 153-photo bottle into four pieces).
+    matcher = preset.matcher
+    if silhouette and matcher == "auto" and analysis.image_count <= _OBJECT_EXHAUSTIVE_LIMIT:
+        matcher = "exhaustive"
+
+    def photogrammetry(classic: bool, features: str = "sift") -> PhotogrammetryResult:
         return run_photogrammetry(
             src,
             run.out / "reconstruction",
             run.settings,
             PhotogrammetryOptions(
                 quality=quality,  # type: ignore[arg-type]
-                matcher=preset.matcher,
+                matcher=matcher,
                 dense="auto" if classic else "off",
                 use_gpu=wants_gpu(run.settings),
                 build_mesh=classic,
                 poisson_depth=preset.poisson_depth,
                 density_quantile=preset.density_quantile,
+                features=features,  # type: ignore[arg-type]
+                # Silhouette objects only need the cameras: fewer features keep
+                # exhaustive matching of a few hundred photos fast on any GPU.
+                max_features=None if classic else _CAMERA_FEATURES,
             ),
-            overwrite=opt.overwrite or not classic,
+            overwrite=opt.overwrite or not classic or features != "sift",
         )
 
-    photo = run.step("photogrammetry", lambda: photogrammetry(classic=not silhouette))
+    try:
+        photo = run.step("photogrammetry", lambda: photogrammetry(classic=not silhouette))
+    except ProcessingError as exc:
+        # Rescue for hard sets: learned AI features (ALIKED + LightGlue) place
+        # photos that SIFT cannot. Slower (CPU), so only when SIFT fell short.
+        logger.info("SIFT could not place the photos (%s); retrying with AI features", exc.message)
+        try:
+            photo = run.step(
+                "photogrammetry_ai",
+                lambda: photogrammetry(classic=not silhouette, features="aliked"),
+            )
+        except (ProcessingError, DependencyMissingError, ExternalToolError):
+            raise exc from None
+        run.warnings.append("Photos placed with AI features (ALIKED + LightGlue).")
     mesh_path: str | None = photo.mesh_path
     upright = False
+    hull_world: list[list[float]] | None = None
     if silhouette:
         from reverse3d.reconstruction.silhouette import visual_hull
         from reverse3d.vision.segmenter import ObjectSegmenter
@@ -374,6 +444,7 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
             run.details["silhouette"] = hull.to_dict()
             mesh_path = hull.mesh_path
             upright = True
+            hull_world = hull.to_world
     if photo.registered_images >= 0.9 * max(photo.total_images, 1):
         # COLMAP placed (almost) every photo: the quick pre-check's capture advice
         # would only confuse.
@@ -422,6 +493,8 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
         keep_largest=preset.keep_largest,
         repair=opt.repair,
     )
+    if upright and hull_world is not None:
+        _texture(run, model, photo, hull_world, opt.scale)
     return _measure(run, model)
 
 
@@ -610,7 +683,12 @@ def run_recipe(
         source = prepare_heic_input(source, out)  # iPhone HEIC photos -> JPEG
     stats = _RECIPES[recipe](run, source, opt)
     if opt.render:
-        _render(run, Path(run.outputs.get("model_color") or run.outputs["model"]), opt.overwrite)
+        textured = run.details.get("texture") and run.outputs.get("model_glb")
+        _render(
+            run,
+            Path(textured or run.outputs.get("model_color") or run.outputs["model"]),
+            opt.overwrite,
+        )
 
     summary: dict[str, Any] = {
         "recipe": recipe,

{reverse3d-0.9.0 → reverse3d-0.11.0}/reverse3d/reconstruction/photogrammetry.py

@@ -94,6 +94,12 @@ class PhotogrammetryOptions:
     poisson_depth: int | None = None
     #: share of the least supported surface trimmed after Poisson.
     density_quantile: float = 0.02
+    #: "sift" (fast, GPU) or "aliked": learned ALIKED features + LightGlue matching,
+    #: which places photos of hard sets SIFT cannot (CPU, much slower).
+    features: Literal["sift", "aliked"] = "sift"
+    #: SIFT features per photo; None uses the quality preset. Placing cameras
+    #: alone (silhouette objects) needs far fewer than a dense surface.
+    max_features: int | None = None
 
     def validate(self) -> None:
         if self.quality not in _PRESETS:
@@ -297,18 +303,43 @@ class ColmapPipeline:
             "--ImageReader.single_camera",
             "1" if options.single_camera else "0",
         ]
+        learned = options.features == "aliked"
+        if learned:
+            from reverse3d.offline import colmap_model_path, download_colmap_models
+
+            if not colmap_model_path("aliked-n16rot.onnx"):
+                download_colmap_models()
+            aliked = colmap_model_path("aliked-n16rot.onnx")
+            if aliked is None:
+                raise DependencyMissingError(
+                    "The AI feature model (ALIKED) is not on this computer.",
+                    hint="Connect to the internet once and run: reverse3d offline prepare",
+                )
+            # ONNX on the CPU: the CUDA runtime it needs is not bundled with COLMAP.
+            args += [
+                "--FeatureExtraction.type",
+                "ALIKED_N16ROT",
+                "--FeatureExtraction.use_gpu",
+                "0",
+                "--AlikedExtraction.n16rot_model_path",
+                str(aliked),
+            ]
         self._stage(
             result,
             "feature_extractor",
             self._with_options(
                 "feature_extractor",
                 args,
-                {
+                {}
+                if learned
+                else {
                     ("FeatureExtraction.use_gpu", "SiftExtraction.use_gpu"): gpu,
                     ("FeatureExtraction.max_image_size", "SiftExtraction.max_image_size"): str(
                         preset["max_image_size"]
                     ),
-                    ("SiftExtraction.max_num_features",): str(preset["max_features"]),
+                    ("SiftExtraction.max_num_features",): str(
+                        options.max_features or preset["max_features"]
+                    ),
                 },
             ),
         )
@@ -324,8 +355,19 @@ class ColmapPipeline:
             matcher = "exhaustive" if len(images) <= _EXHAUSTIVE_LIMIT else "sequential"
         command = f"{matcher}_matcher"
         extra: dict[tuple[str, ...], str] = {
-            ("FeatureMatching.use_gpu", "SiftMatching.use_gpu"): gpu
+            ("FeatureMatching.use_gpu", "SiftMatching.use_gpu"): "0" if learned else gpu
         }
+        if learned:
+            from reverse3d.offline import colmap_model_path
+
+            glue = colmap_model_path("aliked-lightglue.onnx")
+            if glue is None:
+                raise DependencyMissingError(
+                    "The AI matching model (LightGlue) is not on this computer.",
+                    hint="Connect to the internet once and run: reverse3d offline prepare",
+                )
+            extra[("FeatureMatching.type",)] = "ALIKED_LIGHTGLUE"
+            extra[("AlikedMatching.lightglue_model_path",)] = str(glue)
         if matcher == "spatial":
             extra[("SpatialMatching.is_gps",)] = "1"
         try: