# OVOW-Bench

OVOW-Bench is the evaluation toolkit for instance-level 3D/4D scene
reconstruction, and is the `benchmark/` component of the
[OVOW](https://github.com/SparcAI-Inc/OVOW) repository. It holds only evaluator
code and protocol metadata: it intentionally contains **no ground truth,
benchmark results, or model predictions**. The data is published separately as
`OVOW_Bench_Data` on Hugging Face.

## Metrics

The release evaluator reports:

- Scene-IoU AABB and OBB (higher is better)
- Object-IoU AABB and OBB after Hungarian matching and object-count penalty
  (higher is better)
- Photometric Loss: `100 * mean(normalized RGB MSE)` (lower is better)
- N-CLIP: `10 * mean(1 - CLIPSim(pred_render, gt_render))` (lower is better)

Geometry is evaluated after the alignment specified by the protocol. Visual
metrics use GT-camera renders of the aligned scenes. The public defaults are in
[`configs/release_protocol.json`](configs/release_protocol.json); the complete
definitions are in [`docs/EVALUATION_PROTOCOL.md`](docs/EVALUATION_PROTOCOL.md).

## Repository contents

```text
configs/                 Public evaluator defaults
scripts/                 Evaluation, rendering, validation, and data utilities
tests/                   Unit tests for evaluator helpers and release checks
```

Benchmark data, generated reports, rendered images, caches, and model
predictions are excluded from version control.

## Installation

Requirements:

- Python 3.10 or 3.11
- Blender with background Python execution and Eevee or Cycles support
- A local copy or Hugging Face cache entry for
  `openai/clip-vit-base-patch32`
- CUDA is optional; CLIP falls back to CPU

The recommended setup uses Conda:

```bash
conda env create -f environment.yml
conda activate ovow-bench
python scripts/check_env.py
```

Conda installs Python and delegates the Python packages to the repository's
single source of truth, `requirements.txt`. Blender remains a separate system
dependency.

Alternatively, use Python's built-in virtual environment:

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python scripts/check_env.py
```

The evaluator loads CLIP with `local_files_only=True`; evaluation does not
silently download model weights.

## Get the public example data

Download the data with `huggingface-cli download` (or Git LFS) and pass its
local path through `--data_root`; it can live anywhere writable. The dataset
identifier is filled in here once the Hugging Face upload is public:

```bash
huggingface-cli download <OVOW_Bench_Data dataset id> --repo-type dataset \
  --local-dir /path/to/OVOW_Bench_Data
```

The examples below assume the data sits next to the OVOW checkout, so that
`--data_root ../OVOW_Bench_Data` resolves from inside `benchmark/`. Adjust the
path to wherever you unpacked it.

## Data and submission layout

Ground truth follows this layout:

```text
OVOW_Bench_Data/gt/<sample_id>/
  scene.blend             # or scene.glb / scene.gltf
  scene.png               # reference image when provided
  metadata.json
```

Put a method's predictions under a new model key. Do not modify `gt/`:

```text
OVOW_Bench_Data/<model_name>/<sample_id>/
  scene.blend             # or scene.glb / scene.gltf
```

For example, predictions for a method named `my_method` go in
`OVOW_Bench_Data/my_method/...`. User predictions should remain local and must
not be pushed to the public data repository.

Validate the included GT subset and checksums:

```bash
python scripts/validate_release.py \
  --data_root ../OVOW_Bench_Data \
  --track_manifest ../OVOW_Bench_Data/manifests/example_dynamic.jsonl \
  --check_sha256
```

Validate a submission before evaluation:

```bash
python scripts/validate_release.py \
  --data_root ../OVOW_Bench_Data \
  --track_manifest ../OVOW_Bench_Data/manifests/example_dynamic.jsonl \
  --models my_method
```

## Run the evaluator

```bash
python scripts/run_parallel_eval.py \
  --protocol configs/release_protocol.json \
  --data_root ../OVOW_Bench_Data \
  --track_manifest ../OVOW_Bench_Data/manifests/example_dynamic.jsonl \
  --models my_method \
  --gpus 0 \
  --workers_per_gpu 1 \
  --blender_bin blender \
  --out_root /path/to/ovow_bench_outputs
```

Use a writable output directory outside the repository for large runs. The
evaluator is strict by default:

- every requested model must contain every selected sample;
- any failed sample causes a non-zero exit;
- cached reports are reused only when the evaluation configuration and scene
  file signatures match;
- summaries include sample coverage and refuse incomplete aggregation.

`--allow_partial` is available for debugging only. Results produced with that
flag are marked incomplete and should not be used for method comparison.

## Outputs

The output root contains:

```text
results_per_sample.csv
results_summary.json
<sample_id>/run_config.json
<sample_id>/pipeline.log
<sample_id>/reports/final_report.json
```

`results_summary.json` records the metric definitions, expected sample count,
per-model coverage, and missing rows (if partial mode was explicitly enabled).

## Tests

Run the unit tests without writing Python caches:

```bash
PYTHONDONTWRITEBYTECODE=1 python -m unittest discover -s tests -v
```

The unit tests do not require Blender or CLIP weights. A full end-to-end run
does.

## Scope

This release evaluates already reconstructed scenes. It does not include the
OVOW reconstruction pipeline, third-party baseline implementations, historical
evaluation outputs, or complete private benchmark data.

## Citation

See [`CITATION.cff`](../CITATION.cff) at the repository root for the OVOW paper
citation.

## License

This evaluator is OVOW-authored code and is covered by the repository's
[MIT license](../LICENSE). Note that the assembled OVOW repository as a whole
is a mixed-license, non-commercial research release — see [NOTICE](../NOTICE)
and [THIRD_PARTY.md](../THIRD_PARTY.md). The `OVOW_Bench_Data` dataset is
distributed separately and carries its own license.