README.md

---
license: cc-by-nc-4.0
extra_gated_heading: Acknowledge the terms to access this dataset
extra_gated_prompt: >-
  Access is granted for non-commercial research and evaluation use only. By requesting access you
  agree not to redistribute this dataset or any derivative data, to cite Dhi Technologies in any
  publication or output that uses it, and to obtain a separate commercial license via dhi-tech.com
  before any commercial use. Access requests are reviewed manually by Dhi Technologies.
extra_gated_fields:
  Name: text
  Affiliation: text
  Intended use: text
  I agree to use this dataset for non-commercial research and evaluation only, and not to redistribute it: checkbox
extra_gated_button_content: Submit request
tags:
  - 3d-vision
  - camera-calibration
  - metric-localization
  - self-calibration
  - synthetic
pretty_name: Fixed-Camera 3D Benchmark
size_categories:
  - n<1K
---

# Fixed-Camera 3D Benchmark

**Product:** fixed-camera-3d
("fixedcam3d"): turns any fixed camera into a metric 3D sensor via self-calibration from ordinary
walking people, then reports metric position, speed, and height. Pure Python (numpy/scipy), no
GPU, no model weights.

## Synthetic data, real-data validation in progress

Scenes are procedurally generated from a **known** pinhole camera (height, tilt, and focal all
ground truth) observing walkers of known height, position, and speed, with detector-like box
noise added. The self-calibration and localization pipeline is the **real product code** run
against this synthetic input; nothing about the estimator is mocked. **Real annotated CCTV
footage has not been run through this pipeline yet**, and public multi-camera ground-truth sets
such as WILDTRACK have not been evaluated either; that is explicitly the next (GPU-phase) step
per the repo's own docs.

## What's in this dataset

- **`scenes.jsonl`** (288 rows, about 6.9 MB): one row per camera configuration in a full grid
  over mount height, tilt, observation noise, and generation seed (height, tilt, and focal all
  ground truth). Each row has:
  - `camera_truth`: the ground-truth camera geometry (`height_m`, `tilt_deg`, `focal_px`,
    `image_width`, `image_height`)
  - `noise_px`: the detector-box noise (standard deviation, pixels) applied to that row
  - `seed`: the generation seed for that row
  - `calibration_observations`: 80 synthetic noisy person-detection boxes used to self-calibrate
    (each with `true_xy_m` / `true_height_m` ground truth)
  - `eval_observations`: 60 held-out synthetic boxes used to score the calibrated pipeline
    (empty when that row's calibration did not converge or the geometry cannot see the walker
    region at all; see the table notes below)
- **`bench_results.json`** (about 263 KB): `grid_axes` (the exact grid), `grid` (the full
  per-config results table: height, tilt, focal, noise, seed, recovered camera, calibration
  `residual` and `sensitivity_m_per_half_deg` conditioning probe, position RMSE and p90, speed
  MAE, height MAE, recovered tilt error), and `aggregate` (overall and per-height / per-tilt /
  per-noise group statistics). This is the source of every number below.

The previous version of this dataset had 3 configurations (the repo's default sweep). This
version supersedes it with the 288-config grid; the old 3-row numbers used per-config focal
lengths (1200 / 1400 / 1700 px) and are not directly comparable to the fixed 2112 px focal used
here.

## How to load it

Verified against the actual files in this repository (prints `288 scenes`, the five row keys,
and the position RMSE of the first grid config):

```python
import json
from huggingface_hub import hf_hub_download

repo_id = "Dhi-Technologies/fixed-camera-3d-benchmark"
scenes_path = hf_hub_download(repo_id, "scenes.jsonl", repo_type="dataset")
bench_path = hf_hub_download(repo_id, "bench_results.json", repo_type="dataset")

scenes = [json.loads(line) for line in open(scenes_path)]
bench = json.load(open(bench_path))

print(len(scenes), "scenes")
print(list(scenes[0].keys()))   # camera_truth, noise_px, seed, calibration_observations, eval_observations
print(bench["grid"][0]["position_rmse_m"])
print(bench["aggregate"]["overall_position_rmse_m"])
```

## Measured results (288-config grid)

All numbers are measured by running the real pipeline on every config; nothing is extrapolated.
Of 288 configs, **267 converged and are scored**; 16 are geometrically unobservable (the walker
region lies entirely outside the field of view at 2.5 m / 60 deg and 3.5 m / 60 deg, so
self-calibration is impossible and the rows say so); 5 more collected observations but failed
the calibrator's own convergence gate (4 of 8 runs at 2.5 m / 45 deg, 1 of 8 at 12 m / 10 deg).

Overall position RMSE across the 267 scored configs: **mean 9.75 m, median 2.59 m, min 0.032 m,
max 84.9 m**. The mean is dominated by shallow-tilt geometries; the table below shows where the
error actually lives.

**Mean position RMSE (m) per height x tilt**, averaged over noise {1.0, 1.5, 2.0, 3.0} px and
seeds {0, 1}, converged rows only (fractions mark cells where some runs did not converge):

| height \ tilt | 10 deg | 18 deg | 26 deg | 35 deg | 45 deg | 60 deg |
|---|---:|---:|---:|---:|---:|---:|
| 2.5 m | 13.33 | 13.16 | 6.54 | 7.86 | 4.95 (4/8) | no fit (0/8) |
| 3.5 m | 15.31 | 3.69 | 0.45 | 10.13 | 7.95 | no fit (0/8) |
| 5.0 m | 19.96 | 3.90 | 0.36 | 1.84 | 1.15 | 1.41 |
| 7.0 m | 24.64 | 38.50 | 3.41 | 0.69 | 1.36 | **0.15** |
| 9.0 m | 24.28 | 7.32 | 9.30 | 4.71 | 1.09 | 0.29 |
| 12.0 m | 42.56 (7/8) | **54.29** | 5.61 | 1.91 | 0.83 | 0.37 |

- **Best-conditioned geometry: 7 m / 60 deg** (mean RMSE 0.149 m). Steep, elevated mounts are
  consistently sub-meter: every 60 deg cell from 7 m up is below 0.4 m.
- **Worst-conditioned geometry: 12 m / 18 deg** (mean RMSE 54.29 m). This generalizes the
  shallow-angle disclosure the 3-config version of this card made for its 3 m / 20 deg row: at
  tilt 10 to 18 deg the fit is genuinely ill-conditioned (median RMSE 23.05 m at 10 deg, 7.81 m
  at 18 deg, versus 0.25 m at 60 deg), and it gets worse from high mounts because a high, shallow
  camera sees only the far field, where a small tilt error costs tens of meters. The calibrator's
  `sensitivity_m_per_half_deg` conditioning probe and `notes` flag these rows directly.
- **Unobservable geometries are reported, not dropped**: at 2.5 m / 60 deg and 3.5 m / 60 deg the
  fixed walker region is entirely outside the frame, no observation can ever be collected, and
  the rows record that fact with empty observation lists and null metrics.
- **Noise matters less than geometry** in this sweep. Restricted to well-conditioned tilts
  (>= 26 deg), median RMSE rises monotonically from 0.90 m at 1.0 px noise to 1.27 m at 3.0 px;
  averaged over the whole grid the noise effect is lost inside the geometry spread.
- Recovered tilt error across scored configs: median 2.83 deg, p90 12.48 deg. Speed MAE median
  0.142 m/s; height MAE median 0.051 m.
- Seed check: mean RMSE is 11.38 m (seed 0) versus 8.14 m (seed 1). The gap sits almost entirely
  in the ill-conditioned cells, where run-to-run variance is large; well-conditioned cells agree
  closely across seeds.

For every row, see `bench_results.json` (`grid`); group summaries are precomputed in
`aggregate`.

## Schema notes

- Positions are metric (meters), on the ground plane, with the camera as origin unless noted in
  `camera_truth`.
- The camera model is a pure pinhole with no lens distortion, yaw, or roll terms, and no rolling
  shutter model.
- This is an evaluation-only population: `calibration_observations` and `eval_observations` are
  disjoint synthetic draws for the same ground-truth camera, not a train/test split over real
  footage.
- There is **no independent subject-distance axis**: the walker region is fixed at
  [-8, 8] x [4, 35] m for every config, so subject distance varies only as a consequence of
  camera geometry (a high shallow camera sees only the far part of that region). Do not read
  this grid as a distance sweep.

## Method card, no trained weights

Pure Python (numpy/scipy), no GPU and no model weights. Self-calibration solves for camera
height, tilt, and focal length from ordinary walking-person detections (a coarse grid search over
the three parameters followed by soft-L1 refinement); localization back-projects foot points to
the ground plane. Ill-conditioned and impossible geometries are disclosed in the table above
rather than dropped from it.

## Regeneration provenance

Regenerated on 2026-07-10 (previous version: 3 configs, 2026-07-09) by sweeping the real
pipeline over the full grid:

- heights_m: [2.5, 3.5, 5.0, 7.0, 9.0, 12.0]
- tilts_deg: [10, 18, 26, 35, 45, 60]
- noise_px: [1.0, 1.5, 2.0, 3.0]
- seeds: [0, 1]
- focal_px: 2112.0 for every config (1.1 x the 1920 px image width, the middle of the
  calibrator's own focal-factor grid), image 1920x1080
- 80 calibration walkers and 60 eval points per config (the defaults)

Driver logic: for each of the 6 x 6 x 4 x 2 = 288 configs, call
`fixedcam3d.bench.run_bench(CameraModel(height_m=h, tilt_rad=deg2rad(t), focal_px=2112.0),
n_calibration_walkers=80, n_eval_points=60, noise_px=n, seed=s)` for the metrics, and replay the
identical seeded draw sequence to capture the per-observation ground truth for `scenes.jsonl`
(validated: recomputing position RMSE from the captured eval observations reproduces run_bench
to 1e-9). Geometries that can never see the walker region are detected with a deterministic
visibility scan and recorded as non-converged rows instead of sampling forever. Full grid wall
clock: 607 s on an Apple Silicon Mac (CPU only).

## Limitations

- Synthetic only in this dataset: every scene comes from a known, simulated pinhole camera. No
  real annotated CCTV footage or public dataset such as WILDTRACK has been run through this
  pipeline yet.
- Two generation seeds (0 and 1): each cell of the summary table averages at most 8 runs, and
  the ill-conditioned cells show large run-to-run variance, so treat per-cell numbers as
  indicative rather than tight estimates.
- One focal length (2112 px): the grid varies height, tilt, and noise, not optics. The retired
  3-config version used other focals, so focal sensitivity is not covered by this release.
- Ground-contact detection is naive (bottom-center of the detection box treated as the foot
  point), so occlusion at the frame edge or by other objects can silently produce a wrong ground
  point, a limitation this synthetic benchmark does not stress because its boxes are clean by
  construction.
- The height prior is a single population-mean scalar per scene, not per-subject, so a
  systematically biased population (for example, mostly children) would bias calibration in a way
  this synthetic sweep, which uses a fixed height distribution, does not surface.
- Rolling shutter and lens distortion are not modeled, so fast subjects or wide-angle lenses on
  real hardware would violate assumptions this synthetic data does not test.

## License

This dataset is released under **CC BY-NC 4.0** (non-commercial). Access is gated and requires
manual approval: it is provided for non-commercial research and evaluation only, redistribution
is not permitted, and any publication or output using it should cite Dhi Technologies. Commercial
use requires a separate agreement; contact [dhi-tech.com](https://dhi-tech.com).

## Try it

- Live demo (static, precomputed RMSE table plus per-config visualization):
  [fixed-camera-3d-demo](https://huggingface.co/spaces/Dhi-Technologies/fixed-camera-3d-demo)
- Blog: [Six products, one honesty thesis](https://huggingface.co/datasets/Dhi-Technologies/blog/blob/main/04_portfolio_overview.md)
- Dhi Labs: [dhi-tech.com/labs](https://dhi-tech.com/labs)

## Source & research context

- Code: proprietary, closed source permanently; not a publicly browsable repository. Partnership or access inquiries: [dhi-tech.com](https://dhi-tech.com).
- Companion paper: Dhi Labs paper 08 (fixed-camera 3D), in preparation
- Collection: [Dhi Labs, honest edge vision AI](https://huggingface.co/collections/Dhi-Technologies/dhi-labs-honest-edge-vision-ai-6a4eb297cbd60f5f673cc2d7)
- Blog dataset: https://huggingface.co/datasets/Dhi-Technologies/blog
- Org: https://huggingface.co/Dhi-Technologies, GitHub org: https://github.com/DHI-Technologies-Inc