def __getitem__(self, idx): #scale = self.scale[self.idx_scale] scale = 1 idx = self._get_index(idx) img_in, img_tar = self._load_file(idx) # print("img_in ", img_in) # print("idx ", idx) img_in, img_tar, pi, ai = self._get_patch(img_in, img_tar) img_in, img_tar = common.set_channel(img_in, img_tar, self.args.n_colors) try: retVal = common.np2Tensor(img_in, img_tar, self.args.rgb_range) prevRetVal = retVal except: print("failed to common.np2Tensor. idx is: ", idx) return retVal
def __getitem__(self, idx): scale = self.scale[self.idx_scale] idx = self._get_index(idx) img_in, img_tar,img_in4,img_in2 = self._load_file(idx) img_in, img_tar,img_in4,img_in2, pi, ai = self._get_patch(img_in, img_tar,img_in4,img_in2) if self.train: img_in, img_tar,img_in4,img_in2 = common.set_channel_Three( img_in, img_tar,img_in4,img_in2, self.args.n_colors) return common.np2Tensor_Three(img_in, img_tar,img_in4,img_in2, self.args.rgb_range) #return common.np2Tensor(img_in, img_tar, self.args.rgb_range) else: img_in, img_tar = common.set_channel( img_in, img_tar, self.args.n_colors) return common.np2Tensor(img_in, img_tar, self.args.rgb_range)
def test(self): torch.set_grad_enabled(False) self.ckp.write_log("\nEvaluation on video:") self.model.eval() timer_test = utility.timer() for idx_scale, scale in enumerate(self.scale): vidcap = cv2.VideoCapture(self.args.dir_demo) total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT)) vidwri = cv2.VideoWriter( self.ckp.get_path("{}_x{}.avi".format(self.filename, scale)), cv2.VideoWriter_fourcc(*"XVID"), vidcap.get(cv2.CAP_PROP_FPS), ( int(scale * vidcap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(scale * vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT)), ), ) tqdm_test = tqdm(range(total_frames), ncols=80) for _ in tqdm_test: success, lr = vidcap.read() if not success: break lr, = common.set_channel(lr, n_channels=self.args.n_colors) lr, = common.np2Tensor(lr, rgb_range=self.args.rgb_range) lr, = self.prepare(lr.unsqueeze(0)) sr = self.model(lr, idx_scale) sr = utility.quantize(sr, self.args.rgb_range).squeeze(0) normalized = sr * 255 / self.args.rgb_range ndarr = normalized.byte().permute(1, 2, 0).cpu().numpy() vidwri.write(ndarr) vidcap.release() vidwri.release() self.ckp.write_log("Total: {:.2f}s\n".format(timer_test.toc()), refresh=True) torch.set_grad_enabled(True)
def __getitem__(self, idx): lr_path = self.img_path[idx] video_path = os.path.dirname(lr_path) video_name = os.path.basename(video_path) frame_idx = int(os.path.basename(lr_path).split('.')[0]) filename = video_name + '_{}'.format(frame_idx) idxs = self.index_generation(frame_idx, self.video_len[video_path], self.args.n_frames) lrs = [] for idx in idxs: img_path = os.path.join(os.path.dirname(lr_path), '{}.png'.format(idx)) temp = misc.imread(img_path) lrs.append(temp) lrs = np.array(lrs) lrs = common.set_channel([lrs], self.args.n_colors)[0] lrs = common.np2Tensor([lrs], self.args.rgb_range)[0] return lrs, -1, filename
def __getitem__(self, idx): hr, hr_path = self._load_file(idx) lr = None lr_path = None # Generate LR image from the HR image on the fly. hr, lr = self.generate_lr_hr(hr, idx) # LR_PATH key is not really used anywhere so its ok to set it to an # arbitrary value. lr_path = 'none' # if self.train: # lr, hr = self._get_patch(lr, hr) lr_tensor, hr_tensor = common.np2Tensor([lr, hr], self.opt['rgb_range']) # return {'LR': lr_tensor, 'HR': hr_tensor, 'LR_path': lr_path, 'HR_path': hr_path} return { 'LQ': lr_tensor, 'GT': hr_tensor, 'LQ_path': lr_path, 'GT_path': hr_path }
def __getitem__(self, idx): lr, hr = self._load_file(idx) lr, hr = self._get_patch(lr, hr) lr, hr = common.set_channel(lr, hr, n_channels=self.opt.n_colors) lr_tensor, hr_tensor = common.np2Tensor(lr, hr, rgb_range=self.opt.rgb_range) # prob = 1.0 # alpha = 0.7 # aux_prob = 1.0 # aux_alpha = 1.2 # hr_tensor, lr_tensor = common.cutmixup( # hr_tensor.clone(), lr_tensor.clone(), # mixup_prob=aux_prob, mixup_alpha=aux_alpha, # cutmix_prob=prob, cutmix_alpha=alpha, # ) # hr_=tensor_to_np(hr_tensor) # lr_=tensor_to_np(lr_tensor) # # cv2.imwrite("./hr.png",hr_) # cv2.imwrite("./lr.png", lr_) return lr_tensor, hr_tensor
def __getitem__(self, idx): if self.train and self.args.process: lr, hr, filename = self._load_file_from_loaded_data(idx) else: lr, hr, filename = self._load_file(idx) if self.train: lr_extend = hr else: lr_extend = misc.imresize(lr, size=self.args.scale * 100, interp='bicubic') lr, lr_extend, hr = self.get_patch(lr, lr_extend, hr) lr, lr_extend, hr = common.set_channel(lr, lr_extend, hr, n_channels=self.args.n_colors) lr_tensor, lre_tensor, hr_tensor = common.np2Tensor( lr, lr_extend, hr, rgb_range=self.args.rgb_range, n_colors=self.args.n_colors) return lr_tensor, lre_tensor, hr_tensor, filename
def __getitem__(self, idx): # 将二进制文件转为imageio lr, hr, filename = self._load_file(idx) pair = self.get_patch(lr, hr) pair = common.set_channel(*pair, n_channels=self.args.n_colors) # 生成kernel pair_t = common.np2Tensor(*pair, rgb_range=self.args.rgb_range) k = utils_sisr.gen_kernel(scale_factor=np.array( [self.scale, self.scale])) # Gaussian blur r_value = np.random.randint(0, 8) if r_value > 3: k = utils_deblur.blurkernel_synthesis(h=25) # motion blur else: sf_k = random.choice(self.scale) k = utils_sisr.gen_kernel(scale_factor=np.array( [sf_k, sf_k])) # Gaussian blur mode_k = np.random.randint(0, 8) k = util.augment_img(k, mode=mode_k) if np.random.randint(0, 8) == 1: noise_level = 0 / 255.0 else: noise_level = np.random.randint(0, self.sigma_max) / 255.0 # --------------------------- # Low-quality image # --------------------------- img_L = ndimage.filters.convolve(patch_H, np.expand_dims(k, axis=2), mode='wrap') img_L = img_L[0::self.sf, 0::self.sf, ...] # add Gaussian noise img_L = util.uint2single(img_L) + np.random.normal( 0, noise_level, img_L.shape) img_H = patch_H return pair_t[0], pair_t[1], filename
def __getitem__(self, idx): lr, hr, lr_path, hr_path = self._load_file(idx) if self.train: lr, hr = self._get_patch(lr, hr) lr_tensor, hr_tensor = common.np2Tensor([lr, hr], self.opt['rgb_range']) return {'LR': lr_tensor, 'HR': hr_tensor, 'LR_path': lr_path, 'HR_path': hr_path}
def __getitem__(self, idx): lr, hr, lrpan, pan, lr_path = self._load_file(idx) if self.train: lr, hr, lrpan, pan= self._get_patch(lr, hr, lrpan, pan, msx2=self.msx2) lr_tensor, hr_tensor, lrpan_tensor, pan_tensor = common.np2Tensor([lr, hr, lrpan, pan], self.opt['run_range'], self.opt['img_range']) return {'LR': lr_tensor, 'HR': hr_tensor, 'LRPAN': lrpan_tensor, 'PAN':pan_tensor, 'LR_path': lr_path}
def __getitem__(self, idx): # get LR image lr, lr_path = self._load_file(idx) lr_tensor = common.np2Tensor([lr], self.opt['rgb_range'])[0] return {'LR': lr_tensor, 'LR_path': lr_path}
def __getitem__(self, idx): if self.args.use_stats: lr, hr, mask,mask_grads, filename = self._load_file(idx) elif self.args.use_real and (self.name in ['SIDD','SIDDVAL','NAM']): lr, hr, mask, noisemap, filename = self._load_file(idx) else: lr, hr, mask, filename = self._load_file(idx) if self.args.debug: # if self.args.compute_grads: print('got item') print(lr.shape, hr.shape,mask.shape) if self.args.predict_groups: mask = self.into_groups(mask) if (not(self.args.compute_grads and ((not self.train) or lr.shape[0]*lr.shape[1]<2000*2000))) and (not(self.args.predict_groups and ((not self.train) or lr.shape[0]*lr.shape[1]<2000*2000))): if (self.mask_type == 'raisr') and (not self.args.pre_raisr): pair = self.get_patch(lr, hr) mask = self.get_raisr_buckets(pair[1]) else: if self.args.pre_raisr and (not self.args.compute_grads)and (not self.args.predict_groups): mask = np.expand_dims(mask, -1) if self.args.use_stats: lr, hr,mask_grads, mask = self.get_patch(lr, hr,mask_grad=mask_grads, mask=mask) elif self.args.use_real and (self.name in ['SIDD','SIDDVAL','NAM']): lr, hr, noisemap, mask = self.get_patch(lr, hr, mask_grad=noisemap, mask=mask) else: lr,hr,mask = self.get_patch(lr, hr, mask=mask) if self.args.debug: print('data augmented!') print(mask.shape) print(mask.dtype) print(mask[10:20,10:20,0]) if self.train and self.args.drop_mask: mask = self.drop_mask(mask) pair= (lr,hr,mask) else: pair = (lr,hr,mask) if self.args.debug: print(pair[0].shape,pair[1].shape, pair[2].shape) #if self.args.real_isp or self.args.use_real: # if not (self.name in ['SIDD','SIDDVAL','NAM']): # lr, noisemap = AddRealNoise((hr.astype(np.float32))/255., self.CRF_para, self.iCRF_para, self.I_gl, self.B_gl, self.I_inv_gl, self.B_inv_gl) # lr = lr * 255. # else: # if self.args.model == 'unet_noisemap': # _, noisemap = AddRealNoise(hr, self.CRF_para, self.iCRF_para, self.I_gl, self.B_gl, self.I_inv_gl, self.B_inv_gl) # if self.args.real_isp: # mask = np.concatenate((mask,noisemap),axis=-1) # if self.args.debug: # print('noisemap and concatenate shape: ', noisemap.shape, noisemap.dtype, mask.shape, mask.dtype) pair = (lr,hr,mask) pair = common.set_channel(*pair, n_channels=self.args.n_colors) if self.args.debug: print('channels set!') print(pair[0].shape, pair[1].shape,pair[2].shape) if (self.mask_type == 'raisr') and (not self.args.pre_raisr): pair.append(mask) if (self.args.pre_raisr): if not (self.args.compute_grads or self.args.predict_groups): pair[2] = pair[2].squeeze(-1) pair_t = common.np2Tensor(*pair, rgb_range=self.args.rgb_range) if self.args.use_stats: np_transpose = np.ascontiguousarray(mask_grads.transpose((2, 0, 1))) mask_grads = torch.from_numpy(np_transpose).float() lr_grads = torch.cat((pair_t[0],mask_grads),0) if self.args.use_real: np_transpose = np.ascontiguousarray(noisemap.transpose((2, 0, 1))) noisemap = torch.from_numpy(np_transpose).float() lr_grads = torch.cat((pair_t[0],noisemap),0) if self.args.debug: if self.args.compute_grads or self.args.predict_groups: print(pair_t[0].shape, pair_t[1].shape,pair_t[2].shape) if self.args.use_stats or self.args.use_real: return lr_grads, pair_t[1], pair_t[2], filename else: return pair_t[0], pair_t[1], pair_t[2], filename
def __getitem__(self, idx): lr, hr, filename = self._load_file(idx) lr, hr = self._get_patch(lr, hr) lr, hr = common.set_channel([lr, hr], self.args.n_colors) lr_tensor, hr_tensor = common.np2Tensor([lr, hr], self.args.rgb_range) return lr_tensor, hr_tensor, filename
def load_img(path): lr = imageio.imread(path) lr, = common.set_channel(lr, n_channels=args.n_colors) lr_t, = common.np2Tensor(lr, rgb_range=args.rgb_range) lr_t = lr_t.view(1, 3, 384, 510).to(torch.device('cuda')) return lr_t
def __getitem__(self, idx): lr1,lr2, lr3, hr, lr_path1, lr_path2, lr_path3, hr_path = self._load_file(idx) if self.train: lr1, lr2, lr3, hr = self._get_patch(lr1,lr2, lr3, hr) lr_tensor1, lr_tensor2, lr_tensor3, hr_tensor = common.np2Tensor([lr1,lr2, lr3, hr], self.opt['rgb_range']) return {'LR1': lr_tensor1, 'LR2': lr_tensor2, 'LR3': lr_tensor3, 'HR': hr_tensor, 'LR_path1': lr_path1, 'LR_path2': lr_path2, 'LR_path3': lr_path3, 'HR_path': hr_path}
def __getitem__(self, idx): if self.args.real: if self.args.process: lrs, _, _, filenames = self._load_file_from_loaded_data(idx) else: lrs, _, _, filenames = self._load_file(idx) if len(lrs.shape) == 4: b, ih, iw, _ = lrs.shape else: lrs = np.array([np.expand_dims(lr, axis=2) for lr in lrs]) b, ih, iw, _ = lrs.shape #print(lrs.shape) ip = self.args.patch_size ix = random.randrange(0, iw - ip + 1) iy = random.randrange(0, ih - ip + 1) patches = [self.get_patch(lr, None, ix, iy) for lr in lrs] lrs = np.array([patch[0] for patch in patches]) lrs = np.array( common.set_channel(*lrs, n_channels=self.args.n_colors)) lr_tensors = common.np2Tensor(*lrs, rgb_range=self.args.rgb_range, n_colors=self.args.n_colors) return torch.stack(lr_tensors), filenames else: if self.args.process: lrs, hrs, kernels, filenames = self._load_file_from_loaded_data( idx) else: lrs, hrs, kernels, filenames = self._load_file(idx) if len(lrs.shape) == 4: b, ih, iw, _ = lrs.shape else: lrs = np.array([np.expand_dims(lr, axis=2) for lr in lrs]) b, ih, iw, _ = lrs.shape #print(lrs.shape) ip = self.args.patch_size ix = random.randrange(0, iw - ip + 1) iy = random.randrange(0, ih - ip + 1) patches = [ self.get_patch(lr, hr, ix, iy) for lr, hr in zip(lrs, hrs) ] lrs = np.array([patch[0] for patch in patches]) hrs = np.array([patch[1] for patch in patches]) kernels = np.array([kernel for kernel in kernels]) lrs = np.array( common.set_channel(*lrs, n_channels=self.args.n_colors)) hrs = np.array( common.set_channel(*hrs, n_channels=self.args.n_colors)) lr_tensors = common.np2Tensor(*lrs, rgb_range=self.args.rgb_range, n_colors=self.args.n_colors) hr_tensors = common.np2Tensor(*hrs, rgb_range=self.args.rgb_range, n_colors=self.args.n_colors) if self.args.pca_input: kernel_tensors = torch.from_numpy(kernels).float() else: kernels = np.reshape( kernels, (kernels.shape[0], kernels.shape[1], kernels.shape[2], 1)) kernel_tensors = common.kernel2Tensor( *kernels, rgb_range=self.args.rgb_range, n_colors=self.args.n_colors, norm=False) kernel_tensors = torch.stack(kernel_tensors) return torch.stack(lr_tensors), torch.stack( hr_tensors), kernel_tensors, filenames
def __getitem__(self, idx): filename = os.path.split(self.filelist[idx])[-1] filename, _ = os.path.splitext(filename) lr = misc.imread(self.filelist[idx]) lr = common.set_channel(lr, self.args.n_colors) return common.np2Tensor([lr], self.args.rgb_range)[0], -1, filename, -1
def __getitem__(self, idx): lr, hr = self._load_file(idx) lr, hr = self._get_patch(lr, hr) lr, hr = common.set_channel(lr, hr, n_channels=self.opt.n_colors) lr_tensor, hr_tensor = common.np2Tensor(lr, hr, rgb_range=self.opt.rgb_range) return lr_tensor, hr_tensor
def __getitem__(self, idx): img_lr, img_hr = self._load_file(idx) img_lr, img_hr = self._get_patch(img_lr, img_hr) img_lr, img_hr = common.set_channel(img_lr, img_hr, self.args.n_colors) return common.np2Tensor(img_lr, img_hr, self.args.rgb_range)
print("Model has {:.2f}M Parameters".format( (np.sum([i.numel() for i in model.parameters()])) / 1.e6)) model = model model.eval() checkpoint.done() LR_path = args.dir_data save_path = '../experiment/LR_result' img_list = glob.glob(os.path.join(LR_path, '*.png')) torch.set_grad_enabled(False) for i in tqdm.tqdm(img_list, ncols=80): img = imageio.imread(i) lr = common.set_channel(img, n_channels=3) # *解耦 从而可以传入*args lr = (common.np2Tensor(lr[0], rgb_range=255)[0]).unsqueeze(0).cuda() pred = model(lr, 1) #detach 类似于原来的data,只不过现在tensor与variable合并,但是detach更安全(修改原tensor求导会报错) #先取到与tensor的data内容,再转cpu再转numpy pred = pred.detach().squeeze(0).permute(1, 2, 0).clamp(0, 255).cpu().numpy() pred = pred.astype('uint8') imageio.imwrite(os.path.join(save_path, (i.split('/')[-1])), pred, format='png')
def __getitem__(self, idx): # get LR image lr, lr_path, pan, pan_path = self._load_file(idx) lr_tensor, pan_tensor = common.np2Tensor([lr, pan], self.opt['run_range'], self.opt['img_range']) return {'LR': lr_tensor, 'LR_path': lr_path, 'PAN': pan_tensor, 'PAN_path': pan_path }