from __future__ import division import os.path import numpy as np import torch.utils.data as data import cv2 from packaging import version import torch def load_flo(path): with open(path, 'rb') as f: magic = np.fromfile(f, np.float32, count=1) assert(202021.25 == magic),'Magic number incorrect. Invalid .flo file' w = np.fromfile(f, np.int32, count=1)[0] h = np.fromfile(f, np.int32, count=1)[0] data = np.fromfile(f, np.float32, count=2*w*h) # Reshape data into 3D array (columns, rows, bands) data2D = np.resize(data, (h, w, 2)) return data2D def pad_to_same_shape(im1, im2, flow, mask): # pad to same shape if len(im1.shape) == 2: im1 = np.dstack([im1,im1,im1]) if len(im2.shape) == 2: im2 = np.dstack([im2,im2,im2]) if im1.shape[0] <= im2.shape[0]: pad_y_1 = im2.shape[0] - im1.shape[0] pad_y_2 = 0 else: pad_y_1 = 0 pad_y_2 = im1.shape[0] - im2.shape[0] if im1.shape[1] <= im2.shape[1]: pad_x_1 = im2.shape[1] - im1.shape[1] pad_x_2 = 0 else: pad_x_1 = 0 pad_x_2 = im1.shape[1] - im2.shape[1] # images are padded to the right and bottom so it does not change values of the flow estimated. im1 = cv2.copyMakeBorder(im1, 0, pad_y_1, 0, pad_x_1, cv2.BORDER_CONSTANT) im2 = cv2.copyMakeBorder(im2, 0, pad_y_2, 0, pad_x_2, cv2.BORDER_CONSTANT) # value so that they are not represented when plottung gt (value of 0 would # represent them), nan when interpolating is not good flow = cv2.copyMakeBorder(flow, 0, pad_y_2, 0, pad_x_2, cv2.BORDER_REPLICATE) mask = cv2.copyMakeBorder(mask, 0, pad_y_2, 0, pad_x_2, cv2.BORDER_CONSTANT) return im1, im2, flow, mask def make_dataset(dir): """For TSS""" images = [] dir_list = [f for f in os.listdir(os.path.join(dir)) if os.path.isdir(os.path.join(dir, f))] for image_dir in sorted(dir_list): # print(image_dir) if image_dir in ['FG3DCar', 'JODS', 'PASCAL']: folders_list = [f for f in os.listdir(os.path.join(dir, image_dir)) if os.path.isdir(os.path.join(dir, image_dir, f))] for folders in sorted(folders_list): img_dir = os.path.join(image_dir, folders) cat = None if 'Car' in img_dir: cat = 'car' else: cat = folders.split('_')[0].lower() cat_match_dict={ 'busd': 'bus', 'bike': 'bicycle', 'plane': 'aeroplane', 'suv': 'car', } if cat in cat_match_dict.keys(): cat = cat_match_dict[cat] # the flow is taken both ways ! img1 = os.path.join(img_dir, 'image1.png') img2 = os.path.join(img_dir, 'image2.png') flow_map = os.path.join(img_dir, 'flow2.flo') images.append([[img1, img2], flow_map, cat]) img1 = os.path.join(img_dir, 'image2.png') img2 = os.path.join(img_dir, 'image1.png') # target flow_map = os.path.join(img_dir, 'flow1.flo') images.append([[img1, img2], flow_map, cat]) else: if 'Car' in dir: cat = 'car' else: cat = image_dir.split('_')[0].lower() if cat in ['busd', 'bike', 'plane', 'suv']: cat_match_dict = { 'busd': 'bus', 'bike': 'bicycle', 'plane': 'aeroplane', 'suv': 'car', } cat = cat_match_dict[cat] img_dir = image_dir # the flow is taken both ways img1 = os.path.join(img_dir, 'image1.png') # path to image_1 img2 = os.path.join(img_dir, 'image2.png') # path to image_3, they say image 10 is the reference flow_map = os.path.join(img_dir, 'flow2.flo') images.append([[img1, img2], flow_map, cat]) img1 = os.path.join(img_dir, 'image2.png') img2 = os.path.join(img_dir, 'image1.png') flow_map = os.path.join(img_dir, 'flow1.flo') images.append([[img1, img2], flow_map, cat]) return images def flow_loader(root, path_imgs, path_flo): imgs = [os.path.join(root, path) for path in path_imgs] flo = os.path.join(root, path_flo) flow = load_flo(flo) base_path = os.path.dirname(path_flo) image_number = path_flo[-5] # getting the mask number, either 1 or 2 depending which image is the target ! path_mask = os.path.join(root, base_path, 'mask{}.png'.format(image_number)) mask = cv2.imread(path_mask, 0)/255 # before it was 255, we want mask in range 0,1 images = [cv2.imread(img)[:,:,::-1].astype(np.uint8) for img in imgs] source_size = images[0].shape # threshold is max size of source image for pck im1, im2, flow, mask = pad_to_same_shape(images[0], images[1], flow, mask) return [im1, im2], flow, mask.astype(np.uint8), source_size def flow_loader_with_paths(root, path_imgs, path_flo): imgs = [os.path.join(root, path) for path in path_imgs] flo = os.path.join(root, path_flo) flow = load_flo(flo) base_path = os.path.dirname(path_flo) image_number = path_flo[-5] # getting the mask number, either 1 or 2 depending which image is the target ! path_mask = os.path.join(root, base_path, 'mask{}.png'.format(image_number)) mask = cv2.imread(path_mask, 0)/255 # before it was 255, we want mask in range 0,1 images = [cv2.imread(img)[:, :, ::-1].astype(np.uint8) for img in imgs] source_size = images[0].shape # threshold is max size of source image for pck target_size = images[1].shape im1, im2, flow, mask = pad_to_same_shape(images[0], images[1], flow, mask) return [im1, im2], flow, mask.astype(np.uint8), source_size, target_size, path_flo class TSSDataset(data.Dataset): """TSS dataset. Builds the dataset of TSS image pairs and corresponding ground-truth flow fields.""" def __init__(self, root, source_image_transform=None, target_image_transform=None, flow_transform=None, co_transform=None, num_samples=None): """ Args: root: path to root folder source_image_transform: image transformations to apply to source images target_image_transform: image transformations to apply to target images flow_transform: flow transformations to apply to ground-truth flow fields co_transform: transformations to apply to both images and ground-truth flow fields split: split (float) between training and testing, 0 means all pairs are in test_dataset Output in __getittem__: source_image target_image flow_map correspondence_mask: valid correspondences (only on foreground objects here) source_image_size target_image_size """ test_list = make_dataset(root) self.root = root if num_samples is not None: test_list = test_list[:num_samples] self.path_list = test_list self.first_image_transform = source_image_transform self.second_image_transform = target_image_transform self.target_transform = flow_transform self.co_transform = co_transform self.loader = flow_loader def __getitem__(self, index): """ Args: index: Returns: Dictionary with fieldnames: source_image target_image flow_map correspondence_mask: valid correspondences (only on foreground objects here) source_image_size target_image_size """ inputs, target, cat = self.path_list[index] inputs, target, mask, source_size, target_size, path_flo = flow_loader_with_paths(self.root, inputs, target) if self.first_image_transform is not None: inputs[0] = self.first_image_transform(inputs[0]) if self.second_image_transform is not None: inputs[1] = self.second_image_transform(inputs[1]) if self.target_transform is not None: target = self.target_transform(target) L_pck = float(max(source_size)) return {'source_image': inputs[0], 'target_image': inputs[1], 'flow_map': target, 'correspondence_mask': mask.astype(np.bool_) if version.parse(torch.__version__) >= version.parse("1.1") else mask.astype(np.uint8), 'source_image_size': np.array(source_size), 'target_image_size': np.array(target_size), 'pckthres': L_pck, 'category': cat } def __len__(self): return len(self.path_list)