| |
| """Render a real KITTI-C2L pair, without synthesizing or retouching sensor data. |
| |
| Requirements: numpy, pillow, pyarrow, matplotlib. |
| Use the frozen legacy metadata and v1.1 calibration_reference.json. The exact |
| published seed regenerates the independent sensor deltas, which are checked |
| against the legacy row before composing the v1.1 full-projection extrinsic. |
| The same central crop, raw LiDAR scan, range colours and marker style are used |
| in both panels. This is a geometry illustration, not a model prediction. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import hashlib |
| import io |
| import json |
| from pathlib import Path |
|
|
| import matplotlib |
|
|
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| import numpy as np |
| import pyarrow.parquet as pq |
| from matplotlib.colors import Normalize |
| from PIL import Image |
|
|
|
|
| def euler_matrix(degrees): |
| r, p, y = np.deg2rad(degrees) |
| rx = np.array([[1, 0, 0], [0, np.cos(r), -np.sin(r)], [0, np.sin(r), np.cos(r)]]) |
| ry = np.array([[np.cos(p), 0, np.sin(p)], [0, 1, 0], [-np.sin(p), 0, np.cos(p)]]) |
| rz = np.array([[np.cos(y), -np.sin(y), 0], [np.sin(y), np.cos(y), 0], [0, 0, 1]]) |
| return rz @ ry @ rx |
|
|
|
|
| def sensor_delta(rng, max_rotation, max_translation): |
| angles = rng.uniform(-max_rotation, max_rotation, 3) |
| translation = rng.uniform(-max_translation, max_translation, 3) |
| transform = np.eye(4) |
| transform[:3, :3] = euler_matrix(angles) |
| transform[:3, 3] = translation |
| return transform, angles, translation |
|
|
|
|
| def file_sha256(path): |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def prepare(args): |
| matches = pq.read_table( |
| args.metadata, |
| filters=[("sequence", "=", args.sequence), ("frame_index", "=", args.frame), ("stage", "=", args.stage)], |
| ).to_pylist() |
| if len(matches) != 1: |
| raise ValueError(f"Expected one metadata row, got {len(matches)}") |
| row = matches[0] |
| refs = json.loads(args.reference.read_text()) |
| calibration = refs["calibrations"][row["raw_date"]] |
| reference = np.array(calibration["T_rectified_camera2_from_velodyne_cm"]) |
| intrinsics = np.array(calibration["K_rectified_camera2"]) |
| rng = np.random.default_rng(row["sample_seed"]) |
| lidar, lidar_angles, lidar_t = sensor_delta(rng, row["stage_max_rotation_deg"], row["stage_max_translation_cm"]) |
| camera, camera_angles, camera_t = sensor_delta(rng, row["stage_max_rotation_deg"], row["stage_max_translation_cm"]) |
| for name, angles, translation in [("lidar", lidar_angles, lidar_t), ("cam", camera_angles, camera_t)]: |
| stored = [row[f"delta_{name}_{axis}_deg"] for axis in ("roll", "pitch", "yaw")] |
| np.testing.assert_allclose(angles, stored, rtol=1e-6, atol=1e-6) |
| stored_t = [row[f"delta_{name}_t{axis}_cm"] for axis in "xyz"] |
| np.testing.assert_allclose(translation, stored_t, rtol=1e-6, atol=1e-5) |
| legacy = reference.copy() |
| legacy[:3, 3] -= np.array(calibration["translation_delta_from_legacy_cm"]) |
| legacy_miscal = camera @ legacy @ np.linalg.inv(lidar) |
| np.testing.assert_allclose(legacy[:3, :3], np.array(row["gt_R_cam_from_velo"]).reshape(3, 3), atol=5e-8) |
| np.testing.assert_allclose(legacy[:3, 3], row["gt_t_cam_from_velo_cm"], atol=3e-6) |
| np.testing.assert_allclose(legacy_miscal[:3, :3], np.array(row["miscal_R_cam_from_velo"]).reshape(3, 3), atol=5e-8) |
| np.testing.assert_allclose(legacy_miscal[:3, 3], row["miscal_t_cam_from_velo_cm"], atol=1e-5) |
| miscal = camera @ reference @ np.linalg.inv(lidar) |
|
|
| wanted = f"{args.sequence}_{args.frame:06d}" |
| asset = None |
| for batch in pq.ParquetFile(args.assets).iter_batches(batch_size=16): |
| for candidate in batch.to_pylist(): |
| if candidate["frame_id"] == wanted: |
| asset = candidate |
| break |
| if asset is not None: |
| break |
| if asset is None: |
| raise ValueError(f"No asset {wanted} in {args.assets}") |
| assert asset["sequence"] == row["sequence"] |
| assert asset["raw_frame_index"] == row["raw_frame_index"] |
| image = np.array(Image.open(io.BytesIO(asset["image_png"])).convert("RGB")) |
| scan = np.frombuffer(asset["points_bin"], dtype="<f4").reshape(-1, 4) |
| points_cm = scan[:, :3].astype(np.float64) * 100 |
| ranges = np.linalg.norm(scan[:, :3], axis=1) |
| asset_sha256 = file_sha256(args.assets) |
| published_shard = "841dfff386059908515c05376cd6226d0dce84402798341dce2b138d32f228d6" |
| if args.sequence == "00" and args.frame == 120: |
| assert asset_sha256 == published_shard, "Asset shard differs from published inventory" |
| provenance = { |
| "dataset": "mcocheteux/KITTI-C2L-Dataset", |
| "source_revision": "115005094f96a9cca4a1ea8c64a387c0cbb4de72", |
| "geometry_protocol": "full_projection_v1_1", |
| "sample_id": row["sample_id"], |
| "sample_seed": row["sample_seed"], |
| "camera_id": row["camera_id"], |
| "raw_date": row["raw_date"], |
| "raw_drive": row["raw_drive"], |
| "raw_frame_index": row["raw_frame_index"], |
| "image_png_sha256": hashlib.sha256(asset["image_png"]).hexdigest(), |
| "points_bin_sha256": hashlib.sha256(asset["points_bin"]).hexdigest(), |
| "asset_shard_sha256": asset_sha256, |
| "legacy_metadata_sha256": hashlib.sha256(args.metadata.read_bytes()).hexdigest(), |
| "calibration_reference_sha256": hashlib.sha256(args.reference.read_bytes()).hexdigest(), |
| "reference_transform_cm": reference.tolist(), |
| "miscalibrated_transform_cm": miscal.tolist(), |
| "intrinsics": intrinsics.tolist(), |
| "source_shape": list(image.shape), |
| "crop_xyxy": [220, 0, 1020, 376], |
| "point_colours": "Unchanged raw LiDAR Euclidean range, turbo, 2 to 60 metres", |
| "projection_filter": "Positive camera Z above 2 metres; native image field of view; raw range 2 to 60 metres", |
| "sensor_data_modified": False, |
| "model_prediction": False, |
| "license": "CC BY-NC-SA 3.0; KITTI: A. Geiger, P. Lenz, C. Stiller, R. Urtasun (2013)", |
| "checks": { |
| "seed_deltas_match_published_metadata": True, |
| "legacy_recomposition_matches_published_extrinsic": True, |
| "same_image_scan_crop_and_colour_scale_both_panels": True, |
| "asset_shard_matches_published_sha256": asset_sha256 == published_shard, |
| }, |
| } |
| return row, image, points_cm, ranges, reference, miscal, intrinsics, provenance |
|
|
|
|
| def project(points_cm, transform, intrinsics, width, height, ranges): |
| camera = points_cm @ transform[:3, :3].T + transform[:3, 3] |
| positive = camera[:, 2] > 200 |
| uv = np.full((len(camera), 2), np.nan) |
| homogeneous = camera[positive] @ intrinsics.T |
| uv[positive] = homogeneous[:, :2] / homogeneous[:, 2:3] |
| valid = positive & (ranges >= 2) & (ranges <= 60) |
| valid &= (uv[:, 0] >= 0) & (uv[:, 0] < width) & (uv[:, 1] >= 0) & (uv[:, 1] < height) |
| return uv[valid], ranges[valid] |
|
|
|
|
| def render(args): |
| row, image, points, ranges, reference, miscal, intrinsics, provenance = prepare(args) |
| plt.rcParams.update({"font.family": "DejaVu Sans", "svg.fonttype": "none"}) |
| width, height = 2400, 1320 |
| fig = plt.figure(figsize=(width / 150, height / 150), dpi=150, facecolor="#F6F7F9") |
| ink, muted = "#142438", "#556477" |
|
|
| def text(x, y, value, size, **kw): |
| return fig.text(x / width, 1 - y / height, value, fontsize=size * 72 / 150, |
| color=kw.pop("color", ink), va="top", **kw) |
|
|
| text(104, 64, "KITTI-C2L", 104, weight="bold") |
| text(108, 192, "Reproducible camera–LiDAR calibration", 49, color=muted) |
| text(2294, 91, "REAL KITTI DATA", 26, ha="right", weight="bold", color=muted) |
| text(2294, 133, "Controlled synthetic miscalibration", 25, ha="right", color=muted) |
|
|
| panel_y, panel_h, panel_w = 382, 509.48, 1084 |
| crop = provenance["crop_xyxy"] |
| for index, (x, transform, title, colour, subtitle) in enumerate([ |
| (104, miscal, "Synthetic miscalibration", "#B85120", f"Published stage {args.stage} perturbation"), |
| (1212, reference, "KITTI reference calibration", "#087F79", "Full-projection reference · v1.1"), |
| ]): |
| text(x, 293, title, 48, weight="bold", color=colour) |
| text(x, 354, subtitle, 29, color=muted) |
| ax = fig.add_axes([x / width, 1 - (panel_y + panel_h + 30) / height, panel_w / width, panel_h / height]) |
| ax.imshow(image, interpolation="nearest") |
| uv, depth = project(points, transform, intrinsics, image.shape[1], image.shape[0], ranges) |
| order = np.argsort(depth)[::-1] |
| ax.scatter(uv[order, 0], uv[order, 1], c=depth[order], cmap="turbo", norm=Normalize(2, 60), |
| s=1.0, alpha=0.9, linewidths=0, rasterized=True) |
| ax.set_xlim(crop[0] - .5, crop[2] - .5) |
| ax.set_ylim(crop[3] - .5, crop[1] - .5) |
| ax.set_aspect("equal", adjustable="box") |
| ax.set_axis_off() |
| provenance[f"panel_{index}_visible_points"] = int(((uv[:, 0] >= crop[0]) & (uv[:, 0] < crop[2]) & (uv[:, 1] >= crop[1]) & (uv[:, 1] < crop[3])).sum()) |
|
|
| text(104, 973, "Same image. Same LiDAR scan. Different extrinsics.", 48, weight="bold") |
| text(108, 1045, "LiDAR points are coloured by distance; only the projection geometry changes.", 33, color=muted) |
| gradient = fig.add_axes([108 / width, 1 - 1140 / height, 440 / width, 18 / height]) |
| gradient.imshow(np.linspace(2, 60, 440)[None, :], cmap="turbo", aspect="auto", extent=[2, 60, 0, 1]) |
| gradient.set_axis_off() |
| text(108, 1155, "2 m", 25, color=muted) |
| text(548, 1155, "60 m", 25, color=muted, ha="right") |
| text(595, 1117, "LiDAR range", 28, color=muted) |
| text(2296, 1117, f"Sequence {args.sequence} · Frame {args.frame:06d} · Stage {args.stage}", 28, color=muted, ha="right") |
| text(2296, 1155, "Geometry illustration · no model prediction", 26, color=muted, ha="right") |
| fig.add_artist(plt.Line2D([104 / width, 2296 / width], [1 - 1220 / height] * 2, |
| color="#D9DFE7", linewidth=.8, transform=fig.transFigure)) |
| text(108, 1249, "Source: KITTI / Geiger et al. (2013) · CC BY-NC-SA 3.0", 25, color=muted) |
| text(2296, 1249, "huggingface.co/datasets/mcocheteux/KITTI-C2L-Dataset", 24, color=muted, ha="right") |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| fig.savefig(args.output, dpi=150, facecolor=fig.get_facecolor(), metadata={"Title": "KITTI-C2L calibration comparison", "Description": "Real sensor projections; synthetic miscalibration versus KITTI reference; no model prediction."}) |
| plt.close(fig) |
| |
| |
| encoded = base64.b64encode(args.output.read_bytes()).decode("ascii") |
| svg = ( |
| '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' |
| f'width="{width}" height="{height}" viewBox="0 0 {width} {height}">\n' |
| '<title>KITTI-C2L: synthetic miscalibration and KITTI reference calibration</title>\n' |
| '<desc>Real sequence 00 frame 120, stage 3; identical sensor data, crop, and range colours; ' |
| 'v1.1 full-projection geometry. Source: KITTI / Geiger et al. (2013), CC BY-NC-SA 3.0. ' |
| 'Geometry illustration, no model prediction.</desc>\n' |
| f'<image width="{width}" height="{height}" xlink:href="data:image/png;base64,{encoded}"/>\n' |
| '</svg>\n' |
| ) |
| args.output.with_suffix(".svg").write_text(svg) |
| Image.open(args.output).save(args.output.with_suffix(".webp"), quality=92, method=6) |
| args.output.with_suffix(".json").write_text(json.dumps(provenance, indent=2) + "\n") |
| print(json.dumps({"output": str(args.output), "sample": row["sample_id"], "checks": provenance["checks"]})) |
|
|
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--metadata", type=Path, required=True, help="Frozen legacy data/train.parquet") |
| parser.add_argument("--reference", type=Path, required=True, help="release/v1.1.0/calibration_reference.json") |
| parser.add_argument("--assets", type=Path, required=True, help="Asset shard containing the chosen frame") |
| parser.add_argument("--sequence", default="00") |
| parser.add_argument("--frame", type=int, default=120) |
| parser.add_argument("--stage", type=int, default=3) |
| parser.add_argument("--output", type=Path, required=True) |
| render(parser.parse_args()) |
|
|
