mcocheteux/KITTI-C2L-Dataset

KITTI-C2L: Camera–LiDAR Extrinsic Calibration

v1.1.0 — source-consistent calibration update (October 17, 2026). For new experiments, select metadata_full_projection and windows_full_projection. These use the complete KITTI projection matrix, correcting a 0.51–0.83 cm translation difference in our legacy conversion. This is an exact conversion of the supplied calibration, not newly measured or independently improved physical ground truth.

The metadata (including the default configuration) and windows configurations retain the frozen v1.0 labels for reproducibility. All configurations share the same 22,400 source frames and 50 sensor shards; the new metadata adds no recordings. Never mix label conventions within an experiment. See the calibration audit and migration guide, standalone calibration matrices, and v1-trained checkpoint re-evaluation.

KITTI-C2L is a reproducible KITTI-derived dataset for training and evaluating camera–LiDAR extrinsic calibration under controlled synthetic miscalibration. It provides fixed perturbations, ground-truth and miscalibrated extrinsics, and references to the corresponding KITTI frames. Camera and LiDAR transforms are perturbed independently before composing the relative extrinsic.

Same image and LiDAR scan, different extrinsics. Sequence 00, frame 000120; left: the published stage-3 synthetic perturbation; right: the v1.1 KITTI reference. Both panels use the same central crop and LiDAR-range colour scale. This is a geometry illustration, not a model prediction.

Download the SVG figure · Reproduce the figure and inspect its provenance. Source: KITTI / Geiger et al. (2013), CC BY-NC-SA 3.0.

The self-contained dataset is already uploaded to Hugging Face. It includes 44 training and 6 test asset shards, approximately 52 GB in total, plus the frozen calibration metadata. Each image and point cloud is stored once per source frame, shared across difficulty stages and sequence windows. A lightweight metadata-only package remains available for users with local KITTI data. Both carry KITTI's CC BY-NC-SA 3.0 terms. This release supports single-frame experiments and constant-error sequence windows. It does not contain measured sensor drift or establish parity with published UniCal accuracy.

Release contents

The asset configuration contains 19,608 train frames and 2,792 test frames. The legacy metadata and windows below reference those same source recordings. The new metadata_full_projection and windows_full_projection configurations use data_v1_1/ and have exactly the same respective row counts:

Configuration	File	Rows	Underlying frames
metadata train	data/train.parquet	98,040	19,608
metadata test	data/test.parquet	13,960	2,792
windows train	data/windows_train.parquet	3,290	Same 19,608
windows test	data/windows_test.parquet	475	Same 2,792

Metadata has five rows per frame, one for each difficulty stage. Windows have five rows per non-overlapping window. They reuse the same sensor frames and must not be counted as additional independent recordings.

The original Parquet bytes are frozen from source commit d4ba9d7. The manifest records SHA-256 checksums, sizes and per-sequence row counts. Provenance records the original generator commit and source-calibration hashes. The protocol fixes the seeds, split policy and conventions. The frames configuration exposes the existing asset shards. The pinned Hub manifest records their inventory and audit scope. Metadata-only downloaders can skip these shards.

Load the metadata

From a local release directory, install pyarrow and read without executing custom loading code:

import pyarrow.parquet as pq

rows = pq.read_table("data_v1_1/train.parquet").to_pylist()
train = [r for r in rows if r["sequence"] != "07" and r["stage"] == 5]
validation = [r for r in rows if r["sequence"] == "07" and r["stage"] == 5]
test = [r for r in pq.read_table("data_v1_1/test.parquet").to_pylist() if r["stage"] == 5]

The Hub exposes five configurations. The examples below use the new full-projection labels. For a large asset configuration, stream rather than loading all sensor bytes into RAM:

from datasets import load_dataset

repo = "mcocheteux/KITTI-C2L-Dataset"
dataset = load_dataset(repo, "metadata_full_projection", revision="v1.1.0")
windows = load_dataset(repo, "windows_full_projection", revision="v1.1.0")
frames = load_dataset(repo, "frames", split="train", streaming=True, revision="v1.1.0")

from kitti_c2l.loader.dataset import materialize_sample_from_assets

asset = next(iter(frames))
# Join by frame identity, not by relying on ordering between configurations.
row = next(r for r in dataset["train"]
           if r["sequence"] == asset["sequence"]
           and r["frame_index"] == asset["frame_index"] and r["stage"] == 5)
sample = materialize_sample_from_assets(row, asset)

Install the loader (Python 3.10–3.12) before running the examples above:

pip install datasets 'https://huggingface.co/datasets/mcocheteux/KITTI-C2L-Dataset/resolve/v1.1.0/downloads/kitti_c2l-0.2.0-py3-none-any.whl'

The loader and generator source and source archive are available without GitHub access. To materialize from an existing local Raw download:

from kitti_c2l.loader.dataset import materialize_sample, materialize_window_frame

sample = materialize_sample(train[0], kitti_raw_root="/path/to/kitti_raw")
# image: uint8 RGB [H,W,3]; points: float32 [N,3], CENTIMETRES.
# lidar_depth: float32 [1,H,W], inverse depth using centimetre-based distances.
# Divide points/translations by 100 for a metre-based pipeline; inverse depth
# values must be multiplied by 100 to convert cm^-1 to m^-1.

# For a window row, use offsets 0 <= offset < row["window_length"].
# materialize_window_frame(window_row, frame_offset=0, kitti_raw_root="...")

The bundled loader expects KITTI Raw layout: <root>/<date>/<date>_drive_<drive>_sync/image_02/data/<raw_frame_index:010d>.png and the matching velodyne_points/data/*.bin. Odometry-layout users must resolve sequence/frame_index themselves; the bundled loader does not accept an odometry directory directly. Optional PyTorch support requires pip install torch.

Benchmark splits

The stored source train split includes sequences 00, 01, 02, 04–08; test contains 09 and 10. The recommended benchmark holds out all of 07 for validation, leaving 00, 01, 02, 04, 05, 06, 08 for training. Apply the same holdout to both configurations, before constructing batches. At stage 5 this gives 18,507 training, 1,101 validation and 2,792 test frames.

Do not randomly split adjacent frames, put different stages of one frame in different splits, or mix frame/window versions of a recording across splits. Choose checkpoints and hyperparameters using validation only. Report both test drives individually as well as the aggregate, and report seed variation. The test frames are from the labelled KITTI Odometry 00–10 subset, not KITTI's hidden leaderboard test set; this is an independent calibration protocol.

Sequence 03 is excluded because its corresponding Raw drive was unavailable when this snapshot was built. v1 covers 10 of 11 labelled odometry sequences. Sequence 08 starts at Raw frame 1100, not zero. Its drive 2011_09_30_drive_0028 is used as a test drive in some published calibration protocols: models trained on full C2L must not claim unseen-test performance there. Use a separately named training split excluding 08 for that comparison.

Perturbations and coordinates

Stage	Each sensor's rotation, per axis	Each sensor's translation, per axis
1	±20°	±150 cm
2	±10°	±100 cm
3	±5°	±50 cm
4	±2°	±20 cm
5	±1°	±10 cm

Draws are uniform per axis, with LiDAR rotation and translation sampled first, then camera rotation and translation from a seeded NumPy generator. Bounds apply to each sensor, not the final relative transform. Composing two perturbations produces a different, generally wider relative-error distribution than applying one bounded relative perturbation. Report the selected stages; pooled-stage results cannot be compared directly with stage-5 results.

Rotations act on column vectors: p_B = R_B_from_A @ p_A + t_B_from_A. Matrices are row-major lists. Euler draws use degrees with R = Rz(yaw) @ Ry(pitch) @ Rx(roll) (fixed-axis XYZ). Translations in metadata are centimetres, camera intrinsics are in pixels, and camera_id=2 refers to rectified left colour images. KITTI point-cloud files store metres; the bundled loader converts them to centimetres.

Using homogeneous matrices, the frozen protocol is:

T_init = delta_cam @ T_gt @ inverse(delta_lidar)
T_decal = T_init @ inverse(T_gt)
T_init = T_decal @ T_gt
T_corrected = inverse(predicted_T_decal) @ T_init

A model may instead predict the inverse correction; document which target it uses. The sampling represents synthetic coordinate-transform errors applied to fixed recordings, not a physical re-recording after moving either sensor.

metadata samples independently per (sequence, frame, stage), with base seed 20260712. windows uses base seed 20260714, one fixed perturbation per (sequence, window_start, stage), and non-overlapping 30-frame tiles (approximately 3 seconds). Final tiles may be shorter. Do not feed adjacent independently perturbed metadata rows to a model assuming a constant error; use window rows and stop/reset temporal state at every boundary. Drift and step-jump variants are not part of v1.

Schema

The exact Arrow schemas are defined in schema.py.

Fields	Meaning
sample_id / window_id	Stable (sequence, frame-or-window-start, stage) identifier
sequence, frame_index	Odometry sequence and zero-based frame index
window_start_frame, window_length	Window start and actual length (windows only)
split, stage, stage_max_*	Source train/test assignment and per-sensor bounds
sample_seed, delta_lidar_*, delta_cam_*	Seed and sampled sensor deltas, degrees/cm
gt_R_cam_from_velo, gt_t_cam_from_velo_cm	Ground-truth relative rotation (9 values) and translation (3)
miscal_R_cam_from_velo, miscal_t_cam_from_velo_cm	Composed miscalibrated relative transform
camera_intrinsics, image_width, image_height, camera_id	Row-major 3×3 K, dimensions and rectified camera
raw_date, raw_drive, raw_frame_index	Source Raw reference (metadata)
raw_frame_start_index	Source Raw window start (windows)

Evaluation and existing evidence

BASELINES.md records our three-seed UniCal comparisons, training recipe, metrics and reproduction instructions. The machine-readable assessment preserves source-report hashes and paired uncertainty. The preparation verification records the three exported-checkpoint re-evaluations; the optional separate model artifacts are identified in baselines_manifest.json. PROTOCOL.md defines evaluation targets and metric formulas.

Frozen C2L supports useful calibration learning in our unchanged-main UniCal runs. Our improved implementation gives better native-target results but about 14–15% worse usual-relative errors than usual KITTI under its matched short recipe. Regenerating customary relative perturbations on the same frames meets our 10% comparison margin. The two target distributions must remain separate. These are research baselines from one implementation family on two held-out drives, not evidence of universal parity, published UniCal reproduction or real-world calibration robustness.

Known limitations

• Synthetic errors, fixed underlying recordings, one KITTI rig/camera selection and a narrow driving domain. No measured mounting changes, other weather or independent real-world ground truth beyond KITTI's calibration.
• Legacy v1.0 labels use an x-only baseline shift. The full three-component shift solve(K, P[:,3]) differs by 0.51–0.83 cm in Euclidean translation. The v1.1 full-projection configurations correct this conversion. Neither convention establishes sub-centimetre physical ground-truth accuracy. All historical training comparisons above use the legacy v1.0 labels.
• Only sequences 09/10 provide held-out evidence here. Broader claims require other methods and independent datasets. Repeated model development against these public test frames weakens their value as unseen evidence.

Upload audit

The pinned Hub inventory covers all 50 shard schemas and all 22,400 frame identities/source mappings. Metadata checksums match the training snapshot. The smallest train/test shards were additionally downloaded and all 149 sensor pairs matched local KITTI Raw byte-for-byte and decoded successfully. Other payload hashes are Hub LFS declarations; this is not a full 52 GB payload re-download. See the audit manifest and payload verification.

Reproduce and validate

For the v1.1 full-projection protocol, follow CALIBRATION.md and pass --camera-model full_projection_v1_1 during generation. The commands below audit and regenerate the frozen legacy v1.0 subset.

Inside the source checkout:

uv sync --python 3.11 --extra dev --extra release --locked
uv run kitti-c2l validate --root .
# Also compare every sequence's GT against your local source calibration:
uv run kitti-c2l validate --root . --kitti-calib-root /path/to/kitti_raw
uv run pytest
uv build

Regenerate metadata into a separate directory with kitti-c2l generate --kitti-calib-root /path/to/kitti_raw --output-dir scratch/frame and windows with kitti-c2l generate-windows --kitti-calib-root /path/to/kitti_raw --output-dir scratch/window. Do not overwrite the frozen files. Seeds define the numerical protocol; exact Parquet encoding can depend on library versions. Use the manifest to verify downloaded bytes and compare rows when regenerating with another Arrow version.

See RELEASING.md for the local staging and publication steps.

Source data, licensing and citation

Data and derived calibration metadata are CC BY-NC-SA 3.0, following KITTI; see LICENSE-DATA. The loader and generation code are MIT; see LICENSE. The mirrored UniCal assessment retains CC BY-NC 4.0; see third-party provenance. Baseline model weights and their UniCal source use CC BY-NC 4.0 and are packaged separately; see BASELINES.md. The frames shards contain verbatim KITTI PNG images and Velodyne binary scans; KITTI attribution, noncommercial and share-alike terms apply. The metadata-only alternative contains no sensor payloads. Local asset-building functionality does not itself grant redistribution rights.

Cite KITTI and this dataset using CITATION.cff. v1.1.0 — released October 17, 2026. The versioned snapshot adds the full-projection metadata, calibration audit and baseline re-evaluations while retaining the existing 50 sensor shards, frozen metadata, loader source and downloads, and verified UniCal checkpoints. Pin revision="v1.1.0" in load_dataset calls for reproducible experiments. This release has no DOI or PyPI publication.