reverse3d 0.4.0__tar.gz → 0.5.0__tar.gz

{reverse3d-0.4.0/reverse3d.egg-info → reverse3d-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.4.0
+Version: 0.5.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>
@@ -33,6 +33,7 @@ Requires-Dist: numpy>=1.26
 Requires-Dist: scipy>=1.11
 Requires-Dist: opencv-python-headless>=4.9
 Requires-Dist: pillow>=10.3
+Requires-Dist: pillow-heif>=1.1
 Requires-Dist: trimesh>=4.4
 Requires-Dist: shapely>=2.0
 Requires-Dist: mapbox-earcut>=1.0
@@ -422,7 +423,7 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 | 🛰️ **Piloto automático** | Detección de la entrada, reintentos inteligentes, carpeta vigilada, `RESUMEN.md` | Reglas deterministas, sin IA |
 | 🔌 **Offline** | Detección de conexión, cambio automático, modelos fijados por revisión | `~/.reverse3d/models` |
 
-**Formatos:** imágenes `png jpg jpeg tif tiff bmp webp` · mallas `stl obj ply glb gltf off` · nubes `ply xyz pcd`.
+**Formatos:** imágenes `png jpg jpeg tif tiff bmp webp`, y fotos de iPhone `heic heif` (se convierten a JPEG conservando el EXIF) · mallas `stl obj ply glb gltf off` · nubes `ply xyz pcd`.
 
 ---
 

{reverse3d-0.4.0 → reverse3d-0.5.0}/README.md

@@ -356,7 +356,7 @@ Si las fotos están borrosas o falta una herramienta, **no reintenta en vano**:
 | 🛰️ **Piloto automático** | Detección de la entrada, reintentos inteligentes, carpeta vigilada, `RESUMEN.md` | Reglas deterministas, sin IA |
 | 🔌 **Offline** | Detección de conexión, cambio automático, modelos fijados por revisión | `~/.reverse3d/models` |
 
-**Formatos:** imágenes `png jpg jpeg tif tiff bmp webp` · mallas `stl obj ply glb gltf off` · nubes `ply xyz pcd`.
+**Formatos:** imágenes `png jpg jpeg tif tiff bmp webp`, y fotos de iPhone `heic heif` (se convierten a JPEG conservando el EXIF) · mallas `stl obj ply glb gltf off` · nubes `ply xyz pcd`.
 
 ---
 

{reverse3d-0.4.0 → reverse3d-0.5.0}/pyproject.toml

@@ -41,6 +41,7 @@ dependencies = [
     "scipy>=1.11",
     "opencv-python-headless>=4.9",
     "pillow>=10.3",
+    "pillow-heif>=1.1",
     "trimesh>=4.4",
     "shapely>=2.0",
     "mapbox-earcut>=1.0",

reverse3d-0.5.0/reverse3d/_version.py

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

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/autopilot.py

@@ -8,8 +8,11 @@ rules, no AI model), so it works the same offline and on any machine:
    silhouette, a single photo, a mesh or a point cloud.
 2. It runs the matching recipe and retries only when another setting can fix
    the failure (another mask method, higher photogrammetry quality, stronger
-   mesh repair). Problems that need the user (blurry photos, a missing tool)
-   stop immediately with a clear hint.
+   mesh repair). Problems that need the user (a missing tool, an unreadable
+   input) stop immediately with a clear hint.
+   When a photo set cannot be reconstructed (photos that do not overlap,
+   shiny or changing surfaces...), it still delivers a model: an AI-depth
+   relief of the best photo, flagged as approximate, plus capture advice.
 3. It writes ``RESUMEN.md``: what was detected, sizes, files and next steps.
 """
 
@@ -32,8 +35,15 @@ from reverse3d.errors import (
     ProcessingError,
     Reverse3DError,
 )
+from reverse3d.imaging import prepare_heic_input
 from reverse3d.recipes import MaskMethod, RecipeOptions, run_recipe
-from reverse3d.security import IMAGE_EXTENSIONS, MESH_EXTENSIONS, POINT_CLOUD_EXTENSIONS
+from reverse3d.security import (
+    HEIC_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    MESH_EXTENSIONS,
+    POINT_CLOUD_EXTENSIONS,
+    list_images,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -124,7 +134,7 @@ def detect_input(path: str | Path) -> Detection:
     src = Path(path).expanduser()
     if src.is_dir():
         files = [p for p in sorted(src.iterdir()) if p.is_file() and _visible(p)]
-        images = [p for p in files if p.suffix.lower() in IMAGE_EXTENSIONS]
+        images = [p for p in files if p.suffix.lower() in IMAGE_EXTENSIONS | HEIC_EXTENSIONS]
         meshes = [p for p in files if p.suffix.lower() in MESH_EXTENSIONS | POINT_CLOUD_EXTENSIONS]
         if len(images) >= _MIN_PHOTOS:
             return Detection(
@@ -195,6 +205,112 @@ def _mesh_from_points(detection: Detection, out: Path, settings: Settings, overw
     return target
 
 
+def _nearer_part(mask: np.ndarray, disparity: np.ndarray) -> np.ndarray:
+    """Keep the part of ``mask`` that stands out from the surface (the object,
+    not the desk, pad or light glow around it): Otsu split of its height."""
+    inside = mask > 0
+    if inside.sum() < 100 or (~inside).sum() < 100:
+        return mask
+    from reverse3d.reconstruction.depth_estimation import height_above_support
+
+    height = height_above_support(mask, disparity)
+    values = height[inside]
+    lo, hi = float(np.percentile(values, 1)), float(np.percentile(values, 99))
+    if hi - lo < 1e-6:
+        return mask
+    scaled = ((height - lo) / (hi - lo) * 255).clip(0, 255).astype(np.uint8)
+    threshold, _ = cv2.threshold(
+        scaled[inside].reshape(-1, 1), 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+    near: np.ndarray = np.where(inside & (scaled > threshold), 255, 0).astype(np.uint8)
+    near = cv2.morphologyEx(near, cv2.MORPH_OPEN, np.ones((7, 7), np.uint8))
+    count, labels, stats, _ = cv2.connectedComponentsWithStats(near)
+    if count <= 1:
+        return mask
+    largest = 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA]))
+    near = np.where(labels == largest, 255, 0).astype(np.uint8)
+    contours, _ = cv2.findContours(near, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    filled = np.zeros_like(near)
+    cv2.drawContours(filled, contours, -1, 255, thickness=cv2.FILLED)
+    # A tiny blob means the split failed (a flat object): keep the first mask.
+    return filled if filled.sum() >= 0.2 * inside.sum() * 255 else mask
+
+
+def _best_photo(folder: Path, out: Path, settings: Settings) -> tuple[Path, Path | None]:
+    """Photo for the fallback relief, and a mask that isolates the object in it.
+
+    Every photo gets a quick GrabCut; the one where the object looks largest,
+    whole and sharp wins. Its mask is then refined at higher resolution and
+    trimmed with the AI depth so the desk and background stay out of the relief.
+    """
+    from reverse3d.hardware import torch_device
+    from reverse3d.imaging import downscale, load_image, save_image
+    from reverse3d.reconstruction.depth_estimation import predict_depth
+    from reverse3d.vision.mask_extractor import foreground_mask, mask_score
+
+    images = list_images(folder, max_images=settings.max_images, max_bytes=settings.max_input_bytes)
+    best: tuple[float, Path] | None = None
+    for path in images:
+        small, _ = downscale(load_image(path, settings), 320)
+        gray = cv2.cvtColor(small, cv2.COLOR_BGR2GRAY)
+        sharp = min(float(cv2.Laplacian(gray, cv2.CV_64F).var()) / 300.0, 1.0)
+        try:
+            score = mask_score(foreground_mask(small, work_side=320)) * (0.5 + 0.5 * sharp)
+        except cv2.error:
+            score = 0.1 * sharp
+        if best is None or score > best[0]:
+            best = (score, path)
+    if best is None:  # pragma: no cover - detect_input guarantees photos
+        raise ProcessingError("No photo available for the fallback relief.")
+    score, photo = best
+    if score < 0.15:
+        return photo, None  # no clear object: keep the whole photo
+
+    full = load_image(photo, settings)
+    work, _ = downscale(full, 800)
+    mask = foreground_mask(work, work_side=800)
+    try:
+        rgb = cv2.cvtColor(work, cv2.COLOR_BGR2RGB)
+        mask = _nearer_part(
+            mask, predict_depth(rgb, device=torch_device(settings), settings=settings)
+        )
+    except Reverse3DError as exc:  # depth model unavailable: the GrabCut mask still helps
+        logger.info("Depth refinement of the fallback mask skipped: %s", exc.message)
+    mask = cv2.erode(mask, np.ones((3, 3), np.uint8))
+    mask = cv2.resize(mask, (full.shape[1], full.shape[0]), interpolation=cv2.INTER_NEAREST)
+    return photo, save_image(mask, out / "fallback_mask.png", overwrite=True)
+
+
+def _relief_fallback(
+    source: Path,
+    out: Path,
+    settings: Settings,
+    base: RecipeOptions,
+    reason: str,
+    history: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Photogrammetry was not possible: build an approximate model from the best photo."""
+    photo, mask = _best_photo(source, out, settings)
+    logger.info("Photogrammetry not possible; building an AI-depth relief from %s", photo.name)
+    summary = run_recipe(
+        "photo_to_relief",
+        photo,
+        out,
+        settings,
+        replace(base, overwrite=True, mask_path=str(mask) if mask else None),
+    )
+    if mask:
+        summary["outputs"]["mask"] = str(mask)
+    history.append({"attempt": f"fallback=photo_to_relief ({photo.name})", "ok": True})
+    summary["warnings"] = [
+        "A full 3D model could not be reconstructed from these photos "
+        f"({reason}). This is an approximate relief from the best photo, {photo.name}.",
+        *summary.get("warnings", []),
+    ]
+    summary["fallback"] = {"from": "photos_to_model", "photo": str(photo), "reason": reason}
+    return summary
+
+
 def auto_run(
     input_path: str | Path,
     output_dir: str | Path,
@@ -212,6 +328,8 @@ def auto_run(
         Reverse3DError: every attempt failed (the last error is raised).
     """
     base = options or RecipeOptions()
+    # iPhone photos (HEIC) are converted to JPEG first; other inputs pass through.
+    input_path = prepare_heic_input(input_path, output_dir)
     detection = detect_input(input_path)
     if detection.recipe is None:
         raise InputValidationError(
@@ -228,10 +346,17 @@ def auto_run(
     history: list[dict[str, Any]] = []
     summary: dict[str, Any] | None = None
     last_error: Reverse3DError | None = None
+    capture_advice: list[str] = []
     for attempt in _attempt_plan(detection, base):
         try:
             summary = run_recipe(detection.recipe, source, out, settings, attempt.options)
-        except (CaptureQualityError, DependencyMissingError, InputValidationError) as exc:
+        except CaptureQualityError as exc:
+            history.append({"attempt": attempt.label, "ok": False, "error": exc.message})
+            if detection.kind != "photos":
+                raise
+            last_error = exc
+            break  # better settings will not fix the capture: go to the fallback
+        except (DependencyMissingError, InputValidationError) as exc:
             history.append({"attempt": attempt.label, "ok": False, "error": exc.message})
             raise  # the user has to act: retrying with other settings will not help
         except (ProcessingError, ExternalToolError) as exc:
@@ -261,11 +386,26 @@ def auto_run(
                     summary = stronger
         break
 
+    if summary is None and detection.kind == "photos" and last_error is not None:
+        reason = last_error.message.split(":", 1)[0].rstrip(".")
+        capture_advice = [
+            "Para un modelo 3D completo: 30-60 fotos en orden alrededor del objeto, sin moverlo, "
+            "con luz pareja y sin reflejos (las luces RGB apagadas; en superficies brillantes, "
+            "spray mate o talco).",
+        ]
+        try:
+            summary = _relief_fallback(source, out, settings, base, reason, history)
+        except Reverse3DError as exc:
+            logger.warning("Relief fallback failed: %s", exc.message)
+            history.append(
+                {"attempt": "fallback=photo_to_relief", "ok": False, "error": exc.message}
+            )
+            raise last_error from exc
     if summary is None:
         raise last_error or ProcessingError("No processing attempt could run.")
 
     summary["auto"] = {"detected": detection.to_dict(), "attempts": history}
-    summary["next_steps"] = next_steps(detection, summary, base)
+    summary["next_steps"] = capture_advice + next_steps(detection, summary, base)
     summary["outputs"]["summary"] = str(write_summary(out, detection, summary))
     return summary
 
@@ -288,11 +428,12 @@ def next_steps(detection: Detection, summary: dict[str, Any], options: RecipeOpt
             "Las medidas están en píxeles: indica la escala con --units-per-pixel "
             "para tener medidas reales."
         )
-    if detection.kind == "photo":
+    relief = detection.kind == "photo" or "fallback" in summary
+    if relief:
         steps.append(
             "La profundidad con IA es relativa: usa --scale si necesitas un tamaño concreto."
         )
-    if detection.kind == "photo":
+    if relief:
         steps.append(
             "Un relieve es una superficie abierta: dale grosor en tu programa 3D "
             "si lo vas a imprimir."

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/imaging.py

@@ -8,6 +8,8 @@ paths work on Windows (``cv2.imread`` does not support them).
 
 from __future__ import annotations
 
+import logging
+import shutil
 from pathlib import Path
 
 import cv2
@@ -16,7 +18,14 @@ from PIL import Image
 
 from reverse3d.config import Settings
 from reverse3d.errors import InputValidationError, ProcessingError
-from reverse3d.security import IMAGE_EXTENSIONS, prepare_output_file, validate_input_file
+from reverse3d.security import (
+    HEIC_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    prepare_output_file,
+    validate_input_file,
+)
+
+logger = logging.getLogger(__name__)
 
 
 def check_image_header(path: Path, max_pixels: int) -> tuple[int, int]:
@@ -77,3 +86,55 @@ def downscale(image: np.ndarray, max_dim: int) -> tuple[np.ndarray, float]:
     scale = max_dim / longest
     resized = cv2.resize(image, (round(w * scale), round(h * scale)), interpolation=cv2.INTER_AREA)
     return resized, scale
+
+
+def _heic_to_jpeg(src: Path, dst: Path) -> Path:
+    """Decode one HEIC/HEIF photo and save it as JPEG, keeping its EXIF (focal length)."""
+    import pillow_heif
+
+    pillow_heif.register_heif_opener()
+    try:
+        with Image.open(src) as image:
+            exif = image.info.get("exif")
+            rgb = image.convert("RGB")
+            kwargs: dict[str, object] = {"quality": 95}
+            if exif:
+                kwargs["exif"] = exif
+            rgb.save(dst, "JPEG", **kwargs)
+    except Exception as exc:  # pillow-heif raises several error types
+        raise InputValidationError(f"Could not read the HEIC photo {src.name}: {exc}") from exc
+    return dst
+
+
+def prepare_heic_input(path: str | Path, work_dir: str | Path) -> Path:
+    """Return ``path`` ready for OpenCV and COLMAP, converting HEIC/HEIF photos to JPEG.
+
+    A HEIC file becomes ``work_dir/photos_jpg/<name>.jpg``; a folder with HEIC
+    photos becomes ``work_dir/photos_jpg`` holding the converted photos plus the
+    other images. Inputs without HEIC are returned unchanged.
+    """
+    src = Path(path).expanduser()
+    if src.is_file() and src.suffix.lower() not in HEIC_EXTENSIONS:
+        return src
+    if src.is_dir():
+        files = [p for p in sorted(src.iterdir()) if p.is_file() and not p.name.startswith(".")]
+        if not any(p.suffix.lower() in HEIC_EXTENSIONS for p in files):
+            return src
+    elif not src.is_file():
+        return src
+    target = Path(work_dir).expanduser() / "photos_jpg"
+    target.mkdir(parents=True, exist_ok=True)
+    if src.is_file():
+        return _heic_to_jpeg(src, target / f"{src.stem}.jpg")
+    converted = 0
+    for item in files:
+        ext = item.suffix.lower()
+        if ext in HEIC_EXTENSIONS:
+            out = target / f"{item.stem}.jpg"
+            if not out.exists():
+                _heic_to_jpeg(item, out)
+            converted += 1
+        elif ext in IMAGE_EXTENSIONS and not (target / item.name).exists():
+            shutil.copy2(item, target / item.name)
+    logger.info("Converted %d HEIC photo(s) to JPEG", converted)
+    return target

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/recipes.py

@@ -23,6 +23,8 @@ from __future__ import annotations
 
 import json
 import logging
+import math
+import shutil
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -71,6 +73,8 @@ class RecipeOptions:
     overwrite: bool = False
     #: plan_to_part: how the drawing is separated from the background.
     mask_method: MaskMethod = "otsu"
+    #: 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.
     repair: Literal["normal", "strong"] = "normal"
 
@@ -184,13 +188,33 @@ def _measure(run: _Run, mesh: Path) -> MeshStats:
 # ─── recipes ──────────────────────────────────────────────────────────────────
 
 
+# Smallest overlapping group worth reconstructing when the rest of a set does not match.
+_MIN_GROUP = 8
+
+
 def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.reconstruction.photogrammetry import PhotogrammetryOptions, run_photogrammetry
     from reverse3d.vision.feature_matcher import analyze_image_set
 
     analysis = run.step("analyze", lambda: analyze_image_set(src, run.settings))
     run.details["analysis"] = analysis.to_dict()
-    if not analysis.suitable_for_photogrammetry:
+    if not analysis.suitable_for_photogrammetry and analysis.connected_images >= _MIN_GROUP:
+        # Part of the set overlaps well: reconstruct from that group only.
+        dropped = set(analysis.weak_links)
+        group_dir = run.out / "photos_used"
+        group_dir.mkdir(parents=True, exist_ok=True)
+        for image in sorted(src.iterdir()):
+            if image.is_file() and image.name not in dropped and not image.name.startswith("."):
+                target = group_dir / image.name
+                if not target.exists():
+                    shutil.copy2(image, target)
+        run.warnings.append(
+            f"Used the {analysis.connected_images} photos that overlap; skipped "
+            f"{len(dropped)} that do not match the rest."
+        )
+        run.details["photos_used"] = analysis.connected_images
+        src = group_dir
+    elif not analysis.suitable_for_photogrammetry:
         if not opt.force_analysis:
             raise CaptureQualityError(
                 "The photo set is not suitable for photogrammetry: "
@@ -290,9 +314,24 @@ def _scan_to_cad(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     return stats
 
 
+# A relief mesh has one vertex per sampled pixel: keep phone photos (12+ MP) light.
+_RELIEF_MAX_VERTICES = 500_000
+
+
+def _relief_stride(src: Path, minimum: int) -> int:
+    """Pixel step so the relief stays under ``_RELIEF_MAX_VERTICES`` vertices."""
+    from PIL import Image
+
+    with Image.open(src) as image:
+        width, height = image.size
+    return max(minimum, math.ceil(math.sqrt(width * height / _RELIEF_MAX_VERTICES)))
+
+
 def _photo_to_relief(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
     from reverse3d.reconstruction.depth_estimation import estimate_depth
 
+    stride = _relief_stride(src, profile_values(run.settings).depth_stride)
+
     depth = run.step(
         "depth",
         lambda: estimate_depth(
@@ -300,15 +339,43 @@ def _photo_to_relief(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
             run.out / "depth",
             run.settings,
             device=torch_device(run.settings),
-            stride=profile_values(run.settings).depth_stride,
+            stride=stride,
+            mask_path=opt.mask_path,
             overwrite=opt.overwrite,
         ),
     )
     run.details["depth"] = depth.to_dict()
+    model = run.out / "model.stl"
+    if opt.mask_path:
+        # The object is isolated: build a closed solid standing on its surface.
+        import numpy as np
+
+        from reverse3d.imaging import load_image
+        from reverse3d.mesh_io import save_mesh
+        from reverse3d.reconstruction.depth_estimation import object_solid
+
+        disparity = np.load(depth.depth_npy_path, allow_pickle=False)
+        mask = load_image(opt.mask_path, run.settings, flags=0)
+        solid = run.step("solid", lambda: object_solid(disparity, mask, stride=stride))
+        solid_path = save_mesh(solid, run.out / "depth" / "object_solid.ply", overwrite=True)
+        run.warnings.append(
+            "Single-photo model: the hidden side is flat and the height is estimated, "
+            "so proportions are approximate."
+        )
+        _clean(
+            run,
+            Path(solid_path),
+            model,
+            scale=opt.scale,
+            overwrite=opt.overwrite,
+            fill_holes=True,
+            align="obb",
+            keep_largest=True,
+        )
+        return _measure(run, model)
     run.warnings.append("Monocular depth is relative: shape is approximate, not metric.")
     if depth.mesh_path is None:  # pragma: no cover - make_mesh is always on here
         raise ProcessingError("Depth estimation produced no mesh.")
-    model = run.out / "model.stl"
     _clean(
         run,
         Path(depth.mesh_path),
@@ -366,7 +433,12 @@ def run_recipe(
     out = prepare_output_dir(output_dir)
     run = _Run(recipe=recipe, settings=settings, out=out)
     start = time.perf_counter()
-    stats = _RECIPES[recipe](run, Path(input_path), opt)
+    source = Path(input_path)
+    if recipe != "scan_to_cad" and recipe != "mesh_report":
+        from reverse3d.imaging import prepare_heic_input
+
+        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)
 

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/reconstruction/depth_estimation.py

@@ -29,7 +29,7 @@ import numpy as np
 import trimesh
 
 from reverse3d.config import Settings
-from reverse3d.errors import DependencyMissingError, InputValidationError
+from reverse3d.errors import DependencyMissingError, InputValidationError, ProcessingError
 from reverse3d.imaging import load_image, save_image
 from reverse3d.mesh_io import save_mesh
 from reverse3d.security import prepare_output_dir, prepare_output_file
@@ -261,3 +261,101 @@ def estimate_depth(
         height=h,
         mesh_faces=faces,
     )
+
+
+def height_above_support(mask: np.ndarray, disparity: np.ndarray) -> np.ndarray:
+    """Disparity minus the plane fitted to the surface around the object.
+
+    Photos look down at an angle, so the desk itself gets nearer towards the
+    bottom of the frame; removing that plane leaves how much each pixel stands
+    out from the surface the object rests on.
+    """
+    h, w = disparity.shape
+    ring = cv2.dilate(mask, np.ones((41, 41), np.uint8)) > 0
+    around = ring & (mask == 0)
+    if around.sum() < 200:
+        around = mask == 0
+    ys, xs = np.nonzero(around)
+    step = max(1, len(xs) // 20000)
+    xs, ys = xs[::step], ys[::step]
+    design = np.column_stack([xs, ys, np.ones_like(xs)]).astype(np.float64)
+    coeffs, *_ = np.linalg.lstsq(design, disparity[ys, xs].astype(np.float64), rcond=None)
+    grid_y, grid_x = np.mgrid[0:h, 0:w]
+    plane = coeffs[0] * grid_x + coeffs[1] * grid_y + coeffs[2]
+    return disparity - plane
+
+
+def object_solid(
+    disparity: np.ndarray,
+    mask: np.ndarray,
+    *,
+    stride: int = 4,
+    height_ratio: float = 0.35,
+    smooth_px: int = 9,
+) -> trimesh.Trimesh:
+    """Closed, printable solid of the object in a photo: smoothed height above
+    the surface it rests on, a flat base and side walls.
+
+    ``height_ratio`` sets the tallest point relative to the object's longest
+    side (single-photo depth has no scale; 0.35 suits most hand-held objects).
+
+    Raises:
+        ProcessingError: the mask is empty or the object has no height.
+    """
+    inside = mask > 0
+    if inside.sum() < 100:
+        raise ProcessingError("The object mask is empty.")
+    k = smooth_px | 1
+    height = height_above_support(np.where(inside, 255, 0).astype(np.uint8), disparity)
+    weights = inside.astype(np.float32)
+    num = cv2.GaussianBlur(np.where(inside, height, 0).astype(np.float32), (k, k), 0)
+    den = cv2.GaussianBlur(weights, (k, k), 0)
+    height = np.where(inside, num / np.maximum(den, 1e-6), 0)
+    # Smooth outline: no jagged pixel stairs on the side walls.
+    outline = cv2.GaussianBlur(weights * 255, (2 * k + 1, 2 * k + 1), 0) > 127
+    h = height[::stride, ::stride]
+    keep = outline[::stride, ::stride]
+    if keep.sum() < 16:
+        raise ProcessingError("The object is too small in the photo.")
+    h = np.clip(h - np.percentile(h[keep], 2), 0, None)
+    peak = float(h[keep].max())
+    if peak <= 0:
+        raise ProcessingError("The object shows no height above its surface.")
+    ys, xs = np.nonzero(keep)
+    extent = float(max(np.ptp(xs), np.ptp(ys)) + 1)
+    z = h / peak * height_ratio * extent
+    # Round the outline: height eases to a low rim instead of a vertical cliff.
+    rim = cv2.distanceTransform(keep.astype(np.uint8), cv2.DIST_L2, 5)
+    z = z * (0.15 + 0.85 * np.sqrt(np.clip(rim / (0.08 * extent), 0.0, 1.0)))
+
+    index = -np.ones(keep.shape, dtype=np.int64)
+    index[keep] = np.arange(int(keep.sum()))
+    # A thin base slab keeps the top and bottom apart everywhere (closed solid).
+    base = 0.03 * extent
+    top = np.column_stack([xs, -ys, z[ys, xs] + base]).astype(np.float64)
+    bottom = top.copy()
+    bottom[:, 2] = 0.0
+    a, b = index[:-1, :-1], index[:-1, 1:]
+    c, d_ = index[1:, :-1], index[1:, 1:]
+    ok = (a >= 0) & (b >= 0) & (c >= 0) & (d_ >= 0)
+    a, b, c, d_ = a[ok], b[ok], c[ok], d_[ok]
+    top_faces = np.vstack([np.column_stack([a, c, b]), np.column_stack([b, c, d_])])
+    n = len(top)
+    bottom_faces = top_faces[:, ::-1] + n
+    edges = np.vstack([top_faces[:, [0, 1]], top_faces[:, [1, 2]], top_faces[:, [2, 0]]])
+    _, inverse, counts = np.unique(
+        np.sort(edges, axis=1), axis=0, return_inverse=True, return_counts=True
+    )
+    border = edges[counts[inverse.ravel()] == 1]
+    walls = np.vstack(
+        [
+            np.column_stack([border[:, 1], border[:, 0], border[:, 0] + n]),
+            np.column_stack([border[:, 1], border[:, 0] + n, border[:, 1] + n]),
+        ]
+    )
+    solid = trimesh.Trimesh(
+        np.vstack([top, bottom]), np.vstack([top_faces, bottom_faces, walls]), process=True
+    )
+    solid.remove_unreferenced_vertices()
+    trimesh.repair.fix_normals(solid)
+    return solid

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/reconstruction/photogrammetry.py

@@ -59,6 +59,11 @@ _PRESETS: dict[str, dict[str, int]] = {
     "high": {"max_image_size": 3200, "max_features": 16384, "poisson_depth": 10},
 }
 
+# Below these, the sparse model is too thin for a usable surface: stop before the
+# (slow) dense stage so the caller can fall back to something better.
+_MIN_REGISTERED = 5
+_MIN_SPARSE_POINTS = 1000
+
 # Above this many images exhaustive matching (O(n²)) becomes impractical.
 _EXHAUSTIVE_LIMIT = 150
 
@@ -335,6 +340,12 @@ class ColmapPipeline:
                 best, best_stats = model, stats
         result.sparse_model_dir = str(best)
         result.registered_images, result.sparse_points = best_stats
+        if result.registered_images < _MIN_REGISTERED or result.sparse_points < _MIN_SPARSE_POINTS:
+            raise ProcessingError(
+                f"COLMAP placed {result.registered_images}/{len(images)} photos with only "
+                f"{result.sparse_points} 3D points: too little for a reliable model.",
+                hint="More overlap, a still object, even light and matte surfaces are needed.",
+            )
         if result.registered_images and result.registered_images < len(images) * 0.5:
             result.warnings.append(
                 f"Only {result.registered_images}/{len(images)} images were registered."

{reverse3d-0.4.0 → reverse3d-0.5.0}/reverse3d/security.py

@@ -34,6 +34,8 @@ from reverse3d.errors import (
 logger = logging.getLogger(__name__)
 
 IMAGE_EXTENSIONS = frozenset({".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp"})
+#: iPhone / modern camera photos; converted to JPEG before processing.
+HEIC_EXTENSIONS = frozenset({".heic", ".heif"})
 MESH_EXTENSIONS = frozenset({".stl", ".obj", ".ply", ".glb", ".gltf", ".off"})
 POINT_CLOUD_EXTENSIONS = frozenset({".ply", ".xyz", ".pcd"})
 JSON_EXTENSIONS = frozenset({".json"})