| """ |
| Cub3 dataset loading utilities for Alligat0R pre-training and fine-tuning. |
| |
| Usage: |
| from cub3 import NuScenesDataset, ScanNetDataset |
| |
| dataset = NuScenesDataset(overlap="all", nuscenes_root="data/nuscenes", with_seg=True) |
| img1, img2, seg1, seg2 = dataset[0] |
| |
| See https://github.com/thibautloiseau/alligat0r for full training scripts. |
| """ |
|
|
| import json |
| import numpy as np |
| import torch |
| import torchvision.transforms as transforms |
| import torchvision.transforms.functional as F |
| from torch.utils.data import Dataset |
| from scipy.spatial.transform import Rotation as Rot |
| from pathlib import Path |
| from PIL import Image |
|
|
|
|
| |
| |
| |
|
|
| _nuscenes_default_transform = transforms.Compose([ |
| transforms.Resize(size=336, max_size=512, interpolation=transforms.InterpolationMode.BICUBIC), |
| transforms.ColorJitter(brightness=(0.6, 1.4), contrast=(0.6, 1.4), saturation=(0.6, 1.4), hue=0.0), |
| transforms.ToTensor(), |
| transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), |
| ]) |
|
|
| _nuscenes_inference_transform = transforms.Compose([ |
| transforms.Resize(size=336, max_size=512, interpolation=transforms.InterpolationMode.BICUBIC), |
| transforms.ToTensor(), |
| transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), |
| ]) |
|
|
|
|
| class NuScenesDataset(Dataset): |
| """Cub3 dataset loader for nuScenes image pairs with covisibility masks. |
| |
| Args: |
| overlap: ``"50"`` for Cub3-50 or ``"all"`` for Cub3-all. |
| nuscenes_root: path to the raw nuScenes images (``sweeps/`` subdirectory). |
| cub3_root: path to the Cub3 annotations directory. |
| with_seg: if True, return covisibility segmentation masks. |
| need_pose: if True, return relative pose (quaternion + translation). |
| binary_mode: optional binary classification variant |
| (``"covis_vs_all"`` or ``"fov_vs_out"``). Default: three-class. |
| sensitivity: fraction of labels to randomly perturb (label-noise regularization). |
| """ |
|
|
| def __init__( |
| self, |
| overlap="all", |
| nuscenes_root="data/nuscenes", |
| cub3_root="data/Cub3/nuscenes", |
| with_seg=False, |
| need_pose=False, |
| binary_mode=None, |
| sensitivity=0.0, |
| ): |
| self.transforms = _nuscenes_default_transform |
| self.train_samples = json.load(open(f"{cub3_root}/train_samples_{overlap}.json")) |
| self.nuscenes_root = nuscenes_root |
| self.with_seg = with_seg |
| self.need_pose = need_pose |
| self.binary_mode = binary_mode |
| self.sensitivity = sensitivity |
|
|
| if with_seg: |
| self.seg_root = f"{cub3_root}/train_seg_{overlap}" |
|
|
| def __len__(self): |
| return len(self.train_samples) |
|
|
| def _load_image(self, img): |
| sensor = img.split("__")[1] |
| img_path = Path(self.nuscenes_root) / "sweeps" / sensor / img |
| return self.transforms(Image.open(img_path)) |
|
|
| def _load_seg(self, scene, img1, img2): |
| seg_path = Path(self.seg_root) / scene / "seg_aligned" / f"{img1}+{img2}.png" |
| seg = np.array(Image.open(seg_path).convert("L")) |
|
|
| if self.binary_mode == "covis_vs_all": |
| seg_classes = torch.zeros_like(torch.from_numpy(seg), dtype=torch.long) |
| seg_classes[(seg == 128) | (seg == 0)] = 1 |
| elif self.binary_mode == "fov_vs_out": |
| seg_classes = torch.zeros_like(torch.from_numpy(seg), dtype=torch.long) |
| seg_classes[seg == 0] = 1 |
| else: |
| seg_classes = torch.zeros_like(torch.from_numpy(seg), dtype=torch.long) |
| seg_classes[seg == 128] = 1 |
| seg_classes[seg == 0] = 2 |
|
|
| if self.sensitivity > 0: |
| random_mask = torch.rand(seg_classes.size()) < self.sensitivity |
| random_labels = torch.randint(1, 3, size=seg_classes.size()) |
| seg_classes = (seg_classes + random_mask * random_labels) % 3 |
|
|
| seg_classes = seg_classes.unsqueeze(0) |
| seg_classes = F.resize( |
| seg_classes, size=336, max_size=512, interpolation=transforms.InterpolationMode.NEAREST |
| ).squeeze(0) |
| return seg_classes |
|
|
| def __getitem__(self, idx): |
| img1_name, img2_name, scene, pose, overlap, angle, dist_ratio = self.train_samples[idx] |
| img1 = self._load_image(img1_name) |
| img2 = self._load_image(img2_name) |
| to_return = [img1, img2] |
|
|
| if self.with_seg: |
| seg1 = self._load_seg(scene, img1_name, img2_name) |
| seg2 = self._load_seg(scene, img2_name, img1_name) |
| to_return.extend([seg1, seg2]) |
|
|
| if self.need_pose: |
| pose_matrix = np.array(pose) |
| R = pose_matrix[:3, :3] |
| t = pose_matrix[:3, 3].astype(np.float32) |
| q = Rot.from_matrix(R).as_quat().astype(np.float32) |
| to_return.extend([q, t]) |
|
|
| return to_return |
|
|
|
|
| |
| |
| |
|
|
| _scannet_default_transform = transforms.Compose([ |
| transforms.Resize(size=(384, 512), interpolation=transforms.InterpolationMode.BICUBIC), |
| transforms.ColorJitter(brightness=(0.6, 1.4), contrast=(0.6, 1.4), saturation=(0.6, 1.4), hue=0.0), |
| transforms.ToTensor(), |
| transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), |
| ]) |
|
|
| _scannet_inference_transform = transforms.Compose([ |
| transforms.Resize(size=(384, 512), interpolation=transforms.InterpolationMode.BICUBIC), |
| transforms.ToTensor(), |
| transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), |
| ]) |
|
|
|
|
| class ScanNetDataset(Dataset): |
| """Cub3 dataset loader for ScanNet image pairs with covisibility masks. |
| |
| Args: |
| overlap: ``"50"`` for Cub3-50 or ``"all"`` for Cub3-all. |
| scannet_root: path to the raw ScanNet images. |
| cub3_root: path to the Cub3 annotations directory. |
| with_seg: if True, return covisibility segmentation masks. |
| need_pose: if True, return relative pose (quaternion + translation). |
| binary_mode: optional binary classification variant. |
| sensitivity: fraction of labels to randomly perturb. |
| """ |
|
|
| def __init__( |
| self, |
| overlap="all", |
| scannet_root="data/scannet", |
| cub3_root="data/Cub3/scannet", |
| with_seg=False, |
| need_pose=False, |
| binary_mode=None, |
| sensitivity=0.0, |
| ): |
| self.transforms = _scannet_default_transform |
| self.train_samples = json.load(open(f"{cub3_root}/train_samples_{overlap}.json")) |
| self.scannet_root = scannet_root |
| self.with_seg = with_seg |
| self.need_pose = need_pose |
| self.binary_mode = binary_mode |
| self.sensitivity = sensitivity |
|
|
| if with_seg: |
| self.seg_root = cub3_root |
|
|
| def __len__(self): |
| return len(self.train_samples) |
|
|
| def _load_image(self, scene, img): |
| img_path = Path(self.scannet_root) / "scans" / scene / "color" / img |
| return self.transforms(Image.open(img_path)) |
|
|
| def _load_seg(self, scene, img1, img2): |
| seg_path = Path(self.seg_root) / scene / "segs" / f"{img1}+{img2}.png" |
| seg = np.array(Image.open(seg_path).convert("L")) |
| seg_classes = torch.zeros_like(torch.from_numpy(seg), dtype=torch.long) |
| seg_classes[seg == 42] = -100 |
|
|
| if self.binary_mode == "covis_vs_all": |
| seg_classes[(seg == 128) | (seg == 0)] = 1 |
| elif self.binary_mode == "fov_vs_out": |
| seg_classes[seg == 0] = 1 |
| else: |
| seg_classes[seg == 128] = 1 |
| seg_classes[seg == 0] = 2 |
|
|
| if self.sensitivity > 0: |
| random_mask = torch.rand(seg_classes.size()) < self.sensitivity |
| random_labels = torch.randint(1, 3, size=seg_classes.size()) |
| seg_classes_mod = (seg_classes + random_mask * random_labels) % 3 |
| seg_classes_mod[seg_classes == -100] = -100 |
| seg_classes = seg_classes_mod |
|
|
| seg_classes = seg_classes.unsqueeze(0) |
| seg_classes = F.resize( |
| seg_classes, size=(384, 512), interpolation=transforms.InterpolationMode.NEAREST |
| ).squeeze(0) |
| return seg_classes |
|
|
| def __getitem__(self, idx): |
| scene, img1_name, img2_name, overlap, angle, dist_ratio, pose = self.train_samples[idx] |
| img1 = self._load_image(scene, img1_name) |
| img2 = self._load_image(scene, img2_name) |
| to_return = [img1, img2] |
|
|
| if self.with_seg: |
| seg1 = self._load_seg(scene, img1_name, img2_name) |
| seg2 = self._load_seg(scene, img2_name, img1_name) |
| to_return.extend([seg1, seg2]) |
|
|
| if self.need_pose: |
| pose_matrix = np.array(pose) |
| R = pose_matrix[:3, :3] |
| t = pose_matrix[:3, 3].astype(np.float32) |
| q = Rot.from_matrix(R).as_quat().astype(np.float32) |
| to_return.extend([q, t]) |
|
|
| return to_return |
|
|
