reverse3d 0.11.0__tar.gz → 0.11.2__tar.gz

{reverse3d-0.11.0/reverse3d.egg-info → reverse3d-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.11.0
+Version: 0.11.2
 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.11.2/reverse3d/_version.py

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

{reverse3d-0.11.0 → reverse3d-0.11.2}/reverse3d/recipes.py

@@ -442,6 +442,13 @@ def _photos_to_model(run: _Run, src: Path, opt: RecipeOptions) -> MeshStats:
             mesh_path = photo.mesh_path
         else:
             run.details["silhouette"] = hull.to_dict()
+            if hull.unreliable:
+                names = ", ".join(Path(n).stem for n in hull.unreliable[:5])
+                more = "…" if len(hull.unreliable) > 5 else ""
+                run.warnings.append(
+                    f"{len(hull.unreliable)} photo(s) did not match the rest and were "
+                    f"down-weighted: {names}{more}. Retake them if the object moved."
+                )
             mesh_path = hull.mesh_path
             upright = True
             hull_world = hull.to_world

{reverse3d-0.11.0 → reverse3d-0.11.2}/reverse3d/reconstruction/silhouette.py

@@ -22,7 +22,9 @@ from __future__ import annotations
 
 import importlib
 import logging
-from dataclasses import asdict, dataclass
+import os
+from dataclasses import asdict, dataclass, field
+from functools import partial
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -88,6 +90,8 @@ class HullResult:
     to_world: list[list[float]] | None = None
     #: engine that fused the silhouettes: "reverse3d" (open) or "reverse3d-core X.Y"
     engine: str = "reverse3d"
+    #: photos reverse3d-core judged inconsistent with the rest (moved object, bad cut-out)
+    unreliable: list[str] = field(default_factory=list)
 
     def to_dict(self) -> dict[str, object]:
         return asdict(self)
@@ -182,32 +186,246 @@ def _grabcut(
     return np.where((init == cv2.GC_FGD) | (init == cv2.GC_PR_FGD), 255, 0).astype(np.uint8)
 
 
+# Largest pixel coordinate kept in the int16 projections (outside any work image).
+_PIXEL_MAX = 32000
+
+# reverse3d-core weight below which a photo is reported as inconsistent.
+_UNRELIABLE_WEIGHT = 0.3
+
+# A support plane must face the photographer's "up" (phones are held upright).
+_MAX_TABLE_TILT_DEG = 30.0
+_MIN_TABLE_COS = float(np.cos(np.radians(_MAX_TABLE_TILT_DEG)))
+# Sparse points a table needs (a dark slatted table yields few).
+_MIN_TABLE_POINTS = 12
+# The carved hull has an unseen keel under the object, so a real table may cut a
+# fair part of it; a plane cutting more than this is not under the object.
+_MAX_PLANE_CUT = 0.3
+
+
 def _support_plane(
-    points: np.ndarray, center: np.ndarray, radius: float, cameras: np.ndarray
+    points: np.ndarray,
+    center: np.ndarray,
+    radius: float,
+    cameras: np.ndarray,
+    occupied: np.ndarray | None = None,
+    up: np.ndarray | None = None,
 ) -> tuple[np.ndarray, float] | None:
-    """The table under the object: RANSAC plane through nearby sparse points, normal up."""
-    near = points[np.linalg.norm(points - center, axis=1) < 1.2 * radius]
-    if len(near) < 30:
-        return None
+    """The table under the object: RANSAC plane through nearby sparse points, normal up.
+
+    A room offers many planes (floor, walls, a door, chair seats). Candidates are
+    tried from the best supported down; one is the support only if it faces the
+    cameras' mean "up", the object stands on top of it and close to it, and it
+    does not cut through the carved object. Otherwise no plane is used at all.
+    """
+    if occupied is not None and len(occupied):
+        # Around the carved object itself (a tall object's table is far from its centre).
+        lo = occupied.min(axis=0) - 0.5 * radius
+        hi = occupied.max(axis=0) + 0.5 * radius
+        near = points[np.all((points >= lo) & (points <= hi), axis=1)]
+    else:
+        near = points[np.linalg.norm(points - center, axis=1) < 1.2 * radius]
+    if up is not None and occupied is not None and len(occupied) and len(near) >= 30:
+        layer = _table_layer(near, occupied, up, radius)
+        if layer is not None:
+            n, d = layer
+            if np.median(cameras @ n + d) >= 0 and float(center @ n + d) > 0:
+                cut = float(np.mean(occupied @ n + d < 0.015 * radius))
+                if cut <= _MAX_PLANE_CUT:
+                    return n, d
     rng = np.random.default_rng(0)
-    best: tuple[np.ndarray, float, int] | None = None
-    for _ in range(400):
-        s = near[rng.choice(len(near), 3, replace=False)]
-        n = np.cross(s[1] - s[0], s[2] - s[0])
-        norm = np.linalg.norm(n)
-        if norm < 1e-12:
-            continue
-        n /= norm
-        d = -float(n @ s[0])
-        count = int((np.abs(near @ n + d) < 0.01 * radius).sum())
-        if best is None or count > best[2]:
-            best = (n, d, count)
-    if best is None or best[2] < 20:
+    for _ in range(5):
+        if len(near) < 30:
+            return None
+        best: tuple[np.ndarray, float, int] | None = None
+        for _ in range(1500):
+            s = near[rng.choice(len(near), 3, replace=False)]
+            n = np.cross(s[1] - s[0], s[2] - s[0])
+            norm = np.linalg.norm(n)
+            if norm < 1e-12:
+                continue
+            n /= norm
+            d = -float(n @ s[0])
+            # Only roughly horizontal planes compete: walls and doors have far more
+            # points than a dark table and would always win.
+            if up is not None and abs(float(n @ up)) < _MIN_TABLE_COS:
+                continue
+            # ... and only below the object, close to it (not the top of a cap,
+            # a shelf or a chair seat behind it).
+            if np.median(cameras @ n + d) < 0:
+                n, d = -n, -d
+            if float(center @ n + d) < 0.0:
+                continue
+            if occupied is not None and len(occupied):
+                # The object must reach down to it (not a floor far below the table)
+                # and stand on it (not a shelf or a seat at mid height).
+                above = occupied @ n + d
+                if float(np.min(above)) > 0.05 * radius:
+                    continue
+                if float(np.mean(above < 0.015 * radius)) > _MAX_PLANE_CUT:
+                    continue
+            elif float(center @ n + d) > radius:
+                continue
+            count = int((np.abs(near @ n + d) < 0.01 * radius).sum())
+            if best is None or count > best[2]:
+                best = (n, d, count)
+        if best is None or best[2] < _MIN_TABLE_POINTS:
+            return None
+        n, d, _ = best
+        if np.median(cameras @ n + d) < 0:  # cameras are above the table
+            n, d = -n, -d
+        height = float(center @ n + d)
+        tilt = float(np.degrees(np.arccos(np.clip(n @ up, -1.0, 1.0)))) if up is not None else 0.0
+        cut = (
+            float(np.mean(occupied @ n + d < 0.015 * radius))
+            if occupied is not None and len(occupied)
+            else 0.0
+        )
+        reason = (
+            "object below it"
+            if height < 0
+            else "too far below the object"
+            if (occupied is None or not len(occupied)) and height > radius
+            else f"tilted {tilt:.0f} deg from the cameras' up"
+            if tilt > _MAX_TABLE_TILT_DEG
+            else f"it would cut {cut:.0%} of the object"
+            if cut > _MAX_PLANE_CUT
+            else None
+        )
+        if reason is None:
+            return n, d
+        logger.info("Plane rejected as support (%s)", reason)
+        near = near[np.abs(near @ n + d) >= 0.01 * radius]
+    return None
+
+
+# Base completion: the typical cross-section is measured in this band of the
+# object's height, and a complete one is searched for no higher than this.
+_BASE_TYPICAL = (0.2, 0.6)
+_BASE_MAX_SEARCH = 0.4
+
+
+def _complete_base(
+    volume: np.ndarray, grid: np.ndarray, normal: np.ndarray, offset: float, voxel: float
+) -> np.ndarray:
+    """Extend an object standing on a table down to it.
+
+    The lowest band of an object is where cut-outs fail most (a white base on a
+    light table, its reflection, a shadow), leaving a slanted or bitten base. A
+    standing object reaches the table, so the cross-section just above that band
+    is extruded down to the table. Only voxels under that cross-section are added
+    (legs stay legs), and nothing is removed.
+    """
+    occ = volume.reshape(-1) > 0.5
+    if not occ.any():
+        return volume
+    h = grid @ normal + offset
+    top = float(h[occ].max())
+    if top <= 0:
+        return volume
+    # Reference: the lowest cross-section that is already complete (area close to
+    # the typical one of the object's middle), searched upwards from the table.
+    hs = h[occ]
+    edges = np.arange(0.0, top + voxel, voxel)
+    area, _ = np.histogram(hs, edges)
+    mid = (edges[:-1] >= _BASE_TYPICAL[0] * top) & (edges[:-1] < _BASE_TYPICAL[1] * top)
+    if not mid.any():
+        return volume
+    typical = float(np.median(area[mid]))
+    lo = None
+    for k in range(len(area) - 2):
+        if edges[k] > _BASE_MAX_SEARCH * top:
+            break
+        if min(area[k], area[k + 1], area[k + 2]) >= 0.9 * typical:
+            lo = float(edges[k])
+            break
+    if lo is None or lo <= voxel:
+        return volume  # already whole down to the table, or no clean reference
+    ref = occ & (h >= lo) & (h < lo + 3 * voxel)
+    if ref.sum() < 20:
+        return volume
+    helper = np.array([1.0, 0.0, 0.0]) if abs(normal[0]) < 0.9 else np.array([0.0, 1.0, 0.0])
+    e1 = np.cross(normal, helper)
+    e1 /= np.linalg.norm(e1)
+    e2 = np.cross(normal, e1)
+    xy = np.stack([grid @ e1, grid @ e2], axis=1)
+    origin = xy.min(axis=0)
+    ij = np.floor((xy - origin) / voxel).astype(np.int64)
+    footprint = np.zeros(ij.max(axis=0) + 1, bool)
+    footprint[ij[ref, 0], ij[ref, 1]] = True
+    from scipy import ndimage
+
+    footprint = ndimage.binary_closing(footprint, iterations=1)
+    below = (h >= 0) & (h < lo) & footprint[ij[:, 0], ij[:, 1]]
+    added = int((below & ~occ).sum())
+    if added:
+        logger.info("Base completed down to the table (%d voxels)", added)
+    out = volume.reshape(-1).copy()
+    out[below] = 1.0
+    return out.reshape(volume.shape)
+
+
+def _coarse_grabcut(image: np.ndarray, rect: tuple[int, int, int, int]) -> np.ndarray:
+    """GrabCut at half resolution (4x fewer pixels): enough for a first silhouette."""
+    h, w = image.shape[:2]
+    half = cv2.resize(image, (w // 2, h // 2), interpolation=cv2.INTER_AREA)
+    x, y, rw, rh = rect
+    fg = _grabcut(
+        half, np.zeros(half.shape[:2], np.uint8), (x // 2, y // 2, max(2, rw // 2), max(2, rh // 2))
+    )
+    return cv2.resize(fg, (w, h), interpolation=cv2.INTER_NEAREST)
+
+
+def _parallel(jobs: list[Callable[[], np.ndarray]]) -> list[np.ndarray]:
+    """Run per-photo OpenCV jobs on every core (OpenCV releases the GIL)."""
+    from concurrent.futures import ThreadPoolExecutor
+
+    workers = max(1, min(len(jobs), (os.cpu_count() or 2)))
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        return list(pool.map(lambda job: job(), jobs))
+
+
+def _table_layer(
+    near: np.ndarray, occupied: np.ndarray, up: np.ndarray, radius: float
+) -> tuple[np.ndarray, float] | None:
+    """The densest horizontal layer of sparse points just under the object.
+
+    Knowing "up" turns the table search into 1-D: a histogram of point heights
+    around the object's lowest point. The layer is fitted by least squares, which
+    tolerates a slatted or slightly uneven top that thin RANSAC bands miss.
+    """
+    heights = near @ up
+    base = float(np.min(occupied @ up))
+    step = 0.02 * radius
+    edges = np.arange(base - 0.5 * radius, base + 0.3 * radius + step, step)
+    counts, _ = np.histogram(heights, edges)
+    if counts.max(initial=0) < _MIN_TABLE_POINTS:
+        return None
+    peak = int(np.argmax(counts))
+    level = (edges[peak] + edges[peak + 1]) / 2
+    layer = near[np.abs(heights - level) < 2 * step]
+    if len(layer) < _MIN_TABLE_POINTS:
+        return None
+    centre = layer.mean(axis=0)
+    _, _, vt = np.linalg.svd(layer - centre, full_matrices=False)
+    n = vt[2] if vt[2] @ up > 0 else -vt[2]
+    if float(n @ up) < _MIN_TABLE_COS:
+        return None
+    return n, -float(n @ centre)
+
+
+def _box_around(
+    sel: np.ndarray, u: np.ndarray, v: np.ndarray, shape: tuple[int, ...]
+) -> tuple[int, int, int, int] | None:
+    """GrabCut box around the projected voxels ``sel``, with a generous margin."""
+    if sel.sum() < 50:
         return None
-    n, d, _ = best
-    if np.median(cameras @ n + d) < 0:  # cameras are above the table
-        n, d = -n, -d
-    return n, d
+    us, vs = u[sel], v[sel]
+    w, h = int(us.max() - us.min() + 1), int(vs.max() - vs.min() + 1)
+    x0 = max(0, int(us.min() - 0.2 * w))
+    y0 = max(0, int(vs.min() - 0.3 * h))
+    x1 = min(shape[1] - 1, int(us.max() + 0.2 * w))
+    y1 = min(shape[0] - 1, int(vs.max() + 0.3 * h))
+    return x0, y0, max(2, x1 - x0), max(2, y1 - y0)
 
 
 def _vertex_colors(
@@ -459,34 +677,57 @@ def visual_hull(
             )
         )
 
-    # First silhouettes: GrabCut in a box around where the object projects.
-    masks: list[np.ndarray] = []
-    for (small, scale), view in zip(images, views, strict=True):
-        uv, z = _project(center[None], view)
-        if z[0] <= 0:
-            masks.append(np.zeros(small.shape[:2], np.uint8))
-            continue
-        cu, cv_ = uv[0] * scale
-        half = view.camera.fx * scale * 0.6 * radius / z[0]
-        x0, y0 = max(0, int(cu - half)), max(0, int(cv_ - 1.6 * half))
-        x1 = min(small.shape[1] - 1, int(cu + half))
-        y1 = min(small.shape[0] - 1, int(cv_ + 1.6 * half))
-        init = np.zeros(small.shape[:2], np.uint8)
-        rect = (x0, y0, max(2, x1 - x0), max(2, y1 - y0))
-        fg = _grabcut(small, init, rect)
-        masks.append(cv2.morphologyEx(fg, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8)))
-
     n = resolution
-    axis = np.linspace(-radius, radius, n)
-    gx, gy, gz = np.meshgrid(axis, axis, axis, indexing="ij")
-    grid = np.stack([gx.ravel(), gy.ravel(), gz.ravel()], axis=1) + center
-    projections = []
-    for (small, scale), view in zip(images, views, strict=True):
-        uv, z = _project(grid, view)
-        u = np.round(uv[:, 0] * scale).astype(np.int64)
-        v = np.round(uv[:, 1] * scale).astype(np.int64)
-        inside = (z > 0) & (u >= 0) & (v >= 0) & (u < small.shape[1]) & (v < small.shape[0])
-        projections.append((u, v, inside))
+
+    def frame(
+        center: np.ndarray,
+        radius: float,
+        boxes: list[tuple[int, int, int, int] | None] | None = None,
+    ) -> tuple[list[np.ndarray], np.ndarray, list[tuple[np.ndarray, np.ndarray, np.ndarray]]]:
+        """First silhouettes (GrabCut in a box around where the object projects),
+        the voxel grid of the cube center +/- radius and its projection in every photo."""
+        rects: list[tuple[int, int, int, int] | None] = []
+        for i, ((small, scale), view) in enumerate(zip(images, views, strict=True)):
+            if boxes is not None and boxes[i] is not None:
+                rects.append(boxes[i])
+                continue
+            uv, z = _project(center[None], view)
+            if z[0] <= 0:
+                rects.append(None)
+                continue
+            cu, cv_ = uv[0] * scale
+            half = view.camera.fx * scale * 0.6 * radius / z[0]
+            x0, y0 = max(0, int(cu - half)), max(0, int(cv_ - 1.6 * half))
+            x1 = min(small.shape[1] - 1, int(cu + half))
+            y1 = min(small.shape[0] - 1, int(cv_ + 1.6 * half))
+            rects.append((x0, y0, max(2, x1 - x0), max(2, y1 - y0)))
+
+        def cut(small: np.ndarray, rect: tuple[int, int, int, int] | None) -> np.ndarray:
+            if rect is None:
+                return np.zeros(small.shape[:2], np.uint8)
+            fg = _coarse_grabcut(small, rect)
+            return cv2.morphologyEx(fg, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
+
+        masks = _parallel(
+            [partial(cut, small, rect) for (small, _), rect in zip(images, rects, strict=True)]
+        )
+
+        axis = np.linspace(-radius, radius, n)
+        gx, gy, gz = np.meshgrid(axis, axis, axis, indexing="ij")
+        grid = np.stack([gx.ravel(), gy.ravel(), gz.ravel()], axis=1) + center
+        projections = []
+        for (small, scale), view in zip(images, views, strict=True):
+            uv, z = _project(grid, view)
+            # int16 pixel coordinates (work images are at most 640 px): 4x less memory
+            # than int64 for millions of voxels times hundreds of photos.
+            u = np.clip(np.round(uv[:, 0] * scale), -1, _PIXEL_MAX).astype(np.int16)
+            v = np.clip(np.round(uv[:, 1] * scale), -1, _PIXEL_MAX).astype(np.int16)
+            inside = (z > 0) & (u >= 0) & (v >= 0) & (u < small.shape[1]) & (v < small.shape[0])
+            projections.append((u, v, inside))
+
+        return masks, grid, projections
+
+    masks, grid, projections = frame(center, radius)
 
     core = core_engine()
     core_cameras = (
@@ -509,13 +750,19 @@ def visual_hull(
         else None
     )
     engine = f"reverse3d-core {core.__version__}" if core is not None else "reverse3d"
+    core_weights: np.ndarray | None = None
 
     def carve(mask_list: list[np.ndarray], tolerance: int) -> np.ndarray:
-        nonlocal core_cameras, engine
+        nonlocal core_cameras, engine, core_weights
         if core is not None and core_cameras is not None:
             try:
                 binary = [np.where(m > 0, 255, 0).astype(np.uint8) for m in mask_list]
-                prob, _ = core.fuse_cameras(core_cameras, binary, grid)
+                try:  # reverse3d-core >= 0.2: coarse-to-fine on the grid
+                    prob, core_weights = core.fuse_cameras(
+                        core_cameras, binary, grid, grid_shape=(n, n, n)
+                    )
+                except TypeError:
+                    prob, core_weights = core.fuse_cameras(core_cameras, binary, grid)
                 return np.asarray(prob) > 0.5
             except Exception as exc:  # never fail a job because of the optional engine
                 logger.warning("reverse3d-core failed (%s); using the open method", exc)
@@ -534,6 +781,42 @@ def visual_hull(
         return (seen >= 3) & (votes >= seen - allowed)
 
     keep = carve(masks, 2)
+    # The cameras' convergence point is biased when many photos are close-ups of one
+    # part (a cap): if the carved object reaches the edge of the cube, re-centre the
+    # cube on it, enlarge it and start again (masks included, their box depends on it).
+    for _ in range(2):
+        cube = keep.reshape(n, n, n)
+        if not (
+            cube[0].any()
+            or cube[-1].any()
+            or cube[:, 0].any()
+            or cube[:, -1].any()
+            or cube[:, :, 0].any()
+            or cube[:, :, -1].any()
+        ):
+            break
+        occupied = grid[keep]
+        center = (occupied.min(axis=0) + occupied.max(axis=0)) / 2
+        radius *= 1.5
+        logger.info("Object reaches the carving volume's edge: re-centred and enlarged")
+        projections.clear()  # free the previous projections first (gigabytes)
+        masks, grid, projections = frame(center, radius)
+        keep = carve(masks, 2)
+    # The first boxes come from the cameras' convergence point and can crop the object
+    # (its base, when many photos are close-ups of the top). Re-cut every photo inside
+    # a box around where the carved object projects, with margin, while it grows.
+    for _ in range(2):
+        before = int(keep.sum())
+        boxes = [
+            _box_around(keep & inside, u, v, small.shape)
+            for (u, v, inside), (small, _) in zip(projections, images, strict=True)
+        ]
+        projections.clear()  # free the previous projections first (gigabytes)
+        masks, grid, projections = frame(center, radius, boxes)
+        keep = carve(masks, 2)
+        if int(keep.sum()) < 1.05 * before:
+            break
+        logger.info("Object grew to %d voxels with photo boxes around it", int(keep.sum()))
     # 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:
@@ -564,23 +847,30 @@ def visual_hull(
             masks = ai_masks
             keep = carve(masks, 1)
         refinements = 0
+
+    def refine(
+        small: np.ndarray, u: np.ndarray, v: np.ndarray, inside: np.ndarray, old: np.ndarray
+    ) -> np.ndarray:
+        hull: np.ndarray = np.zeros(small.shape[:2], np.uint8)
+        sel = keep & inside
+        hull[v[sel], u[sel]] = 255
+        hull = cv2.morphologyEx(hull, cv2.MORPH_CLOSE, np.ones((9, 9), np.uint8))
+        if not hull.any():
+            return old
+        init = np.full(small.shape[:2], cv2.GC_BGD, np.uint8)
+        init[cv2.dilate(hull, np.ones((25, 25), np.uint8)) > 0] = cv2.GC_PR_BGD
+        init[hull > 0] = cv2.GC_PR_FGD
+        init[cv2.erode(hull, np.ones((21, 21), np.uint8)) > 0] = cv2.GC_FGD
+        fg = _grabcut(small, init, None)
+        return cv2.morphologyEx(fg, cv2.MORPH_OPEN, np.ones((5, 5), np.uint8))
+
     for _ in range(refinements):
-        refined: list[np.ndarray] = []
-        for (small, _), (u, v, inside), old in zip(images, projections, masks, strict=True):
-            hull: np.ndarray = np.zeros(small.shape[:2], np.uint8)
-            sel = keep & inside
-            hull[v[sel], u[sel]] = 255
-            hull = cv2.morphologyEx(hull, cv2.MORPH_CLOSE, np.ones((9, 9), np.uint8))
-            if not hull.any():
-                refined.append(old)
-                continue
-            init = np.full(small.shape[:2], cv2.GC_BGD, np.uint8)
-            init[cv2.dilate(hull, np.ones((25, 25), np.uint8)) > 0] = cv2.GC_PR_BGD
-            init[hull > 0] = cv2.GC_PR_FGD
-            init[cv2.erode(hull, np.ones((21, 21), np.uint8)) > 0] = cv2.GC_FGD
-            fg = _grabcut(small, init, None)
-            refined.append(cv2.morphologyEx(fg, cv2.MORPH_OPEN, np.ones((5, 5), np.uint8)))
-        masks = refined
+        masks = _parallel(
+            [
+                partial(refine, small, u, v, inside, old)
+                for (small, _), (u, v, inside), old in zip(images, projections, masks, strict=True)
+            ]
+        )
         keep = carve(masks, 1)
 
     # Concavities and through-holes (a handle loop, the inside of a cup) never
@@ -607,11 +897,16 @@ def visual_hull(
             )
 
     volume = keep.reshape(n, n, n).astype(np.float32)
-    plane = _support_plane(points, center, radius, cameras)
+    camera_up = -np.mean([view.rotation[1] for view in views], axis=0)
+    camera_up /= np.linalg.norm(camera_up) + 1e-12
+    plane = _support_plane(
+        points, center, radius, cameras, grid[volume.reshape(-1) > 0.5], camera_up
+    )
     if plane is not None:
         normal, offset = plane
         height = (grid @ normal + offset).reshape(n, n, n)
         volume[height < 0.015 * radius] = 0
+        volume = _complete_base(volume, grid, normal, offset, 2 * radius / (n - 1))
     # 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)
@@ -670,4 +965,11 @@ def visual_hull(
         carved_by_depth,
         np.linalg.inv(world_to_model).tolist(),
         engine,
+        [
+            view.name
+            for view, weight in zip(views, core_weights, strict=True)
+            if weight < _UNRELIABLE_WEIGHT
+        ]
+        if core_weights is not None and engine != "reverse3d"
+        else [],
     )

{reverse3d-0.11.0 → reverse3d-0.11.2/reverse3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse3d
-Version: 0.11.0
+Version: 0.11.2
 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.11.0 → reverse3d-0.11.2}/tests/test_silhouette.py

@@ -311,7 +311,9 @@ class _FakeCore:
             ok = np.ones(len(points), bool)
             ok[inside] = mask[v[inside], u[inside]] > 127
             keep &= ok
-        return keep.astype(np.float32), np.ones(len(cameras))
+        weights = np.ones(len(cameras))
+        weights[-1] = 0.1  # the core distrusts the last photo
+        return keep.astype(np.float32), weights
 
 
 def test_the_proprietary_core_fuses_the_silhouettes_when_installed(
@@ -326,6 +328,7 @@ def test_the_proprietary_core_fuses_the_silhouettes_when_installed(
     assert core.calls >= 1
     assert result.engine == "reverse3d-core 9.9.9"
     assert result.voxels > 500
+    assert len(result.unreliable) == 1
 
 
 def test_a_failing_core_falls_back_to_the_open_method(
@@ -339,3 +342,82 @@ def test_a_failing_core_falls_back_to_the_open_method(
     result = visual_hull(images, text, tmp_path / "hull.ply", resolution=48, refinements=1)
     assert core.calls == 1
     assert result.engine == "reverse3d"
+    assert result.unreliable == []
+
+
+def test_a_wall_through_the_object_is_not_taken_for_the_table() -> None:
+    from reverse3d.reconstruction.silhouette import _support_plane
+
+    rng = np.random.default_rng(0)
+    table = np.column_stack([rng.uniform(-1, 1, 200), rng.uniform(-1, 1, 200), np.zeros(200)])
+    # More points on a vertical plane that crosses the object (a door, a wall).
+    wall = np.column_stack([np.full(400, 0.1), rng.uniform(-1, 1, 400), rng.uniform(0, 1.5, 400)])
+    obj = np.column_stack(
+        [rng.uniform(-0.3, 0.3, 3000), rng.uniform(-0.3, 0.3, 3000), rng.uniform(0.02, 1.2, 3000)]
+    )
+    cameras = np.array([[3.0, 0.0, 1.5], [-3.0, 0.5, 1.6], [0.0, 3.0, 1.4], [0.5, -3.0, 1.5]])
+    center = np.array([0.0, 0.0, 0.6])
+    plane = _support_plane(
+        np.vstack([table, wall]), center, 1.0, cameras, obj, np.array([0.0, 0.0, 1.0])
+    )
+    assert plane is not None
+    normal, offset = plane
+    assert abs(normal[2]) > 0.99  # the table, not the wall
+    assert np.mean(obj @ normal + offset < 0) < 0.05
+
+
+def test_a_sparse_slatted_table_under_a_tall_object_is_found() -> None:
+    from reverse3d.reconstruction.silhouette import _support_plane
+
+    rng = np.random.default_rng(1)
+    # Few points on an uneven, slatted table top (z ~ 0 +- 0.03), far below the centre.
+    slats = rng.uniform(-1.5, 1.5, (60, 2))
+    table = np.column_stack([slats, rng.normal(0.0, 0.015, 60)])
+    # Many points on a wall and on the top of the object (its cap).
+    wall = np.column_stack([np.full(600, 1.2), rng.uniform(-2, 2, 600), rng.uniform(0, 4, 600)])
+    cap = np.column_stack([rng.uniform(-0.2, 0.2, (300, 2)), np.full(300, 3.4)])
+    obj = np.column_stack([rng.uniform(-0.4, 0.4, (4000, 2)), rng.uniform(0.0, 3.4, 4000)])
+    cameras = np.array([[4.0, 0.0, 2.0], [-4.0, 0.5, 3.5], [0.0, 4.0, 1.0], [0.5, -4.0, 4.5]])
+    center = np.array([0.0, 0.0, 2.6])  # pulled up by close-ups of the cap
+    up = np.array([0.0, 0.0, 1.0])
+    plane = _support_plane(np.vstack([table, wall, cap]), center, 1.0, cameras, obj, up)
+    assert plane is not None
+    normal, offset = plane
+    assert normal[2] > 0.99
+    assert abs(offset) < 0.05  # the table top at z = 0
+
+
+def _voxels(n: int = 60) -> tuple[np.ndarray, float]:
+    axis = np.linspace(-1.5, 1.5, n)
+    gx, gy, gz = np.meshgrid(axis, axis, axis + 1.4, indexing="ij")
+    return np.stack([gx.ravel(), gy.ravel(), gz.ravel()], axis=1), float(axis[1] - axis[0])
+
+
+def test_a_bitten_base_is_completed_down_to_the_table() -> None:
+    from reverse3d.reconstruction.silhouette import _complete_base
+
+    grid, voxel = _voxels()
+    r = np.hypot(grid[:, 0], grid[:, 1])
+    bottle = (r < 0.5) & (grid[:, 2] >= 0) & (grid[:, 2] < 2.5)
+    bitten = bottle & ~((grid[:, 0] > 0) & (grid[:, 2] < 0.25))  # half the base missing
+    volume = bitten.astype(np.float32).reshape(60, 60, 60)
+    out = _complete_base(volume, grid, np.array([0.0, 0.0, 1.0]), 0.0, voxel).reshape(-1) > 0.5
+    base = bottle & (grid[:, 2] < 0.25)
+    assert out[base].mean() > 0.95  # the base is whole again
+    assert not (out & ~bottle).any()  # nothing added outside the object
+
+
+def test_legs_stay_legs_when_the_base_is_completed() -> None:
+    from reverse3d.reconstruction.silhouette import _complete_base
+
+    grid, voxel = _voxels()
+    x, y, z = grid.T
+    legs = (
+        ((np.abs(np.abs(x) - 0.8) < 0.12) & (np.abs(np.abs(y) - 0.8) < 0.12)) & (z >= 0) & (z < 1.0)
+    )
+    top = (np.abs(x) < 1.0) & (np.abs(y) < 1.0) & (z >= 1.0) & (z < 1.2)
+    table = legs | top
+    volume = table.astype(np.float32).reshape(60, 60, 60)
+    out = _complete_base(volume, grid, np.array([0.0, 0.0, 1.0]), 0.0, voxel).reshape(-1) > 0.5
+    between = (np.abs(x) < 0.4) & (np.abs(y) < 0.4) & (z < 0.5)
+    assert not out[between].any()

reverse3d-0.11.0/reverse3d/_version.py

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