KITTI

Bases: TypedDict

KITTI camera/LiDAR calibration

Bases: PointCloudDataset

KITTI 3D object-detection dataset (LiDAR points + raw LiDAR-frame ground-truth boxes).

The raw object split is read from <root>/KITTI/raw/<split>/ and processed once into a per-frame .npy cache (<root>/KITTI/processed_fov/<split>/ when fov=True, else <root>/KITTI/processed/), so each __getitem__ is a flat array read. The whole split is processed; split_file only selects which cached frames to load. Frames are loaded lazily from the cache, so a full split does not need to fit in host memory.

KITTI requires manual download (a license must be accepted), so download=True raises with the download URL rather than fetching anything.

Parameters:

• root (PathLike) –

  Dataset root; raw data is read from <root>/KITTI/raw/<split>/.

• train (bool, default: True ) –

  If True, reads the training split directory, otherwise testing.

• split_file (Optional[PathLike], default: None ) –

  Optional text file of frame ids (one per line) selecting which cached frames to load; defaults to every processed frame.

• fov (bool, default: True ) –

  Restrict points to the front-camera field of view (requires image_2/). Baked into the cache.

• return_calib (bool, default: False ) –

  Also emit the calib (the composed \((3, 4)\) LiDAR-to-image matrix \(P_2 [R_0 T_\text{velo}]\) with the perspective-divide row from \(R_0 T_\text{velo}\), the projected_ignore_mask contract) and image_shape (image (height, width)) keys, read lazily at access time from the raw calib/ txt and the image_2/ PNG header (both must be present in the raw split).

• transform (Optional[Callable[[Dict[str, Any]], Dict[str, Any]]], default: None ) –

  Callable applied to each sample dict (e.g. RelabelBoxes + the model's transform).

• download (bool, default: False ) –

  Unsupported; raises a RuntimeError pointing at the manual download page when set.

• force_download (bool, default: False ) –

  Unsupported; raises like download.

• force_process (bool, default: False ) –

  Reprocess the raw split even if a cache already exists.

• show_progress (bool, default: True ) –

  Show a progress bar while processing.

• num_workers (Optional[int], default: None ) –

  Worker processes for processing, or None for sequential processing.

from torch_pointcloud.datasets import KITTI

dataset = KITTI(root="data", train=True)
sample = dataset[0]
sample["pos"].shape  # (N, 3)
sample["box"].shape  # (K, 7)

Methods:

• download –

  KITTI must be downloaded manually after accepting its license.

• process –

  Convert every raw frame in the split into its .npy cache directory.

• process_frame –

  Read one raw frame (optionally FOV-filtered) and write its .npy cache.

• load –

  Enumerate the cached frames to load, honoring split_file when given.

Attributes:

• processed_dir (str) –

  Path to the processed cache directory, suffixed _fov when the clouds are cropped to the camera view.

• raw_split_dir (Path) –

  Path to the split's raw directory.

• processed_split_dir (Path) –

  Path to the split's processed cache directory.

• frame_ids (List[str]) –

  Frame ids of the loaded samples, in dataset order.

• name (str) –

  Name of the dataset directory.

• data_dir (str) –

  Path to the dataset directory <root>/<name>.

• raw_dir (str) –

  Path to the raw download directory.

processed_dir: str

raw_split_dir: Path

processed_split_dir: Path

frame_ids: List[str]

name: str

data_dir: str

raw_dir: str

download(force: bool = False) -> None

process(
    force: bool = False,
    num_workers: Optional[int] = None,
    show_progress: bool = True,
) -> None

process_frame(frame: str) -> None

load() -> None