diff --git a/codes/data/base_unsupervised_image_dataset.py b/codes/data/base_unsupervised_image_dataset.py new file mode 100644 index 00000000..24a2c54d --- /dev/null +++ b/codes/data/base_unsupervised_image_dataset.py @@ -0,0 +1,113 @@ +import torch +from torch.utils import data +from data.image_corruptor import ImageCorruptor +from data.chunk_with_reference import ChunkWithReference +import os +import cv2 + +# Class whose purpose is to hold as much logic as can possibly be shared between datasets that operate on raw image +# data and nothing else (which also have a very specific directory structure being used, as dictated by +# ChunkWithReference). +class BaseUnsupervisedImageDataset(data.Dataset): + def __init__(self, opt): + self.opt = opt + self.corruptor = ImageCorruptor(opt) + self.target_hq_size = opt['target_size'] if 'target_size' in opt.keys() else None + self.multiple = opt['force_multiple'] if 'force_multiple' in opt.keys() else 1 + self.for_eval = opt['eval'] if 'eval' in opt.keys() else False + self.scale = opt['scale'] if not self.for_eval else 1 + self.paths = opt['paths'] + if not isinstance(self.paths, list): + self.paths = [self.paths] + self.weights = [1] + else: + self.weights = opt['weights'] + + # See if there is a cached directory listing and use that rather than re-scanning everything. This will greatly + # reduce startup costs. + self.chunks = [] + for path, weight in zip(self.paths, self.weights): + cache_path = os.path.join(path, 'cache.pth') + if os.path.exists(cache_path): + chunks = torch.load(cache_path) + # Update the options. + for c in chunks: + c.reload(opt) + else: + chunks = [ChunkWithReference(opt, d) for d in os.scandir(path) if d.is_dir()] + # Prune out chunks that have no images + res = [] + for c in chunks: + if len(c) != 0: + res.append(c) + chunks = res + # Save to a cache. + torch.save(chunks, cache_path) + for w in range(weight): + self.chunks.extend(chunks) + + # Indexing this dataset is tricky. Aid it by having a list of starting indices for each chunk. + start = 0 + self.starting_indices = [] + for c in chunks: + self.starting_indices.append(start) + start += len(c) + self.len = start + + # Utility method for translating a point when the dimensions of an image change. + def resize_point(self, point, orig_dim, new_dim): + oh, ow = orig_dim + nh, nw = new_dim + dh, dw = float(nh) / float(oh), float(nw) / float(ow) + point = int(dh * float(point[0])), int(dw * float(point[1])) + return point + + # Given an HQ square of arbitrary size, resizes it to specifications from opt. + def resize_hq(self, imgs_hq, refs_hq, masks_hq, centers_hq): + # Enforce size constraints + h, w, _ = imgs_hq[0].shape + if self.target_hq_size is not None and self.target_hq_size != h: + hqs_adjusted, hq_refs_adjusted, hq_masks_adjusted, hq_centers_adjusted = [], [], [], [] + for hq, hq_ref, hq_mask, hq_center in zip(imgs_hq, refs_hq, masks_hq, centers_hq): + # It is assumed that the target size is a square. + target_size = (self.target_hq_size, self.target_hq_size) + hqs_adjusted.append(cv2.resize(hq, target_size, interpolation=cv2.INTER_LINEAR)) + hq_refs_adjusted.append(cv2.resize(hq_ref, target_size, interpolation=cv2.INTER_LINEAR)) + hq_masks_adjusted.append(cv2.resize(hq_mask, target_size, interpolation=cv2.INTER_LINEAR)) + hq_centers_adjusted.append(self.resize_point(hq_center, (h, w), target_size)) + h, w = self.target_hq_size, self.target_hq_size + else: + hqs_adjusted, hq_refs_adjusted, hq_masks_adjusted, hq_centers_adjusted = imgs_hq, refs_hq, masks_hq, centers_hq + hq_multiple = self.multiple * self.scale # Multiple must apply to LQ image. + if h % hq_multiple != 0 or w % hq_multiple != 0: + hqs_conformed, hq_refs_conformed, hq_masks_conformed, hq_centers_conformed = [], [], [], [] + for hq, hq_ref, hq_mask, hq_center in zip(hqs_adjusted, hq_refs_adjusted, hq_masks_adjusted, hq_centers_adjusted): + h, w = (h - h % hq_multiple), (w - w % hq_multiple) + hq_centers_conformed.append(self.resize_point(hq_center, hq.shape[:1], (h, w))) + hqs_conformed.append(hq[:h, :w, :]) + hq_refs_conformed.append(hq_ref[:h, :w, :]) + hq_masks_conformed.append(hq_mask[:h, :w, :]) + return hqs_conformed, hq_refs_conformed, hq_masks_conformed, hq_centers_conformed + return hqs_adjusted, hq_refs_adjusted, hq_masks_adjusted, hq_centers_adjusted + + def synthesize_lq(self, hs, hrefs, hmasks, hcenters): + h, w, _ = hs[0].shape + ls, lrs, lms, lcs = [], [], [], [] + for hq, hq_ref, hq_mask, hq_center in zip(hs, hrefs, hmasks, hcenters): + if self.for_eval: + ls.append(hq) + lrs.append(hq_ref) + lms.append(hq_mask) + lcs.append(hq_center) + else: + ls.append(cv2.resize(hq, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR)) + lrs.append(cv2.resize(hq_ref, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR)) + lms.append(cv2.resize(hq_mask, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR)) + lcs.append(self.resize_point(hq_center, (h, w), ls[0].shape[:2])) + # Corrupt the LQ image (only in eval mode) + if not self.for_eval: + ls = self.corruptor.corrupt_images(ls) + return ls, lrs, lms, lcs + + def __len__(self): + return self.len diff --git a/codes/data/single_image_dataset.py b/codes/data/single_image_dataset.py index ec148d83..d1a15f7e 100644 --- a/codes/data/single_image_dataset.py +++ b/codes/data/single_image_dataset.py @@ -1,139 +1,38 @@ -from torch.utils import data -from data.chunk_with_reference import ChunkWithReference -from data.image_corruptor import ImageCorruptor -import os from bisect import bisect_left -import cv2 -import torch import numpy as np -import torchvision.transforms.functional as F +import torch +from torch.utils import data +from data.base_unsupervised_image_dataset import BaseUnsupervisedImageDataset # Builds a dataset composed of a set of folders. Each folder represents a single high resolution image that has been # chunked into patches of fixed size. A reference image is included as well as a list of center points for each patch. -class SingleImageDataset(data.Dataset): - +class SingleImageDataset(BaseUnsupervisedImageDataset): def __init__(self, opt): - self.opt = opt - self.corruptor = ImageCorruptor(opt) - self.target_hq_size = opt['target_size'] if 'target_size' in opt.keys() else None - self.multiple = opt['force_multiple'] if 'force_multiple' in opt.keys() else 1 - self.for_eval = opt['eval'] if 'eval' in opt.keys() else False - self.scale = opt['scale'] if not self.for_eval else 1 - self.paths = opt['paths'] - if not isinstance(self.paths, list): - self.paths = [self.paths] - self.weights = [1] - else: - self.weights = opt['weights'] - - # See if there is a cached directory listing and use that rather than re-scanning everything. This will greatly - # reduce startup costs. - self.chunks = [] - for path, weight in zip(self.paths, self.weights): - cache_path = os.path.join(path, 'cache.pth') - if os.path.exists(cache_path): - chunks = torch.load(cache_path) - # Update the options. - for c in chunks: - c.reload(opt) - else: - chunks = [ChunkWithReference(opt, d) for d in os.scandir(path) if d.is_dir()] - # Prune out chunks that have no images - res = [] - for c in chunks: - if len(c) != 0: - res.append(c) - chunks = res - # Save to a cache. - torch.save(chunks, cache_path) - for w in range(weight): - self.chunks.extend(chunks) - - # Indexing this dataset is tricky. Aid it by having a sorted list of starting indices for each chunk. - start = 0 - self.starting_indices = [] - for c in chunks: - self.starting_indices.append(start) - start += len(c) - self.len = start - - - def resize_point(self, point, orig_dim, new_dim): - oh, ow = orig_dim - nh, nw = new_dim - dh, dw = float(nh) / float(oh), float(nw) / float(ow) - point = int(dh * float(point[0])), int(dw * float(point[1])) - return point + super(SingleImageDataset, self).__init__(opt) def __getitem__(self, item): chunk_ind = bisect_left(self.starting_indices, item) chunk_ind = chunk_ind if chunk_ind < len(self.starting_indices) and self.starting_indices[chunk_ind] == item else chunk_ind-1 hq, hq_ref, hq_center, hq_mask, path = self.chunks[chunk_ind][item-self.starting_indices[chunk_ind]] - # Enforce size constraints - h, w, _ = hq.shape - if self.target_hq_size is not None and self.target_hq_size != h: - # It is assumed that the target size is a square. - target_size = (self.target_hq_size, self.target_hq_size) - hq = cv2.resize(hq, target_size, interpolation=cv2.INTER_LINEAR) - hq_ref = cv2.resize(hq_ref, target_size, interpolation=cv2.INTER_LINEAR) - hq_mask = cv2.resize(hq_mask, target_size, interpolation=cv2.INTER_LINEAR) - hq_center = self.resize_point(hq_center, (h, w), target_size) - h, w = self.target_hq_size, self.target_hq_size - hq_multiple = self.multiple * self.scale # Multiple must apply to LQ image. - if h % hq_multiple != 0 or w % hq_multiple != 0: - h, w = (h - h % hq_multiple), (w - w % hq_multiple) - hq_center = self.resize_point(hq_center, hq.shape[:1], (h, w)) - hq = hq[:h, :w, :] - hq_ref = hq_ref[:h, :w, :] - hq_mask = hq_mask[:h, :w, :] - - # Synthesize the LQ image - if self.for_eval: - lq, lq_ref = hq, hq_ref - else: - lq = cv2.resize(hq, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR) - lq_ref = cv2.resize(hq_ref, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR) - lq_mask = cv2.resize(hq_mask, (h // self.scale, w // self.scale), interpolation=cv2.INTER_LINEAR) - lq_center = self.resize_point(hq_center, (h, w), lq.shape[:2]) - - # Corrupt the LQ image - lq = self.corruptor.corrupt_images([lq])[0] + hs, hrs, hms, hcs = self.resize_hq([hq], [hq_ref], [hq_mask], [hq_center]) + ls, lrs, lms, lcs = self.synthesize_lq(hs, hrs, hms, hcs) # Convert to torch tensor - hq = torch.from_numpy(np.ascontiguousarray(np.transpose(hq, (2, 0, 1)))).float() - hq_ref = torch.from_numpy(np.ascontiguousarray(np.transpose(hq_ref, (2, 0, 1)))).float() - hq_mask = torch.from_numpy(np.ascontiguousarray(hq_mask)).unsqueeze(dim=0) + hq = torch.from_numpy(np.ascontiguousarray(np.transpose(hs[0], (2, 0, 1)))).float() + hq_ref = torch.from_numpy(np.ascontiguousarray(np.transpose(hrs[0], (2, 0, 1)))).float() + hq_mask = torch.from_numpy(np.ascontiguousarray(hms[0])).unsqueeze(dim=0) hq_ref = torch.cat([hq_ref, hq_mask], dim=0) - lq = torch.from_numpy(np.ascontiguousarray(np.transpose(lq, (2, 0, 1)))).float() - lq_ref = torch.from_numpy(np.ascontiguousarray(np.transpose(lq_ref, (2, 0, 1)))).float() - lq_mask = torch.from_numpy(np.ascontiguousarray(lq_mask)).unsqueeze(dim=0) + lq = torch.from_numpy(np.ascontiguousarray(np.transpose(ls[0], (2, 0, 1)))).float() + lq_ref = torch.from_numpy(np.ascontiguousarray(np.transpose(lrs[0], (2, 0, 1)))).float() + lq_mask = torch.from_numpy(np.ascontiguousarray(lms[0])).unsqueeze(dim=0) lq_ref = torch.cat([lq_ref, lq_mask], dim=0) return {'LQ': lq, 'GT': hq, 'gt_fullsize_ref': hq_ref, 'lq_fullsize_ref': lq_ref, - 'lq_center': torch.tensor(lq_center, dtype=torch.long), 'gt_center': torch.tensor(hq_center, dtype=torch.long), + 'lq_center': torch.tensor(lcs[0], dtype=torch.long), 'gt_center': torch.tensor(hcs[0], dtype=torch.long), 'LQ_path': path, 'GT_path': path} - def __len__(self): - return self.len - - - self.corruptor = ImageCorruptor(opt) - self.target_hq_size = opt['target_size'] if 'target_size' in opt.keys() else None - self.multiple = opt['force_multiple'] if 'force_multiple' in opt.keys() else 1 - self.for_eval = opt['eval'] if 'eval' in opt.keys() else False - self.scale = opt['scale'] if not self.for_eval else 1 - self.paths = opt['paths'] - if not isinstance(self.paths, list): - self.paths = [self.paths] - self.weights = [1] - else: - self.weights = opt['weights'] - for path, weight in zip(self.paths, self.weights): - chunks = [ChunkWithReference(opt, d) for d in os.scandir(path) if d.is_dir()] - for w in range(weight): - self.chunks.extend(chunks) if __name__ == '__main__': opt = {