reverse3d 0.6.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.6.0
+Version: 0.8.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>

reverse3d-0.8.0/reverse3d/_version.py

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

{reverse3d-0.6.0 → reverse3d-0.8.0}/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.6.0 → reverse3d-0.8.0}/reverse3d/offline.py

@@ -54,6 +54,8 @@ MODEL_REVISIONS: dict[str, str] = {
     "depth-anything/Depth-Anything-V2-Small-hf": "5426e4f0f36572d16453bbda7a8389317b1bef99",
     "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",
 }
 
 
@@ -100,8 +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 dict(ALLOWED_MODELS)
+    return {**ALLOWED_MODELS, **ALLOWED_SEGMENTERS, **ALLOWED_CLASSIFIERS}
 
 
 def _default_model() -> str:
@@ -177,7 +181,7 @@ def resolve_model(model_id: str, settings: Settings) -> Path:
         return local
     if is_offline(settings):
         raise DependencyMissingError(
-            "The AI depth model is not on this computer and there is no internet connection.",
+            "The AI model is not on this computer and there is no internet connection.",
             hint="Connect to the internet once and run: reverse3d offline prepare",
         )
     try:
@@ -190,7 +194,7 @@ def resolve_model(model_id: str, settings: Settings) -> Path:
     except Exception as exc:  # network errors come in many shapes; report them plainly
         has_internet(refresh=True)
         raise DependencyMissingError(
-            f"Could not download the AI depth model ({exc.__class__.__name__}).",
+            f"Could not download the AI model ({exc.__class__.__name__}).",
             hint="Check your connection and run: reverse3d offline prepare",
         ) from exc
 
@@ -201,7 +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.
     """
-    models = [_default_model()]
+    from reverse3d.vision.classifier import DEFAULT_CLASSIFIER
+    from reverse3d.vision.segmenter import 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]
 
@@ -274,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 = {
@@ -287,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.6.0 → reverse3d-0.8.0}/reverse3d/recipes.py

@@ -36,6 +36,7 @@ from reverse3d.errors import (
     DependencyMissingError,
     InputValidationError,
     ProcessingError,
+    Reverse3DError,
 )
 from reverse3d.hardware import torch_device, wants_gpu
 from reverse3d.profiles import profile_values
@@ -74,6 +75,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.
@@ -155,15 +159,20 @@ def _clean(
 
 
 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",
@@ -193,6 +202,36 @@ def _measure(run: _Run, mesh: Path) -> MeshStats:
 _MIN_GROUP = 8
 
 
+_DEFAULT_LOOK = {
+    "object": "studio",
+    "character": "portrait",
+    "architecture": "architecture",
+    "landscape": "aerial",
+}
+
+
+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,
@@ -203,9 +242,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:
@@ -218,6 +259,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()
@@ -262,6 +305,19 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     upright = False
     if silhouette:
         from reverse3d.reconstruction.silhouette import visual_hull
+        from reverse3d.vision.segmenter import ObjectSegmenter
+
+        def load_segmenter() -> ObjectSegmenter | None:
+            # The AI segmenter keeps dark caps, handles and thin parts; without it
+            # (no AI extra, or offline before the first download) GrabCut is used.
+            try:
+                return ObjectSegmenter(run.settings, device=torch_device(run.settings))
+            except Reverse3DError as exc:
+                logger.info("AI segmentation unavailable (%s); using GrabCut", exc.message)
+                run.warnings.append(
+                    "AI segmentation unavailable: thin or dark parts may be missing."
+                )
+                return None
 
         try:
             hull = run.step(
@@ -270,6 +326,7 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
                     Path(photo.images_dir or ""),
                     Path(photo.sparse_text_dir or ""),
                     run.out / "reconstruction" / "object_hull.ply",
+                    segmenter=load_segmenter,
                 ),
             )
         except ProcessingError as exc:
@@ -307,6 +364,11 @@ 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)
 
 
@@ -495,7 +557,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.6.0 → reverse3d-0.8.0}/reverse3d/reconstruction/silhouette.py

@@ -23,6 +23,7 @@ from __future__ import annotations
 import logging
 from dataclasses import asdict, dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import cv2
 import numpy as np
@@ -30,6 +31,11 @@ import trimesh
 
 from reverse3d.errors import DependencyMissingError, ProcessingError
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from reverse3d.vision.segmenter import ObjectSegmenter
+
 logger = logging.getLogger(__name__)
 
 _WORK_SIDE = 640
@@ -62,6 +68,7 @@ class HullResult:
     voxels: int
     faces: int
     support_plane: bool
+    ai_segmentation: bool = False
 
     def to_dict(self) -> dict[str, object]:
         return asdict(self)
@@ -184,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,
@@ -191,6 +257,7 @@ def visual_hull(
     *,
     resolution: int = 176,
     refinements: int = 3,
+    segmenter: Callable[[], ObjectSegmenter | None] | None = None,
 ) -> HullResult:
     """Carve the object seen by every photo; writes a watertight, upright mesh.
 
@@ -269,6 +336,36 @@ def visual_hull(
         return (seen >= 3) & (votes >= seen - tolerance)
 
     keep = carve(masks, 2)
+    # The AI segmenter is only loaded (or downloaded) once the photos proved usable.
+    ai = segmenter() if segmenter is not None else None
+    if ai is not None:
+        # AI segmentation: a box around the projected hull (taller upwards, where caps
+        # and handles get lost) and a point on it. Two rounds, each from the new hull.
+        states = [ai.embed(cv2.cvtColor(small, cv2.COLOR_BGR2RGB)) for small, _ in images]
+        for _ in range(2):
+            ai_masks: list[np.ndarray] = []
+            for state, (small, _), (u, v, inside), old in zip(
+                states, images, projections, masks, strict=True
+            ):
+                sel = keep & inside
+                if not sel.any():
+                    ai_masks.append(old)
+                    continue
+                us, vs = u[sel], v[sel]
+                x0, x1 = int(us.min()), int(us.max())
+                y0, y1 = int(vs.min()), int(vs.max())
+                pad_x, pad_y = 0.15 * (x1 - x0 + 1), 0.15 * (y1 - y0 + 1)
+                box = (
+                    max(0, int(x0 - pad_x)),
+                    max(0, int(y0 - 2.5 * pad_y)),
+                    min(small.shape[1] - 1, int(x1 + pad_x)),
+                    min(small.shape[0] - 1, int(y1 + pad_y)),
+                )
+                point = (int(np.median(us)), int(np.median(vs)))
+                ai_masks.append(ai.segment(state, box, point))
+            masks = ai_masks
+            keep = carve(masks, 1)
+        refinements = 0
     for _ in range(refinements):
         refined: list[np.ndarray] = []
         for (small, _), (u, v, inside), old in zip(images, projections, masks, strict=True):
@@ -294,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.")
@@ -318,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)
@@ -333,4 +437,6 @@ def visual_hull(
     output_path.parent.mkdir(parents=True, exist_ok=True)
     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)
+    return HullResult(
+        str(output_path), len(views), voxels, len(mesh.faces), plane is not None, ai is not None
+    )

{reverse3d-0.6.0 → reverse3d-0.8.0}/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.6.0 → reverse3d-0.8.0}/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.6.0 → reverse3d-0.8.0}/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,
     )