""" 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 # --------------------------------------------------------------------------- _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 # occluded seg_classes[seg == 0] = 2 # outside FOV 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 # --------------------------------------------------------------------------- _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 # undefined 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 # occluded seg_classes[seg == 0] = 2 # outside FOV 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