reverse3d 0.8.0__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.8.0
+Version: 0.9.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>
@@ -215,10 +215,11 @@ Cada archivo modificado se **respalda antes** (`*.reverse3d-backup-<fecha>`). So
 
 | bash (`install.sh`) | PowerShell (`install.ps1`) | Efecto |
 |---------------------|----------------------------|--------|
-| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA de profundidad, Blender y COLMAP |
-| `--lite` | `-Lite` | Todo menos la IA de profundidad (PyTorch); ahorra hasta ~2.5 GB |
-| `--minimal` | `-Minimal` | Solo núcleo + MCP, sin herramientas externas |
+| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA local (con CUDA si hay NVIDIA), Blender y COLMAP |
+| `--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 |
 | `--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 |

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

@@ -147,10 +147,11 @@ Cada archivo modificado se **respalda antes** (`*.reverse3d-backup-<fecha>`). So
 
 | bash (`install.sh`) | PowerShell (`install.ps1`) | Efecto |
 |---------------------|----------------------------|--------|
-| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA de profundidad, Blender y COLMAP |
-| `--lite` | `-Lite` | Todo menos la IA de profundidad (PyTorch); ahorra hasta ~2.5 GB |
-| `--minimal` | `-Minimal` | Solo núcleo + MCP, sin herramientas externas |
+| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA local (con CUDA si hay NVIDIA), Blender y COLMAP |
+| `--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 |
 | `--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 |

reverse3d-0.9.0/reverse3d/_version.py

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

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

@@ -30,6 +30,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal, TypeVar
 
+import numpy as np
+
 from reverse3d.config import Settings
 from reverse3d.errors import (
     CaptureQualityError,
@@ -135,29 +137,70 @@ def _clean(
     parts, and tiny debris is already dropped by the area filter."""
     from reverse3d.reverse_eng.mesh_cleaner import CleanOptions, clean_mesh_file
 
+    options = CleanOptions(
+        keep_largest_only=keep_largest,
+        fill_holes=fill_holes,
+        align=align,
+        ground=align != "none",
+        scale=scale,
+        max_hole_edges=2000 if repair == "strong" else 200,
+    )
     report = run.step(
         "clean",
-        lambda: clean_mesh_file(
-            src,
-            dst,
-            run.settings,
-            CleanOptions(
-                keep_largest_only=keep_largest,
-                fill_holes=fill_holes,
-                align=align,
-                ground=align != "none",
-                scale=scale,
-                max_hole_edges=2000 if repair == "strong" else 200,
-            ),
-            overwrite=overwrite,
-        ),
+        lambda: clean_mesh_file(src, dst, run.settings, options, overwrite=overwrite),
     )
     run.warnings.extend(report.warnings)
     run.outputs["model"] = str(dst)
     run.details["clean"] = report.to_dict()
+    if _has_vertex_colors(src):
+        # Same cleaning on the coloured mesh (deterministic, colours follow the
+        # vertices): model_color.ply for renders and model.glb for games and viewers.
+        try:
+            color_ply = dst.with_name("model_color.ply")
+            clean_mesh_file(src, color_ply, run.settings, options, overwrite=True)
+            import trimesh
+
+            glb = dst.with_name("model.glb")
+            trimesh.load(color_ply, process=False, force="mesh").export(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
+            logger.info("Coloured model skipped: %s", exc)
     return report.after
 
 
+def _has_vertex_colors(path: Path) -> bool:
+    import trimesh
+
+    try:
+        mesh: Any = trimesh.load(path, process=False, force="mesh")
+    except Exception:
+        return False
+    colors = getattr(mesh.visual, "vertex_colors", None)
+    if colors is None or len(colors) != len(mesh.vertices):
+        return False
+    rgb = np.asarray(colors)[:, :3]
+    return float(np.max(np.std(rgb, axis=0))) > 1.0  # not just a uniform default colour
+
+
+def _color_from_cloud(mesh_path: Path, cloud_path: Path, out: Path) -> Path | None:
+    """Paint a mesh with the colours of the point cloud it was built from."""
+    import trimesh
+    from scipy.spatial import cKDTree
+
+    cloud: Any = trimesh.load(cloud_path, process=False)
+    colors = getattr(cloud, "colors", None)
+    if colors is None or len(colors) != len(getattr(cloud, "vertices", [])):
+        return None
+    mesh: Any = trimesh.load(mesh_path, process=False, force="mesh")
+    _, idx = cKDTree(np.asarray(cloud.vertices)).query(np.asarray(mesh.vertices), k=4)
+    rgb = np.asarray(colors)[idx][..., :3].astype(np.float64).mean(axis=1)
+    rgba = np.column_stack([rgb, np.full(len(rgb), 255.0)]).clip(0, 255).astype(np.uint8)
+    mesh.visual = trimesh.visual.ColorVisuals(mesh, vertex_colors=rgba)
+    mesh.export(out)
+    return out
+
+
 def _render(run: _Run, mesh: Path, overwrite: bool) -> None:
     from reverse3d.rendering.blender_render import RenderOptions, preset_options, render_mesh
 
@@ -210,28 +253,6 @@ _DEFAULT_LOOK = {
 }
 
 
-def _color_outputs(run: _Run, colored: Path, model: Path, scale: float) -> None:
-    """Give the final model the photo colours of the carved hull: model.glb (games,
-    web, viewers) and model_color.ply (renders)."""
-    import numpy as np
-    import trimesh
-    from scipy.spatial import cKDTree
-
-    source: Any = trimesh.load(colored, process=False, force="mesh")
-    target: Any = trimesh.load(model, process=False, force="mesh")
-    colors = getattr(source.visual, "vertex_colors", None)
-    if colors is None or len(colors) != len(source.vertices):
-        return
-    _, nearest = cKDTree(np.asarray(source.vertices) * scale).query(np.asarray(target.vertices))
-    target.visual = trimesh.visual.ColorVisuals(target, vertex_colors=np.asarray(colors)[nearest])
-    glb = run.out / "model.glb"
-    ply = run.out / "model_color.ply"
-    target.export(glb)
-    target.export(ply)
-    run.outputs["model_glb"] = str(glb)
-    run.outputs["model_color"] = str(ply)
-
-
 def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.reconstruction.photogrammetry import (
         PhotogrammetryOptions,
@@ -319,6 +340,18 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
                 )
                 return None
 
+        def load_depth() -> Callable[[np.ndarray], np.ndarray] | None:
+            # AI depth reveals concavities and holes (cup insides, handle loops).
+            from reverse3d.reconstruction.depth_estimation import predict_depth
+
+            device = torch_device(run.settings)
+            try:
+                predict_depth(np.zeros((32, 32, 3), np.uint8), device=device, settings=run.settings)
+            except Reverse3DError as exc:
+                logger.info("AI depth unavailable (%s); concavities stay filled", exc.message)
+                return None
+            return lambda rgb: predict_depth(rgb, device=device, settings=run.settings)
+
         try:
             hull = run.step(
                 "silhouette",
@@ -327,6 +360,7 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
                     Path(photo.sparse_text_dir or ""),
                     run.out / "reconstruction" / "object_hull.ply",
                     segmenter=load_segmenter,
+                    depth=load_depth,
                 ),
             )
         except ProcessingError as exc:
@@ -352,6 +386,30 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
             "Point cloud created but no mesh could be built.",
             hint='Install the meshing extra: pip install "reverse3d[recon]" (Python ≤ 3.12).',
         )
+    cloud = photo.dense_points_path or photo.sparse_points_path
+    if not upright:
+        # Dense scenes: colour from the photos themselves (sharp, independent of how
+        # dense the cloud is); the cloud's colours are the fallback.
+        colored_path = run.out / "reconstruction" / "mesh_color.ply"
+        colored: Path | None = None
+        try:
+            from reverse3d.reconstruction.silhouette import colorize_from_photos
+
+            if photo.images_dir and photo.sparse_text_dir:
+                colored = colorize_from_photos(
+                    Path(mesh_path),
+                    Path(photo.images_dir),
+                    Path(photo.sparse_text_dir),
+                    colored_path,
+                )
+        except Exception as exc:  # colour is a bonus
+            logger.info("Colouring from the photos skipped: %s", exc)
+        if colored is None and cloud:
+            try:
+                colored = _color_from_cloud(Path(mesh_path), Path(cloud), colored_path)
+            except Exception as exc:  # colour is a bonus
+                logger.info("Colouring from the point cloud skipped: %s", exc)
+        mesh_path = str(colored) if colored else mesh_path
     model = run.out / "model.stl"
     _clean(
         run,
@@ -364,11 +422,6 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
         keep_largest=preset.keep_largest,
         repair=opt.repair,
     )
-    if upright:
-        try:
-            _color_outputs(run, Path(mesh_path), model, opt.scale)
-        except Exception as exc:  # colour is a bonus: never fail the model for it
-            logger.info("Colour transfer skipped: %s", exc)
     return _measure(run, model)
 
 

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

@@ -69,6 +69,7 @@ class HullResult:
     faces: int
     support_plane: bool
     ai_segmentation: bool = False
+    depth_carved_voxels: int = 0
 
     def to_dict(self) -> dict[str, object]:
         return asdict(self)
@@ -250,6 +251,102 @@ def _vertex_colors(
     return colors
 
 
+def _fit_inverse_depth(disparity: np.ndarray, depth: np.ndarray) -> tuple[float, float] | None:
+    """Robust fit 1/depth ≈ s·disparity + t (relative AI disparity → metric-like depth)."""
+    inv = 1.0 / depth
+    keep = np.ones(len(inv), bool)
+    for _ in range(3):
+        if keep.sum() < 50:
+            return None
+        a = np.column_stack([disparity[keep], np.ones(int(keep.sum()))])
+        (s, t), *_ = np.linalg.lstsq(a, inv[keep], rcond=None)
+        residual = np.abs(s * disparity + t - inv)
+        mad = float(np.median(residual[keep])) or 1e-9
+        keep = residual < 3 * 1.4826 * mad
+    return (float(s), float(t)) if s > 0 else None
+
+
+def _depth_carve(
+    keep: np.ndarray,
+    grid: np.ndarray,
+    views: list[_View],
+    images: list[tuple[np.ndarray, float]],
+    projections: list[tuple[np.ndarray, np.ndarray, np.ndarray]],
+    masks: list[np.ndarray],
+    estimator: Callable[[np.ndarray], np.ndarray],
+    *,
+    tolerance: float = 0.05,
+    min_votes: int = 3,
+    min_share: float = 0.5,
+) -> np.ndarray:
+    """Empty the voxels that sit clearly in front of the surface the AI depth sees,
+    in at least ``min_votes`` photos *and* in most (``min_share``) of the photos
+    that actually see them. A photo where the voxel lies on the surface votes
+    solid; one where it is hidden behind the surface abstains. A few wrong depth
+    maps therefore cannot carve real material.
+
+    The relative AI depth is calibrated per photo against the carved hull itself
+    (a robust fit on the object's pixels), so only real disagreements carve.
+    """
+    votes = np.zeros(len(grid), np.int32)
+    seen = np.zeros(len(grid), np.int32)
+    for (small, _), view, (u, v, inside), mask in zip(
+        images, views, projections, masks, strict=True
+    ):
+        sel = keep & inside
+        if sel.sum() < 100:
+            continue
+        h, w = small.shape[:2]
+        z = (grid[sel] @ view.rotation.T + view.translation)[:, 2]
+        us, vs = u[sel], v[sel]
+        # Depth of the hull's visible surface per pixel (z-buffer of kept voxels).
+        hull_depth = np.full((h, w), np.inf)
+        np.minimum.at(hull_depth, (vs, us), z)
+        object_px = (mask > 0) & np.isfinite(hull_depth)
+        if object_px.sum() < 100:
+            continue
+        disparity = np.asarray(estimator(cv2.cvtColor(small, cv2.COLOR_BGR2RGB)), np.float64)
+        if disparity.shape != (h, w):
+            disparity = cv2.resize(disparity, (w, h), interpolation=cv2.INTER_LINEAR)
+        fit = _fit_inverse_depth(disparity[object_px], hull_depth[object_px])
+        if fit is None:
+            continue
+        s, t = fit
+        with np.errstate(divide="ignore", invalid="ignore"):
+            observed = 1.0 / np.maximum(s * disparity + t, 1e-9)
+        # A voxel strictly in front of the observed surface, on an object pixel, is air.
+        in_mask = mask[vs, us] > 0
+        front = z < observed[vs, us] * (1.0 - tolerance)
+        on_surface = np.abs(z - observed[vs, us]) <= tolerance * observed[vs, us]
+        idx = np.flatnonzero(sel)
+        seen[idx[in_mask & (front | on_surface)]] += 1  # hidden voxels abstain
+        votes[idx[in_mask & front]] += 1
+    air = (votes >= min_votes) & (votes >= min_share * np.maximum(seen, 1))
+    return keep & ~air
+
+
+def colorize_from_photos(
+    mesh_path: Path, image_dir: Path, model_text_dir: Path, output_path: Path
+) -> Path:
+    """Paint any mesh in COLMAP coordinates with the photos that see it (dense scenes)."""
+    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 colouring.")
+        h, w = bgr.shape[:2]
+        scale = 1280 / max(h, w)
+        size = (round(w * scale), round(h * scale))
+        images.append((cv2.resize(bgr, size, interpolation=cv2.INTER_AREA), scale))
+    mesh: trimesh.Trimesh = trimesh.load(mesh_path, process=False, force="mesh")  # type: ignore[assignment]
+    mesh.visual = trimesh.visual.ColorVisuals(
+        mesh, vertex_colors=_vertex_colors(mesh, views, images)
+    )
+    mesh.export(output_path)
+    return output_path
+
+
 def visual_hull(
     image_dir: Path,
     model_text_dir: Path,
@@ -258,6 +355,7 @@ def visual_hull(
     resolution: int = 176,
     refinements: int = 3,
     segmenter: Callable[[], ObjectSegmenter | None] | None = None,
+    depth: Callable[[], Callable[[np.ndarray], np.ndarray] | None] | None = None,
 ) -> HullResult:
     """Carve the object seen by every photo; writes a watertight, upright mesh.
 
@@ -385,6 +483,16 @@ def visual_hull(
         masks = refined
         keep = carve(masks, 1)
 
+    # Concavities and through-holes (a handle loop, the inside of a cup) never
+    # show in a silhouette: the AI depth of each photo reveals them.
+    estimator = depth() if depth is not None else None
+    carved_by_depth = 0
+    if estimator is not None:
+        before = int(keep.sum())
+        keep = _depth_carve(keep, grid, views, images, projections, masks, estimator)
+        carved_by_depth = before - int(keep.sum())
+        logger.info("AI depth carved %d voxel(s) of concavities", carved_by_depth)
+
     volume = keep.reshape(n, n, n).astype(np.float32)
     plane = _support_plane(points, center, radius, cameras)
     if plane is not None:
@@ -438,5 +546,11 @@ def visual_hull(
     mesh.export(output_path)
     logger.info("Silhouette model: %d views, %d faces", len(views), len(mesh.faces))
     return HullResult(
-        str(output_path), len(views), voxels, len(mesh.faces), plane is not None, ai is not None
+        str(output_path),
+        len(views),
+        voxels,
+        len(mesh.faces),
+        plane is not None,
+        ai is not None,
+        carved_by_depth,
     )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.8.0
+Version: 0.9.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>
@@ -215,10 +215,11 @@ Cada archivo modificado se **respalda antes** (`*.reverse3d-backup-<fecha>`). So
 
 | bash (`install.sh`) | PowerShell (`install.ps1`) | Efecto |
 |---------------------|----------------------------|--------|
-| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA de profundidad, Blender y COLMAP |
-| `--lite` | `-Lite` | Todo menos la IA de profundidad (PyTorch); ahorra hasta ~2.5 GB |
-| `--minimal` | `-Minimal` | Solo núcleo + MCP, sin herramientas externas |
+| *(sin opciones)* | *(sin opciones)* | **Todo**: núcleo, MCP, render, mallado, IA local (con CUDA si hay NVIDIA), Blender y COLMAP |
+| `--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 |
 | `--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 |

{reverse3d-0.8.0 → reverse3d-0.9.0}/reverse3d.egg-info/SOURCES.txt

@@ -60,6 +60,7 @@ tests/test_authorship.py
 tests/test_automation.py
 tests/test_cli.py
 tests/test_cli_automation.py
+tests/test_color.py
 tests/test_config.py
 tests/test_geometry_fit.py
 tests/test_heic.py

reverse3d-0.9.0/tests/test_color.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import trimesh
+
+from reverse3d.config import Settings
+from reverse3d.recipes import _clean, _color_from_cloud, _has_vertex_colors, _Run
+
+
+def _two_tone_cloud(path: Path) -> Path:
+    """Points on a sphere: red on top, blue at the bottom (like a COLMAP fused.ply)."""
+    pts = trimesh.creation.icosphere(subdivisions=5).vertices
+    rgb = np.where(pts[:, 2:3] > 0, [220, 30, 30], [30, 30, 220])
+    trimesh.PointCloud(pts, colors=np.column_stack([rgb, np.full(len(pts), 255)])).export(path)
+    return path
+
+
+def test_mesh_takes_the_colours_of_its_point_cloud(tmp_path: Path) -> None:
+    plain = tmp_path / "mesh.ply"
+    trimesh.creation.icosphere(subdivisions=3).export(plain)
+    assert not _has_vertex_colors(plain)
+    colored = _color_from_cloud(plain, _two_tone_cloud(tmp_path / "cloud.ply"), tmp_path / "c.ply")
+    assert colored is not None and _has_vertex_colors(colored)
+    mesh = trimesh.load(colored, process=False)
+    top = mesh.vertices[:, 2] > 0.3
+    assert mesh.visual.vertex_colors[top, 0].mean() > 150  # red on top
+    assert mesh.visual.vertex_colors[~top & (mesh.vertices[:, 2] < -0.3), 2].mean() > 150
+
+
+def test_cleaning_a_coloured_mesh_also_writes_glb(tmp_path: Path, settings: Settings) -> None:
+    plain = tmp_path / "mesh.ply"
+    trimesh.creation.icosphere(subdivisions=3).export(plain)
+    colored = _color_from_cloud(plain, _two_tone_cloud(tmp_path / "cloud.ply"), tmp_path / "c.ply")
+    assert colored is not None
+    run = _Run(recipe="photos_to_model", settings=settings, out=tmp_path)
+    _clean(run, colored, tmp_path / "model.stl", scale=1.0, overwrite=True)
+    assert {"model", "model_color", "model_glb"} <= set(run.outputs)
+    glb = trimesh.load(run.outputs["model_glb"], force="mesh")
+    assert len(np.unique(np.asarray(glb.visual.vertex_colors)[:, :3], axis=0)) > 1
+
+
+def test_plain_meshes_get_no_colour_outputs(tmp_path: Path, settings: Settings) -> None:
+    plain = tmp_path / "mesh.ply"
+    trimesh.creation.icosphere(subdivisions=3).export(plain)
+    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

reverse3d-0.9.0/tests/test_silhouette.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import cv2
+import numpy as np
+import pytest
+import trimesh
+
+pytest.importorskip("skimage")
+
+from reverse3d.errors import ProcessingError
+from reverse3d.reconstruction.silhouette import convergence_point, read_colmap_text, visual_hull
+
+SIZE = 400
+F = 420.0
+RADIUS, HEIGHT = 0.35, 1.2  # the object: an upright cylinder standing on z = 0
+
+
+def _look_at(eye: np.ndarray, target: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """World→camera rotation and translation (COLMAP convention: +Z forward, +Y down)."""
+    forward = target - eye
+    forward /= np.linalg.norm(forward)
+    right = np.cross(forward, [0.0, 0.0, 1.0])
+    right /= np.linalg.norm(right)
+    down = np.cross(forward, right)
+    rot = np.stack([right, down, forward])
+    return rot, -rot @ eye
+
+
+def _quat(rot: np.ndarray) -> list[float]:
+    return list(
+        trimesh.transformations.quaternion_from_matrix(
+            np.vstack([np.hstack([rot, [[0], [0], [0]]]), [0, 0, 0, 1]])
+        )
+    )
+
+
+def _scene(folder: Path) -> tuple[Path, Path]:
+    images = folder / "images"
+    text = folder / "txt"
+    images.mkdir(parents=True)
+    text.mkdir()
+    rng = np.random.default_rng(0)
+    theta = np.linspace(0, 2 * np.pi, 64, endpoint=False)
+    rim = np.concatenate(
+        [
+            np.stack([RADIUS * np.cos(theta), RADIUS * np.sin(theta), np.full_like(theta, z)], 1)
+            for z in (0.0, HEIGHT)
+        ]
+    )
+    lines = []
+    k = 0
+    for height, count in ((0.6, 12), (2.2, 12), (3.4, 6)):
+        for i in range(count):
+            a = 2 * np.pi * i / count
+            eye = np.array([3.2 * np.cos(a), 3.2 * np.sin(a), height])
+            rot, t = _look_at(eye, np.array([0.0, 0.0, 0.6]))
+            # Textured background, then the white cylinder's silhouette.
+            image = rng.integers(0, 120, (SIZE, SIZE, 3), dtype=np.uint8)
+            image = cv2.GaussianBlur(image, (5, 5), 0)
+            cam = rim @ rot.T + t
+            uv = (cam[:, :2] / cam[:, 2:3]) * F + SIZE / 2
+            cv2.fillConvexPoly(image, cv2.convexHull(uv.astype(np.int32)), (235, 235, 235))
+            name = f"img_{k:02d}.jpg"
+            cv2.imwrite(str(images / name), image)
+            q = _quat(rot)
+            lines.append(f"{k + 1} {q[0]} {q[1]} {q[2]} {q[3]} {t[0]} {t[1]} {t[2]} 1 {name}\n\n")
+            k += 1
+    (text / "cameras.txt").write_text(f"1 PINHOLE {SIZE} {SIZE} {F} {F} {SIZE / 2} {SIZE / 2}\n")
+    (text / "images.txt").write_text("".join(lines))
+    table = np.column_stack([rng.uniform(-1, 1, 400), rng.uniform(-1, 1, 400), np.zeros(400)])
+    table = table[np.hypot(table[:, 0], table[:, 1]) > RADIUS + 0.05]
+    (text / "points3D.txt").write_text(
+        "".join(f"{i + 1} {x} {y} {z} 0 0 0 0\n" for i, (x, y, z) in enumerate(table))
+    )
+    return images, text
+
+
+def test_cameras_converge_on_the_object(tmp_path: Path) -> None:
+    _, text = _scene(tmp_path)
+    views, points = read_colmap_text(text)
+    center, distance = convergence_point(views)
+    assert len(views) == 30 and len(points) > 100
+    assert np.linalg.norm(center - [0, 0, 0.6]) < 0.05
+    assert 3.0 < distance < 3.8
+
+
+def test_visual_hull_rebuilds_an_upright_cylinder(tmp_path: Path) -> None:
+    images, text = _scene(tmp_path)
+    result = visual_hull(images, text, tmp_path / "hull.ply", resolution=80, refinements=1)
+    mesh = trimesh.load(result.mesh_path)
+    assert result.support_plane
+    assert mesh.is_watertight
+    width = (mesh.extents[0] + mesh.extents[1]) / 2
+    assert mesh.bounds[0][2] == pytest.approx(0.0, abs=1e-6)
+    # Height / diameter of the real cylinder is 1.2 / 0.7 ≈ 1.7.
+    assert 1.3 < mesh.extents[2] / width < 2.2
+
+
+def test_too_few_photos(tmp_path: Path) -> None:
+    images, text = _scene(tmp_path)
+    rows = (text / "images.txt").read_text().split("\n\n")
+    (text / "images.txt").write_text("\n\n".join(rows[:5]) + "\n\n")
+    with pytest.raises(ProcessingError, match="at least"):
+        visual_hull(images, text, tmp_path / "hull.ply", resolution=48, refinements=0)
+
+
+class _FakeSegmenter:
+    """Stands in for Segment Anything: the object is the bright part inside the box."""
+
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def embed(self, rgb: np.ndarray) -> dict[str, np.ndarray]:
+        return {"rgb": rgb}
+
+    def segment(
+        self, state: dict[str, np.ndarray], box: tuple[int, int, int, int], point: tuple[int, int]
+    ) -> np.ndarray:
+        self.calls += 1
+        gray = state["rgb"].mean(axis=2)
+        mask = np.zeros(gray.shape, np.uint8)
+        x0, y0, x1, y1 = box
+        mask[y0 : y1 + 1, x0 : x1 + 1] = np.where(gray[y0 : y1 + 1, x0 : x1 + 1] > 200, 255, 0)
+        return mask
+
+
+def test_ai_segmenter_is_loaded_lazily_and_used(tmp_path: Path) -> None:
+    images, text = _scene(tmp_path)
+    fake = _FakeSegmenter()
+    loads: list[int] = []
+
+    def factory() -> _FakeSegmenter:
+        loads.append(1)
+        return fake
+
+    result = visual_hull(
+        images,
+        text,
+        tmp_path / "hull.ply",
+        resolution=64,
+        refinements=1,
+        segmenter=factory,  # type: ignore[arg-type]
+    )
+    assert loads == [1] and fake.calls == 2 * 30  # two AI rounds over the 30 photos
+    assert result.ai_segmentation
+    mesh = trimesh.load(result.mesh_path)
+    width = (mesh.extents[0] + mesh.extents[1]) / 2
+    assert mesh.is_watertight and 1.3 < mesh.extents[2] / width < 2.2
+
+
+def test_without_ai_segmenter_grabcut_is_used(tmp_path: Path) -> None:
+    images, text = _scene(tmp_path)
+    result = visual_hull(
+        images, text, tmp_path / "hull.ply", resolution=48, refinements=1, segmenter=lambda: None
+    )
+    assert not result.ai_segmentation
+
+
+def _cup() -> trimesh.Trimesh:
+    """An open-top box: its silhouette is a solid block from every side."""
+    parts = [
+        trimesh.creation.box(
+            extents=(0.8, 0.8, 0.12),
+            transform=trimesh.transformations.translation_matrix((0, 0, 0.06)),
+        ),
+        trimesh.creation.box(
+            extents=(0.12, 0.8, 1.0),
+            transform=trimesh.transformations.translation_matrix((0.34, 0, 0.5)),
+        ),
+        trimesh.creation.box(
+            extents=(0.12, 0.8, 1.0),
+            transform=trimesh.transformations.translation_matrix((-0.34, 0, 0.5)),
+        ),
+        trimesh.creation.box(
+            extents=(0.8, 0.12, 1.0),
+            transform=trimesh.transformations.translation_matrix((0, 0.34, 0.5)),
+        ),
+        trimesh.creation.box(
+            extents=(0.8, 0.12, 1.0),
+            transform=trimesh.transformations.translation_matrix((0, -0.34, 0.5)),
+        ),
+    ]
+    return trimesh.util.concatenate(parts)
+
+
+def _ray_boxes(origin: np.ndarray, dirs: np.ndarray, boxes: list[np.ndarray]) -> np.ndarray:
+    """Distance along each ray to the nearest axis-aligned box (inf when missed)."""
+    best = np.full(len(dirs), np.inf)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        inv = 1.0 / dirs
+        for lo, hi in boxes:
+            t1, t2 = (lo - origin) * inv, (hi - origin) * inv
+            near = np.nanmax(np.minimum(t1, t2), axis=1)
+            far = np.nanmin(np.maximum(t1, t2), axis=1)
+            hit = (near <= far) & (far > 0)
+            best = np.where(hit & (near < best), np.maximum(near, 0), best)
+    return best
+
+
+def _cup_scene(
+    folder: Path, size: int = 120, focal: float = 130.0
+) -> tuple[Path, Path, list[tuple[np.ndarray, np.ndarray]]]:
+    """Photos of the cup with known cameras, plus the true AI-like disparity of each."""
+    images, text = folder / "images", folder / "txt"
+    images.mkdir(parents=True)
+    text.mkdir()
+    boxes = [part.bounds for part in _cup().split(only_watertight=False)]
+    rng = np.random.default_rng(1)
+    jj, ii = np.meshgrid(np.arange(size), np.arange(size))
+    rays_cam = np.stack(
+        [(jj - size / 2) / focal, (ii - size / 2) / focal, np.ones_like(jj, float)], -1
+    ).reshape(-1, 3)
+    lines: list[str] = []
+    depth_by_image: list[tuple[np.ndarray, np.ndarray]] = []
+    k = 0
+    for height, count in ((0.7, 10), (2.6, 10), (3.6, 6)):
+        for i in range(count):
+            a = 2 * np.pi * i / count
+            eye = np.array([2.6 * np.cos(a), 2.6 * np.sin(a), height])
+            rot, t = _look_at(eye, np.array([0.0, 0.0, 0.5]))
+            dirs = rays_cam @ rot  # camera → world
+            dirs /= np.linalg.norm(dirs, axis=1, keepdims=True)
+            depth = _ray_boxes(eye, dirs, boxes) * (dirs @ rot[2])
+            depth = depth.reshape(size, size)
+            image = cv2.GaussianBlur(
+                rng.integers(0, 110, (size, size, 3), dtype=np.uint8), (3, 3), 0
+            )
+            image[np.isfinite(depth)] = (235, 235, 235)
+            name = f"img_{k:02d}.png"
+            cv2.imwrite(str(images / name), image)
+            far = float(np.nanmax(np.where(np.isfinite(depth), depth, np.nan))) * 2
+            disparity = 1.0 / np.where(np.isfinite(depth), depth, far)
+            depth_by_image.append((cv2.imread(str(images / name)).astype(np.float32), disparity))
+            q = _quat(rot)
+            lines.append(f"{k + 1} {q[0]} {q[1]} {q[2]} {q[3]} {t[0]} {t[1]} {t[2]} 1 {name}\n\n")
+            k += 1
+    (text / "cameras.txt").write_text(
+        f"1 PINHOLE {size} {size} {focal} {focal} {size / 2} {size / 2}\n"
+    )
+    (text / "images.txt").write_text("".join(lines))
+    table = np.column_stack([rng.uniform(-1, 1, 400), rng.uniform(-1, 1, 400), np.zeros(400)])
+    table = table[(np.abs(table[:, 0]) > 0.45) | (np.abs(table[:, 1]) > 0.45)]
+    rows = (f"{i + 1} {x} {y} {z} 0 0 0 0\n" for i, (x, y, z) in enumerate(table))
+    (text / "points3D.txt").write_text("".join(rows))
+    return images, text, depth_by_image
+
+
+def test_ai_depth_carves_the_inside_of_a_cup(tmp_path: Path) -> None:
+    images, text, truth = _cup_scene(tmp_path)
+
+    def estimator(rgb: np.ndarray) -> np.ndarray:
+        # The hull hands over its (resized) copy of a photo: find which one it is
+        # and return that photo's true disparity, like a perfect depth AI would.
+        small = cv2.resize(cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR), truth[0][0].shape[1::-1])
+        best = min(truth, key=lambda item: float(np.abs(item[0] - small).mean()))
+        return cv2.resize(best[1], (rgb.shape[1], rgb.shape[0]), interpolation=cv2.INTER_NEAREST)
+
+    plain = visual_hull(images, text, tmp_path / "plain.ply", resolution=64, refinements=1)
+    carved = visual_hull(
+        images, text, tmp_path / "carved.ply", resolution=64, refinements=1, depth=lambda: estimator
+    )
+    assert carved.depth_carved_voxels > 0
+    solid = trimesh.load(plain.mesh_path)
+    cup = trimesh.load(carved.mesh_path)
+    # The silhouettes alone fill the cup; the AI depth empties a good part of it.
+    assert cup.volume < 0.8 * solid.volume
+    assert cup.is_watertight
+
+
+def test_any_mesh_is_coloured_from_the_photos(tmp_path: Path) -> None:
+    from reverse3d.reconstruction.silhouette import colorize_from_photos
+
+    images, text = _scene(tmp_path)
+    mesh = trimesh.creation.cylinder(radius=RADIUS * 0.98, height=HEIGHT * 0.98, sections=48)
+    mesh = mesh.subdivide().subdivide()  # vertices along the sides, not only at the caps
+    mesh.apply_translation([0, 0, HEIGHT / 2])
+    plain = tmp_path / "cylinder.ply"
+    mesh.export(plain)
+    out = colorize_from_photos(plain, images, text, tmp_path / "colour.ply")
+    colours = np.asarray(trimesh.load(out, process=False).visual.vertex_colors)[:, :3]
+    side = np.abs(mesh.vertices[:, 2] - HEIGHT / 2) < HEIGHT * 0.4
+    assert colours[side].mean() > 200  # the photographed cylinder is white

reverse3d-0.8.0/reverse3d/_version.py

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

reverse3d-0.8.0/tests/test_silhouette.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import cv2
-import numpy as np
-import pytest
-import trimesh
-
-pytest.importorskip("skimage")
-
-from reverse3d.errors import ProcessingError
-from reverse3d.reconstruction.silhouette import convergence_point, read_colmap_text, visual_hull
-
-SIZE = 400
-F = 420.0
-RADIUS, HEIGHT = 0.35, 1.2  # the object: an upright cylinder standing on z = 0
-
-
-def _look_at(eye: np.ndarray, target: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-    """World→camera rotation and translation (COLMAP convention: +Z forward, +Y down)."""
-    forward = target - eye
-    forward /= np.linalg.norm(forward)
-    right = np.cross(forward, [0.0, 0.0, 1.0])
-    right /= np.linalg.norm(right)
-    down = np.cross(forward, right)
-    rot = np.stack([right, down, forward])
-    return rot, -rot @ eye
-
-
-def _quat(rot: np.ndarray) -> list[float]:
-    return list(
-        trimesh.transformations.quaternion_from_matrix(
-            np.vstack([np.hstack([rot, [[0], [0], [0]]]), [0, 0, 0, 1]])
-        )
-    )
-
-
-def _scene(folder: Path) -> tuple[Path, Path]:
-    images = folder / "images"
-    text = folder / "txt"
-    images.mkdir(parents=True)
-    text.mkdir()
-    rng = np.random.default_rng(0)
-    theta = np.linspace(0, 2 * np.pi, 64, endpoint=False)
-    rim = np.concatenate(
-        [
-            np.stack([RADIUS * np.cos(theta), RADIUS * np.sin(theta), np.full_like(theta, z)], 1)
-            for z in (0.0, HEIGHT)
-        ]
-    )
-    lines = []
-    k = 0
-    for height, count in ((0.6, 12), (2.2, 12), (3.4, 6)):
-        for i in range(count):
-            a = 2 * np.pi * i / count
-            eye = np.array([3.2 * np.cos(a), 3.2 * np.sin(a), height])
-            rot, t = _look_at(eye, np.array([0.0, 0.0, 0.6]))
-            # Textured background, then the white cylinder's silhouette.
-            image = rng.integers(0, 120, (SIZE, SIZE, 3), dtype=np.uint8)
-            image = cv2.GaussianBlur(image, (5, 5), 0)
-            cam = rim @ rot.T + t
-            uv = (cam[:, :2] / cam[:, 2:3]) * F + SIZE / 2
-            cv2.fillConvexPoly(image, cv2.convexHull(uv.astype(np.int32)), (235, 235, 235))
-            name = f"img_{k:02d}.jpg"
-            cv2.imwrite(str(images / name), image)
-            q = _quat(rot)
-            lines.append(f"{k + 1} {q[0]} {q[1]} {q[2]} {q[3]} {t[0]} {t[1]} {t[2]} 1 {name}\n\n")
-            k += 1
-    (text / "cameras.txt").write_text(f"1 PINHOLE {SIZE} {SIZE} {F} {F} {SIZE / 2} {SIZE / 2}\n")
-    (text / "images.txt").write_text("".join(lines))
-    table = np.column_stack([rng.uniform(-1, 1, 400), rng.uniform(-1, 1, 400), np.zeros(400)])
-    table = table[np.hypot(table[:, 0], table[:, 1]) > RADIUS + 0.05]
-    (text / "points3D.txt").write_text(
-        "".join(f"{i + 1} {x} {y} {z} 0 0 0 0\n" for i, (x, y, z) in enumerate(table))
-    )
-    return images, text
-
-
-def test_cameras_converge_on_the_object(tmp_path: Path) -> None:
-    _, text = _scene(tmp_path)
-    views, points = read_colmap_text(text)
-    center, distance = convergence_point(views)
-    assert len(views) == 30 and len(points) > 100
-    assert np.linalg.norm(center - [0, 0, 0.6]) < 0.05
-    assert 3.0 < distance < 3.8
-
-
-def test_visual_hull_rebuilds_an_upright_cylinder(tmp_path: Path) -> None:
-    images, text = _scene(tmp_path)
-    result = visual_hull(images, text, tmp_path / "hull.ply", resolution=80, refinements=1)
-    mesh = trimesh.load(result.mesh_path)
-    assert result.support_plane
-    assert mesh.is_watertight
-    width = (mesh.extents[0] + mesh.extents[1]) / 2
-    assert mesh.bounds[0][2] == pytest.approx(0.0, abs=1e-6)
-    # Height / diameter of the real cylinder is 1.2 / 0.7 ≈ 1.7.
-    assert 1.3 < mesh.extents[2] / width < 2.2
-
-
-def test_too_few_photos(tmp_path: Path) -> None:
-    images, text = _scene(tmp_path)
-    rows = (text / "images.txt").read_text().split("\n\n")
-    (text / "images.txt").write_text("\n\n".join(rows[:5]) + "\n\n")
-    with pytest.raises(ProcessingError, match="at least"):
-        visual_hull(images, text, tmp_path / "hull.ply", resolution=48, refinements=0)
-
-
-class _FakeSegmenter:
-    """Stands in for Segment Anything: the object is the bright part inside the box."""
-
-    def __init__(self) -> None:
-        self.calls = 0
-
-    def embed(self, rgb: np.ndarray) -> dict[str, np.ndarray]:
-        return {"rgb": rgb}
-
-    def segment(
-        self, state: dict[str, np.ndarray], box: tuple[int, int, int, int], point: tuple[int, int]
-    ) -> np.ndarray:
-        self.calls += 1
-        gray = state["rgb"].mean(axis=2)
-        mask = np.zeros(gray.shape, np.uint8)
-        x0, y0, x1, y1 = box
-        mask[y0 : y1 + 1, x0 : x1 + 1] = np.where(gray[y0 : y1 + 1, x0 : x1 + 1] > 200, 255, 0)
-        return mask
-
-
-def test_ai_segmenter_is_loaded_lazily_and_used(tmp_path: Path) -> None:
-    images, text = _scene(tmp_path)
-    fake = _FakeSegmenter()
-    loads: list[int] = []
-
-    def factory() -> _FakeSegmenter:
-        loads.append(1)
-        return fake
-
-    result = visual_hull(
-        images,
-        text,
-        tmp_path / "hull.ply",
-        resolution=64,
-        refinements=1,
-        segmenter=factory,  # type: ignore[arg-type]
-    )
-    assert loads == [1] and fake.calls == 2 * 30  # two AI rounds over the 30 photos
-    assert result.ai_segmentation
-    mesh = trimesh.load(result.mesh_path)
-    width = (mesh.extents[0] + mesh.extents[1]) / 2
-    assert mesh.is_watertight and 1.3 < mesh.extents[2] / width < 2.2
-
-
-def test_without_ai_segmenter_grabcut_is_used(tmp_path: Path) -> None:
-    images, text = _scene(tmp_path)
-    result = visual_hull(
-        images, text, tmp_path / "hull.ply", resolution=48, refinements=1, segmenter=lambda: None
-    )
-    assert not result.ai_segmentation