This release is V2-only

NCF ships one camera rectification: V2 (per-camera pinhole). The legacy V1 rectification — images/, masks/, videos_rectified/, labels/obstacles_2d_* and calib/K_rectified.json — is not part of this release and is absent from the HuggingFace repository. Anything referring to it below is historical context.

Use images_rectv2/, masks_rectv2/, videos_rectv2/, labels_rectv2/ and calib/K_rectified_v2.json. provenance.json["rect_version"] is "v2" on every clip.

The paired foggy half (JocelynW/NFF) still ships both versions. If you compare the two halves, compare V2 to V2 — that is the only controlled comparison.

NVIDIA Clear Field (NCF) — multimodal clear-weather driving dataset

The clear-weather half of a matched pair. Real RGB + 128-beam LiDAR + 8/10-stream radar + NeRF-ready offline-refined ego-poses, in clear weather. 17 clips × 20 s @ 10 Hz, curated from the NVIDIA NCore (PhysicalAI-Autonomous-Vehicles) corpus using the same protocol as its counterpart, so the two sets are directly comparable.

Paired counterpart: NVIDIA Foggy Field (NFF) — 15 foggy clips, same sensor rig, same conventions, same rectification version (V2), same toolkit. Only the weather differs. Use them together for weather-ablation work; the manifest.csv and DATASET_SUMMARY.csv column orders are identical so the two tables concatenate. Distribution: this set is the private JocelynW/NCF; the fog set is the private JocelynW/NFF.

Self-contained: everything is inside clips/ plus this README and CONVENTIONS.md. To move it: tar -caf NCF.tar.zst NVIDIA_CLEAR_Field/ (or rsync -aH).

Licence. Derived from the NVIDIA PhysicalAI-Autonomous-Vehicles dataset. The NVIDIA AV Dataset Licence prohibits redistribution of the data or derivatives, including processed frames. This folder is private internal storage. Do not publish it or any frame from it.

---

1. At a glance

• 17 clips, 20.0 s each, 199 timesteps @ 10 Hz, LiDAR-driven sync.
• 7 cameras per clip, in three forms:
  • rectified pinhole frames (official NVIDIA FThetaCameraModel, 0-px border),
  • rectified video (videos_rectified/, 10 fps — one frame per timestep),
  • the original fisheye mp4 (videos/, native 30 fps + its own timestamps).
• 1 spinning LiDAR (128-beam, 10 Hz), per-point timestamps, ego frame.
• 8-stream radar; 10 streams on NCF-04, NCF-05, NCF-15, NCF-18 (adds side_left_srr_3 + side_right_srr_3 — no NFF clip has these). Native polar and Cartesian-ego point clouds.
• 3D + 2D auto-labels (NCore autolabel v2): 3D boxes (ego + world) + per-camera 2D boxes.
• Offline-refined ego-pose per timestep (T_rig_world).
• Previews per clip: LiDAR-BEV-with-boxes video + radar-BEV-Doppler video.
• Geography: 12 countries — 3 United States, 2 each Germany / Poland / Romania, 1 each Austria, Belgium, Denmark, France, Italy, Portugal, Spain, Sweden.
• Lighting: 14 day + 1 dusk + 2 night. Seasons: 9 of 12 calendar months.
• 165,452 3D boxes across 3,316 tracks; 18,100,318 radar returns; 1,042,158,554 LiDAR points.

manifest.csv = the index (one row per clip). DATASET_SUMMARY.csv = full per-clip table. _evaluation/stats/ = the same seven CSV schemas NFF uses, so fog and clear concatenate.

Why these 17

Screened from 306,152 NCore clips: 71,775 carry the full NFF modality suite, 791 were fetched and measured, 313 were reviewed frame-by-frame by eye, 87 passed, 30 were offered as candidates and 18 chosen, of which 17 ship — NCF-17 (Italy, night) was withdrawn by the owner after selection and its directory deleted. Everything downstream counts 17. Weather is not in any NCore metadata field — every clip here was confirmed clear visually, not by threshold. Automated snow detection was tried and discarded (it flagged none of the obviously snow-covered Nordic winter clips).

---

2. Per-clip layout (identical for all 17)

clips/NCF-NN__<uuid8>/
  images/<cam>/frame_0000.jpg .. frame_0198.jpg   # rectified PINHOLE, 7 cams × 199
  videos_rectified/<cam>.mp4                      # the same frames as video, 10 fps
  videos/<cam>.mp4 (+ .timestamps.parquet)        # ORIGINAL FISHEYE, 30 fps
  lidar/sweep_0000.npy .. sweep_0198.npy          # float32 [x,y,z,intensity,timestamp,ring], EGO frame
  labels/
    obstacles_3d_ego.parquet                      # 3D boxes in ego/rig frame (ISO 8855)
    obstacles_3d_world.parquet                    # same boxes in world frame
    obstacles_2d_<cam>.parquet                    # 2D boxes per camera
    tracks.parquet, class_taxonomy.json
  calib/
    K_rectified.json              # {cam: {fx,fy,cx,cy,w,h}}
    T_camera_rig.json             # {cam: 4x4} camera POSE in rig (rig<-camera) — INVERT to project
    T_lidar_rig.json              # lidar extrinsic (rig<-lidar)
    T_rig_world.parquet           # per-timestep flattened 3x4 rig->world; translation = *_03/_13/_23
    camera_intrinsics_ftheta.json # original fisheye FTheta intrinsics
    lidar_intrinsics.json, lidar_timestamps.parquet
  masks/<cam>/valid_mask.png      # valid-pixel mask (fisheye circle -> rectangular canvas)
  splits/                         # nvs_50_50 / nvs_80_20 / nvs_90_10 / reconstruction_all
  radar/
    scans/<stream>.parquet          # NATIVE POLAR
    scans_xyz_ego/<stream>.parquet  # CARTESIAN EGO
    calib/radar_extrinsics.json, radar_streams.json
  preview/bev_lidar_with_boxes.mp4, radar_bev_viz.mp4
  provenance.json                 # uuid + chunk (re-fetchable), lidar_frame marker

The 7 cameras: camera_front_wide_120fov, camera_front_tele_30fov, camera_cross_left_120fov, camera_cross_right_120fov, camera_rear_left_70fov, camera_rear_right_70fov, camera_rear_tele_30fov.

---

3. Quickstart

import json, glob, numpy as np, pandas as pd, cv2
clip = "clips/NCF-01__e9d14055"; t = 50

# rectified pinhole image + intrinsics
img = cv2.imread(f"{clip}/images/camera_front_wide_120fov/frame_{t:04d}.jpg")
K   = json.load(open(f"{clip}/calib/K_rectified.json"))["camera_front_wide_120fov"]

# LiDAR sweep -- ALREADY in the ego frame, do not apply T_lidar_rig again
pc  = np.load(f"{clip}/lidar/sweep_{t:04d}.npy")      # [N,6] x,y,z,intensity,ts,ring

# 3D boxes (ego frame), quaternion is W-FIRST
b   = pd.read_parquet(f"{clip}/labels/obstacles_3d_ego.parquet").query("timestep_idx == @t")

# ego pose at t (rig -> world): translation is the _03/_13/_23 columns
P   = pd.read_parquet(f"{clip}/calib/T_rig_world.parquet")
xyz = P.loc[P.timestep_idx == t, ["T_rig_world_03","T_rig_world_13","T_rig_world_23"]].to_numpy()[0]

# radar, Cartesian ego
r   = pd.read_parquet(f"{clip}/radar/scans_xyz_ego/radar_front_center_imaging_lrr_1.parquet")

Frame indexing. images/<cam>/frame_<t>.jpg, videos_rectified/<cam>.mp4 frame t, lidar/sweep_<t>.npy, labels with timestep_idx == t and pose row t all refer to the same instant, t ∈ [0,198]. The original fisheye videos/*.mp4 run at 30 fps with their own timestamps and are not frame-aligned to t — match via videos/<cam>.timestamps.parquet. Radar runs ~20 Hz; match by timestamp (µs) to the nearest pose timestamp_us (±60 ms).

---

4. Comparison with NFF (fog)

Both sets are 199 timesteps @ 10 Hz with identical layout, so per-clip tables stack directly.

	NCF (clear, 18)	NFF (fog, 15)
dcp_t_mean	0.787 – 0.892	0.568 – 0.724
dcp_vis_m	1,271 – 2,787 m	512 – 892 m
lidar_return_frac	0.525 – 0.739	0.304 – 0.676
countries	12	3 (Sweden 12, Belgium 2, Portugal 1)
lighting	14 day / 1 dusk / 3 night	14 day / 1 night
months covered	9 of 12	Feb–Mar only
radar streams	8, or 10 on four clips	8 on all

The two sets do not overlap on either visibility metric, including across the day/night split — the separation is weather, not exposure.

---

4b. Camera pipeline: V2 is canonical, V1 is retained

Use V2. images_rectv2/, masks_rectv2/, videos_rectv2/, labels_rectv2/ and calib/K_rectified_v2.json. Every clip carries "rect_version": "v2" in provenance.json and a rect_version column in manifest.csv, so a loader can branch on the field rather than guess from a directory name.

V1 is still here and is not going away — images/, masks/, videos_rectified/, labels/obstacles_2d_* and calib/K_rectified.json. It is retained solely so earlier runs can be reproduced. It is not the recommended input for anything new.

The reason is concrete, and it is different in the two halves — which is itself the strongest argument for V2.

NCF V1 forced all seven cameras onto one global pinhole (fx = fy = 640, 1280×960, 90° horizontal FOV). A 30° tele and a 155° fisheye landed on the same grid:

camera	native px/deg	NCF V1 px/deg	NCF V1 content in canvas
front_tele_30fov	65.2	11.2	340×191 = 5.2% (rest black)
rear_tele_30fov	64.2	11.2	343×194 = 5.3%
rear_left/right_70fov	27.5	11.2	935×525 = 35%
front_wide / cross_left / cross_right	16.5	11.2	1280×785 = 77%

NFF V1 did something else entirely: a sane FOV-matched per-camera rectification — 120° cameras at 1280×960/90°, 70° at 1120×800/70°, 30° teles at 480×320/30°, i.e. 11.2 / 14.0 / 15.6 px/deg with no wasted canvas at all. It merely under-sampled: the fog tele got 15.6 px/deg against 64.7 native, a 4.1× loss, in a 480×320 image.

So the two halves were on different camera pipelines under V1. Any V1-based fog-versus-clear comparison was confounded by rectification as well as weather — the clear tele was 1280×960 at 11.2 px/deg with 95% black, the fog tele 480×320 at 15.6 px/deg with none. V2 is what makes the pair a legitimate controlled comparison, because it puts both halves on one per-camera rule at each lens's native angular resolution. That matters more than the resolution gain on its own.

Either way the lost detail is not recoverable — it is gone from the V1 pixels. For NeRF and 3DGS the finest structure either method can reconstruct is bounded by the angular resolution of the input views. V2 re-resamples the untouched f-theta source in videos/, once, at each lens's own resolution; it does not stack interpolation on top of V1.

---

4c. Benchmark splits — and what they do not cover

manifest.csv:benchmark_role / DATASET_SUMMARY.csv:split. 11 train / 4 val / 1 test / 1 held_out, matching the fog set's proportions as closely as 17 clips allow (that shape deviates from the fog ratios by 7.1 points in total, against 7.9 for 12/3/1/1).

split	clips	time of day	countries	radar
train (11)	NCF-01, 02, 04, 05, 06, 07, 09, 10, 11, 12, 14	day only	Austria, Denmark, Germany, Italy, Poland, Portugal, Romania, Spain, United States	8 + 10 stream
val (4)	NCF-03, 08, 13, 16	day + night	Belgium, France, Poland, Sweden	8 only
test (1)	NCF-15	dusk	United States	10
held_out (1)	NCF-18	night	United States	10

Val deliberately spans four countries that do not appear in train, and brackets scene density: NCF-08 is the densest clip in the set (724 tracks) and NCF-13 the sparsest urban one (29 tracks).

Read this before reporting numbers on NCF

These are real limits of the split, not footnotes. They are stated here because a benchmark whose gaps live only in a script comment is a benchmark that gets misreported.

1. Train contains no night clip. Night on NCF is a ZERO-SHOT evaluation. The set has exactly three non-daytime clips — NCF-15 (dusk), NCF-16 (night), NCF-18 (night) — and all three are in eval. This is unavoidable once val is required to contain night: test and held_out already take the other two. A model trained on NCF train has never seen darkness. That is arguably the more honest benchmark, but it must be reported as zero-shot rather than discovered by whoever first gets bad night numbers.
2. Italy and night no longer co-occur in any clip. NCF-17 carried that pair alone and the clip was withdrawn, so no assignment recovers it.
3. Italy has left the evaluation splits entirely. NCF-06 (Italy, day) is the only remaining Italy clip and it sits in train, so Italy is now train-only.
4. Belgium is val-only. It has a single clip, NCF-16, which moved from train to val to carry night.
5. Val is 8-stream radar only. All four 10-stream (high, with the side SRR-3 pair) clips are NCF-04 and NCF-05 (train), NCF-15 (test) and NCF-18 (held_out). This was already true of the pre-withdrawal 18-clip plan, so it is not a new loss — but anyone tuning a radar model on val will never see the side streams there.

_build/bin/assign_splits.py prints all five on every run and re-derives the assignment; the original screening roles stay recoverable in _screening/FINAL30.csv.

---

5. Caveats (honest)

• NCF-01's camera/LiDAR sync drifts; the other 31 clips in the pair do not. 31 of 32 hold their per-camera offset to within σ ≤ 0.244 ms over the clip. NCF-01 alone has σ up to 11.5 ms, with the offset sweeping the full ±16.66 ms — half a 33.3 ms frame period — because the nearest-frame choice walks across a frame boundary mid-clip. No single mean describes that clip; do not average it. _evaluation/stats/sensor_sync_quality.csv carries a sync_regime column (phase_locked / intermediate / drifting) per clip for exactly this reason. If you need tight multi-view timing, use calib/camera_timestamps.parquet rather than assuming all seven cameras share the LiDAR timestamp — on NCF-01 that assumption is worst-case 32 cm of ego travel, and on NCF-10 the two camera groups are 26.57 ms apart.

1. beta_ext / visibility_lidar_m here are DCP-derived, tagged source="dcp_koschmieder", not LiDAR Beer-Lambert measurements. A LiDAR extinction estimator was attempted and rejected: at 5–80 m, return intensity is dominated by surface reflectivity, and the fit did not even rank clips correctly. NFF's own beta_ext column is a measurement for only 4 of its 15 clips (the other 11 have beta_std: null), so treat cross-set β comparisons with care.
2. DCP is unreliable at night — it is a daylight haze model. The three night clips here score inside the clear band, but that is not evidence of anything: in NFF, the heavy-fog night clip NFF-05 also scores "clear" (dcp_t_mean 0.686). Night weather must be judged by eye in both sets.
3. Class names follow NCore, which emits person and rider, never pedestrian or cyclist. For schema parity the n_pedestrian / n_cyclist columns are populated from person / rider; class_distribution.csv carries the true NCore names. Three NCore classes have no NFF column and are surfaced as extra columns: train_or_tram_car (755), stroller (724), protruding_object (397).
4. hour_of_day in NCore metadata is unreliable (a French clip stamped 03h is full daylight). time_of_day here was assigned by eye.
5. Seasons are winter-skewed (11 of 18). That is a property of the NCore full-modality pool, which is Nov–Feb heavy; the only summer coverage in the whole corpus is Poland in July and the USA in August.
6. Labels are auto-labels (NCore autolabel v2), not human annotation.
7. A chunk is not a drive session — it is a ~100-clip shard spanning days and the whole hour range. Weather was therefore screened per clip, never per chunk.

---

• Clip-level benchmark_role was re-assigned to the fog set's train-heavy convention (12 train / 4 val / 1 test / 1 held_out) by _build/bin/assign_splits.py. What it replaced was the screening plan's label, stamped on 791 candidates before the 18 were chosen, so its 5/8/5 split was an accident of the selection rather than a design. The old labels are still in _screening/FINAL30.csv. France and Sweden appear only in val and the US night clip only in held_out, deliberately, so evaluation tests generalisation.

---

6. Provenance and re-fetching

Every clip records clip_uuid and chunk in provenance.json and manifest.csv, so any clip can be re-fetched from NCore with the toolkit:

python scripts/1_download.py --uuid <clip_uuid> --chunk <chunk> --dest raw/NCF-NN --radar med|high
python scripts/2_convert.py  --src raw/NCF-NN --out clips/NCF-NN__<uuid8>

Use --radar high for NCF-04, NCF-05, NCF-15, NCF-18; --radar med otherwise.

orig_id in manifest.csv maps each clip back to its screening-gallery ID (C02 … C30).

---

7. Known toolkit issues fixed during this build

These were found while building NCF and are corrected here. The first three also affect the published NFF clips, which have not been modified:

issue	effect	status
lidar/*.npy written in the LiDAR sensor frame while README/CONVENTIONS specify ego frame; the transform was applied only in the BEV preview renderer	point cloud and 3D boxes in different frames (~1.9 m vertical, ~1.1 m longitudinal). Ground plane sat at −mount height; box-interior points 98 vs 1,325 on NCF-01	fixed in both halves (NCF 2026-10-14, NFF 2026-10-19); all 32 verified ground ≈ 0 and provenance.lidar_frame == "ego" marks it. The toolkit now reads that marker instead of assuming — Warwick-Jocelyn/nff-toolkit PR #2
radar_config hardcoded "med" in nff/convert.py	the 10-stream clips mislabelled as 8-stream	fixed (derived from the stream list)
class counting matched literal pedestrian/cyclist	VRU columns always zero; NFF's clip_diversity.csv says has_pedestrian=False for all 15 while its manifest.csv counts 93 people	fixed via alias map
2_convert.py emits no splits/ and no radar_bev_viz.mp4	clips incomplete vs NFF layout	fixed by a post-convert step

---

8. Visual review, figures and documents

Everything produced for looking at this set lives under _evaluation/:

_evaluation/
  INDEX.html              local review page: all figures, a contact sheet per clip,
                          and a direct link to every preview and camera video
  figures/                12 PNGs, generated from _evaluation/stats/*.csv
  contact_sheets/         18 JPGs, one per clip
  stats/                  7 CSVs (clip_diversity, class_distribution, radar_stats,
                          ego_trajectory_stats, fog_visibility_metrics,
                          sensor_sync_quality, track_length_distribution)
  bin/                    the generators: make_figures, make_overview,
                          make_sheets, make_index

Open _evaluation/INDEX.html in a browser. The links in it are relative, so keep the file where it is. It is local only — the NVIDIA licence forbids redistributing frames, and the page embeds them.

Each contact sheet shows all 7 rectified cameras, the LiDAR and radar bird's-eye views, and the original-fisheye / undistorted pair for front_wide, every panel sampled at the same instant (t = 10.0 s, i.e. timestep 100 and fisheye frame 300).

The figures worth looking at first:

figure	shows
fig12_clear_vs_fog_frames.png	the clearest NCF clips above the densest NFF fog clips, same camera and pipeline
fig01_clear_vs_fog_visibility.png	every clip on the two visibility metrics — the sets do not overlap
fig11_clear_set_overview.png	the clip set, one front-wide frame each (rendered when the set was 18; NCF-17 has since been withdrawn)
fig02 / fig09	country × lighting coverage, and month of capture
fig03 / fig10	class distribution against the fog set, and scene density
fig04 / fig06	ego dynamics, and how long objects stay visible
fig05 / fig07 / fig08	radar volume, LiDAR return fraction, camera↔LiDAR sync

Regenerate the whole layer after any change to the clips:

python3 _build/bin/make_stats.py --clips-root clips --out _evaluation/stats \
        --meta _screening/FINAL30.csv --origin NCore --severity Clear
python3 _build/bin/make_manifest.py --clips-root clips --stats _evaluation/stats \
        --meta _screening/FINAL30.csv --out .
python3 _build/bin/assign_splits.py --root .
python3 _build/bin/make_docs.py --root . --fog ../NVIDIA_FOGGY_Field --date <today>
python3 _evaluation/bin/make_figures.py  --ncf . --nff ../NVIDIA_FOGGY_Field --out _evaluation/figures
python3 _evaluation/bin/make_overview.py --ncf . --nff ../NVIDIA_FOGGY_Field --out _evaluation/figures
python3 _evaluation/bin/make_sheets.py   --clips clips --manifest manifest.csv \
        --tmp /tmp/ncf_frames --out _evaluation/contact_sheets
python3 _evaluation/bin/make_index.py    --root . --out _evaluation/INDEX.html

Two documents mirror the ones the fog set carries, both generated by make_docs.py so their numbers cannot drift from the CSVs:

• DATASET_SUMMARY.md — aggregate roll-up, visibility separation, taxonomy, per-clip table, known issues.
• HF_DATASET_CARD.md — the card to use if and when this is pushed to HuggingFace, with the licence warning at the top. assets/ holds the images it references.

---

9. Citation

Derived from NVIDIA PhysicalAI-Autonomous-Vehicles (NCore). Cite NVIDIA's dataset; this folder is a curated, format-converted subset and is not redistributable.