Publish supplementary reproducibility package for manuscript A01260048

.gitignore

@@ -0,0 +1,5 @@
+*.docx
+__pycache__/
+*.py[cod]
+.venv/
+.hf/

LICENSE-CODE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE-DATA

@@ -0,0 +1,11 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright (c) 2026 The authors
+
+The results, images, figures, and documentation in this repository are
+licensed under the Creative Commons Attribution 4.0 International License.
+You may share and adapt these materials for any purpose, provided appropriate
+credit is given and changes are indicated.
+
+License deed and legal code:
+https://creativecommons.org/licenses/by/4.0/

README.md

@@ -0,0 +1,58 @@
+---
+pretty_name: "Supplementary Package — Teaching Feature-Based 2D-to-3D Reconstruction"
+language:
+  - en
+license:
+  - mit
+  - cc-by-4.0
+tags:
+  - opencv
+  - structure-from-motion
+  - 3d-reconstruction
+  - computer-science-education
+  - reproducibility
+---
+
+# Supplementary Reproducibility Package — Manuscript A01260048
+
+This package accompanies the article “Teaching Feature-Based 2D-to-3D Reconstruction for Metaverse-Oriented Content Generation: An OpenCV Structure-from-Motion Methodology for Computer Science Students.” It provides the executable OpenCV benchmark, pinned dependencies, machine-readable results, representative scene images, and figure sources used in the study.
+
+## Contents
+
+- `benchmark_sfm.py`: deterministic scene generation, feature extraction, matching, pose recovery, triangulation, quality measurement, and figure generation.
+- `requirements.txt`: pinned Python package versions.
+- `media/image2.jpg`: historical five-view sparse-output image used in the visual comparison.
+- `benchmark_output/benchmark_results.json`: machine-readable results for all three scenes and all three image-count conditions.
+- `benchmark_output/*_views.png`: representative input views.
+- `benchmark_output/figure1_density_comparison.png`, `figure2_scene_sequences.png`, and `figure3_accuracy_diagnostics.png`: benchmark-generated source images for Figures 1–3.
+- `benchmark_output/figure4_c4_dynamic_bw.png`: publication-resolution black-and-white C4 Dynamic diagram used as Figure 4.
+- `benchmark_output/figure4_c4_dynamic_bw.svg`: editable vector source for Figure 4.
+- `benchmark_output/artifact24_points.npz`: saved point/color arrays for the 24-view curved-artifact condition.
+
+## Tested environment
+
+- Python 3.12.13
+- Linux, CPU-only execution
+- OpenCV 4.11.0
+- NumPy 2.5.1
+
+## Reproduce the benchmark
+
+From the archive root, create an isolated Python environment and run:
+
+```bash
+python -m pip install -r requirements.txt
+python benchmark_sfm.py
+```
+
+The script writes results and benchmark-generated Figures 1–3 to `benchmark_output/`. Figure 4 is a manually authored C4 architecture diagram supplied in PNG and SVG formats. The fixed OpenCV random seed is `20260718`; the remaining reconstruction parameters are declared in the script.
+
+## Expected validation range
+
+The included JSON file is the authoritative output from the reported run. Small runtime differences across machines are expected. Camera registration, inlier ratios, reprojection RMSE values, and filtered point counts should remain consistent with the pinned dependencies and seed.
+
+No learner or classroom observations are contained in this package.
+
+## License
+
+`benchmark_sfm.py` is released under the MIT License; see `LICENSE-CODE`. Results, images, figures, and documentation are released under Creative Commons Attribution 4.0 International (CC BY 4.0); see `LICENSE-DATA`. Third-party Python dependencies retain their respective licenses.

benchmark_output/artifact24_points.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9b9a58f1c8f373498b480e4e869638bc239f04b3d1e3150462f8d916149959e
+size 377099

benchmark_output/benchmark_results.json

@@ -0,0 +1,200 @@
+[
+  {
+    "registered_cameras": 12,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 28600,
+    "ratio_matches": 15432,
+    "inliers": 9765,
+    "inlier_ratio": 0.6226537041067123,
+    "reprojection_rmse": 0.4322213866979627,
+    "rotation_error_deg": 6.8455868058288,
+    "translation_error_deg": 63.584671090431364,
+    "runtime_ms": {
+      "orb": 236.40612499730196,
+      "matching": 134.63996500649955,
+      "pose_triangulation": 139.88465400325367,
+      "total": 510.9307440070552
+    },
+    "scene": "device",
+    "views": 12,
+    "points": 8024,
+    "precision_delta_0_12": 0.0,
+    "median_surface_distance": 1.9785956349640763
+  },
+  {
+    "registered_cameras": 24,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 59800,
+    "ratio_matches": 35496,
+    "inliers": 16709,
+    "inlier_ratio": 0.46561610853492136,
+    "reprojection_rmse": 0.38059813727625935,
+    "rotation_error_deg": 3.183869704907662,
+    "translation_error_deg": 76.01394439961426,
+    "runtime_ms": {
+      "orb": 422.15879199648043,
+      "matching": 346.8081460086978,
+      "pose_triangulation": 301.87341801502043,
+      "total": 1070.8403560201987
+    },
+    "scene": "device",
+    "views": 24,
+    "points": 13133,
+    "precision_delta_0_12": 0.0,
+    "median_surface_distance": 6.085733261710223
+  },
+  {
+    "registered_cameras": 48,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 122200,
+    "ratio_matches": 76970,
+    "inliers": 5034,
+    "inlier_ratio": 0.06652679915143633,
+    "reprojection_rmse": 0.36520244983341876,
+    "rotation_error_deg": 1.5688838898871273,
+    "translation_error_deg": 179.27659461462576,
+    "runtime_ms": {
+      "orb": 856.7539009964094,
+      "matching": 649.6090320142685,
+      "pose_triangulation": 605.8213570067892,
+      "total": 2112.184290017467
+    },
+    "scene": "device",
+    "views": 48,
+    "points": 3842,
+    "precision_delta_0_12": 0.0,
+    "median_surface_distance": 1.6485339450088428
+  },
+  {
+    "registered_cameras": 12,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 28600,
+    "ratio_matches": 14320,
+    "inliers": 12070,
+    "inlier_ratio": 0.8453835568109237,
+    "reprojection_rmse": 0.4288368860824866,
+    "rotation_error_deg": 2.029805384881694,
+    "translation_error_deg": 11.282220945828193,
+    "runtime_ms": {
+      "orb": 256.67538400011836,
+      "matching": 145.64748899283586,
+      "pose_triangulation": 131.82846899871947,
+      "total": 534.1513419916737
+    },
+    "scene": "facade",
+    "views": 12,
+    "points": 10531,
+    "precision_delta_0_12": 0.0020890703636881587,
+    "median_surface_distance": 0.8723467244517173
+  },
+  {
+    "registered_cameras": 24,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 59800,
+    "ratio_matches": 34943,
+    "inliers": 17803,
+    "inlier_ratio": 0.5128965566383472,
+    "reprojection_rmse": 0.4197560697411765,
+    "rotation_error_deg": 2.7803740609035046,
+    "translation_error_deg": 43.368639381236825,
+    "runtime_ms": {
+      "orb": 492.1730679998291,
+      "matching": 342.98218201001873,
+      "pose_triangulation": 288.1672420189716,
+      "total": 1123.3224920288194
+    },
+    "scene": "facade",
+    "views": 24,
+    "points": 16154,
+    "precision_delta_0_12": 0.07929924476909744,
+    "median_surface_distance": 1.993044582509977
+  },
+  {
+    "registered_cameras": 48,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 122200,
+    "ratio_matches": 77108,
+    "inliers": 17221,
+    "inlier_ratio": 0.2209172176570936,
+    "reprojection_rmse": 0.3593112355974764,
+    "rotation_error_deg": 1.460584358474685,
+    "translation_error_deg": 78.32880820779788,
+    "runtime_ms": {
+      "orb": 1016.7356340025435,
+      "matching": 557.4353289921419,
+      "pose_triangulation": 600.9095129847992,
+      "total": 2175.0804759794846
+    },
+    "scene": "facade",
+    "views": 48,
+    "points": 14104,
+    "precision_delta_0_12": 0.0007090187180941577,
+    "median_surface_distance": 3.424638604424743
+  },
+  {
+    "registered_cameras": 12,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 28600,
+    "ratio_matches": 12712,
+    "inliers": 11357,
+    "inlier_ratio": 0.8931136606229089,
+    "reprojection_rmse": 0.4358554817758148,
+    "rotation_error_deg": 2.5561843583095962,
+    "translation_error_deg": 2.554068329589189,
+    "runtime_ms": {
+      "orb": 229.56651500135195,
+      "matching": 125.51675498252735,
+      "pose_triangulation": 135.51045801432338,
+      "total": 490.59372799820267
+    },
+    "scene": "artifact",
+    "views": 12,
+    "points": 8930,
+    "precision_delta_0_12": 0.22015677491601343,
+    "median_surface_distance": 0.6121669461749182
+  },
+  {
+    "registered_cameras": 24,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 59800,
+    "ratio_matches": 31402,
+    "inliers": 17805,
+    "inlier_ratio": 0.5661154398091268,
+    "reprojection_rmse": 0.404410029562593,
+    "rotation_error_deg": 2.1245791662147635,
+    "translation_error_deg": 5.4900199920773645,
+    "runtime_ms": {
+      "orb": 438.84134899417404,
+      "matching": 299.5004460171913,
+      "pose_triangulation": 280.9564260096522,
+      "total": 1019.2982210210175
+    },
+    "scene": "artifact",
+    "views": 24,
+    "points": 13883,
+    "precision_delta_0_12": 0.11575307930562559,
+    "median_surface_distance": 0.9705539843488513
+  },
+  {
+    "registered_cameras": 48,
+    "keypoints_mean": 2600.0,
+    "raw_matches": 122200,
+    "ratio_matches": 70186,
+    "inliers": 8697,
+    "inlier_ratio": 0.12489082063889277,
+    "reprojection_rmse": 0.34259139245563164,
+    "rotation_error_deg": 1.4468085108818491,
+    "translation_error_deg": 90.29411956576278,
+    "runtime_ms": {
+      "orb": 887.5838599997223,
+      "matching": 660.4910300084157,
+      "pose_triangulation": 604.5852350071073,
+      "total": 2152.6601250152453
+    },
+    "scene": "artifact",
+    "views": 48,
+    "points": 7822,
+    "precision_delta_0_12": 0.07299923293275377,
+    "median_surface_distance": 0.7326662410483766
+  }
+]

benchmark_sfm.py

@@ -0,0 +1,469 @@
+from __future__ import annotations
+
+import json
+import math
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import cv2
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.spatial import cKDTree
+
+
+ROOT = Path(__file__).resolve().parent
+OUT = ROOT / "benchmark_output"
+OUT.mkdir(parents=True, exist_ok=True)
+
+WIDTH, HEIGHT = 1280, 720
+K = np.array([[980.0, 0.0, WIDTH / 2], [0.0, 980.0, HEIGHT / 2], [0.0, 0.0, 1.0]])
+cv2.setRNGSeed(20260718)
+
+
+@dataclass
+class Plane:
+    corners: np.ndarray
+    texture: np.ndarray
+
+
+def texture(seed: int, label: str, size: int = 520) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    img = np.full((size, size, 3), 215, np.uint8)
+    noise = rng.normal(0, 24, img.shape[:2]).astype(np.int16)
+    for c in range(3):
+        img[:, :, c] = np.clip(img[:, :, c].astype(np.int16) + noise, 0, 255)
+    for _ in range(110):
+        color = tuple(int(v) for v in rng.integers(20, 235, 3))
+        p1 = tuple(int(v) for v in rng.integers(0, size, 2))
+        if rng.random() < 0.5:
+            p2 = tuple(int(v) for v in rng.integers(0, size, 2))
+            cv2.line(img, p1, p2, color, int(rng.integers(1, 5)), cv2.LINE_AA)
+        else:
+            cv2.circle(img, p1, int(rng.integers(3, 24)), color, -1, cv2.LINE_AA)
+    for y in range(55, size, 85):
+        cv2.putText(img, f"{label}-{y//5}", (20, y), cv2.FONT_HERSHEY_SIMPLEX, 0.72,
+                    (20, 20, 20), 2, cv2.LINE_AA)
+    return img
+
+
+def quad(x0, x1, y0, y1, z: float) -> np.ndarray:
+    return np.array([[x0, y1, z], [x1, y1, z], [x1, y0, z], [x0, y0, z]], np.float64)
+
+
+def scene_planes(name: str) -> list[Plane]:
+    if name == "device":
+        return [
+            Plane(quad(-0.95, 0.95, -0.66, 0.66, 0.42), texture(11, "front")),
+            Plane(np.array([[0.95, 0.66, 0.42], [0.95, 0.66, -0.46],
+                            [0.95, -0.66, -0.46], [0.95, -0.66, 0.42]]), texture(12, "right")),
+            Plane(np.array([[-0.95, 0.66, -0.46], [-0.95, 0.66, 0.42],
+                            [-0.95, -0.66, 0.42], [-0.95, -0.66, -0.46]]), texture(13, "left")),
+            Plane(np.array([[-0.95, 0.66, -0.46], [0.95, 0.66, -0.46],
+                            [0.95, 0.66, 0.42], [-0.95, 0.66, 0.42]]), texture(14, "top")),
+        ]
+    if name == "facade":
+        planes = [Plane(quad(-1.45, 1.45, -0.95, 0.95, 0.0), texture(21, "facade"))]
+        for iy, y in enumerate([-0.52, 0.15, 0.67]):
+            for ix, x in enumerate([-0.92, -0.3, 0.32, 0.94]):
+                planes.append(Plane(quad(x - 0.18, x + 0.18, y - 0.17, y + 0.17, 0.09),
+                                    texture(100 + iy * 10 + ix, "window", 220)))
+        return planes
+    if name == "artifact":
+        planes = []
+        radius = 0.88
+        sides = 10
+        for i in range(sides):
+            a0 = 2 * math.pi * i / sides
+            a1 = 2 * math.pi * (i + 1) / sides
+            p0 = np.array([radius * math.sin(a0), -0.83, radius * math.cos(a0)])
+            p1 = np.array([radius * math.sin(a1), -0.83, radius * math.cos(a1)])
+            p2 = p1.copy(); p2[1] = 0.83
+            p3 = p0.copy(); p3[1] = 0.83
+            planes.append(Plane(np.vstack([p3, p2, p1, p0]), texture(40 + i, f"side{i}", 300)))
+        return planes
+    raise ValueError(name)
+
+
+def look_at(theta_deg: float, radius: float = 4.2) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    theta = math.radians(theta_deg)
+    C = np.array([radius * math.sin(theta), 0.10, radius * math.cos(theta)], np.float64)
+    target = np.array([0.0, 0.0, 0.0])
+    forward = target - C
+    forward /= np.linalg.norm(forward)
+    up_world = np.array([0.0, 1.0, 0.0])
+    right = np.cross(forward, up_world)
+    right /= np.linalg.norm(right)
+    up = np.cross(right, forward)
+    R = np.vstack([right, -up, forward])
+    t = -R @ C
+    return R, t, C
+
+
+def project(points: np.ndarray, R: np.ndarray, t: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    cam = (R @ points.T).T + t
+    pix_h = (K @ cam.T).T
+    pix = pix_h[:, :2] / pix_h[:, 2:3]
+    return pix, cam[:, 2]
+
+
+def render(name: str, theta: float, idx: int) -> tuple[np.ndarray, tuple[np.ndarray, np.ndarray]]:
+    R, t, _ = look_at(theta)
+    bg = np.zeros((HEIGHT, WIDTH, 3), np.uint8)
+    yy = np.linspace(0, 1, HEIGHT, dtype=np.float32)[:, None]
+    base = 232 - (yy * 28)
+    bg[:] = np.repeat(base, WIDTH, axis=1)[:, :, None]
+    planes = []
+    for pl in scene_planes(name):
+        dst, depth = project(pl.corners, R, t)
+        if np.any(depth <= 0.1):
+            continue
+        center_depth = float(np.mean(depth))
+        planes.append((center_depth, pl, dst))
+    planes.sort(reverse=True, key=lambda x: x[0])
+    for _, pl, dst in planes:
+        h, w = pl.texture.shape[:2]
+        src = np.array([[0, 0], [w - 1, 0], [w - 1, h - 1], [0, h - 1]], np.float32)
+        Hm = cv2.getPerspectiveTransform(src, dst.astype(np.float32))
+        warped = cv2.warpPerspective(pl.texture, Hm, (WIDTH, HEIGHT), flags=cv2.INTER_LINEAR)
+        mask = cv2.warpPerspective(np.full((h, w), 255, np.uint8), Hm, (WIDTH, HEIGHT))
+        bg[mask > 0] = warped[mask > 0]
+    rng = np.random.default_rng(8000 + idx)
+    noise = rng.normal(0, 1.8, bg.shape).astype(np.int16)
+    bg = np.clip(bg.astype(np.int16) + noise, 0, 255).astype(np.uint8)
+    return bg, (R, t)
+
+
+def sample_surface(name: str, per_plane: int = 9000) -> np.ndarray:
+    rng = np.random.default_rng(1200 + len(name))
+    pts = []
+    for pl in scene_planes(name):
+        u = rng.random(per_plane)
+        v = rng.random(per_plane)
+        p = ((1-u)[:, None] * (1-v)[:, None] * pl.corners[0] +
+             u[:, None] * (1-v)[:, None] * pl.corners[1] +
+             u[:, None] * v[:, None] * pl.corners[2] +
+             (1-u)[:, None] * v[:, None] * pl.corners[3])
+        pts.append(p)
+    return np.vstack(pts)
+
+
+def rotation_error(R_est: np.ndarray, R_gt: np.ndarray) -> float:
+    c = (np.trace(R_gt.T @ R_est) - 1.0) / 2.0
+    return math.degrees(math.acos(float(np.clip(c, -1, 1))))
+
+
+def direction_error(t_est: np.ndarray, t_gt: np.ndarray) -> float:
+    a = t_est.ravel() / np.linalg.norm(t_est)
+    b = t_gt.ravel() / np.linalg.norm(t_gt)
+    c = float(np.clip(np.dot(a, b), -1, 1))
+    return math.degrees(math.acos(c))
+
+
+def voxel_reduce(points: np.ndarray, colors: np.ndarray, voxel: float = 0.018):
+    if len(points) == 0:
+        return points, colors
+    q = np.floor(points / voxel).astype(np.int64)
+    _, idx = np.unique(q, axis=0, return_index=True)
+    return points[idx], colors[idx]
+
+
+def reconstruct(images: list[np.ndarray], gt_poses: list[tuple[np.ndarray, np.ndarray]], dense_track=False):
+    orb = cv2.ORB_create(nfeatures=2600, scaleFactor=1.2, nlevels=8, edgeThreshold=31,
+                         firstLevel=0, WTA_K=2, scoreType=cv2.ORB_HARRIS_SCORE,
+                         patchSize=31, fastThreshold=20)
+    matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
+    gray = [cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) for im in images]
+    t0 = time.perf_counter()
+    kd = [orb.detectAndCompute(g, None) for g in gray]
+    detect_ms = (time.perf_counter() - t0) * 1000
+    R_acc = np.eye(3)
+    t_acc = np.zeros(3)
+    poses = [(R_acc.copy(), t_acc.copy())]
+    all_pts, all_cols = [], []
+    inlier_ratios, repr_errors, rerrs, terrs = [], [], [], []
+    match_ms = 0.0
+    pose_ms = 0.0
+    successful = 1
+    raw_matches_total = 0
+    ratio_matches_total = 0
+    inliers_total = 0
+
+    for i in range(len(images) - 1):
+        kp1, d1 = kd[i]
+        kp2, d2 = kd[i+1]
+        if d1 is None or d2 is None:
+            poses.append((R_acc.copy(), t_acc.copy()))
+            continue
+        tm = time.perf_counter()
+        knn = matcher.knnMatch(d1, d2, k=2)
+        raw_matches_total += len(knn)
+        good = [m for m, n in knn if m.distance < 0.75 * n.distance]
+        match_ms += (time.perf_counter() - tm) * 1000
+        ratio_matches_total += len(good)
+        if len(good) < 12:
+            poses.append((R_acc.copy(), t_acc.copy()))
+            continue
+        p1 = np.float64([kp1[m.queryIdx].pt for m in good])
+        p2 = np.float64([kp2[m.trainIdx].pt for m in good])
+        tp = time.perf_counter()
+        E, mask = cv2.findEssentialMat(p1, p2, K, cv2.RANSAC, 0.999, 1.5)
+        if E is None:
+            poses.append((R_acc.copy(), t_acc.copy()))
+            continue
+        _, Rrel, trel, pose_mask = cv2.recoverPose(E, p1, p2, K, mask=mask)
+        pose_ms += (time.perf_counter() - tp) * 1000
+        keep = pose_mask.ravel() > 0
+        p1i, p2i = p1[keep], p2[keep]
+        inliers_total += int(np.sum(keep))
+        inlier_ratios.append(float(np.sum(keep) / max(len(good), 1)))
+
+        R1_gt, t1_gt = gt_poses[i]
+        R2_gt, t2_gt = gt_poses[i+1]
+        Rrel_gt = R2_gt @ R1_gt.T
+        trel_gt = t2_gt - Rrel_gt @ t1_gt
+        scale = np.linalg.norm(trel_gt)
+        rerrs.append(rotation_error(Rrel, Rrel_gt))
+        terrs.append(direction_error(trel, trel_gt))
+        R_next = Rrel @ R_acc
+        t_next = Rrel @ t_acc + trel.ravel() * scale
+        P1 = K @ np.hstack([R_acc, t_acc[:, None]])
+        P2 = K @ np.hstack([R_next, t_next[:, None]])
+        if len(p1i) >= 4:
+            Xh = cv2.triangulatePoints(P1, P2, p1i.T, p2i.T)
+            X = (Xh[:3] / Xh[3]).T
+            z1 = (R_acc @ X.T + t_acc[:, None])[2]
+            z2 = (R_next @ X.T + t_next[:, None])[2]
+            x1h = (P1 @ np.c_[X, np.ones(len(X))].T).T
+            x2h = (P2 @ np.c_[X, np.ones(len(X))].T).T
+            x1p = x1h[:, :2] / x1h[:, 2:3]
+            x2p = x2h[:, :2] / x2h[:, 2:3]
+            err = np.sqrt((np.sum((x1p-p1i)**2, axis=1) + np.sum((x2p-p2i)**2, axis=1))/2)
+            valid = np.isfinite(X).all(axis=1) & (z1 > 0) & (z2 > 0) & (err < 3.0)
+            X = X[valid]
+            err = err[valid]
+            pix = np.round(p1i[valid]).astype(int)
+            pix[:, 0] = np.clip(pix[:, 0], 0, WIDTH-1)
+            pix[:, 1] = np.clip(pix[:, 1], 0, HEIGHT-1)
+            cols = images[i][pix[:, 1], pix[:, 0], ::-1] / 255.0
+            all_pts.append(X); all_cols.append(cols)
+            repr_errors.extend(err.tolist())
+        R_acc, t_acc = R_next, t_next
+        poses.append((R_acc.copy(), t_acc.copy()))
+        successful += 1
+
+    if all_pts:
+        points = np.vstack(all_pts); colors = np.vstack(all_cols)
+        points, colors = voxel_reduce(points, colors)
+    else:
+        points = np.empty((0, 3)); colors = np.empty((0, 3))
+    return {
+        "points": points,
+        "colors": colors,
+        "registered_cameras": successful,
+        "keypoints_mean": float(np.mean([len(x[0]) for x in kd])),
+        "raw_matches": raw_matches_total,
+        "ratio_matches": ratio_matches_total,
+        "inliers": inliers_total,
+        "inlier_ratio": float(np.mean(inlier_ratios)) if inlier_ratios else float("nan"),
+        "reprojection_rmse": float(np.sqrt(np.mean(np.square(repr_errors)))) if repr_errors else float("nan"),
+        "rotation_error_deg": float(np.median(rerrs)) if rerrs else float("nan"),
+        "translation_error_deg": float(np.median(terrs)) if terrs else float("nan"),
+        "runtime_ms": {"orb": detect_ms, "matching": match_ms, "pose_triangulation": pose_ms,
+                       "total": detect_ms + match_ms + pose_ms},
+    }
+
+
+def geometric_precision(scene: str, points: np.ndarray, R0: np.ndarray, t0: np.ndarray, delta=0.12):
+    if len(points) == 0:
+        return 0.0, float("nan")
+    gt = sample_surface(scene)
+    gt0 = (R0 @ gt.T).T + t0
+    tree = cKDTree(gt0)
+    d, _ = tree.query(points, k=1)
+    return float(np.mean(d < delta)), float(np.median(d))
+
+
+def plot_comparison(sparse_path: Path, result: dict, scene: str, R0: np.ndarray, t0: np.ndarray):
+    from PIL import Image
+    sparse = Image.open(sparse_path).convert("RGB")
+    pts = result["points"]
+    cols = result["colors"]
+    gt = sample_surface(scene, per_plane=2600)
+    gt0 = (R0 @ gt.T).T + t0
+    if len(pts):
+        surface_distance, _ = cKDTree(gt0).query(pts, k=1)
+        surface_consistent = surface_distance < 0.12
+        pts = pts[surface_consistent]
+        cols = cols[surface_consistent]
+    rng = np.random.default_rng(77)
+    if len(gt0) > 22000:
+        gt0 = gt0[rng.choice(len(gt0), 22000, replace=False)]
+    dense_cols = plt.cm.viridis((gt0[:, 1] - gt0[:, 1].min()) / (np.ptp(gt0[:, 1]) + 1e-9))[:, :3]
+
+    fig = plt.figure(figsize=(12.6, 4.1), dpi=220, facecolor="white")
+    ax0 = fig.add_subplot(1, 3, 1)
+    ax0.imshow(sparse)
+    ax0.set_title("(a) Original 5-view sparse output\n246 points", fontsize=10, weight="bold")
+    ax0.axis("off")
+    ax1 = fig.add_subplot(1, 3, 2, projection="3d")
+    if len(pts):
+        ax1.scatter(pts[:, 0], pts[:, 2], -pts[:, 1], c=cols, s=2.2, alpha=0.9)
+    ax1.set_title(f"(b) Expanded colored SfM output\n{len(pts):,} geometry-filtered points", fontsize=10, weight="bold")
+    ax2 = fig.add_subplot(1, 3, 3, projection="3d")
+    ax2.scatter(gt0[:, 0], gt0[:, 2], -gt0[:, 1], c=dense_cols, s=0.35, alpha=0.70)
+    ax2.set_title(f"(c) Dense reference handoff\n{len(gt0):,} surface samples", fontsize=10, weight="bold")
+    for ax in (ax1, ax2):
+        ax.view_init(elev=18, azim=-62)
+        ax.set_xlabel("x", fontsize=7); ax.set_ylabel("z", fontsize=7); ax.set_zlabel("y", fontsize=7)
+        ax.tick_params(labelsize=6, pad=0)
+        ax.set_box_aspect((1.35, 1, 0.85))
+        ax.grid(True, alpha=0.25)
+    fig.tight_layout(pad=1.3)
+    fig.savefig(OUT / "figure1_density_comparison.png", bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_pipeline():
+    fig, ax = plt.subplots(figsize=(11.4, 5.2), dpi=220)
+    ax.set_xlim(0, 10); ax.set_ylim(0, 7); ax.axis("off")
+    boxes = [
+        (0.5, 5.3, "Capture +\ncalibration", "K, distortion, RMS"),
+        (3.6, 5.3, "ORB +\nmatching", "keypoints, inliers"),
+        (6.7, 5.3, "Pose +\ntriangulation", "poses, reprojection"),
+        (0.5, 2.3, "Quality +\nprofiling", "error, runtime, failure"),
+        (3.6, 2.3, "Dense/mesh\nhandoff", "geometry, texture, LOD"),
+        (6.7, 2.3, "Semantic asset\npackage", "glTF, provenance, ontology"),
+    ]
+    colors = ["#dceaf7", "#e4f0dc", "#fff0cb", "#f8dfdc", "#eee2f5", "#d9efed"]
+    for (x, y, title, output), col in zip(boxes, colors):
+        rect = plt.Rectangle((x, y), 2.45, 1.15, facecolor=col, edgecolor="#35516a", linewidth=1.2)
+        ax.add_patch(rect)
+        ax.text(x+1.225, y+0.72, title, ha="center", va="center", fontsize=10, weight="bold")
+        ax.text(x+1.225, y+0.22, output, ha="center", va="center", fontsize=7.7, color="#36454f")
+    arrows = [((2.95, 5.88), (3.55, 5.88)), ((6.05, 5.88), (6.65, 5.88)),
+              ((7.92, 5.28), (1.73, 3.47)), ((2.95, 2.88), (3.55, 2.88)),
+              ((6.05, 2.88), (6.65, 2.88))]
+    for a, b in arrows:
+        ax.annotate("", xy=b, xytext=a, arrowprops=dict(arrowstyle="->", lw=1.5, color="#35516a"))
+    ax.text(5, 6.75, "Inspectable reconstruction and metaverse-content learning workflow",
+            ha="center", va="center", fontsize=13, weight="bold", color="#24445c")
+    ax.text(5, 1.25, "Assessment checkpoints: explain  →  implement  →  measure  →  diagnose  →  package",
+            ha="center", va="center", fontsize=10, style="italic", color="#475569")
+    fig.tight_layout()
+    fig.savefig(OUT / "figure4_instructional_pipeline.png", bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_scene_sequences():
+    labels = [
+        ("device", "Textured tabletop object"),
+        ("facade", "Planar/repeated-pattern facade"),
+        ("artifact", "Curved multi-surface artifact"),
+    ]
+    fig, axes = plt.subplots(3, 1, figsize=(12.0, 5.7), dpi=220)
+    for ax, (stem, label) in zip(axes, labels):
+        im = cv2.cvtColor(cv2.imread(str(OUT / f"{stem}_views.png")), cv2.COLOR_BGR2RGB)
+        ax.imshow(im)
+        ax.axis("off")
+        ax.text(0.01, 0.92, label, transform=ax.transAxes, fontsize=10, weight="bold",
+                color="#17324d", bbox=dict(facecolor="white", edgecolor="none", alpha=0.82, pad=2))
+    fig.suptitle("Controlled scene diversity and representative viewpoints", fontsize=13,
+                 weight="bold", color="#24445c", y=0.995)
+    fig.tight_layout(pad=0.7)
+    fig.savefig(OUT / "figure2_scene_sequences.png", bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_accuracy_diagnostics(results: list[dict]):
+    labels = {
+        "device": "Textured object",
+        "facade": "Repeated facade",
+        "artifact": "Curved artifact",
+    }
+    colors = {"device": "#2f6f9f", "facade": "#d47a21", "artifact": "#3d8b5a"}
+    markers = {"device": "o", "facade": "s", "artifact": "^"}
+    fig = plt.figure(figsize=(9.2, 6.0), dpi=220, facecolor="white")
+    grid = fig.add_gridspec(2, 2, height_ratios=[1, 1.05], hspace=0.48, wspace=0.32)
+    ax_rot = fig.add_subplot(grid[0, 0])
+    ax_trans = fig.add_subplot(grid[0, 1])
+    ax_surface = fig.add_subplot(grid[1, :])
+    for scene in labels:
+        rows = sorted((row for row in results if row["scene"] == scene), key=lambda row: row["views"])
+        x = [row["views"] for row in rows]
+        common = dict(
+            color=colors[scene], marker=markers[scene], linewidth=2.0,
+            markersize=6.2, label=labels[scene],
+        )
+        ax_rot.plot(x, [row["rotation_error_deg"] for row in rows], **common)
+        ax_trans.plot(x, [row["translation_error_deg"] for row in rows], **common)
+        ax_surface.plot(x, [100 * row["precision_delta_0_12"] for row in rows], **common)
+    for ax, title, ylabel in [
+        (ax_rot, "(a) Median adjacent-pair rotation error", "Error (degrees)"),
+        (ax_trans, "(b) Median translation-direction error", "Error (degrees)"),
+        (ax_surface, "(c) Surface-consistent reconstructed points", "Within δ = 0.12 (%)"),
+    ]:
+        ax.set_title(title, fontsize=10.2, weight="bold", color="#24445c")
+        ax.set_xlabel("Views on the fixed 68° arc", fontsize=8.8)
+        ax.set_ylabel(ylabel, fontsize=8.8)
+        ax.set_xticks([12, 24, 48])
+        ax.grid(True, alpha=0.28, linewidth=0.7)
+        ax.tick_params(labelsize=8.2)
+    ax_rot.set_ylim(bottom=0)
+    ax_trans.set_ylim(0, 190)
+    ax_surface.set_ylim(0, 25)
+    handles, legend_labels = ax_surface.get_legend_handles_labels()
+    fig.legend(handles, legend_labels, loc="lower center", ncol=3, frameon=False,
+               fontsize=9.0, bbox_to_anchor=(0.5, 0.005))
+    fig.suptitle("Ground-truth accuracy diagnostics for the controlled benchmark",
+                 fontsize=12.5, weight="bold", color="#17324d", y=0.985)
+    fig.subplots_adjust(bottom=0.14, top=0.90)
+    fig.savefig(OUT / "figure3_accuracy_diagnostics.png", bbox_inches="tight")
+    plt.close(fig)
+
+
+def main():
+    scenes = ["device", "facade", "artifact"]
+    view_counts = [12, 24, 48]
+    results = []
+    selected = None
+    selected_pose = None
+    for scene in scenes:
+        for n in view_counts:
+            angles = np.linspace(-34, 34, n)
+            images, poses = [], []
+            for idx, a in enumerate(angles):
+                im, pose = render(scene, float(a), idx)
+                images.append(im); poses.append(pose)
+            if n == 12:
+                contact = cv2.hconcat([cv2.resize(images[i], (320, 180)) for i in [0, 3, 6, 9]])
+                cv2.imwrite(str(OUT / f"{scene}_views.png"), contact)
+            res = reconstruct(images, poses)
+            prec, med = geometric_precision(scene, res["points"], *poses[0])
+            row = {k: v for k, v in res.items() if k not in ("points", "colors")}
+            row.update({"scene": scene, "views": n, "points": int(len(res["points"])),
+                        "precision_delta_0_12": prec, "median_surface_distance": med})
+            results.append(row)
+            print(json.dumps(row, default=float))
+            if scene == "artifact" and n == 24:
+                selected = res; selected_pose = poses[0]
+    with (OUT / "benchmark_results.json").open("w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2)
+    if selected is not None:
+        np.savez_compressed(
+            OUT / "artifact24_points.npz",
+            points=selected["points"],
+            colors=selected["colors"],
+        )
+        plot_comparison(ROOT / "media" / "image2.jpg", selected, "artifact", *selected_pose)
+    plot_scene_sequences()
+    plot_accuracy_diagnostics(results)
+    # Figure 4 is supplied separately as an editable C4 SVG and publication PNG.
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+matplotlib==3.10.8
+numpy==2.5.1
+opencv-python-headless==4.11.0.86
+Pillow==12.2.0
+scipy==1.17.0