def __getitem__(self, index): """Return a data point and its metadata information. Parameters: index (int): a random integer for data indexing Returns a dictionary that contains A and A_paths or LR and LR_path A (tensor): an image in the input domain A_paths (str): the path of the image """ # get single image img_A, A_path = read_single_dataset(self.opt, index, self.A_paths, self.A_env) # change color space if necessary # TODO: move to get_transform() if self.opt.get('color', None): img_A = channel_convert(image_channels(img_A), self.opt['color'], [img_A])[0] # # apply transforms if any # default_int_method = get_default_imethod(image_type(img_A)) # transform_params = get_params(self.opt, image_size(img_A)) # A_transform = get_transform( # self.opt, # transform_params, # # grayscale=(input_nc == 1), # method=default_int_method) # img_A = A_transform(img_A) ######## Convert images to PyTorch Tensors ######## img_A = self.tensor_transform(img_A) if self.vars == 'A': return {'A': img_A, 'A_path': A_path} else: return {'LR': img_A, 'LR_path': A_path}
def __getitem__(self, index): """Return a data point and its metadata information. Parameters: index (int): a random integer for data indexing Returns a dictionary that contains A, B, A_paths and B_paths (or LR, HR, LR_paths and HR_paths) A (tensor): an image in the input domain B (tensor): its corresponding image in the target domain A_paths (str): paths A images B_paths (str): paths B images (can be same as A_paths if using single images) """ scale = self.opt.get('scale') ######## Read the images ######## if self.AB_paths: img_A, img_B, A_path, B_path = read_split_single_dataset( self.opt, index, self.AB_paths, self.AB_env) else: img_A, img_B, A_path, B_path = read_imgs_from_path( self.opt, index, self.A_paths, self.B_paths, self.A_env, self.B_env) ######## Modify the images ######## # for the validation / test phases if self.opt['phase'] != 'train': img_type = image_type(img_B) # B/HR modcrop img_B = modcrop(img_B, scale=scale, img_type=img_type) # modcrop and downscale A/LR if enabled if self.opt['lr_downscale']: img_A = modcrop(img_A, scale=scale, img_type=img_type) # TODO: 'pil' images will use default method for scaling img_A, _ = Scale(img_A, scale, algo=self.opt.get('lr_downscale_types', 777), img_type=img_type) # change color space if necessary # TODO: move to get_transform() color_B = self.opt.get('color', None) or self.opt.get('color_HR', None) if color_B: img_B = channel_convert(image_channels(img_B), color_B, [img_B])[0] color_A = self.opt.get('color', None) or self.opt.get('color_LR', None) if color_A: img_A = channel_convert(image_channels(img_A), color_A, [img_A])[0] ######## Augmentations ######## #Augmentations during training if self.opt['phase'] == 'train': default_int_method = get_default_imethod(image_type(img_A)) # random HR downscale img_A, img_B = random_downscale_B(img_A=img_A, img_B=img_B, opt=self.opt) # validate there's an img_A, if not, use img_B if img_A is None: img_A = img_B print( f"Image A: {A_path} was not loaded correctly, using B pair to downscale on the fly." ) # validate proper dimensions between paired images, generate A if needed img_A, img_B = paired_imgs_check(img_A, img_B, opt=self.opt, ds_kernels=self.ds_kernels) # get and apply the paired transformations below transform_params = get_params(scale_opt(self.opt, scale), image_size(img_A)) A_transform = get_transform( scale_opt(self.opt, scale), transform_params, # grayscale=(input_nc == 1), method=default_int_method) B_transform = get_transform( self.opt, scale_params(transform_params, scale), # grayscale=(output_nc == 1), method=default_int_method) img_A = A_transform(img_A) img_B = B_transform(img_B) # Below are the On The Fly augmentations # get and apply the unpaired transformations below a_aug_params, b_aug_params = get_unpaired_params(self.opt) a_augmentations = get_augmentations( self.opt, params=a_aug_params, noise_patches=self.noise_patches, ) b_augmentations = get_augmentations( self.opt, params=b_aug_params, noise_patches=self.noise_patches, ) img_A = a_augmentations(img_A) img_B = b_augmentations(img_B) # Alternative position for changing the colorspace of A/LR. # color_A = self.opt.get('color', None) or self.opt.get('color_A', None) # if color_A: # img_A = channel_convert(image_channels(img_A), color_A, [img_A])[0] ######## Convert images to PyTorch Tensors ######## tensor_transform = get_totensor(self.opt, params=self.totensor_params, toTensor=True, grayscale=False) img_A = tensor_transform(img_A) img_B = tensor_transform(img_B) if A_path is None: A_path = B_path if self.vars == 'AB': return {'A': img_A, 'B': img_B, 'A_path': A_path, 'B_path': B_path} else: return { 'LR': img_A, 'HR': img_B, 'LR_path': A_path, 'HR_path': B_path }
def __getitem__(self, index): """Return a data point and its metadata information. Parameters: index (int): a random integer for data indexing Returns a dictionary that contains A, B, A_paths and B_paths A (tensor): an image in the input domain B (tensor): its corresponding image in the target domain A_paths (str): paths A images B_paths (str): paths B images """ scale = self.opt.get('scale') ######## Read the images ######## img_A, A_path = read_single_dataset(opt=self.opt, index=index, paths=self.A_paths, env=self.A_env, idx_case='inrange', d_size=self.A_size) img_B, B_path = read_single_dataset(opt=self.opt, index=index, paths=self.B_paths, env=self.B_env, idx_case=self.idx_case, d_size=self.B_size) ######## Modify the images ######## # change color space if necessary # TODO: move to get_transform() color_B = self.opt.get('color', None) or self.opt.get('color_B', None) if color_B: img_B = channel_convert(image_channels(img_B), color_B, [img_B])[0] color_A = self.opt.get('color', None) or self.opt.get('color_A', None) if color_A: img_A = channel_convert(image_channels(img_A), color_A, [img_A])[0] # apply image transformation default_int_method = get_default_imethod(image_type(img_A)) # get first set of random params transform_params_A = get_params(scale_opt(self.opt, scale), image_size(img_A)) # get second set of random params transform_params_B = get_params(self.opt, image_size(img_B)) A_transform = get_transform( scale_opt(self.opt, scale), transform_params_A, # grayscale=(input_nc == 1), method=default_int_method) B_transform = get_transform( self.opt, transform_params_B, # grayscale=(output_nc == 1), method=default_int_method) img_A = A_transform(img_A) img_B = B_transform(img_B) #TODO: not needed initially, but available # get and apply the unpaired transformations below # a_aug_params, b_aug_params = get_unpaired_params(self.opt) # a_augmentations = get_augmentations( # self.opt, # params=a_aug_params, # noise_patches=self.noise_patches, # ) # b_augmentations = get_augmentations( # self.opt, # params=b_aug_params, # noise_patches=self.noise_patches, # ) # img_A = a_augmentations(img_A) # img_B = b_augmentations(img_B) ######## Convert images to PyTorch Tensors ######## tensor_transform = get_totensor(self.opt, params=self.totensor_params, toTensor=True, grayscale=False) img_A = tensor_transform(img_A) img_B = tensor_transform(img_B) if self.vars == 'AB': return {'A': img_A, 'B': img_B, 'A_path': A_path, 'B_path': B_path} else: return { 'LR': img_A, 'HR': img_B, 'LR_path': A_path, 'HR_path': B_path }