reverse3d 0.7.0__tar.gz → 0.8.1__tar.gz

{reverse3d-0.7.0/reverse3d.egg-info → reverse3d-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.7.0
+Version: 0.8.1
 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.7.0 → reverse3d-0.8.1}/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.8.1/reverse3d/_version.py

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

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/autopilot.py

@@ -361,7 +361,12 @@ def auto_run(
         if base.scene == "auto":
             predicted = detect_scene(source, settings)
             scene_info = predicted.to_dict()
-            base = replace(base, scene=predicted.kind)
+            base = replace(
+                base,
+                scene=predicted.kind,
+                subject=predicted.subject,
+                render_preset=predicted.render,
+            )
         elif base.scene in SCENE_PRESETS:
             scene_info = {"kind": base.scene, "confidence": 1.0, "reasons": ["chosen"]}
     summary: dict[str, Any] | None = None

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/offline.py

@@ -55,6 +55,7 @@ MODEL_REVISIONS: dict[str, str] = {
     "depth-anything/Depth-Anything-V2-Base-hf": "b1958afc87fb45a9e3746cb387596094de553ed8",
     "depth-anything/Depth-Anything-V2-Large-hf": "7581137eff8d4e94f6e796d3baea0e9fa79b22d2",
     "facebook/sam-vit-base": "70c1a07f894ebb5b307fd9eaaee97b9dfc16068f",
+    "wkcn/TinyCLIP-ViT-40M-32-Text-19M-LAION400M": "95ec8197b3f2fe7f747865c61ca556cf0768b2f7",
 }
 
 
@@ -101,9 +102,10 @@ def is_offline(settings: Settings) -> bool:
 
 def _allowed_models() -> dict[str, tuple[str, str]]:
     from reverse3d.reconstruction.depth_estimation import ALLOWED_MODELS
+    from reverse3d.vision.classifier import ALLOWED_CLASSIFIERS
     from reverse3d.vision.segmenter import ALLOWED_SEGMENTERS
 
-    return {**ALLOWED_MODELS, **ALLOWED_SEGMENTERS}
+    return {**ALLOWED_MODELS, **ALLOWED_SEGMENTERS, **ALLOWED_CLASSIFIERS}
 
 
 def _default_model() -> str:
@@ -203,10 +205,12 @@ def prepare(settings: Settings, *, include_non_commercial: bool = False) -> dict
     Safe to run any time: models already on disk are skipped. It never raises
     for a missing optional stack; that is reported in the result instead.
     """
+    from reverse3d.vision.classifier import DEFAULT_CLASSIFIER
     from reverse3d.vision.segmenter import DEFAULT_SEGMENTER
 
-    # Depth (reliefs) and segmentation (object silhouettes), both commercial-friendly.
-    models = [_default_model(), DEFAULT_SEGMENTER]
+    # Depth (reliefs), segmentation (silhouettes) and the subject classifier,
+    # all commercial-friendly.
+    models = [_default_model(), DEFAULT_SEGMENTER, DEFAULT_CLASSIFIER]
     if include_non_commercial:
         models += [m for m in _allowed_models() if m not in models]
 
@@ -279,8 +283,18 @@ def offline_status(settings: Settings) -> dict[str, Any]:
 
     env = environment_report(settings, include_offline=False)
     caps: dict[str, bool] = env["capabilities"]  # type: ignore[assignment]
+    from reverse3d.vision.classifier import DEFAULT_CLASSIFIER
+    from reverse3d.vision.segmenter import DEFAULT_SEGMENTER
+
     depth_installed = bool(caps.get("depth_estimation"))
     model_on_disk = local_model_path(_default_model()) is not None
+    # The local AI team: what each model does, and whether it is on this computer.
+    ai_models = {
+        "ai_subject": DEFAULT_CLASSIFIER,
+        "ai_segmentation": DEFAULT_SEGMENTER,
+        "ai_depth": _default_model(),
+    }
+    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()
 
     components = {
@@ -292,13 +306,27 @@ def offline_status(settings: Settings) -> dict[str, Any]:
             "available": caps.get("render_blender", False) or caps.get("render_pyvista", False),
             "offline": True,
         },
-        "ai_depth": {"available": depth_installed, "offline": depth_installed and model_on_disk},
+        **{
+            key: {"available": depth_installed, "offline": depth_installed and on_disk[key]}
+            for key in ai_models
+        },
     }
     missing = []
+    names = {
+        "ai_subject": "AI subject classifier",
+        "ai_segmentation": "AI segmentation",
+        "ai_depth": "AI depth",
+    }
     if depth_installed and not model_on_disk:
         missing.append(
             "AI depth model 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(
+                f"{names[key]} model not downloaded yet: "
+                "run `reverse3d offline prepare` while online."
+            )
     working_offline = is_offline(settings)
     return {
         "mode": settings.offline,

{reverse3d-0.7.0 → reverse3d-0.8.1}/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,
@@ -75,6 +77,9 @@ class RecipeOptions:
     mask_method: MaskMethod = "otsu"
     #: photos_to_model: scene profile (object, character, architecture, landscape) or "auto".
     scene: str = "auto"
+    #: what was photographed (AI classifier) and the render look; None = from the scene.
+    subject: str | None = None
+    render_preset: str | None = None
     #: photo_to_relief: object mask (white = keep), e.g. from the autopilot fallback.
     mask_path: str | None = None
     #: mesh repair strength; "strong" closes much larger holes.
@@ -132,39 +137,85 @@ 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, render_mesh
+    from reverse3d.rendering.blender_render import RenderOptions, preset_options, render_mesh
 
     prof = profile_values(run.settings)
-    options = RenderOptions(
-        width=prof.render_width,
-        height=prof.render_height,
-        samples=prof.render_samples,
-        device="gpu" if wants_gpu(run.settings) else "cpu",
+    look = str(run.details.get("scene", {}).get("render") or "studio")
+    options = preset_options(
+        look,
+        RenderOptions(
+            width=prof.render_width,
+            height=prof.render_height,
+            samples=prof.render_samples,
+            device="gpu" if wants_gpu(run.settings) else "cpu",
+        ),
     )
+    run.details["render_look"] = look
     try:
         result = run.step(
             "render",
@@ -194,6 +245,14 @@ def _measure(run: _Run, mesh: Path) -> MeshStats:
 _MIN_GROUP = 8
 
 
+_DEFAULT_LOOK = {
+    "object": "studio",
+    "character": "portrait",
+    "architecture": "architecture",
+    "landscape": "aerial",
+}
+
+
 def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.reconstruction.photogrammetry import (
         PhotogrammetryOptions,
@@ -204,9 +263,11 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.vision.feature_matcher import analyze_image_set
 
     scene: str
+    subject, look = opt.subject, opt.render_preset
     if opt.scene == "auto":
         detection = run.step("scene", lambda: detect_scene(src, run.settings))
         scene, confidence, predicted = detection.kind, detection.confidence, True
+        subject, look = detection.subject, detection.render
     elif opt.scene in SCENE_PRESETS:
         scene, confidence, predicted = opt.scene, 1.0, False
     else:
@@ -219,6 +280,8 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
         "label": SCENE_LABEL_ES[scene],
         "confidence": confidence,
         "predicted": predicted,
+        "subject": subject,
+        "render": look or _DEFAULT_LOOK[scene],
     }
     analysis = run.step("analyze", lambda: analyze_image_set(src, run.settings))
     run.details["analysis"] = analysis.to_dict()
@@ -310,6 +373,15 @@ 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 and cloud:
+        try:
+            colored = _color_from_cloud(
+                Path(mesh_path), Path(cloud), run.out / "reconstruction" / "mesh_color.ply"
+            )
+            mesh_path = str(colored) if colored else mesh_path
+        except Exception as exc:  # colour is a bonus
+            logger.info("Colouring from the point cloud skipped: %s", exc)
     model = run.out / "model.stl"
     _clean(
         run,
@@ -510,7 +582,7 @@ 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["model"]), opt.overwrite)
+        _render(run, Path(run.outputs.get("model_color") or run.outputs["model"]), opt.overwrite)
 
     summary: dict[str, Any] = {
         "recipe": recipe,

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/reconstruction/silhouette.py

@@ -191,6 +191,65 @@ def _support_plane(
     return n, d
 
 
+def _vertex_colors(
+    mesh: trimesh.Trimesh,
+    views: list[_View],
+    images: list[tuple[np.ndarray, float]],
+    masks: list[np.ndarray] | None = None,
+) -> np.ndarray:
+    """Real colour of every vertex from the photos that see it head-on.
+
+    Each photo votes with weight cos(angle)^2 for the vertices that face it and
+    are not hidden (coarse depth buffer); vertices no photo sees get the median.
+    """
+    verts = np.asarray(mesh.vertices)
+    normals = np.asarray(mesh.vertex_normals)
+    total = np.zeros((len(verts), 3))
+    weight = np.zeros(len(verts))
+    for i, ((small, scale), view) in enumerate(zip(images, views, strict=True)):
+        # Only pixels of the object itself give colour (the carved hull is a bit
+        # larger than the object, so its rim would otherwise pick up background).
+        inner = (
+            cv2.erode(masks[i], np.ones((5, 5), np.uint8)) > 0
+            if masks is not None and masks[i].shape == small.shape[:2]
+            else None
+        )
+        center = -view.rotation.T @ view.translation
+        to_cam = center - verts
+        to_cam /= np.linalg.norm(to_cam, axis=1, keepdims=True)
+        facing = np.einsum("ij,ij->i", normals, to_cam)
+        uv, z = _project(verts, view)
+        u = uv[:, 0] * scale
+        v = uv[:, 1] * scale
+        h, w = small.shape[:2]
+        ok = (facing > 0.2) & (z > 0) & (u >= 0) & (v >= 0) & (u < w - 1) & (v < h - 1)
+        if not ok.any():
+            continue
+        # Coarse z-buffer: a vertex counts only if it is (about) the nearest in its cell.
+        cell = 4
+        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])
+        depth_span = float(np.ptp(z[ok])) or 1.0
+        visible = z[ok] <= zbuf[cv_, cu] + 0.03 * depth_span
+        idx = np.flatnonzero(ok)[visible]
+        if inner is not None:
+            idx = idx[inner[v[idx].astype(np.int64), u[idx].astype(np.int64)]]
+        px = small[v[idx].astype(np.int64), u[idx].astype(np.int64)][:, ::-1].astype(np.float64)
+        wgt = facing[idx] ** 2
+        total[idx] += px * wgt[:, None]
+        weight[idx] += wgt
+    colors = np.zeros((len(verts), 4), np.uint8)
+    seen = weight > 0
+    rgb = np.zeros((len(verts), 3))
+    rgb[seen] = total[seen] / weight[seen, None]
+    rgb[~seen] = np.median(rgb[seen], axis=0) if seen.any() else 180
+    colors[:, :3] = np.clip(rgb, 0, 255).astype(np.uint8)
+    colors[:, 3] = 255
+    return colors
+
+
 def visual_hull(
     image_dir: Path,
     model_text_dir: Path,
@@ -332,6 +391,8 @@ def visual_hull(
         normal, offset = plane
         height = (grid @ normal + offset).reshape(n, n, n)
         volume[height < 0.015 * radius] = 0
+    # Drop structures thinner than a couple of voxels (stray spikes from a few views).
+    volume = ndimage.binary_opening(volume > 0.5, iterations=2).astype(np.float32)
     labels, count = ndimage.label(volume > 0.5)
     if count == 0:
         raise ProcessingError("No object could be isolated in the photos.")
@@ -356,6 +417,11 @@ def visual_hull(
     verts = (verts - 2) / (n - 1) * 2 * radius - radius + center
     mesh = trimesh.Trimesh(verts, faces, process=True)
     trimesh.smoothing.filter_taubin(mesh, lamb=0.5, nu=-0.53, iterations=15)
+    mesh.fix_normals()
+    # Real colours from the photos (kept by PLY export; the model gets them as GLB).
+    mesh.visual = trimesh.visual.ColorVisuals(
+        mesh, vertex_colors=_vertex_colors(mesh, views, images, masks)
+    )
 
     # Stand it upright: +Z along the table normal (or the mean camera "up").
     up = plane[0] if plane is not None else np.mean(cameras - center, axis=0)

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/rendering/_blender_job.py

@@ -136,8 +136,15 @@ def make_material(obj: bpy.types.Object, job: dict) -> None:
     obj.data.materials.append(mat)
 
 
-def add_light(name: str, location: tuple[float, float, float], energy: float, size: float) -> None:
+def add_light(
+    name: str,
+    location: tuple[float, float, float],
+    energy: float,
+    size: float,
+    color: tuple[float, float, float] = (1.0, 1.0, 1.0),
+) -> None:
     data = bpy.data.lights.new(name, type="AREA")
+    data.color = color
     data.energy = energy
     data.size = size
     light = bpy.data.objects.new(name, data)
@@ -153,7 +160,37 @@ def setup_world(job: dict) -> None:
     world.use_nodes = True
     bg = world.node_tree.nodes.get("Background")
     bg.inputs["Color"].default_value = _hex_to_rgba(job["background"])
-    bg.inputs["Strength"].default_value = 0.6
+    outdoor = job.get("preset") in ("architecture", "aerial")
+    bg.inputs["Strength"].default_value = 1.0 if outdoor else 0.6
+
+
+def add_sun(elevation_deg: float, azimuth_deg: float, energy: float) -> None:
+    data = bpy.data.lights.new("sun", type="SUN")
+    data.energy = energy
+    data.angle = math.radians(1.5)  # soft daylight shadows
+    sun = bpy.data.objects.new("sun", data)
+    bpy.context.collection.objects.link(sun)
+    sun.rotation_euler = (math.radians(90 - elevation_deg), 0.0, math.radians(azimuth_deg))
+
+
+def setup_lights(r: float, job: dict) -> None:
+    """Lighting of each look (see RENDER_PRESETS in blender_render.py)."""
+    preset = job.get("preset", "studio")
+    if preset in ("architecture", "aerial"):
+        add_sun(55 if preset == "architecture" else 65, 140, 4.0)
+        add_light("sky_fill", (-r * 4, -r * 3, r * 3), 150 * r * r, r * 4, (0.85, 0.9, 1.0))
+    elif preset == "portrait":
+        add_light("key", (r * 3, -r * 3, r * 2.5), 900 * r * r, r * 1.5, (1.0, 0.93, 0.85))
+        add_light("fill", (-r * 4, -r * 2, r * 1.5), 160 * r * r, r * 3)
+        add_light("rim", (-r * 1, r * 4, r * 3), 900 * r * r, r * 1.2, (0.75, 0.85, 1.0))
+    elif preset == "showroom":
+        add_light("top", (0, 0, r * 5), 1200 * r * r, r * 4)
+        add_light("key", (r * 4, -r * 3, r * 2), 600 * r * r, r * 3)
+        add_light("rim", (-r * 3, r * 4, r * 2), 700 * r * r, r * 2.5)
+    else:  # studio
+        add_light("key", (r * 3, -r * 3, r * 4), 800 * r * r, r * 2)
+        add_light("fill", (-r * 4, -r * 2, r * 2), 300 * r * r, r * 3)
+        add_light("rim", (0, r * 4, r * 3), 500 * r * r, r * 2)
 
 
 def setup_camera(radius: float, center_z: float, job: dict) -> bpy.types.Object:
@@ -162,7 +199,7 @@ def setup_camera(radius: float, center_z: float, job: dict) -> bpy.types.Object:
     rig.location = (0, 0, center_z)
 
     cam_data = bpy.data.cameras.new("reverse3d_camera")
-    cam_data.lens = 50
+    cam_data.lens = float(job.get("lens_mm", 50))
     cam = bpy.data.objects.new("reverse3d_camera", cam_data)
     bpy.context.collection.objects.link(cam)
     # camera.angle is the FOV of the longer image side; fit the sphere in the shorter one.
@@ -248,10 +285,7 @@ def main() -> None:
     shade(obj, job["shading"])
     make_material(obj, job)
     setup_world(job)
-    r = max(radius, 0.1)
-    add_light("key", (r * 3, -r * 3, r * 4), 800 * r * r, r * 2)
-    add_light("fill", (-r * 4, -r * 2, r * 2), 300 * r * r, r * 3)
-    add_light("rim", (0, r * 4, r * 3), 500 * r * r, r * 2)
+    setup_lights(max(radius, 0.1), job)
     rig = setup_camera(radius, center_z, job)
     setup_ground(job)
     setup_render(job)

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/rendering/blender_render.py

@@ -19,7 +19,7 @@ import re
 import tempfile
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Literal
+from typing import Any, Literal
 
 from reverse3d.config import Settings
 from reverse3d.errors import DependencyMissingError, InputValidationError, ProcessingError
@@ -63,6 +63,9 @@ class RenderOptions:
     ground: bool = True
     shading: Literal["auto", "smooth", "flat"] = "auto"
     vertex_colors: bool = True
+    #: look of the shot: studio, showroom, portrait, architecture or aerial.
+    preset: str = "studio"
+    lens_mm: float = 50.0
 
     def validate(self) -> None:
         checks = [
@@ -82,12 +85,63 @@ class RenderOptions:
             (0 <= self.azimuth_deg <= 360, "azimuth_deg must be in [0, 360]"),
             (0 <= self.turntable_frames <= 360, "turntable_frames must be in [0, 360]"),
             (self.shading in ("auto", "smooth", "flat"), "shading must be auto, smooth or flat"),
+            (self.preset in RENDER_PRESETS, f"preset must be one of {', '.join(RENDER_PRESETS)}"),
+            (10 <= self.lens_mm <= 300, "lens_mm must be in [10, 300]"),
         ]
         for ok, message in checks:
             if not ok:
                 raise InputValidationError(message)
 
 
+#: Camera, lens and backdrop of each look (lights are set up in the Blender job).
+RENDER_PRESETS: dict[str, dict[str, Any]] = {
+    # Products and parts: seamless light backdrop, three soft boxes.
+    "studio": {
+        "lens_mm": 50.0,
+        "elevation_deg": 25.0,
+        "azimuth_deg": 35.0,
+        "background": "#f4f5f7",
+    },
+    # Vehicles: longer lens, low angle, glossy paint, showroom grey.
+    "showroom": {
+        "lens_mm": 70.0,
+        "elevation_deg": 12.0,
+        "azimuth_deg": 40.0,
+        "background": "#e6e9ee",
+        "roughness": 0.22,
+    },
+    # People and animals: portrait lens, eye level, dark backdrop, warm key + cool rim.
+    "portrait": {
+        "lens_mm": 85.0,
+        "elevation_deg": 6.0,
+        "azimuth_deg": 25.0,
+        "background": "#1d222b",
+    },
+    # Buildings and interiors: wide lens, sun and sky.
+    "architecture": {
+        "lens_mm": 28.0,
+        "elevation_deg": 20.0,
+        "azimuth_deg": 40.0,
+        "background": "#bcd4ea",
+    },
+    # Terrain and forests: high aerial view in daylight.
+    "aerial": {
+        "lens_mm": 35.0,
+        "elevation_deg": 55.0,
+        "azimuth_deg": 30.0,
+        "background": "#cfe0ee",
+    },
+}
+
+
+def preset_options(preset: str, base: RenderOptions | None = None) -> RenderOptions:
+    """Render options for a look, keeping size, samples and device from ``base``."""
+    from dataclasses import replace
+
+    name = preset if preset in RENDER_PRESETS else "studio"
+    return replace(base or RenderOptions(), preset=name, **RENDER_PRESETS[name])
+
+
 @dataclass
 class RenderResult:
     """Paths of the rendered images and the backend that produced them."""

{reverse3d-0.7.0 → reverse3d-0.8.1}/reverse3d/scenes.py

@@ -102,6 +102,12 @@ class SceneDetection:
     recommended: tuple[int, int]
     enough_photos: bool
     advice: list[str] = field(default_factory=list)
+    #: what the AI classifier saw (product, person, animal, vehicle, building...), if available.
+    subject: str | None = None
+    subject_label: str | None = None
+    subject_scores: dict[str, float] = field(default_factory=dict)
+    #: render look: studio, showroom, portrait, architecture or aerial.
+    render: str = "studio"
 
     def to_dict(self) -> dict[str, object]:
         return asdict(self)
@@ -307,6 +313,26 @@ def score_scene(signals: SceneSignals) -> tuple[dict[str, float], list[str]]:
     return {k: round(max(v, 0.0), 3) for k, v in scores.items()}, reasons
 
 
+def _ai_subject(images: list[Path], settings: Settings) -> tuple[str | None, dict[str, float]]:
+    """The AI classifier's subject for a sample of the photos (None if unavailable)."""
+    from reverse3d.errors import Reverse3DError
+    from reverse3d.vision.classifier import classify_photos
+
+    step = max(1, len(images) // _SAMPLE)
+    try:
+        scores = classify_photos(images[::step][:_SAMPLE], settings)
+    except Reverse3DError as exc:
+        logger.info("AI subject classifier unavailable: %s", exc.message)
+        return None, {}
+    return max(scores, key=scores.__getitem__), scores
+
+
+def _subject_label(subject: str | None) -> str | None:
+    from reverse3d.vision.classifier import SUBJECT_LABEL_ES
+
+    return SUBJECT_LABEL_ES.get(subject) if subject else None
+
+
 def detect_scene(image_dir: str | Path, settings: Settings) -> SceneDetection:
     """Predict the scene kind of a photo folder (takes a few seconds)."""
     directory = validate_input_dir(image_dir)
@@ -319,6 +345,20 @@ def detect_scene(image_dir: str | Path, settings: Settings) -> SceneDetection:
     ranked = sorted(scores.values(), reverse=True)
     margin = ranked[0] - (ranked[1] if len(ranked) > 1 else 0.0)
     confidence = round(min(0.97, 0.5 + margin * 1.5), 2)
+    subject, subject_scores = _ai_subject(images, settings)
+    render = (
+        "aerial" if kind == "landscape" else "architecture" if kind == "architecture" else "studio"
+    )
+    if subject is not None:
+        from reverse3d.vision.classifier import SUBJECT_RENDER, SUBJECT_SCENE
+
+        flight = signals.drone and signals.nadir_share > 0.3
+        if flight:  # a drone looking down is terrain whatever the AI thinks it sees
+            subject = "terrain" if subject not in ("forest", "terrain") else subject
+        kind = SUBJECT_SCENE[subject]  # type: ignore[assignment]
+        render = SUBJECT_RENDER[subject]
+        confidence = round(min(0.98, max(subject_scores.get(subject, 0.0), 0.5)), 2)
+        reasons.insert(0, f"ai_{subject}")
     preset = SCENE_PRESETS[kind]
     enough = signals.photos >= preset.min_photos
     if not enough:
@@ -337,6 +377,10 @@ def detect_scene(image_dir: str | Path, settings: Settings) -> SceneDetection:
         recommended=preset.recommended,
         enough_photos=enough,
         advice=advice,
+        subject=subject,
+        subject_label=_subject_label(subject),
+        subject_scores={k: round(v, 3) for k, v in subject_scores.items()},
+        render=render,
     )
 
 

reverse3d-0.8.1/reverse3d/vision/classifier.py

@@ -0,0 +1,170 @@
+"""What was photographed: a small local AI (TinyCLIP, MIT) that names the subject.
+
+The subject drives everything downstream: how the photos are reconstructed
+(scene profile), how the model is rendered (studio, portrait, architecture or
+aerial light) and which capture advice is given. TinyCLIP compares the photos
+with short descriptions of each subject (zero-shot), so no training data is
+needed and new subjects are a line of text.
+
+Like the other AI models, it is allowlisted, pinned to an exact commit,
+loaded from safetensors only and works offline after the first download.
+"""
+
+from __future__ import annotations
+
+import logging
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from reverse3d.config import Settings
+from reverse3d.errors import DependencyMissingError
+
+logger = logging.getLogger(__name__)
+
+ALLOWED_CLASSIFIERS: dict[str, tuple[str, str]] = {
+    "wkcn/TinyCLIP-ViT-40M-32-Text-19M-LAION400M": ("clip", "MIT"),
+}
+DEFAULT_CLASSIFIER = "wkcn/TinyCLIP-ViT-40M-32-Text-19M-LAION400M"
+
+#: subject -> descriptions (averaged). Order matters only for ties.
+SUBJECTS: dict[str, tuple[str, ...]] = {
+    "product": (
+        "a photo of a product on a table",
+        "a photo of a bottle, cup or household object",
+        "a photo of an object on a desk",
+    ),
+    "part": ("a photo of a mechanical part", "a photo of a tool or machine component"),
+    "figure": ("a photo of a statue or figurine", "a photo of a toy or sculpture"),
+    "person": ("a photo of a person", "a photo of a man or a woman standing"),
+    "animal": ("a photo of an animal", "a photo of a dog, cat or pet", "a photo of a wild animal"),
+    "vehicle": ("a photo of a car", "a photo of a vehicle or motorcycle"),
+    "building": ("a photo of a building exterior", "a photo of a house facade"),
+    "interior": ("a photo of a room interior", "a photo of the inside of a house"),
+    "forest": ("a photo of a forest or trees", "a photo of plants and vegetation"),
+    "terrain": ("an aerial photo of land or terrain", "a photo of a landscape or field"),
+}
+
+#: How each subject is reconstructed (scene profile) ...
+SUBJECT_SCENE: dict[str, str] = {
+    "product": "object",
+    "part": "object",
+    "figure": "object",
+    "vehicle": "object",
+    "person": "character",
+    "animal": "character",
+    "building": "architecture",
+    "interior": "architecture",
+    "forest": "landscape",
+    "terrain": "landscape",
+}
+#: ... and rendered.
+SUBJECT_RENDER: dict[str, str] = {
+    "product": "studio",
+    "part": "studio",
+    "figure": "studio",
+    "vehicle": "showroom",
+    "person": "portrait",
+    "animal": "portrait",
+    "building": "architecture",
+    "interior": "architecture",
+    "forest": "aerial",
+    "terrain": "aerial",
+}
+SUBJECT_LABEL_ES: dict[str, str] = {
+    "product": "Objeto o producto",
+    "part": "Pieza mecánica",
+    "figure": "Figura o escultura",
+    "vehicle": "Vehículo",
+    "person": "Persona",
+    "animal": "Animal",
+    "building": "Edificio",
+    "interior": "Interior",
+    "forest": "Bosque o vegetación",
+    "terrain": "Terreno o paisaje",
+}
+
+
+def classifier_available() -> bool:
+    """True when the AI stack (torch + transformers) is installed."""
+    try:
+        import torch  # noqa: F401
+        import transformers  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
+def _features(output: Any) -> Any:
+    """Projected embeddings: a tensor in transformers 4, an output object in 5."""
+    return output if hasattr(output, "norm") else output.pooler_output
+
+
+@lru_cache(maxsize=1)
+def _load(model_dir: str) -> tuple[Any, Any, Any]:
+    import torch
+    from transformers import CLIPModel, CLIPProcessor
+
+    try:
+        from transformers.utils import logging as hf_logging
+
+        hf_logging.disable_progress_bar()
+        hf_logging.set_verbosity_error()
+    except ImportError:  # pragma: no cover
+        pass
+    # model_dir is the local snapshot of a commit-pinned, allowlisted model.
+    model: Any = CLIPModel.from_pretrained(  # nosec B615
+        model_dir, local_files_only=True, use_safetensors=True, trust_remote_code=False
+    )
+    processor = CLIPProcessor.from_pretrained(model_dir, local_files_only=True)  # nosec B615
+    model.eval()
+    prompts = [p for texts in SUBJECTS.values() for p in texts]
+    with torch.no_grad():
+        tokens = processor(text=prompts, return_tensors="pt", padding=True)
+        text = _features(model.get_text_features(**tokens))
+        text = text / text.norm(dim=-1, keepdim=True)
+    # One averaged, normalised embedding per subject.
+    rows, start = [], 0
+    for texts in SUBJECTS.values():
+        emb = text[start : start + len(texts)].mean(0)
+        rows.append(emb / emb.norm())
+        start += len(texts)
+    return model, processor, torch.stack(rows)
+
+
+def classify_photos(paths: list[Path], settings: Settings) -> dict[str, float]:
+    """Probability of each subject for a set of photos (averaged over them).
+
+    Raises:
+        DependencyMissingError: the AI extra or the model is not available.
+    """
+    if not classifier_available():
+        raise DependencyMissingError(
+            "The AI subject classifier is not installed.", hint='pip install "reverse3d[depth]"'
+        )
+    import torch
+    from PIL import Image
+
+    from reverse3d.offline import force_offline_env, is_offline, resolve_model
+
+    model_dir = resolve_model(DEFAULT_CLASSIFIER, settings)
+    if is_offline(settings):
+        force_offline_env()
+    model, processor, subjects = _load(str(model_dir))
+    images = []
+    for path in paths:
+        with Image.open(path) as image:
+            rgb = image.convert("RGB")
+            rgb.thumbnail((448, 448))
+            images.append(rgb)
+    with torch.no_grad():
+        pixels = processor(images=images, return_tensors="pt")
+        feats = _features(model.get_image_features(**pixels))
+        feats = feats / feats.norm(dim=-1, keepdim=True)
+        logits = model.logit_scale.exp() * feats @ subjects.T
+        probs = logits.softmax(dim=-1).mean(0).cpu().numpy()
+    result = {name: float(p) for name, p in zip(SUBJECTS, np.asarray(probs), strict=True)}
+    logger.info("Subject: %s", max(result, key=result.__getitem__))
+    return result

{reverse3d-0.7.0 → reverse3d-0.8.1/reverse3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.7.0
+Version: 0.8.1
 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.7.0 → reverse3d-0.8.1}/reverse3d.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ reverse3d/reverse_eng/measure.py
 reverse3d/reverse_eng/mesh_cleaner.py
 reverse3d/reverse_eng/parametric.py
 reverse3d/vision/__init__.py
+reverse3d/vision/classifier.py
 reverse3d/vision/feature_matcher.py
 reverse3d/vision/mask_extractor.py
 reverse3d/vision/segmenter.py
@@ -59,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.8.1/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.7.0 → reverse3d-0.8.1}/tests/test_offline_autopilot.py

@@ -125,9 +125,11 @@ class TestModels:
 
     def test_every_allowlisted_model_is_pinned(self, tmp_path: Path) -> None:
         from reverse3d.reconstruction.depth_estimation import ALLOWED_MODELS
+        from reverse3d.vision.classifier import ALLOWED_CLASSIFIERS
         from reverse3d.vision.segmenter import ALLOWED_SEGMENTERS
 
-        assert set(ALLOWED_MODELS) | set(ALLOWED_SEGMENTERS) == set(offline.MODEL_REVISIONS)
+        allowed = set(ALLOWED_MODELS) | set(ALLOWED_SEGMENTERS) | set(ALLOWED_CLASSIFIERS)
+        assert allowed == set(offline.MODEL_REVISIONS)
         assert all(len(sha) == 40 for sha in offline.MODEL_REVISIONS.values())
         other = tmp_path / "_r3d_home" / "models" / ("models--" + SMALL.replace("/", "--"))
         (other / "snapshots" / "unreviewed").mkdir(parents=True)

{reverse3d-0.7.0 → reverse3d-0.8.1}/tests/test_scenes.py

@@ -112,3 +112,55 @@ def test_presets_and_advice_cover_every_scene() -> None:
         assert scene_advice(kind, preset.recommended[0])[0]
     assert not SCENE_PRESETS["architecture"].fill_holes
     assert SCENE_PRESETS["object"].fill_holes
+
+
+def _fake_subject(monkeypatch: pytest.MonkeyPatch, subject: str) -> None:
+    from reverse3d import scenes
+
+    monkeypatch.setattr(
+        scenes, "_ai_subject", lambda *_a: (subject, {subject: 0.9, "product": 0.1})
+    )
+
+
+@pytest.mark.parametrize(
+    ("subject", "kind", "render"),
+    [
+        ("person", "character", "portrait"),
+        ("animal", "character", "portrait"),
+        ("vehicle", "object", "showroom"),
+        ("building", "architecture", "architecture"),
+        ("forest", "landscape", "aerial"),
+    ],
+)
+def test_ai_subject_decides_scene_and_render(
+    tmp_path: Path,
+    settings: Settings,
+    monkeypatch: pytest.MonkeyPatch,
+    subject: str,
+    kind: str,
+    render: str,
+) -> None:
+    _fake_subject(monkeypatch, subject)
+    (tmp_path / "set").mkdir()
+    for i in range(4):
+        cv2.imwrite(str(tmp_path / "set" / f"{i}.jpg"), _facade())
+    detection = detect_scene(tmp_path / "set", settings)
+    assert (detection.kind, detection.render, detection.subject) == (kind, render, subject)
+    assert detection.reasons[0] == f"ai_{subject}" and detection.subject_label
+
+
+def test_a_drone_flight_is_terrain_whatever_the_ai_says(
+    tmp_path: Path, settings: Settings, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _fake_subject(monkeypatch, "building")
+    for i in range(6):
+        _gps_jpeg(tmp_path / "vuelo" / f"DJI_{i:04d}.jpg", 8.98 + i * 0.0005, -79.52)
+        # Gimbal pointing straight down, as DJI writes it in the XMP block.
+        path = tmp_path / "vuelo" / f"DJI_{i:04d}.jpg"
+        path.write_bytes(path.read_bytes() + b'<x drone-dji:GimbalPitchDegree="-90.0"/>')
+    detection = detect_scene(tmp_path / "vuelo", settings)
+    assert (detection.kind, detection.subject, detection.render) == (
+        "landscape",
+        "terrain",
+        "aerial",
+    )

reverse3d-0.7.0/reverse3d/_version.py

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