Publish 2603-view indoor evaluation dataset and restore instructions

README.md

@@ -143,3 +143,19 @@ The prepared data does not replace access agreements for original source assets.
 ![3D-FRONT visible masks](previews/3dfront/train-overlay.png)
 
 [Posed object geometry](previews/3dfront/train-geometry.glb)
+
+<!-- partprobe3d-frozen-evaluation:start -->
+## Frozen indoor evaluation
+
+The optional [indoor evaluation bundle](optional/evaluation/indoor/README.md) contains 2,603 images with visible masks and GT object meshes.
+It includes all 100 PICASSO images, all 1,503 MessyKitchens images, and 1,000 random 3D-FRONT test views.
+The transfer is 23.40 GB.
+MessyKitchens shares 100 GT scene meshes across its views.
+Default training downloads exclude this bundle.
+
+Apply the loader patch described in the bundle documentation before evaluating its samples.
+
+```bash
+python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset indoor --optional evaluation
+```
+<!-- partprobe3d-frozen-evaluation:end -->

code/evaluation.patch

@@ -13,6 +13,224 @@ index f3de37d..c9cba24 100644
      "capture": CaptureLoader,
      "combined": CombinedLoader,
      "extent": ExtentLoader,
+diff --git a/evaluation/artifacts.py b/evaluation/artifacts.py
+index d61612c..8cb65e6 100644
+--- a/evaluation/artifacts.py
++++ b/evaluation/artifacts.py
+@@ -1,12 +1,17 @@
+ """Shared previews, result records and Markdown reports."""
+ from collections import Counter
++import hashlib
+ import json
+ import os
+ from pathlib import Path
++from threading import Lock
++from uuid import uuid4
+ 
+ import numpy as np
+ from PIL import Image, ImageDraw, ImageFont
+ 
++from utils.hashing import gt_hash
++
+ from .glb import validate_input, write_prediction
+ 
+ 
+@@ -226,8 +231,56 @@ def sample_record(sample, index):
+             "visibility": sample.visibility, "dataset_metadata": sample.metadata}
+ 
+ 
+-def prepare_sample(folder, sample, provenance, gt_name="ground_truth.glb"):
++def link_ground_truth(source, destination):
++    """Atomically replace a view's GT path with a relative link."""
++    source, destination = Path(source), Path(destination)
++    if destination.is_symlink() and destination.resolve() == source.resolve():
++        return
++    temporary = destination.with_name(f".{destination.name}.{uuid4().hex}")
++    try:
++        temporary.symlink_to(os.path.relpath(source.resolve(), destination.parent.resolve()))
++        os.replace(temporary, destination)
++    finally:
++        temporary.unlink(missing_ok=True)
++
++
++class GroundTruthStore:
++    """Store each scene mesh once and retain the GT path for every view."""
++    def __init__(self, directory):
++        self.directory = Path(directory)
++        self._lock = Lock()
++        self._written = set()
++
++    def target(self, digest, coordinate_frame, identity_mode, provenance):
++        signature = {"gt_sha256": digest, "coordinate_frame": coordinate_frame,
++                     "identity_mode": identity_mode, "provenance": provenance}
++        key = hashlib.sha256(json.dumps(signature, sort_keys=True).encode()).hexdigest()
++        return self.directory / f"{key}.glb"
++
++    def write(self, destination, sample, provenance, digest):
++        identity = sample.metadata.get("input_mask_identity", "mask")
++        target = self.target(digest, sample.gt_coordinate_frame, identity, provenance)
++        with self._lock:
++            if target not in self._written:
++                target.parent.mkdir(parents=True, exist_ok=True)
++                temporary = target.with_name(f".{uuid4().hex}.glb")
++                try:
++                    write_prediction(temporary, sample.gt_meshes,
++                                     coordinate_frame=sample.gt_coordinate_frame, units="m",
++                                     identity_mode=identity, method="ground-truth", provenance=provenance)
++                    os.replace(temporary, target)
++                finally:
++                    temporary.unlink(missing_ok=True)
++                self._written.add(target)
++        link_ground_truth(target, destination)
++
++
++def prepare_sample(folder, sample, provenance, gt_name="ground_truth.glb", *, gt_store=None, gt_digest=None):
+     previews(folder, sample.rgb, sample.masks)
++    if gt_store is not None and sample.gt_coordinate_frame == "model_scene":
++        gt_store.write(folder / gt_name, sample, provenance,
++                       gt_digest if gt_digest is not None else gt_hash(sample.gt_meshes))
++        return
+     write_prediction(folder / gt_name, sample.gt_meshes, coordinate_frame=sample.gt_coordinate_frame,
+                      units="m", identity_mode=sample.metadata.get("input_mask_identity", "mask"),
+                      method="ground-truth", provenance=provenance)
+diff --git a/evaluation/evaluate.py b/evaluation/evaluate.py
+index e50d3ea..318de5c 100644
+--- a/evaluation/evaluate.py
++++ b/evaluation/evaluate.py
+@@ -12,7 +12,7 @@ from dataloader.registry import DATASETS
+ from .glb import write_prediction
+ from .inference import METHODS
+ from .inference.base import REPO_ROOT
+-from .artifacts import prepare_sample, previews, report, sample_record, save_json
++from .artifacts import GroundTruthStore, prepare_sample, previews, report, sample_record, save_json
+ from .arguments import output_paths
+ from .predictions import MeshPredictions
+ from . import workflows
+@@ -53,6 +53,8 @@ def main(argv=None):
+     select.add_argument("--count", type=int, default=8)
+     select.add_argument("--workers", type=int, default=1,
+                         help="Concurrent CPU readers for selection preparation")
++    compact = commands.add_parser("compact-selection", help="Share duplicate GT meshes in a frozen selection")
++    compact.add_argument("--selection", required=True)
+     infer.add_argument("--method", choices=METHODS, required=True)
+     infer.add_argument("--config", required=True, help="JSON constructor kwargs for the inference class")
+     for sub in (select, meshes):
+@@ -79,6 +81,15 @@ def main(argv=None):
+         return 0
+     if hasattr(args, "samples") and args.samples < 32:
+         parser.error("--samples must be at least 32")
++    if args.command == "compact-selection":
++        selection_path = Path(args.selection).resolve()
++        output_paths(parser, selection_path.parent, REPO_ROOT, no_report=True)
++        try:
++            result = workflows.compact_selection(selection_path)
++        except (ValueError, KeyError, FileNotFoundError) as exc:
++            parser.error(str(exc))
++        print(json.dumps(result, indent=2))
++        return 0
+     if args.command == "select" and args.workers < 1:
+         parser.error("--workers must be positive")
+     if args.command == "meshes":
+@@ -181,6 +192,7 @@ def main(argv=None):
+     if selected and any(index not in selected for index in indices):
+         parser.error("--indices/--index must belong to the frozen selection")
+     rows = []
++    gt_store = GroundTruthStore(output / "ground_truth")
+     for index in indices:
+         frame = loader[index]
+         if selected:
+@@ -194,7 +206,8 @@ def main(argv=None):
+         ) if args.input else None
+         if source_prediction is not None and source_prediction.resolve() == gt_path.resolve():
+             gt_path = folder / "scoring_ground_truth.glb"
+-        prepare_sample(folder, frame, loader.provenance(), gt_path.name)
++        prepare_sample(folder, frame, loader.provenance(), gt_path.name, gt_store=gt_store,
++                       gt_digest=selected[index]["gt_sha256"] if selected else None)
+         row = {**sample_record(frame, index), "status": "ok", "ground_truth_glb": gt_path.name}
+         prediction = folder / "prediction.glb"
+         started = time.perf_counter()
+diff --git a/evaluation/workflows.py b/evaluation/workflows.py
+index 3968d22..5f985e0 100644
+--- a/evaluation/workflows.py
++++ b/evaluation/workflows.py
+@@ -11,9 +11,10 @@ import traceback
+ import numpy as np
+ from PIL import Image
+ 
+-from utils.hashing import gt_hash, input_hashes
++from utils.hashing import gt_hash, input_hashes, sha256
+ 
+-from .artifacts import prepare_sample, report, sample_record, sample_statistics, sample_statistics_table, save_json
++from .artifacts import (GroundTruthStore, link_ground_truth, prepare_sample, report, sample_record,
++                        sample_statistics, sample_statistics_table, save_json)
+ from dataloader.registry import DATASETS
+ from .glb import read_prediction, write_prediction
+ from .metrics import MATCHING_VERSION, SCENE_ALIGNMENT_VERSION, TETRIS3D_ALIGNMENT_VERSION, evaluate
+@@ -123,11 +124,14 @@ def select(args, output):
+                 "sampling": "uniform samples without replacement; sorted population indices",
+                 "population_frames": len(loader), "frames": []}
+     provenance = manifest["dataset_provenance"]
++    gt_store = GroundTruthStore(output / "ground_truth")
+     def prepare(index):
+         sample = loader[index]
+-        prepare_sample(output / "inputs" / sample.key, sample, provenance)
++        digest = gt_hash(sample.gt_meshes)
++        prepare_sample(output / "inputs" / sample.key, sample, provenance,
++                       gt_store=gt_store, gt_digest=digest)
+         return {**sample_record(sample, index), **input_hashes(sample.rgb, sample.masks),
+-                "gt_sha256": gt_hash(sample.gt_meshes)}
++                "gt_sha256": digest}
+     workers = getattr(args, "workers", 1)
+     if workers == 1:
+         manifest["frames"] = [prepare(index) for index in indices]
+@@ -140,6 +144,47 @@ def select(args, output):
+     return 0
+ 
+ 
++def compact_selection(selection_path):
++    """Share byte-identical GT exports without changing a frozen selection."""
++    selection_path = Path(selection_path).resolve()
++    selection = read_json(selection_path)
++    root = selection_path.parent
++    store = GroundTruthStore(root / "ground_truth")
++    groups = {}
++    original_inodes = {}
++    for frame in selection["frames"]:
++        path = root / "inputs" / frame["key"] / "ground_truth.glb"
++        if not path.parent.resolve().is_relative_to(root / "inputs"):
++            raise ValueError(f"GT path must remain inside the selection inputs: {path}")
++        target = store.target(frame["gt_sha256"], frame["gt_coordinate_frame"],
++                              frame.get("dataset_metadata", {}).get("input_mask_identity", "mask"),
++                              selection["dataset_provenance"])
++        digest = sha256(path)
++        info = path.stat()
++        original_inodes[(info.st_dev, info.st_ino)] = info.st_size
++        group = groups.setdefault(target, {"digest": digest, "paths": [], "bytes": info.st_size})
++        if digest != group["digest"]:
++            raise ValueError(f"GT exports with the same geometry contain different bytes: {path}")
++        group["paths"].append(path)
++    # Validate all existing files before replacing any view paths.
++    for target, group in groups.items():
++        if target.exists() and sha256(target) != group["digest"]:
++            raise ValueError(f"Shared GT export differs from the frozen files: {target}")
++    store.directory.mkdir(parents=True, exist_ok=True)
++    for target, group in groups.items():
++        if not target.exists():
++            # A hard link retains the verified bytes while view paths change.
++            os.link(group["paths"][0], target, follow_symlinks=True)
++        for path in group["paths"]:
++            link_ground_truth(target, path)
++    result = {"views": len(selection["frames"]), "unique_gt_meshes": len(groups),
++              "previous_unique_bytes": sum(original_inodes.values()),
++              "shared_gt_bytes": sum(group["bytes"] for group in groups.values()),
++              "selection_sha256": sha256(selection_path)}
++    save_json(root / "ground_truth_storage.json", result)
++    return result
++
++
+ def collect_runs(run, selection):
+     """Collect recorded model outputs and disjoint shards by their method metadata."""
+     expected = {frame["key"]: frame for frame in selection["frames"]}
 diff --git a/dataloader/frozen.py b/dataloader/frozen.py
 new file mode 100644
 index 0000000..2a43518

code/evaluation_manifest.json

@@ -1,8 +1,11 @@
 {
   "base_git_revision": "290027fe9f281a21db978a48da21bb9be90e5517",
-  "patch_sha256": "4e996043fd61be711cb2fba624f89107040c1fe99dacbce7ba42c4067e47e765",
+  "patch_sha256": "02a780a4df7abbfb37090beb86664d026b4dcc0d945fc7927a8621d4bf2d7fd0",
   "files": {
     "dataloader/registry.py": "97690914f4c50c9f7d31213bb9dab174bc740cdd62bf7b217ccfe456b6b387e7",
+    "evaluation/artifacts.py": "232f1b6ffd0374813ea93857ecb378c317a962b2bfbbb4cce0fd7d28e88fe12c",
+    "evaluation/evaluate.py": "3d9115be9eb34e1e6193a31f3fb4e5bf770f60b70701dbf7d67017376b87ed17",
+    "evaluation/workflows.py": "0623408a288a31d5502531f377c5492b985b5dc69429858d21180eaf0b06d2ba",
     "dataloader/frozen.py": "5efdb2209519d556f363599226d0d511de14009529899813b48a5574432bc508",
     "preprocess/evaluation.py": "e6c72bb985e38e219885db4dbc2c68d31c5f6dcac2a8c0f9fcd37aa86565ba19",
     "evaluation/configs/picasso_frozen.json": "39a3bbd78f4a5014624c8a190669154a52013af374bbdd2253d549ff981dab2b",

optional/evaluation/indoor/README.md

@@ -0,0 +1,78 @@
+# PartProbe3D frozen indoor evaluation
+
+This bundle contains 2,603 single-image evaluation samples and their GT object meshes.
+It requires about 23.4 GB, including RGB images, visible masks, previews, and shared geometry.
+It contains no training samples, depth maps, model weights, or image features.
+
+| Dataset | Images | Unique GT exports | Selection |
+| --- | ---: | ---: | --- |
+| PICASSO | 100 | 100 | All released images from ten scenes |
+| MessyKitchens | 1,503 | 100 | All released images from 100 scenes |
+| 3D-FRONT | 1,000 | 1,000 | Random prepared test views with seed 42, without replacement |
+
+The 3D-FRONT population contains 10,066 prepared views from 935 test rooms.
+The selected views cover 635 rooms and retain their test assignments.
+Each MessyKitchens scene has one GT export, shared across its views through relative manifest paths.
+All archive members contain regular files.
+
+## Restore
+
+Use the PartProbe3D checkout at Git revision `290027fe9f281a21db978a48da21bb9be90e5517`.
+Apply the supplied loader patch to that checkout:
+
+```bash
+hf download cubec/PartProbe3D-preprocessed code/evaluation.patch --repo-type dataset --local-dir outputs/huggingface/bootstrap
+git apply --check outputs/huggingface/bootstrap/code/evaluation.patch
+git apply outputs/huggingface/bootstrap/code/evaluation.patch
+python -m pip install -e '.[preprocess]'
+python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset indoor --optional evaluation
+```
+
+The downloader pins one Hub revision and verifies every archive checksum before restoration.
+The optional bundle restores to `datasets/evaluation/indoor/`.
+Default training downloads exclude this bundle.
+The source manifest at `code/evaluation_manifest.json` records the loader files and patch checksum.
+
+## Read samples
+
+```python
+from dataloader.frozen import FrozenEvaluationLoader
+
+dataset = FrozenEvaluationLoader('datasets/evaluation/indoor/messykitchen')
+sample = dataset[0]
+rgb, masks, meshes = sample.rgb, sample.masks, sample.gt_meshes
+```
+
+Use `--dataset frozen` for shared evaluation commands.
+The configuration files are `evaluation/configs/picasso_frozen.json`, `evaluation/configs/messykitchen_frozen.json`, and `evaluation/configs/front3d_frozen.json`.
+Original source datasets are unnecessary for this loader.
+
+```bash
+python -m evaluation.evaluate select --dataset frozen \
+  --dataset-config evaluation/configs/messykitchen_frozen.json \
+  --count 1503 --seed 42 --workers 4 --output outputs/evaluation/messykitchen_frozen
+```
+
+Each dataset contains `manifest.json`, `source_selection.json`, `views/`, and `ground_truth/`.
+The manifest records file checksums, original sample indices, mask settings, and dataset provenance.
+RGB pixels and mask labels preserve their frozen selection checksums.
+GT files preserve the original exported GLB bytes and their float32 vertex representation.
+The original geometry hash remains provenance under `source_gt_sha256`.
+
+PICASSO and 3D-FRONT GT meshes use OpenCV camera coordinates in meters.
+MessyKitchens GT meshes use the registered scene coordinates in meters.
+Its SAM3 masks have no released GT correspondence or camera calibration.
+Use scene-relative alignment for MessyKitchens scoring.
+
+## Sources and terms
+
+Original dataset terms continue to apply to their images and meshes.
+This derived bundle introduces no replacement license for source data.
+
+- [PICASSO official release](https://github.com/MIT-SPARK/Picasso#data) supplies RGB images, instance annotations, object meshes, and poses.
+- [MessyKitchens official project](https://github.com/MessyKitchens/MessyKitchens) supplies the real photographs and registered scene meshes under CC BY-NC 4.0.
+- [3D-FRONT official project](https://tianchi.aliyun.com/specials/promotion/alibaba-3d-scene-dataset) supplies the rooms and furniture used for our rendered test views.
+
+MessyKitchens authors are Junaid Ahmed Ansari, Ran Ding, Fabio Pizzati, and Ivan Laptev.
+Its original dataset card and citation remain in `messykitchen/SOURCE_README.md`.
+PartProbe3D adds predicted SAM3 masks for MessyKitchens and prepares the 3D-FRONT captures.

training/index.json

@@ -84,6 +84,17 @@
     "evaluation/ycbv": {
       "component": "optional/evaluation/ycbv",
       "bytes": 1669857280
+    },
+    "evaluation/indoor": {
+      "component": "optional/evaluation/indoor",
+      "bytes": 23404277760,
+      "views": 2603,
+      "datasets": {
+        "picasso": 100,
+        "messykitchen": 1503,
+        "3dfront": 1000
+      },
+      "loader_patch": "code/evaluation.patch"
     }
   },
   "base_git_revision": "aac7b493e1e5e10512857a2582233c99fedda9c5"