reverse3d 0.9.0__tar.gz → 0.10.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.9.0
+Version: 0.10.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
@@ -219,7 +220,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 +359,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.
@@ -416,6 +417,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.10.0}/README.md

@@ -151,7 +151,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 +290,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.
@@ -348,6 +348,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.10.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.10.0/reverse3d/_version.py

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

{reverse3d-0.9.0 → reverse3d-0.10.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.10.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,20 @@ def _clean(
     return report.after
 
 
+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 +268,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,
@@ -304,7 +343,7 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     # white or glossy surfaces. Open scenes keep classic dense reconstruction.
     silhouette = scene in ("object", "character")
 
-    def photogrammetry(classic: bool) -> PhotogrammetryResult:
+    def photogrammetry(classic: bool, features: str = "sift") -> PhotogrammetryResult:
         return run_photogrammetry(
             src,
             run.out / "reconstruction",
@@ -317,13 +356,28 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
                 build_mesh=classic,
                 poisson_depth=preset.poisson_depth,
                 density_quantile=preset.density_quantile,
+                features=features,  # type: ignore[arg-type]
             ),
-            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 +428,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 +477,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 +667,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.10.0}/reverse3d/reconstruction/photogrammetry.py

@@ -94,6 +94,9 @@ 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"
 
     def validate(self) -> None:
         if self.quality not in _PRESETS:
@@ -297,13 +300,36 @@ 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"]
@@ -324,8 +350,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:

{reverse3d-0.9.0 → reverse3d-0.10.0}/reverse3d/reconstruction/silhouette.py

@@ -70,6 +70,8 @@ class HullResult:
     support_plane: bool
     ai_segmentation: bool = False
     depth_carved_voxels: int = 0
+    #: 4x4 matrix from the model's coordinates back to the COLMAP world (textures).
+    to_world: list[list[float]] | None = None
 
     def to_dict(self) -> dict[str, object]:
         return asdict(self)
@@ -540,7 +542,9 @@ def visual_hull(
     transform = np.eye(4)
     transform[:3, :3] = basis
     mesh.apply_transform(transform)
-    mesh.apply_translation([-mesh.centroid[0], -mesh.centroid[1], -mesh.bounds[0][2]])
+    shift = np.array([-mesh.centroid[0], -mesh.centroid[1], -mesh.bounds[0][2]])
+    mesh.apply_translation(shift)
+    world_to_model = trimesh.transformations.translation_matrix(shift) @ transform
 
     output_path.parent.mkdir(parents=True, exist_ok=True)
     mesh.export(output_path)
@@ -553,4 +557,5 @@ def visual_hull(
         plane is not None,
         ai is not None,
         carved_by_depth,
+        np.linalg.inv(world_to_model).tolist(),
     )

reverse3d-0.10.0/reverse3d/reconstruction/texture.py

@@ -0,0 +1,195 @@
+"""Photo textures: a UV-mapped texture baked from the photos (detail beyond vertices).
+
+Per-vertex colour can only be as detailed as the mesh. A texture is not: every
+texel gets its own colour, so logos, lettering and fine patterns survive on a
+light mesh. Steps:
+
+1. unwrap the mesh into a UV atlas (xatlas, MIT);
+2. rasterise each triangle into the atlas to know the 3D point and normal of
+   every texel;
+3. colour each texel from the photos that see it head-on and unoccluded
+   (weights favour frontal views, so the result stays sharp);
+4. bleed colour into the empty gutters so mip-mapping shows no seams.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+import trimesh
+
+from reverse3d.errors import DependencyMissingError, ProcessingError
+from reverse3d.reconstruction.silhouette import _project, _View, read_colmap_text
+
+logger = logging.getLogger(__name__)
+
+
+def _unwrap(mesh: trimesh.Trimesh) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    try:
+        import xatlas
+    except ImportError as exc:  # pragma: no cover - core dependency
+        raise DependencyMissingError(
+            "xatlas is needed for textures.", hint="pip install xatlas"
+        ) from exc
+    vmapping, indices, uvs = xatlas.parametrize(
+        np.asarray(mesh.vertices, np.float32), np.asarray(mesh.faces, np.uint32)
+    )
+    return np.asarray(vmapping), np.asarray(indices, np.int64), np.asarray(uvs, np.float64)
+
+
+def _texel_points(
+    verts: np.ndarray, faces: np.ndarray, uvs: np.ndarray, size: int
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """For every covered texel: (row, col), its 3D point and the face normal."""
+    face_id = np.full((size, size), -1, np.int32)
+    px = uvs * (size - 1)
+    px[:, 1] = (size - 1) - px[:, 1]  # glTF v goes up, image rows go down
+    for f, tri in enumerate(faces):
+        cv2.fillConvexPoly(face_id, np.round(px[tri]).astype(np.int32), f)
+    rows, cols = np.nonzero(face_id >= 0)
+    fids = face_id[rows, cols]
+    tri = faces[fids]
+    a, b, c = px[tri[:, 0]], px[tri[:, 1]], px[tri[:, 2]]
+    p = np.column_stack([cols, rows]).astype(np.float64)
+    v0, v1, v2 = b - a, c - a, p - a
+    d00 = (v0 * v0).sum(1)
+    d01 = (v0 * v1).sum(1)
+    d11 = (v1 * v1).sum(1)
+    d20 = (v2 * v0).sum(1)
+    d21 = (v2 * v1).sum(1)
+    denom = d00 * d11 - d01 * d01
+    denom[np.abs(denom) < 1e-12] = 1e-12
+    w1 = np.clip((d11 * d20 - d01 * d21) / denom, 0, 1)
+    w2 = np.clip((d00 * d21 - d01 * d20) / denom, 0, 1)
+    w0 = np.clip(1 - w1 - w2, 0, 1)
+    points = (
+        w0[:, None] * verts[tri[:, 0]]
+        + w1[:, None] * verts[tri[:, 1]]
+        + w2[:, None] * verts[tri[:, 2]]
+    )
+    e1 = verts[tri[:, 1]] - verts[tri[:, 0]]
+    e2 = verts[tri[:, 2]] - verts[tri[:, 0]]
+    normals = np.cross(e1, e2)
+    normals /= np.maximum(np.linalg.norm(normals, axis=1, keepdims=True), 1e-12)
+    return np.column_stack([rows, cols]), points, normals
+
+
+def _bilinear(img: np.ndarray, u: np.ndarray, v: np.ndarray) -> np.ndarray:
+    """Bilinear colour samples at sub-pixel positions (no size limits, unlike remap)."""
+    x0 = np.floor(u).astype(np.int64)
+    y0 = np.floor(v).astype(np.int64)
+    fx = (u - x0)[:, None]
+    fy = (v - y0)[:, None]
+    x1 = np.minimum(x0 + 1, img.shape[1] - 1)
+    y1 = np.minimum(y0 + 1, img.shape[0] - 1)
+    top = img[y0, x0] * (1 - fx) + img[y0, x1] * fx
+    bottom = img[y1, x0] * (1 - fx) + img[y1, x1] * fx
+    return np.asarray(top * (1 - fy) + bottom * fy, np.float64)
+
+
+def _bake(
+    points: np.ndarray,
+    normals: np.ndarray,
+    views: list[_View],
+    images: list[tuple[np.ndarray, float]],
+) -> tuple[np.ndarray, np.ndarray]:
+    """Colour per texel and whether any photo saw it."""
+    total = np.zeros((len(points), 3))
+    weight = np.zeros(len(points))
+    for (img, scale), view in zip(images, views, strict=True):
+        center = -view.rotation.T @ view.translation
+        to_cam = center - points
+        to_cam /= np.linalg.norm(to_cam, axis=1, keepdims=True)
+        facing = np.einsum("ij,ij->i", normals, to_cam)
+        uv, z = _project(points, view)
+        u, v = uv[:, 0] * scale, uv[:, 1] * scale
+        h, w = img.shape[:2]
+        ok = (facing > 0.15) & (z > 0) & (u >= 0) & (v >= 0) & (u < w - 1) & (v < h - 1)
+        if not ok.any():
+            continue
+        cell = 3
+        cu = (u[ok] / cell).astype(np.int64)
+        cv_ = (v[ok] / cell).astype(np.int64)
+        zbuf = np.full((h // cell + 1, w // cell + 1), np.inf)
+        np.minimum.at(zbuf, (cv_, cu), z[ok])
+        span = float(np.ptp(z[ok])) or 1.0
+        visible = z[ok] <= zbuf[cv_, cu] + 0.02 * span
+        idx = np.flatnonzero(ok)[visible]
+        sample = _bilinear(img, u[idx], v[idx])[:, ::-1]  # BGR -> RGB
+        wgt = facing[idx] ** 6  # strongly prefer frontal views: sharp, not averaged mush
+        total[idx] += sample * wgt[:, None]
+        weight[idx] += wgt
+    seen = weight > 0
+    colours = np.zeros((len(points), 3))
+    colours[seen] = total[seen] / weight[seen, None]
+    return colours, seen
+
+
+def bake_texture(
+    mesh: trimesh.Trimesh,
+    image_dir: Path,
+    model_text_dir: Path,
+    *,
+    to_world: np.ndarray | None = None,
+    size: int = 2048,
+    max_side: int = 2048,
+) -> trimesh.Trimesh:
+    """A copy of ``mesh`` with UVs and a texture baked from the COLMAP photos.
+
+    ``to_world`` maps the mesh's coordinates to the COLMAP world (4x4), when the
+    mesh was moved or scaled after reconstruction.
+
+    Raises:
+        ProcessingError: photos cannot be read or nothing could be baked.
+    """
+    from PIL import Image
+
+    views, _ = read_colmap_text(model_text_dir)
+    images: list[tuple[np.ndarray, float]] = []
+    for view in views:
+        bgr = cv2.imread(str(image_dir / view.name))
+        if bgr is None:
+            raise ProcessingError(f"Could not read {view.name} for the texture.")
+        h, w = bgr.shape[:2]
+        scale = min(1.0, max_side / max(h, w))
+        if scale < 1.0:
+            bgr = cv2.resize(
+                bgr, (round(w * scale), round(h * scale)), interpolation=cv2.INTER_AREA
+            )
+        images.append((bgr, scale))
+
+    vmapping, faces, uvs = _unwrap(mesh)
+    verts_model = np.asarray(mesh.vertices)[vmapping]
+    verts_world = verts_model
+    if to_world is not None:
+        verts_world = trimesh.transform_points(verts_model, to_world)
+    texel_rc, points, normals = _texel_points(verts_world, faces, uvs, size)
+    colours, seen = _bake(points, normals, views, images)
+    if not seen.any():
+        raise ProcessingError("No photo sees the model: the texture could not be baked.")
+
+    texture: np.ndarray = np.zeros((size, size, 3), np.uint8)
+    covered = np.zeros((size, size), np.uint8)
+    fill = np.median(colours[seen], axis=0)
+    colours[~seen] = fill
+    rr, cc = texel_rc[:, 0], texel_rc[:, 1]
+    texture[rr, cc] = np.clip(colours, 0, 255).astype(np.uint8)
+    covered[rr, cc] = 255
+    # Isolated wrong texels (a grazing view catching background) look like salt and
+    # pepper; a 3x3 median removes them and keeps lettering and edges.
+    texture = cv2.medianBlur(texture, 3)
+    # Bleed colours into the gutters between UV islands (no seams when filtered).
+    texture = cv2.inpaint(texture, 255 - covered, 3, cv2.INPAINT_TELEA) if size <= 2048 else texture
+
+    material = trimesh.visual.material.PBRMaterial(
+        baseColorTexture=Image.fromarray(texture), metallicFactor=0.0, roughnessFactor=0.7
+    )
+    textured = trimesh.Trimesh(verts_model, faces, process=False)
+    visual: Any = trimesh.visual.TextureVisuals(uv=uvs, material=material)
+    textured.visual = visual
+    logger.info("Texture baked: %dx%d from %d photos", size, size, len(views))
+    return textured

{reverse3d-0.9.0 → reverse3d-0.10.0}/reverse3d/rendering/_blender_job.py

@@ -121,6 +121,13 @@ def shade(obj: bpy.types.Object, mode: str) -> None:
 
 
 def make_material(obj: bpy.types.Object, job: dict) -> None:
+    existing = obj.active_material
+    if (
+        existing is not None
+        and existing.node_tree is not None
+        and any(node.type == "TEX_IMAGE" for node in existing.node_tree.nodes)
+    ):
+        return  # a photo texture (glTF import): keep it as it is
     mat = bpy.data.materials.new("reverse3d_material")
     mat.use_nodes = True
     bsdf = mat.node_tree.nodes.get("Principled BSDF")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.9.0
+Version: 0.10.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
@@ -219,7 +220,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 +359,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.
@@ -416,6 +417,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.10.0}/reverse3d.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ reverse3d/reconstruction/depth_estimation.py
 reverse3d/reconstruction/photogrammetry.py
 reverse3d/reconstruction/pointcloud.py
 reverse3d/reconstruction/silhouette.py
+reverse3d/reconstruction/texture.py
 reverse3d/rendering/__init__.py
 reverse3d/rendering/_blender_job.py
 reverse3d/rendering/blender_render.py
@@ -72,4 +73,5 @@ tests/test_render.py
 tests/test_scenes.py
 tests/test_security.py
 tests/test_silhouette.py
+tests/test_texture.py
 tests/test_vision.py

{reverse3d-0.9.0 → reverse3d-0.10.0}/reverse3d.egg-info/requires.txt

@@ -1,6 +1,7 @@
 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.9.0 → reverse3d-0.10.0}/tests/test_color.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 
 import numpy as np
+import pytest
 import trimesh
 
 from reverse3d.config import Settings
@@ -47,3 +48,17 @@ def test_plain_meshes_get_no_colour_outputs(tmp_path: Path, settings: Settings)
     run = _Run(recipe="mesh_report", settings=settings, out=tmp_path)
     _clean(run, plain, tmp_path / "model.stl", scale=1.0, overwrite=True)
     assert "model_glb" not in run.outputs
+
+
+def test_glb_stands_up_in_y_up_viewers(tmp_path: Path) -> None:
+    from reverse3d.recipes import _export_glb
+
+    tall = trimesh.creation.box(extents=(1.0, 1.0, 4.0))  # Z-up, like our models
+    tall.apply_translation((0, 0, 2.0))
+    _export_glb(tall, tmp_path / "m.glb")
+    scene = trimesh.load(tmp_path / "m.glb")
+    extents = scene.to_geometry().extents
+    assert extents[1] == pytest.approx(4.0)  # glTF up axis is Y
+    # Viewers that read only the geometry (Studio) still get the Z-up mesh.
+    raw = next(iter(scene.geometry.values()))
+    assert raw.extents[2] == pytest.approx(4.0)

reverse3d-0.10.0/tests/test_texture.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+import trimesh
+
+pytest.importorskip("xatlas")
+sys.path.insert(0, str(Path(__file__).parent))
+
+from test_silhouette import HEIGHT, RADIUS, _scene
+
+from reverse3d.reconstruction.texture import bake_texture
+
+
+def test_texture_is_baked_from_the_photos(tmp_path: Path) -> None:
+    images, text = _scene(tmp_path)
+    mesh = trimesh.creation.cylinder(radius=RADIUS * 0.98, height=HEIGHT * 0.98, sections=48)
+    mesh = mesh.subdivide()
+    mesh.apply_translation([0, 0, HEIGHT / 2])
+    # The model is usually moved after reconstruction: give the baker the way back.
+    moved = mesh.copy()
+    moved.apply_translation([5.0, 0, 0])
+    to_world = trimesh.transformations.translation_matrix([-5.0, 0, 0])
+    textured = bake_texture(moved, images, text, to_world=to_world, size=256)
+    image = np.asarray(textured.visual.material.baseColorTexture)
+    assert image.shape == (256, 256, 3)
+    assert textured.visual.uv.shape == (len(textured.vertices), 2)
+    assert np.allclose(textured.bounds, moved.bounds, atol=1e-6)  # geometry unchanged
+    # The cylinder is white in every photo: most of the texture is bright.
+    assert np.median(image) > 200
+    glb = tmp_path / "model.glb"
+    textured.export(glb)
+    assert glb.stat().st_size > 1000

reverse3d-0.9.0/reverse3d/_version.py

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