def get_patch(self, lr, hr): scale = self.scale[self.idx_scale] # print("scale:",scale) if self.train: lr, hr = common.get_patch(lr, hr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large) if not self.args.no_augment: lr, hr = common.augment(lr, hr) elif not self.benchmark: lr, hr = common.get_patch(lr, hr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large) if not self.args.no_augment: lr, hr = common.augment(lr, hr) else: try: ih, iw = lr.shape[:2] except: ih, iw = lr[0]['image'].shape[:2] try: hr = hr[0:ih * scale, 0:iw * scale] except: hr = hr[0]['image'][0:ih * scale, 0:iw * scale] return lr, hr
def _get_patch_bk(self, lr, hr): LR_size = self.opt['LR_size'] lr, hr = common.get_patch(lr, hr, LR_size, self.scale) lr, hr = common.augment([lr, hr]) return lr, hr
def get_patch(self, lr, hr): scale = self.scale[self.idx_scale] if self.train: lr, hr = common.get_patch(lr, hr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large) #print(lr.shape) if not self.args.no_augment: lr, hr = common.augment(lr, hr) # print(lr.shape) else: # lr, hr = common.get_patch( # lr, hr, # patch_size=self.args.patch_size, # scale=scale, # multi=(len(self.scale) > 1), # input_large=self.input_large # ) # if not self.args.no_augment: lr, hr = common.augment(lr, hr) ih, iw = lr.shape[:2] hr = hr[0:ih * scale, 0:iw * scale] return lr, hr
def _get_patch(self, lr, hr,lr2=None,hr2=None): patch_size = self.args.patch_size scale = self.scale[self.idx_scale] multi_scale = len(self.scale) > 1 if self.train: if (self.args.nmodels == 1): lr, hr = common.get_patch( lr, hr, patch_size, scale, multi_scale=multi_scale ) lr, hr = common.augment([lr, hr]) lr = common.add_noise(lr, self.args.noise) else: lr, hr, lr2, hr2 = common.get_patch_2model( lr, hr, lr2, hr2, patch_size, scale, multi_scale=multi_scale ) else: if (self.args.nmodels == 1): ih, iw = lr.shape[0:2] hr = hr[0:ih * scale, 0:iw * scale] else: ih, iw = lr.shape[0:2] hr = hr[0:ih * scale, 0:iw * scale] hr2 = hr2[0:ih * scale, 0:iw * scale] return lr, hr, lr2, hr2
def _get_patch(self, ): # lr, hr): patch_size = self.args.patch_size scale = self.scale[0] multi_scale = len(self.scale) > 1 batch_size = 1 #min(self.args.batch_size, len(self.remain_idx)) # scale = self.scale[self.idx_scale] # multi_scale = len(self.scale) > 1 idx = self.remain_idx[:batch_size] self.remain_idx = self.remain_idx[batch_size:] lr, hr = self.raw_lr[idx], self.raw_hr[idx] lr = lr.astype(np.float32)[0] hr = hr.astype(np.float32)[0] lr = lr[:, :, ::-1] hr = hr[:, :, ::-1] # lr = lr.transpose(2,0,1) # hr = hr.transpose(2,0,1) if self.train: lr, hr = common.get_patch(lr, hr, patch_size, scale, multi_scale=multi_scale) lr, hr = common.augment([lr, hr]) # lr = common.add_noise(lr, self.args.noise) else: ih, iw = lr.shape[0:2] hr = hr[0:ih * scale, 0:iw * scale] return lr, hr
def __getitem__(self, idx): blur = imageio.imread(self.blur_list[idx], pilmode='RGB') if len(self.sharp_list) > 0: sharp = imageio.imread(self.sharp_list[idx], pilmode='RGB') imgs = [blur, sharp] else: imgs = [blur] if self.mode == 'train': imgs = common.crop(*imgs, ps=self.args.patch_size) if self.args.augment: imgs = common.augment(*imgs, hflip=True, rot=True, shuffle=True, change_saturation=True, rgb_range=self.args.rgb_range) imgs[0] = common.add_noise(imgs[0], sigma_sigma=2, rgb_range=self.args.rgb_range) else: pass # deliver test image as is. if self.args.gaussain_pyramid: imgs = common.generate_pyramid(*imgs, n_scales=self.args.n_scales) imgs = common.np2tensor(*imgs) relpath = os.path.relpath(self.blur_list[idx], self.subset_root) blur = imgs[0] sharp = imgs[1] if len(imgs) > 1 else False return blur, sharp, idx, relpath
def _get_patch(self, hr, filename): patch_size = self.args.patch_size if self.train: scale = self.scale[0] if self.args.task_type == 'denoising': lr, hr = common.get_patch_noise( hr, patch_size, scale ) if self.args.task_type == 'SISR': lr, hr = common.get_patch_bic( hr, patch_size, scale ) if self.args.task_type == 'JIAR': lr, hr = common.get_patch_compress( hr, patch_size, scale ) lr, hr = common.augment([lr, hr]) return lr, hr, scale else: scale = self.scale[0] if self.args.task_type == 'denoising': lr, hr = common.add_img_noise( hr, scale ) if self.args.task_type == 'SISR': lr, hr = self._get_patch_test( hr, patch_size, scale ) if self.args.task_type == 'JIAR': lr, hr = common.get_img_compress( hr, patch_size, scale ) return lr, hr, scale
def get_patch(self, lr, hr, lrr, hq): scale = self.scale[self.idx_scale] multi_scale = len(self.scale) > 1 if self.train: lr, hr = common.get_patch(lr, hr, patch_size=self.args.patch_size, scale=scale, multi_scale=multi_scale) lrr, _ = common.get_patch(lrr, lrr, patch_size=self.args.patch_size, scale=scale, multi_scale=multi_scale) hq, _ = common.get_patch(hq, hq, patch_size=self.args.patch_size, scale=scale, multi_scale=multi_scale) if not self.args.no_augment: lr, hr, lrr, hq = common.augment(lr, hr, lrr, hq) else: ih, iw = lr.shape[:2] hr = hr[0:ih, 0:iw] lrr = lrr[0:ih, 0:iw] hq = hq[0:ih, 0:iw] return lr, hr, lrr, hq
def get_patch(self, lr, labels): data = [] data.append(lr) for label in labels: data.append(label) # LR, HR, labels scale = self.scale[self.idx_scale] if self.n_colors == 4: scale = scale * 2 #print(scale) #print(self.args.test_patch_size) if self.train: data = common.get_patch(*data, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large) else: data = common.get_center_patch( *data, patch_size=self.args.test_patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large) if self.train and not self.args.no_augment: data = common.augment(*data) #print(data[0].shape) #print(data[1].shape) return data
def get_patch(self, lr, hr, ix, iy): """ Returns patches for multiple scales """ scale = self.scale if self.train: patch_size = self.args.patch_size - (self.args.patch_size % 4) lr, hr = common.get_patch( lr, hr, patch_size=patch_size, scale=scale, ix=ix, iy=iy ) if not self.args.no_augment: lr, hr = common.augment(lr, hr) else: ih, iw = lr.shape[:2] ih -= ih % 4 iw -= iw % 4 lr = lr[:ih, :iw] hr = hr[:ih * scale, :iw * scale] return lr, hr
def get_patch(self, lhr, ix, iy, hflip, vflip, rot90, scale): """ Returns patches for multiple scales """ '''if self.train: ih, iw = lr.shape[:2] ih -= ih % 4 iw -= iw % 4 lr = lr[:ih, :iw] hr = hr[:ih * scale, :iw * scale]''' if self.train: #patch_size = self.args.patch_size - (self.args.patch_size % 4) lhr = common.get_patch_onlyLR( lhr, patch_size_w=self.args.patch_size_w, patch_size_h=self.args.patch_size_h, ix=ix, iy=iy, scale=scale ) if not self.args.no_augment: #lhr = img_as_ubyte(transform.rotate(lhr, jiao)) lhr = common.augment(lhr, hflip, vflip, rot90) '''else: ih, iw, _ = lhr.shape ih = int(ih/scale) iw = int(iw/scale) ih -= ih % 4 iw += iw % 4 lhr = lhr[:ih*scale, :iw*scale]''' return lhr
def _get_patch(self, lr, hr): LR_size = self.opt['LR_size'] # random crop and augment lr, hr = common.get_patch(lr, hr, LR_size, self.scale) lr, hr = common.augment([lr, hr]) lr = common.add_noise(lr, self.opt['noise']) return lr, hr
def __getitem__(self, idx): scale = self.scale[self.scaleIdx] if self.train: idx = (idx % self.args.nTrain) + 1 else: idx = (idx + self.args.valOffset) + 1 quality = random.randrange(len( self.args.quality)) if self.train else -1 if self.args.ext == 'png': nameIn, nameTar = self.getFileName(idx, quality) imgIn = sio.imread(nameIn) imgTar = sio.imread(nameTar) elif self.args.ext == 'pt': nameIn, nameTar = self.getFileName(idx, quality) imgIn = torch.load(nameIn).numpy() imgTar = torch.load(nameTar).numpy() elif self.args.ext == 'ptpack': imgIn = self.packIn[self.scaleIdx][quality][idx].numpy() imgTar = self.packTar[idx].numpy() if self.train: imgIn, imgTar, pi = common.getPatch(imgIn, imgTar, self.args, scale) imgIn, imgTar, ai = common.augment(imgIn, imgTar) else: (ih, iw, c) = imgIn.shape imgTar = imgTar[0:ih * scale, 0:iw * scale, :] imgIn, imgTar = common.setChannel(imgIn, imgTar, self.args.nChannel) return common.np2Tensor(imgIn, imgTar, self.args.rgbRange, self.args.precision)
def _get_patch(self, lr1, lr2, lr3, hr): LR_size = self.opt['LR_size'] # random crop and augment lr1, lr2, lr3, hr = common.get_patch(lr1, lr2, lr3, hr, LR_size, self.scale) lr1, lr2, lr3, hr = common.augment([lr1, lr2, lr3, hr]) return lr1, lr2, lr3, hr
def get_patch_no(self, lr, hr, pts): scale = self.scale[self.idx_scale] if self.train: if not self.args.no_augment: lr, hr, pts = common.augment(lr, hr, pts) return lr, hr, pts
def get_patch(self, lr, hr, nr): lr, hr, nr = common.get_patch(lr, hr, nr, patch_size=self.opt.patch_size, n_channels=1) lr, hr, nr = common.augment(lr, hr, nr) return lr, hr, nr
def _get_patch(self, ir, vis): Label_Size = self.opt['Label_Size'] if self.train: ir, vis = common.get_patch(ir, vis, Label_Size, self.scale) ir, vis = common.augment([ir, vis]) ir = common.add_noise(ir, self.opt['noise']) return ir, vis
def generate_lr_hr(self, hr, idx): if self.train: # pick a blur kernel randomly k_idx = random.randrange(0,self.n_filters) kernel = self.filter_bank[k_idx] if len(kernel.shape) > 2: assert(False, "cannot handle 3d kernels") [k_h, k_w] = kernel.shape[:2] [h, w, c] = hr.shape[:3] # After convolution with the blur kernel the patch size should be equal to self.hr_size # The valid sizez before convolution are given below patch_h = self.hr_size + k_h - 1 patch_w = self.hr_size + k_w - 1 # randomly extract a patch of this size from the hr image. hr_patch = self.extract_hrpatch(hr, patch_h, patch_w) blurred_stack = [] # blur the patch using the kernel for ch in range(c): blurred_stack.append(convolve2d(hr_patch[:,:,ch], kernel, mode='valid')) blurred = np.stack(blurred_stack, axis=2) assert(blurred.shape[0]==self.hr_size, "Blurred shape = {}, valid hr shape = {}".format(blurred.shape, self.hr_size)) lr = blurred[::self.scale, ::self.scale, :] assert(lr.shape[0]==self.lr_size, "lr shape = {}, valid shape = {}".format(lr.shape, self.lr_size)) valid_hr_patch = hr_patch[int(k_h/2):-int(k_h/2), int(k_w/2):-int(k_w/2), :] noise_patch = self.get_noise_patch(lr.shape) noise_scaling = np.random.random()*3 + 1 lr += noise_scaling*noise_patch lr = np.clip(lr, 0, 255) lr, valid_hr_patch = common.augment([lr, valid_hr_patch]) # lr = misc.imresize(hr, 1/self.scale, interp='bicubic') # Add noise. # noise_level = random.random()*3 # noise_patch = np.random.normal(0, noise_level, (self.lr_size, self.lr_size)) # lr = lr + noise_patch[:,:,None] # lr = np.clip(lr, 0, 255) return valid_hr_patch, lr else: k_idx = idx % self.n_filters kernel = self.filter_bank[k_idx] [k_h, k_w] = kernel.shape[:2] [h, w, c] = hr.shape[:3] blurred_stack = [] # blur the patch using the kernel for ch in range(c): blurred_stack.append(convolve2d(hr[:,:,ch], kernel, mode='valid')) blurred = np.stack(blurred_stack, axis=2) lr = blurred[::self.scale, ::self.scale, :] valid_hr = hr[int(k_h/2):-int(k_h/2), int(k_w/2):-int(k_w/2), :] noise_level = random.random()*12 noise_patch = np.random.normal(0, noise_level, (lr.shape[0], lr.shape[1])) lr = lr + noise_patch[:,:,None] lr = np.clip(lr, 0, 255) return valid_hr, lr
def get_patch(self, lr, hr): scale = self.scale[self.idx_scale] lr, hr = common.get_mspatch(lr, hr, patch_size=self.args.patch_size, scale=scale) if not self.args.no_augment: lr, hr = common.augment(lr, hr) return lr, hr
def _get_patch(self, lr, hr, lrpan, pan, msx2=False): LR_size = self.opt['LR_size'] # random crop and augment lr, hr, lrpan, pan = common.get_patch(lr, hr, pan, LR_size, self.scale, lrpan=lrpan, msx2=msx2) lr, hr, lrpan, pan = common.augment([lr, hr, lrpan, pan]) lr = common.add_noise(lr, self.opt['noise']) return lr, hr, lrpan, pan
def _get_patch(self, lr, hr, scale, patch_size, phase_str): if phase_str == 'train': lr, hr = common.get_patch( lr, hr, patch_size, scale) lr, hr = common.augment([lr, hr], self.opt['use_flip'], self.opt['use_rot']) lr = common.add_noise(lr, self.opt['noise']) else: hr = common.modcrop(hr, scale) return lr, hr
def _get_patch(self, lr, hr): LR_size = self.opt['LR_size'] # random crop and augment lr, hr = common.get_patch(lr, hr, LR_size, self.scale) # print('shapes again here', lr.shape, hr.shape) lr, hr = common.augment([lr, hr]) # lr = common.add_noise(lr, self.opt['noise']) # print('shapes again', lr.shape, hr.shape) return lr, hr
def _get_patch(self, img_in, img_tar): patch_size = self.opt.patch_size scale = self.scale if self.train: img_in, img_tar = common.get_patch( img_in, img_tar, patch_size=patch_size, scale=scale) img_in, img_tar = common.augment(img_in, img_tar) else: ih, iw = img_in.shape[:2] img_tar = img_tar[0:ih * scale, 0:iw * scale, :] return img_in, img_tar
def _get_patch(self, lr, hr): LR_size = self.opt['LR_size'] if self.train: lr, hr = common.get_patch( lr, hr, LR_size, self.scale) lr, hr = common.augment([lr, hr]) lr = common.add_noise(lr, self.opt['noise']) else: hr = common.modcrop(hr, self.scale) return lr, hr
def get_patch(self, lr, hr): scale = self.scale[self.idx_scale] if self.train: hr, lr = common.get_patch(hr, lr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=True) if self.args.no_augment: lr, hr = common.augment(lr, hr) return lr, hr
def get_patch(self, lr, hr): scale = self.scale[0] if self.train: lr, hr = common.get_patch( lr, hr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), ) if not self.args.no_augment: lr, hr = common.augment(lr, hr) return lr, hr
def _get_patch(self, hr, filename): patch_size = self.args.patch_size if self.train: scale = self.scale[0] lr, hr = common.get_patch_noise(hr, patch_size, scale) lr, hr = common.augment([lr, hr]) return lr, hr, scale else: scale = self.scale[0] lr, hr = common.add_img_noise(hr, scale) return lr, hr, scale
def _get_patch(self, img_input, img_tar): patch_size = self.args.patch_size scale = self.scale if self.train: img_input, img_tar = common.get_patch(img_input, img_tar, patch_size, scale) img_input, img_tar = common.augment([img_input, img_tar]) img_input = common.add_noise(img_input, self.sigma) else: ih, iw = img_input.shape[0:2] img_tar = img_tar[0:ih * scale, 0:iw * scale] return img_input, img_tar
def _get_patch(self, img_in, img_tar): scale = self.scale[self.idx_scale] if self.train: img_in, img_tar, pi = common.get_patch( img_in, img_tar, self.args, scale) img_in, img_tar, ai = common.augment(img_in, img_tar) return img_in, img_tar, pi, ai else: ih, iw, c = img_in.shape img_tar = img_tar[0:ih * scale, 0:iw * scale, :] return img_in, img_tar, None, None
def get_patch(self, lr, hr): scale = 1 if self.mode == 'train': lr, hr = common.get_patch(lr, hr, patch_size=self.args.patch_size, n_channels=self.n_channels) if self.args.augment: lr, hr = common.augment(lr, hr) else: ih, iw = lr.shape[:2] hr = hr[0:ih * scale, 0:iw * scale] return lr, hr