commit from ssq

.gitignore

@@ -0,0 +1,4 @@
+# script
+git.sh
+Allweather/pretrained_models/net_g_best.pth
+Allweather/pretrained_models/net_g_real.pth

Allweather/Options/Allweather_Histoformer.yml

@@ -0,0 +1,155 @@
+# general settings
+name: Allweather_Histotormer
+model_type: ImageCleanModel
+scale: 1
+num_gpu: 4  # set num_gpu: 0 for cpu mode
+manual_seed: 100
+
+# dataset and data loader settings
+datasets:
+  train:
+    name: TrainSet
+    type: Dataset_PairedImage
+    dataroot_gt: /home1/ssq/data/allweather/gt/
+    dataroot_lq: /home1/ssq/data/allweather/input/
+    geometric_augs: true
+
+    filename_tmpl: '{}'
+    io_backend:
+      type: disk
+
+    # data loader
+    use_shuffle: true
+    num_worker_per_gpu: 8
+    batch_size_per_gpu: 8
+
+    ### -------------Progressive training--------------------------
+    mini_batch_sizes: [8,5,2,1,1]             # Batch size per gpu   
+    iters: [92000,84000,56000,36000,32000]
+    gt_size: 362   # Max patch size for progressive training
+    gt_sizes: [128,160,256,320,362]  # Patch sizes for progressive training.
+    ### ------------------------------------------------------------
+
+    ### ------- Training on single fixed-patch size 128x128---------
+    # mini_batch_sizes: [8]   
+    # iters: [300000]
+    # gt_size: 128   
+    # gt_sizes: [128]
+    ### ------------------------------------------------------------
+
+    dataset_enlarge_ratio: 1
+    prefetch_mode: ~
+
+  val_snow_s:
+    name: ValSet_Snow100K-S
+    type: Dataset_PairedImage
+    dataroot_gt: /home1/ssq/data/allweather/test/Snow100K-S/gt/
+    dataroot_lq: /home1/ssq/data/allweather/test/Snow100K-S/synthetic/
+    io_backend:
+      type: disk
+  val_snow_l:
+    name: ValSet_Snow100K-L
+    type: Dataset_PairedImage
+    dataroot_gt: /home1/ssq/data/allweather/test/Snow100K-L/gt/
+    dataroot_lq: /home1/ssq/data/allweather/test/Snow100K-L/synthetic/
+    io_backend:
+      type: disk
+  val_test1:
+    name: ValSet_Test1
+    type: Dataset_PairedImage
+    dataroot_gt: /home1/ssq/data/allweather/test/Test1/gt/
+    dataroot_lq: /home1/ssq/data/allweather/test/Test1/input/
+    io_backend:
+      type: disk
+  val_raindrop:
+    name: ValSet_RainDrop
+    type: Dataset_PairedImage
+    dataroot_gt: /home1/ssq/data/allweather/test/RainDrop/gt/
+    dataroot_lq: /home1/ssq/data/allweather/test/RainDrop/input/
+    io_backend:
+      type: disk
+
+
+# network structures
+network_g:
+  type: Histoformer
+  inp_channels: 3
+  out_channels: 3
+  dim: 36
+  num_blocks: [4,4,6,8]
+  num_refinement_blocks: 4
+  heads: [1,2,4,8]
+  ffn_expansion_factor: 2.667
+  bias: False
+  LayerNorm_type: WithBias
+  dual_pixel_task: False
+
+
+# path
+path:
+  pretrain_network_g: ~
+  strict_load_g: true
+  resume_state: ~
+
+# training settings
+train:
+  total_iter: 300000
+  warmup_iter: -1 # no warm up
+  use_grad_clip: true
+
+  # Split 300k iterations into two cycles. 
+  # 1st cycle: fixed 3e-4 LR for 92k iters. 
+  # 2nd cycle: cosine annealing (3e-4 to 1e-6) for 208k iters.
+  scheduler:
+    type: CosineAnnealingRestartCyclicLR # ReduceLROnPlateau
+    periods: [92000, 208000]       
+    restart_weights: [1,1]
+    eta_mins: [0.0003,0.000001]   
+  
+  mixing_augs:
+    mixup: false
+    mixup_beta: 1.2
+    use_identity: true
+
+  optim_g:
+    type: AdamW
+    lr: !!float 3e-4
+    weight_decay: !!float 1e-4
+    betas: [0.9, 0.999]
+  
+  # losses
+  pixel_opt:
+    type: L1Loss
+    loss_weight: 1
+    reduction: mean
+  seq_opt:
+    type: Pearson
+
+# validation settings
+val:
+  window_size: 8
+  val_freq: !!float 1e3
+  save_img: true
+  rgb2bgr: true
+  use_image: true
+  max_minibatch: 8
+
+  metrics:
+    psnr: # metric name, can be arbitrary
+      type: calculate_psnr
+      crop_border: 0
+      test_y_channel: true
+
+# logging settings
+logger:
+  print_freq: 10
+  save_checkpoint_freq: !!float 1e3
+  use_tb_logger: true
+  wandb:
+    project: ~
+    resume_id: ~
+
+# dist training settings
+dist_params:
+  backend: nccl
+  port: 29500

Allweather/compute_psnr.py

@@ -0,0 +1,136 @@
+import argparse
+import cv2
+import os
+import numpy as np
+from skimage.metrics import mean_squared_error
+from skimage.measure import compare_ssim
+from skimage.metrics import structural_similarity
+from skimage.metrics import peak_signal_noise_ratio
+#import lpips
+import torch
+from tqdm import tqdm
+
+#from niqe.niqe import compute_niqe
+
+#criterion = lpips.LPIPS(net='vgg', lpips=True, pnet_rand=False, pretrained=True).cuda()
+def rgb2ycbcr(im, only_y=True):
+    '''
+    same as matlab rgb2ycbcr
+    :parame img: uint8 or float ndarray
+    '''
+    in_im_type = im.dtype
+    im = im.astype(np.float64)
+    if in_im_type != np.uint8:
+        im *= 255.
+    # convert
+    if only_y:
+        rlt = np.dot(im, np.array([65.481, 128.553, 24.966])/ 255.0) + 16.0
+    else:
+        rlt = np.matmul(im, np.array([[65.481,  -37.797, 112.0  ],
+                                      [128.553, -74.203, -93.786],
+                                      [24.966,  112.0,   -18.214]])/255.0) + [16, 128, 128]
+    if in_im_type == np.uint8:
+        rlt = rlt.round()
+    else:
+        rlt /= 255.
+
+    return rlt.astype(in_im_type)
+
+def rgb2ycbcrTorch(im, only_y=True):
+    '''
+    same as matlab rgb2ycbcr
+    Input:
+        im: float [0,1], N x 3 x H x W
+        only_y: only return Y channel
+    '''
+    im_temp = im.permute([0,2,3,1]) * 255.0  # N x H x W x C --> N x H x W x C, [0,255]
+    # convert
+    if only_y:
+        rlt = torch.matmul(im_temp, torch.tensor([65.481, 128.553, 24.966],
+                                        device=im.device, dtype=im.dtype).view([3,1])/ 255.0) + 16.0
+    else:
+        rlt = torch.matmul(im_temp, torch.tensor([[65.481,  -37.797, 112.0  ],
+                                                  [128.553, -74.203, -93.786],
+                                                  [24.966,  112.0,   -18.214]],
+                                                  device=im.device, dtype=im.dtype)/255.0) + \
+                                                    torch.tensor([16, 128, 128]).view([-1, 1, 1, 3])
+    rlt /= 255.0
+    rlt.clamp_(0.0, 1.0)
+    return rlt.permute([0, 3, 1, 2])
+
+def readim(file):
+    # print(file)
+    img = cv2.imread(file)
+    img = img.astype(np.float32)
+    return img / 255.
+
+def loadfiles(folder):
+    files = os.listdir(folder)
+    return natsorted(files)
+
+def resize(im, size, crop=True):
+    if crop:
+        return im[:size[0], :size[1]]
+    else:
+        return cv2.resize(im, size)
+
+from natsort import natsorted
+
+def np2torch(img):
+    im = img.astype(np.float32) / 255
+    im = torch.tensor(im).permute((2,0,1)).unsqueeze(0)
+    return im.cuda()
+
+def compute_metrics(path1, path2, ycbcr=True):
+    print(path1)
+    files1 = loadfiles(path1)
+    files2 = loadfiles(path2)
+    print(len(files1), len(files2))
+    psnr = []
+    ssim = []
+    mse = []
+    lpips = []
+    niqe = []
+    crop = False
+    for file1, file2 in tqdm(zip(files1, files2)):
+        img1 = readim(os.path.join(path1, file1))
+        img2 = readim(os.path.join(path2, file2))
+        if img1.shape != img2.shape:
+            if not crop:
+                img1 = resize(img1, img2.shape[:2][::-1], False)
+            else:
+                img1 = resize(img1, img2.shape, True)
+        # print(img1.shape, img2.shape, img1.max())
+        MSE = mean_squared_error(img1, img2)
+        if ycbcr:
+            img1 = rgb2ycbcr(img1, True)
+            img2 = rgb2ycbcr(img2, True)
+        diff = (img2 - img1)
+        # print(diff.mean(), diff.max(), diff.min(), diff.shape)
+        PSNR = peak_signal_noise_ratio(img1, img2, data_range=1)
+        SSIM = structural_similarity(img1, img2, win_size=11, multichannel=False if ycbcr else True, data_range=1)
+        
+        mse.append(MSE)
+        psnr.append(PSNR)
+        ssim.append(SSIM)
+
+
+    mean_mse, mean_psnr, mean_ssim = np.mean(mse), np.mean(psnr), np.mean(ssim)
+    print(mean_mse, mean_psnr, mean_ssim)
+    return mean_mse, mean_psnr, mean_ssim
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    # path setting
+    parser.add_argument('--path1', type=str,default= "") # modify the experiments name-->modify all save path
+    parser.add_argument('--path2', type=str,default= "")
+    args = parser.parse_args()
+
+    path1 = ''
+    path2 = ''
+    if len(args.path1) != 0:
+        path1 = args.path1
+    if len(args.path2) != 0:
+        path2 = args.path2
+ 
+    compute_metrics(path1, path2, True)

Allweather/pretrained_models/README.md

@@ -0,0 +1 @@
+pre-trained models are available [here](https://drive.google.com/drive/folders/1dmPhr8Z5iPRx9lh7TwdUFPSfwGIxp5l0?usp=drive_link)

Allweather/test_histoformer.py

@@ -0,0 +1,89 @@
+import numpy as np
+import os
+import argparse
+from tqdm import tqdm
+
+import torch.nn as nn
+import torch
+import torch.nn.functional as F
+import util
+
+from natsort import natsorted
+from glob import glob
+import sys
+sys.path.append(os.path.join(os.getcwd(), ".."))
+from basicsr.models.archs.histoformer_arch import Histoformer
+from skimage import img_as_ubyte
+from pdb import set_trace as stx
+import time
+parser = argparse.ArgumentParser(description='Image Deraining using Restormer')
+
+parser.add_argument('--input_dir', default='./Datasets/', type=str, help='Directory of validation images')
+parser.add_argument('--result_dir', default='./results/', type=str, help='Directory for results')
+parser.add_argument('--weights', default='./pretrained_models/deraining.pth', type=str, help='Path to weights')
+parser.add_argument('--yaml_file', default='Options/Allweather_Histoformer.yml', type=str, help='Path to weights')
+
+args = parser.parse_args()
+
+####### Load yaml #######
+yaml_file = args.yaml_file
+import yaml
+
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
+
+x = yaml.load(open(yaml_file, mode='r'), Loader=Loader)
+
+s = x['network_g'].pop('type')
+##########################
+
+model_restoration = Histoformer(**x['network_g'])
+
+checkpoint = torch.load(args.weights)
+'''
+from thop import profile
+flops, params = profile(model_restoration, inputs=(torch.randn(1, 3, 256,256), ))
+print('FLOPs = ' + str(flops/1000**3) + 'G')
+print('Params = ' + str(params/1000**2) + 'M')
+'''
+model_restoration.load_state_dict(checkpoint['params'])
+print("===>Testing using weights: ",args.weights)
+model_restoration.cuda()
+model_restoration = nn.DataParallel(model_restoration)
+model_restoration.eval()
+
+factor = 8
+
+result_dir  = os.path.join(args.result_dir)
+os.makedirs(result_dir, exist_ok=True)
+inp_dir = os.path.join(args.input_dir)
+files = natsorted(glob(os.path.join(inp_dir, '*.png')) + glob(os.path.join(inp_dir, '*.jpg')))
+with torch.no_grad():
+    for file_ in tqdm(files):
+        torch.cuda.ipc_collect()
+        torch.cuda.empty_cache()
+
+        img = np.float32(util.load_img(file_))/255.
+        img = torch.from_numpy(img).permute(2,0,1)
+        input_ = img.unsqueeze(0).cuda()
+
+        # Padding in case images are not multiples of 8
+        h,w = input_.shape[2], input_.shape[3]
+        H,W = ((h+factor)//factor)*factor, ((w+factor)//factor)*factor
+        padh = H-h if h%factor!=0 else 0
+        padw = W-w if w%factor!=0 else 0
+        input_ = F.pad(input_, (0,padw,0,padh), 'reflect')
+
+        time1 = time.time()
+        restored = model_restoration(input_)
+        time2 = time.time()
+        #print(time2-time1)
+
+        # Unpad images to original dimensions
+        restored = restored[:,:,:h,:w]
+
+        restored = torch.clamp(restored,0,1).cpu().detach().permute(0, 2, 3, 1).squeeze(0).numpy()
+
+        util.save_img((os.path.join(result_dir, os.path.splitext(os.path.split(file_)[-1])[0]+'.png')), img_as_ubyte(restored))

Allweather/util.py

@@ -0,0 +1,86 @@
+import numpy as np
+import os
+import cv2
+import math
+
+def calculate_psnr(img1, img2, border=0):
+    # img1 and img2 have range [0, 255]
+    #img1 = img1.squeeze()
+    #img2 = img2.squeeze()
+    if not img1.shape == img2.shape:
+        raise ValueError('Input images must have the same dimensions.')
+    h, w = img1.shape[:2]
+    img1 = img1[border:h-border, border:w-border]
+    img2 = img2[border:h-border, border:w-border]
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    mse = np.mean((img1 - img2)**2)
+    if mse == 0:
+        return float('inf')
+    return 20 * math.log10(255.0 / math.sqrt(mse))
+
+
+# --------------------------------------------
+# SSIM
+# --------------------------------------------
+def calculate_ssim(img1, img2, border=0):
+    '''calculate SSIM
+    the same outputs as MATLAB's
+    img1, img2: [0, 255]
+    '''
+    #img1 = img1.squeeze()
+    #img2 = img2.squeeze()
+    if not img1.shape == img2.shape:
+        raise ValueError('Input images must have the same dimensions.')
+    h, w = img1.shape[:2]
+    img1 = img1[border:h-border, border:w-border]
+    img2 = img2[border:h-border, border:w-border]
+
+    if img1.ndim == 2:
+        return ssim(img1, img2)
+    elif img1.ndim == 3:
+        if img1.shape[2] == 3:
+            ssims = []
+            for i in range(3):
+                ssims.append(ssim(img1[:,:,i], img2[:,:,i]))
+            return np.array(ssims).mean()
+        elif img1.shape[2] == 1:
+            return ssim(np.squeeze(img1), np.squeeze(img2))
+    else:
+        raise ValueError('Wrong input image dimensions.')
+
+
+def ssim(img1, img2):
+    C1 = (0.01 * 255)**2
+    C2 = (0.03 * 255)**2
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+
+    mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]  # valid
+    mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                                            (sigma1_sq + sigma2_sq + C2))
+    return ssim_map.mean()
+
+def load_img(filepath):
+    return cv2.cvtColor(cv2.imread(filepath), cv2.COLOR_BGR2RGB)
+
+def save_img(filepath, img):
+    cv2.imwrite(filepath,cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+
+def load_gray_img(filepath):
+    return np.expand_dims(cv2.imread(filepath, cv2.IMREAD_GRAYSCALE), axis=2)
+
+def save_gray_img(filepath, img):
+    cv2.imwrite(filepath, img)

app.py

@@ -2,14 +2,14 @@ import torch
 import gradio as gr
 import numpy as np
 import torch.nn.functional as F
+from skimage import img_as_ubyte
 
 from Allweather.util import load_img, save_img
 from basicsr.models.archs.histoformer_arch import Histoformer
 
-model_restoration = Histoformer()
-model, transform = Histoformer.create_model_and_transforms()
-model = model.to(device)
-model.eval()
+model_restoration = Histoformer.from_pretrained("sunsean/Histoformer-real")
+
+model_restoration.eval()
 
 factor = 8
 def predict(input_img):
@@ -25,11 +25,11 @@ def predict(input_img):
     input_ = F.pad(input_, (0,padw,0,padh), 'reflect')
     return input_
     prediction = model_restoration(input_)
-    output_path = "inverse_depth_map.png"
-    restored = restored[:,:,:h,:w]
+    output_path = "restored.png"
+    result_dir = restored[:,:,:h,:w]
     restored = torch.clamp(restored,0,1).cpu().detach().permute(0, 2, 3, 1).squeeze(0).numpy()
 
-    save_img((os.path.join(result_dir, os.path.splitext(os.path.split(file_)[-1])[0]+'.png')), img_as_ubyte(restored))
+    save_img(result_dir, img_as_ubyte(restored))
 
 example_images = [
     "examples/example.jpeg",

basicsr/data/__init__.py

@@ -0,0 +1,126 @@
+import importlib
+import numpy as np
+import random
+import torch
+import torch.utils.data
+from functools import partial
+from os import path as osp
+
+from data.prefetch_dataloader import PrefetchDataLoader
+from utils import get_root_logger, scandir
+from utils.dist_util import get_dist_info
+
+__all__ = ['create_dataset', 'create_dataloader']
+
+# automatically scan and import dataset modules
+# scan all the files under the data folder with '_dataset' in file names
+data_folder = osp.dirname(osp.abspath(__file__))
+dataset_filenames = [
+    osp.splitext(osp.basename(v))[0] for v in scandir(data_folder)
+    if v.endswith('_dataset.py')
+]
+# import all the dataset modules
+_dataset_modules = [
+    importlib.import_module(f'data.{file_name}')
+    for file_name in dataset_filenames
+]
+
+
+def create_dataset(dataset_opt):
+    """Create dataset.
+
+    Args:
+        dataset_opt (dict): Configuration for dataset. It constains:
+            name (str): Dataset name.
+            type (str): Dataset type.
+    """
+    dataset_type = dataset_opt['type']
+
+    # dynamic instantiation
+    for module in _dataset_modules:
+        dataset_cls = getattr(module, dataset_type, None)
+        if dataset_cls is not None:
+            break
+    if dataset_cls is None:
+        raise ValueError(f'Dataset {dataset_type} is not found.')
+
+    dataset = dataset_cls(dataset_opt)
+
+    logger = get_root_logger()
+    logger.info(
+        f'Dataset {dataset.__class__.__name__} - {dataset_opt["name"]} '
+        'is created.')
+    return dataset
+
+
+def create_dataloader(dataset,
+                      dataset_opt,
+                      num_gpu=1,
+                      dist=False,
+                      sampler=None,
+                      seed=None):
+    """Create dataloader.
+
+    Args:
+        dataset (torch.utils.data.Dataset): Dataset.
+        dataset_opt (dict): Dataset options. It contains the following keys:
+            phase (str): 'train' or 'val'.
+            num_worker_per_gpu (int): Number of workers for each GPU.
+            batch_size_per_gpu (int): Training batch size for each GPU.
+        num_gpu (int): Number of GPUs. Used only in the train phase.
+            Default: 1.
+        dist (bool): Whether in distributed training. Used only in the train
+            phase. Default: False.
+        sampler (torch.utils.data.sampler): Data sampler. Default: None.
+        seed (int | None): Seed. Default: None
+    """
+    phase = dataset_opt['phase']
+    rank, _ = get_dist_info()
+    if phase == 'train':
+        if dist:  # distributed training
+            batch_size = dataset_opt['batch_size_per_gpu']
+            num_workers = dataset_opt['num_worker_per_gpu']
+        else:  # non-distributed training
+            multiplier = 1 if num_gpu == 0 else num_gpu
+            batch_size = dataset_opt['batch_size_per_gpu'] * multiplier
+            num_workers = dataset_opt['num_worker_per_gpu'] * multiplier
+        dataloader_args = dict(
+            dataset=dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+            sampler=sampler,
+            drop_last=True)
+        if sampler is None:
+            dataloader_args['shuffle'] = True
+        dataloader_args['worker_init_fn'] = partial(
+            worker_init_fn, num_workers=num_workers, rank=rank,
+            seed=seed) if seed is not None else None
+    elif phase in ['val', 'test']:  # validation
+        dataloader_args = dict(
+            dataset=dataset, batch_size=1, shuffle=False, num_workers=0)
+    else:
+        raise ValueError(f'Wrong dataset phase: {phase}. '
+                         "Supported ones are 'train', 'val' and 'test'.")
+
+    dataloader_args['pin_memory'] = dataset_opt.get('pin_memory', False)
+
+    prefetch_mode = dataset_opt.get('prefetch_mode')
+    if prefetch_mode == 'cpu':  # CPUPrefetcher
+        num_prefetch_queue = dataset_opt.get('num_prefetch_queue', 1)
+        logger = get_root_logger()
+        logger.info(f'Use {prefetch_mode} prefetch dataloader: '
+                    f'num_prefetch_queue = {num_prefetch_queue}')
+        return PrefetchDataLoader(
+            num_prefetch_queue=num_prefetch_queue, **dataloader_args)
+    else:
+        # prefetch_mode=None: Normal dataloader
+        # prefetch_mode='cuda': dataloader for CUDAPrefetcher
+        return torch.utils.data.DataLoader(**dataloader_args)
+
+
+def worker_init_fn(worker_id, num_workers, rank, seed):
+    # Set the worker seed to num_workers * rank + worker_id + seed
+    worker_seed = num_workers * rank + worker_id + seed
+    np.random.seed(worker_seed)
+    random.seed(worker_seed)

basicsr/data/data_sampler.py

@@ -0,0 +1,49 @@
+import math
+import torch
+from torch.utils.data.sampler import Sampler
+
+
+class EnlargedSampler(Sampler):
+    """Sampler that restricts data loading to a subset of the dataset.
+
+    Modified from torch.utils.data.distributed.DistributedSampler
+    Support enlarging the dataset for iteration-based training, for saving
+    time when restart the dataloader after each epoch
+
+    Args:
+        dataset (torch.utils.data.Dataset): Dataset used for sampling.
+        num_replicas (int | None): Number of processes participating in
+            the training. It is usually the world_size.
+        rank (int | None): Rank of the current process within num_replicas.
+        ratio (int): Enlarging ratio. Default: 1.
+    """
+
+    def __init__(self, dataset, num_replicas, rank, ratio=1):
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.epoch = 0
+        self.num_samples = math.ceil(
+            len(self.dataset) * ratio / self.num_replicas)
+        self.total_size = self.num_samples * self.num_replicas
+
+    def __iter__(self):
+        # deterministically shuffle based on epoch
+        g = torch.Generator()
+        g.manual_seed(self.epoch)
+        indices = torch.randperm(self.total_size, generator=g).tolist()
+
+        dataset_size = len(self.dataset)
+        indices = [v % dataset_size for v in indices]
+
+        # subsample
+        indices = indices[self.rank:self.total_size:self.num_replicas]
+        assert len(indices) == self.num_samples
+
+        return iter(indices)
+
+    def __len__(self):
+        return self.num_samples
+
+    def set_epoch(self, epoch):
+        self.epoch = epoch

basicsr/data/data_util.py

@@ -0,0 +1,390 @@
+import cv2
+cv2.setNumThreads(1)
+import numpy as np
+import torch
+from os import path as osp
+from torch.nn import functional as F
+
+from basicsr.data.transforms import mod_crop
+from basicsr.utils import img2tensor, scandir
+
+
+def read_img_seq(path, require_mod_crop=False, scale=1):
+    """Read a sequence of images from a given folder path.
+
+    Args:
+        path (list[str] | str): List of image paths or image folder path.
+        require_mod_crop (bool): Require mod crop for each image.
+            Default: False.
+        scale (int): Scale factor for mod_crop. Default: 1.
+
+    Returns:
+        Tensor: size (t, c, h, w), RGB, [0, 1].
+    """
+    if isinstance(path, list):
+        img_paths = path
+    else:
+        img_paths = sorted(list(scandir(path, full_path=True)))
+    imgs = [cv2.imread(v).astype(np.float32) / 255. for v in img_paths]
+    if require_mod_crop:
+        imgs = [mod_crop(img, scale) for img in imgs]
+    imgs = img2tensor(imgs, bgr2rgb=True, float32=True)
+    imgs = torch.stack(imgs, dim=0)
+    return imgs
+
+
+def generate_frame_indices(crt_idx,
+                           max_frame_num,
+                           num_frames,
+                           padding='reflection'):
+    """Generate an index list for reading `num_frames` frames from a sequence
+    of images.
+
+    Args:
+        crt_idx (int): Current center index.
+        max_frame_num (int): Max number of the sequence of images (from 1).
+        num_frames (int): Reading num_frames frames.
+        padding (str): Padding mode, one of
+            'replicate' | 'reflection' | 'reflection_circle' | 'circle'
+            Examples: current_idx = 0, num_frames = 5
+            The generated frame indices under different padding mode:
+            replicate: [0, 0, 0, 1, 2]
+            reflection: [2, 1, 0, 1, 2]
+            reflection_circle: [4, 3, 0, 1, 2]
+            circle: [3, 4, 0, 1, 2]
+
+    Returns:
+        list[int]: A list of indices.
+    """
+    assert num_frames % 2 == 1, 'num_frames should be an odd number.'
+    assert padding in ('replicate', 'reflection', 'reflection_circle',
+                       'circle'), f'Wrong padding mode: {padding}.'
+
+    max_frame_num = max_frame_num - 1  # start from 0
+    num_pad = num_frames // 2
+
+    indices = []
+    for i in range(crt_idx - num_pad, crt_idx + num_pad + 1):
+        if i < 0:
+            if padding == 'replicate':
+                pad_idx = 0
+            elif padding == 'reflection':
+                pad_idx = -i
+            elif padding == 'reflection_circle':
+                pad_idx = crt_idx + num_pad - i
+            else:
+                pad_idx = num_frames + i
+        elif i > max_frame_num:
+            if padding == 'replicate':
+                pad_idx = max_frame_num
+            elif padding == 'reflection':
+                pad_idx = max_frame_num * 2 - i
+            elif padding == 'reflection_circle':
+                pad_idx = (crt_idx - num_pad) - (i - max_frame_num)
+            else:
+                pad_idx = i - num_frames
+        else:
+            pad_idx = i
+        indices.append(pad_idx)
+    return indices
+
+
+def paired_paths_from_lmdb(folders, keys):
+    """Generate paired paths from lmdb files.
+
+    Contents of lmdb. Taking the `lq.lmdb` for example, the file structure is:
+
+    lq.lmdb
+    ├── data.mdb
+    ├── lock.mdb
+    ├── meta_info.txt
+
+    The data.mdb and lock.mdb are standard lmdb files and you can refer to
+    https://lmdb.readthedocs.io/en/release/ for more details.
+
+    The meta_info.txt is a specified txt file to record the meta information
+    of our datasets. It will be automatically created when preparing
+    datasets by our provided dataset tools.
+    Each line in the txt file records
+    1)image name (with extension),
+    2)image shape,
+    3)compression level, separated by a white space.
+    Example: `baboon.png (120,125,3) 1`
+
+    We use the image name without extension as the lmdb key.
+    Note that we use the same key for the corresponding lq and gt images.
+
+    Args:
+        folders (list[str]): A list of folder path. The order of list should
+            be [input_folder, gt_folder].
+        keys (list[str]): A list of keys identifying folders. The order should
+            be in consistent with folders, e.g., ['lq', 'gt'].
+            Note that this key is different from lmdb keys.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+    assert len(folders) == 2, (
+        'The len of folders should be 2 with [input_folder, gt_folder]. '
+        f'But got {len(folders)}')
+    assert len(keys) == 2, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'But got {len(keys)}')
+    input_folder, gt_folder = folders
+    input_key, gt_key = keys
+
+    if not (input_folder.endswith('.lmdb') and gt_folder.endswith('.lmdb')):
+        raise ValueError(
+            f'{input_key} folder and {gt_key} folder should both in lmdb '
+            f'formats. But received {input_key}: {input_folder}; '
+            f'{gt_key}: {gt_folder}')
+    # ensure that the two meta_info files are the same
+    with open(osp.join(input_folder, 'meta_info.txt')) as fin:
+        input_lmdb_keys = [line.split('.')[0] for line in fin]
+    with open(osp.join(gt_folder, 'meta_info.txt')) as fin:
+        gt_lmdb_keys = [line.split('.')[0] for line in fin]
+    if set(input_lmdb_keys) != set(gt_lmdb_keys):
+        raise ValueError(
+            f'Keys in {input_key}_folder and {gt_key}_folder are different.')
+    else:
+        paths = []
+        for lmdb_key in sorted(input_lmdb_keys):
+            paths.append(
+                dict([(f'{input_key}_path', lmdb_key),
+                      (f'{gt_key}_path', lmdb_key)]))
+        return paths
+
+
+def paired_paths_from_meta_info_file(folders, keys, meta_info_file,
+                                     filename_tmpl):
+    """Generate paired paths from an meta information file.
+
+    Each line in the meta information file contains the image names and
+    image shape (usually for gt), separated by a white space.
+
+    Example of an meta information file:
+    ```
+    0001_s001.png (480,480,3)
+    0001_s002.png (480,480,3)
+    ```
+
+    Args:
+        folders (list[str]): A list of folder path. The order of list should
+            be [input_folder, gt_folder].
+        keys (list[str]): A list of keys identifying folders. The order should
+            be in consistent with folders, e.g., ['lq', 'gt'].
+        meta_info_file (str): Path to the meta information file.
+        filename_tmpl (str): Template for each filename. Note that the
+            template excludes the file extension. Usually the filename_tmpl is
+            for files in the input folder.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+    assert len(folders) == 2, (
+        'The len of folders should be 2 with [input_folder, gt_folder]. '
+        f'But got {len(folders)}')
+    assert len(keys) == 2, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'But got {len(keys)}')
+    input_folder, gt_folder = folders
+    input_key, gt_key = keys
+
+    with open(meta_info_file, 'r') as fin:
+        gt_names = [line.split(' ')[0] for line in fin]
+
+    paths = []
+    for gt_name in gt_names:
+        basename, ext = osp.splitext(osp.basename(gt_name))
+        input_name = f'{filename_tmpl.format(basename)}{ext}'
+        input_path = osp.join(input_folder, input_name)
+        gt_path = osp.join(gt_folder, gt_name)
+        paths.append(
+            dict([(f'{input_key}_path', input_path),
+                  (f'{gt_key}_path', gt_path)]))
+    return paths
+
+
+def paired_paths_from_folder(folders, keys, filename_tmpl):
+    """Generate paired paths from folders.
+
+    Args:
+        folders (list[str]): A list of folder path. The order of list should
+            be [input_folder, gt_folder].
+        keys (list[str]): A list of keys identifying folders. The order should
+            be in consistent with folders, e.g., ['lq', 'gt'].
+        filename_tmpl (str): Template for each filename. Note that the
+            template excludes the file extension. Usually the filename_tmpl is
+            for files in the input folder.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+    assert len(folders) == 2, (
+        'The len of folders should be 2 with [input_folder, gt_folder]. '
+        f'But got {len(folders)}')
+    assert len(keys) == 2, (
+        'The len of keys should be 2 with [input_key, gt_key]. '
+        f'But got {len(keys)}')
+    input_folder, gt_folder = folders
+    input_key, gt_key = keys
+
+    input_paths = list(scandir(input_folder))
+    gt_paths = list(scandir(gt_folder))
+    assert len(input_paths) == len(gt_paths), (
+        f'{input_key} and {gt_key} datasets have different number of images: '
+        f'{len(input_paths)}, {len(gt_paths)}.')
+    paths = []
+    for idx in range(len(gt_paths)):
+        gt_path = gt_paths[idx]
+#        if "lns" in gt_path:
+#            continue
+        basename, ext = osp.splitext(osp.basename(gt_path))
+        input_path = input_paths[idx]
+        basename_input, ext_input = osp.splitext(osp.basename(input_path))
+        input_name = f'{filename_tmpl.format(basename)}{ext_input}'
+        input_path = osp.join(input_folder, input_name)
+        assert input_name in input_paths, (f'{input_name} is not in '
+                                           f'{input_key}_paths.')
+        gt_path = osp.join(gt_folder, gt_path)
+        paths.append(
+            dict([(f'{input_key}_path', input_path),
+                  (f'{gt_key}_path', gt_path)]))
+    return paths
+
+def paired_DP_paths_from_folder(folders, keys, filename_tmpl):
+    """Generate paired paths from folders.
+
+    Args:
+        folders (list[str]): A list of folder path. The order of list should
+            be [input_folder, gt_folder].
+        keys (list[str]): A list of keys identifying folders. The order should
+            be in consistent with folders, e.g., ['lq', 'gt'].
+        filename_tmpl (str): Template for each filename. Note that the
+            template excludes the file extension. Usually the filename_tmpl is
+            for files in the input folder.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+    assert len(folders) == 3, (
+        'The len of folders should be 3 with [inputL_folder, inputR_folder, gt_folder]. '
+        f'But got {len(folders)}')
+    assert len(keys) == 3, (
+        'The len of keys should be 2 with [inputL_key, inputR_key, gt_key]. '
+        f'But got {len(keys)}')
+    inputL_folder, inputR_folder, gt_folder = folders
+    inputL_key, inputR_key, gt_key = keys
+
+    inputL_paths = list(scandir(inputL_folder))
+    inputR_paths = list(scandir(inputR_folder))
+    gt_paths = list(scandir(gt_folder))
+    assert len(inputL_paths) == len(inputR_paths) == len(gt_paths), (
+        f'{inputL_key} and {inputR_key} and {gt_key} datasets have different number of images: '
+        f'{len(inputL_paths)}, {len(inputR_paths)}, {len(gt_paths)}.')
+    paths = []
+    for idx in range(len(gt_paths)):
+        gt_path = gt_paths[idx]
+        basename, ext = osp.splitext(osp.basename(gt_path))
+        inputL_path = inputL_paths[idx]
+        basename_input, ext_input = osp.splitext(osp.basename(inputL_path))
+        inputL_name = f'{filename_tmpl.format(basename)}{ext_input}'
+        inputL_path = osp.join(inputL_folder, inputL_name)
+        assert inputL_name in inputL_paths, (f'{inputL_name} is not in '
+                                           f'{inputL_key}_paths.')
+        inputR_path = inputR_paths[idx]
+        basename_input, ext_input = osp.splitext(osp.basename(inputR_path))
+        inputR_name = f'{filename_tmpl.format(basename)}{ext_input}'
+        inputR_path = osp.join(inputR_folder, inputR_name)
+        assert inputR_name in inputR_paths, (f'{inputR_name} is not in '
+                                           f'{inputR_key}_paths.')
+        gt_path = osp.join(gt_folder, gt_path)
+        paths.append(
+            dict([(f'{inputL_key}_path', inputL_path),
+                  (f'{inputR_key}_path', inputR_path),
+                  (f'{gt_key}_path', gt_path)]))
+    return paths
+
+
+def paths_from_folder(folder):
+    """Generate paths from folder.
+
+    Args:
+        folder (str): Folder path.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+
+    paths = list(scandir(folder))
+    paths = [osp.join(folder, path) for path in paths]
+    return paths
+
+
+def paths_from_lmdb(folder):
+    """Generate paths from lmdb.
+
+    Args:
+        folder (str): Folder path.
+
+    Returns:
+        list[str]: Returned path list.
+    """
+    if not folder.endswith('.lmdb'):
+        raise ValueError(f'Folder {folder}folder should in lmdb format.')
+    with open(osp.join(folder, 'meta_info.txt')) as fin:
+        paths = [line.split('.')[0] for line in fin]
+    return paths
+
+
+def generate_gaussian_kernel(kernel_size=13, sigma=1.6):
+    """Generate Gaussian kernel used in `duf_downsample`.
+
+    Args:
+        kernel_size (int): Kernel size. Default: 13.
+        sigma (float): Sigma of the Gaussian kernel. Default: 1.6.
+
+    Returns:
+        np.array: The Gaussian kernel.
+    """
+    from scipy.ndimage import filters as filters
+    kernel = np.zeros((kernel_size, kernel_size))
+    # set element at the middle to one, a dirac delta
+    kernel[kernel_size // 2, kernel_size // 2] = 1
+    # gaussian-smooth the dirac, resulting in a gaussian filter
+    return filters.gaussian_filter(kernel, sigma)
+
+
+def duf_downsample(x, kernel_size=13, scale=4):
+    """Downsamping with Gaussian kernel used in the DUF official code.
+
+    Args:
+        x (Tensor): Frames to be downsampled, with shape (b, t, c, h, w).
+        kernel_size (int): Kernel size. Default: 13.
+        scale (int): Downsampling factor. Supported scale: (2, 3, 4).
+            Default: 4.
+
+    Returns:
+        Tensor: DUF downsampled frames.
+    """
+    assert scale in (2, 3,
+                     4), f'Only support scale (2, 3, 4), but got {scale}.'
+
+    squeeze_flag = False
+    if x.ndim == 4:
+        squeeze_flag = True
+        x = x.unsqueeze(0)
+    b, t, c, h, w = x.size()
+    x = x.view(-1, 1, h, w)
+    pad_w, pad_h = kernel_size // 2 + scale * 2, kernel_size // 2 + scale * 2
+    x = F.pad(x, (pad_w, pad_w, pad_h, pad_h), 'reflect')
+
+    gaussian_filter = generate_gaussian_kernel(kernel_size, 0.4 * scale)
+    gaussian_filter = torch.from_numpy(gaussian_filter).type_as(x).unsqueeze(
+        0).unsqueeze(0)
+    x = F.conv2d(x, gaussian_filter, stride=scale)
+    x = x[:, :, 2:-2, 2:-2]
+    x = x.view(b, t, c, x.size(2), x.size(3))
+    if squeeze_flag:
+        x = x.squeeze(0)
+    return x

basicsr/data/meta_info/meta_info_REDS4_test_GT.txt

@@ -0,0 +1,4 @@
+000 100 (720,1280,3)
+011 100 (720,1280,3)
+015 100 (720,1280,3)
+020 100 (720,1280,3)

basicsr/data/meta_info/meta_info_REDS_GT.txt

@@ -0,0 +1,270 @@
+000 100 (720,1280,3)
+001 100 (720,1280,3)
+002 100 (720,1280,3)
+003 100 (720,1280,3)
+004 100 (720,1280,3)
+005 100 (720,1280,3)
+006 100 (720,1280,3)
+007 100 (720,1280,3)
+008 100 (720,1280,3)
+009 100 (720,1280,3)
+010 100 (720,1280,3)
+011 100 (720,1280,3)
+012 100 (720,1280,3)
+013 100 (720,1280,3)
+014 100 (720,1280,3)
+015 100 (720,1280,3)
+016 100 (720,1280,3)
+017 100 (720,1280,3)
+018 100 (720,1280,3)
+019 100 (720,1280,3)
+020 100 (720,1280,3)
+021 100 (720,1280,3)
+022 100 (720,1280,3)
+023 100 (720,1280,3)
+024 100 (720,1280,3)
+025 100 (720,1280,3)
+026 100 (720,1280,3)
+027 100 (720,1280,3)
+028 100 (720,1280,3)
+029 100 (720,1280,3)
+030 100 (720,1280,3)
+031 100 (720,1280,3)
+032 100 (720,1280,3)
+033 100 (720,1280,3)
+034 100 (720,1280,3)
+035 100 (720,1280,3)
+036 100 (720,1280,3)
+037 100 (720,1280,3)
+038 100 (720,1280,3)
+039 100 (720,1280,3)
+040 100 (720,1280,3)
+041 100 (720,1280,3)
+042 100 (720,1280,3)
+043 100 (720,1280,3)
+044 100 (720,1280,3)
+045 100 (720,1280,3)
+046 100 (720,1280,3)
+047 100 (720,1280,3)
+048 100 (720,1280,3)
+049 100 (720,1280,3)
+050 100 (720,1280,3)
+051 100 (720,1280,3)
+052 100 (720,1280,3)
+053 100 (720,1280,3)
+054 100 (720,1280,3)
+055 100 (720,1280,3)
+056 100 (720,1280,3)
+057 100 (720,1280,3)
+058 100 (720,1280,3)
+059 100 (720,1280,3)
+060 100 (720,1280,3)
+061 100 (720,1280,3)
+062 100 (720,1280,3)
+063 100 (720,1280,3)
+064 100 (720,1280,3)
+065 100 (720,1280,3)
+066 100 (720,1280,3)
+067 100 (720,1280,3)
+068 100 (720,1280,3)
+069 100 (720,1280,3)
+070 100 (720,1280,3)
+071 100 (720,1280,3)
+072 100 (720,1280,3)
+073 100 (720,1280,3)
+074 100 (720,1280,3)
+075 100 (720,1280,3)
+076 100 (720,1280,3)
+077 100 (720,1280,3)
+078 100 (720,1280,3)
+079 100 (720,1280,3)
+080 100 (720,1280,3)
+081 100 (720,1280,3)
+082 100 (720,1280,3)
+083 100 (720,1280,3)
+084 100 (720,1280,3)
+085 100 (720,1280,3)
+086 100 (720,1280,3)
+087 100 (720,1280,3)
+088 100 (720,1280,3)
+089 100 (720,1280,3)
+090 100 (720,1280,3)
+091 100 (720,1280,3)
+092 100 (720,1280,3)
+093 100 (720,1280,3)
+094 100 (720,1280,3)
+095 100 (720,1280,3)
+096 100 (720,1280,3)
+097 100 (720,1280,3)
+098 100 (720,1280,3)
+099 100 (720,1280,3)
+100 100 (720,1280,3)
+101 100 (720,1280,3)
+102 100 (720,1280,3)
+103 100 (720,1280,3)
+104 100 (720,1280,3)
+105 100 (720,1280,3)
+106 100 (720,1280,3)
+107 100 (720,1280,3)
+108 100 (720,1280,3)
+109 100 (720,1280,3)
+110 100 (720,1280,3)
+111 100 (720,1280,3)
+112 100 (720,1280,3)
+113 100 (720,1280,3)
+114 100 (720,1280,3)
+115 100 (720,1280,3)
+116 100 (720,1280,3)
+117 100 (720,1280,3)
+118 100 (720,1280,3)
+119 100 (720,1280,3)
+120 100 (720,1280,3)
+121 100 (720,1280,3)
+122 100 (720,1280,3)
+123 100 (720,1280,3)
+124 100 (720,1280,3)
+125 100 (720,1280,3)
+126 100 (720,1280,3)
+127 100 (720,1280,3)
+128 100 (720,1280,3)
+129 100 (720,1280,3)
+130 100 (720,1280,3)
+131 100 (720,1280,3)
+132 100 (720,1280,3)
+133 100 (720,1280,3)
+134 100 (720,1280,3)
+135 100 (720,1280,3)
+136 100 (720,1280,3)
+137 100 (720,1280,3)
+138 100 (720,1280,3)
+139 100 (720,1280,3)
+140 100 (720,1280,3)
+141 100 (720,1280,3)
+142 100 (720,1280,3)
+143 100 (720,1280,3)
+144 100 (720,1280,3)
+145 100 (720,1280,3)
+146 100 (720,1280,3)
+147 100 (720,1280,3)
+148 100 (720,1280,3)
+149 100 (720,1280,3)
+150 100 (720,1280,3)
+151 100 (720,1280,3)
+152 100 (720,1280,3)
+153 100 (720,1280,3)
+154 100 (720,1280,3)
+155 100 (720,1280,3)
+156 100 (720,1280,3)
+157 100 (720,1280,3)
+158 100 (720,1280,3)
+159 100 (720,1280,3)
+160 100 (720,1280,3)
+161 100 (720,1280,3)
+162 100 (720,1280,3)
+163 100 (720,1280,3)
+164 100 (720,1280,3)
+165 100 (720,1280,3)
+166 100 (720,1280,3)
+167 100 (720,1280,3)
+168 100 (720,1280,3)
+169 100 (720,1280,3)
+170 100 (720,1280,3)
+171 100 (720,1280,3)
+172 100 (720,1280,3)
+173 100 (720,1280,3)
+174 100 (720,1280,3)
+175 100 (720,1280,3)
+176 100 (720,1280,3)
+177 100 (720,1280,3)
+178 100 (720,1280,3)
+179 100 (720,1280,3)
+180 100 (720,1280,3)
+181 100 (720,1280,3)
+182 100 (720,1280,3)
+183 100 (720,1280,3)
+184 100 (720,1280,3)
+185 100 (720,1280,3)
+186 100 (720,1280,3)
+187 100 (720,1280,3)
+188 100 (720,1280,3)
+189 100 (720,1280,3)
+190 100 (720,1280,3)
+191 100 (720,1280,3)
+192 100 (720,1280,3)
+193 100 (720,1280,3)
+194 100 (720,1280,3)
+195 100 (720,1280,3)
+196 100 (720,1280,3)
+197 100 (720,1280,3)
+198 100 (720,1280,3)
+199 100 (720,1280,3)
+200 100 (720,1280,3)
+201 100 (720,1280,3)
+202 100 (720,1280,3)
+203 100 (720,1280,3)
+204 100 (720,1280,3)
+205 100 (720,1280,3)
+206 100 (720,1280,3)
+207 100 (720,1280,3)
+208 100 (720,1280,3)
+209 100 (720,1280,3)
+210 100 (720,1280,3)
+211 100 (720,1280,3)
+212 100 (720,1280,3)
+213 100 (720,1280,3)
+214 100 (720,1280,3)
+215 100 (720,1280,3)
+216 100 (720,1280,3)
+217 100 (720,1280,3)
+218 100 (720,1280,3)
+219 100 (720,1280,3)
+220 100 (720,1280,3)
+221 100 (720,1280,3)
+222 100 (720,1280,3)
+223 100 (720,1280,3)
+224 100 (720,1280,3)
+225 100 (720,1280,3)
+226 100 (720,1280,3)
+227 100 (720,1280,3)
+228 100 (720,1280,3)
+229 100 (720,1280,3)
+230 100 (720,1280,3)
+231 100 (720,1280,3)
+232 100 (720,1280,3)
+233 100 (720,1280,3)
+234 100 (720,1280,3)
+235 100 (720,1280,3)
+236 100 (720,1280,3)
+237 100 (720,1280,3)
+238 100 (720,1280,3)
+239 100 (720,1280,3)
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+242 100 (720,1280,3)
+243 100 (720,1280,3)
+244 100 (720,1280,3)
+245 100 (720,1280,3)
+246 100 (720,1280,3)
+247 100 (720,1280,3)
+248 100 (720,1280,3)
+249 100 (720,1280,3)
+250 100 (720,1280,3)
+251 100 (720,1280,3)
+252 100 (720,1280,3)
+253 100 (720,1280,3)
+254 100 (720,1280,3)
+255 100 (720,1280,3)
+256 100 (720,1280,3)
+257 100 (720,1280,3)
+258 100 (720,1280,3)
+259 100 (720,1280,3)
+260 100 (720,1280,3)
+261 100 (720,1280,3)
+262 100 (720,1280,3)
+263 100 (720,1280,3)
+264 100 (720,1280,3)
+265 100 (720,1280,3)
+266 100 (720,1280,3)
+267 100 (720,1280,3)
+268 100 (720,1280,3)
+269 100 (720,1280,3)

basicsr/data/meta_info/meta_info_REDSofficial4_test_GT.txt

@@ -0,0 +1,4 @@
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+246 100 (720,1280,3)
+257 100 (720,1280,3)

basicsr/data/meta_info/meta_info_REDSval_official_test_GT.txt

@@ -0,0 +1,30 @@
+240 100 (720,1280,3)
+241 100 (720,1280,3)
+242 100 (720,1280,3)
+243 100 (720,1280,3)
+244 100 (720,1280,3)
+245 100 (720,1280,3)
+246 100 (720,1280,3)
+247 100 (720,1280,3)
+248 100 (720,1280,3)
+249 100 (720,1280,3)
+250 100 (720,1280,3)
+251 100 (720,1280,3)
+252 100 (720,1280,3)
+253 100 (720,1280,3)
+254 100 (720,1280,3)
+255 100 (720,1280,3)
+256 100 (720,1280,3)
+257 100 (720,1280,3)
+258 100 (720,1280,3)
+259 100 (720,1280,3)
+260 100 (720,1280,3)
+261 100 (720,1280,3)
+262 100 (720,1280,3)
+263 100 (720,1280,3)
+264 100 (720,1280,3)
+265 100 (720,1280,3)
+266 100 (720,1280,3)
+267 100 (720,1280,3)
+268 100 (720,1280,3)
+269 100 (720,1280,3)

basicsr/data/meta_info/meta_info_Vimeo90K_test_fast_GT.txt

@@ -0,0 +1,1225 @@
+00001/0625 7 (256,448,3)
+00001/0632 7 (256,448,3)
+00001/0807 7 (256,448,3)
+00001/0832 7 (256,448,3)
+00001/0834 7 (256,448,3)
+00001/0836 7 (256,448,3)
+00002/0004 7 (256,448,3)
+00002/0112 7 (256,448,3)
+00002/0116 7 (256,448,3)
+00002/0123 7 (256,448,3)
+00002/0455 7 (256,448,3)
+00002/0602 7 (256,448,3)
+00002/0976 7 (256,448,3)
+00002/0980 7 (256,448,3)
+00002/0983 7 (256,448,3)
+00002/1000 7 (256,448,3)
+00003/0022 7 (256,448,3)
+00003/0031 7 (256,448,3)
+00003/0035 7 (256,448,3)
+00003/0041 7 (256,448,3)
+00003/0073 7 (256,448,3)
+00003/0107 7 (256,448,3)
+00003/0111 7 (256,448,3)
+00003/0114 7 (256,448,3)
+00003/0117 7 (256,448,3)
+00003/0121 7 (256,448,3)
+00003/0499 7 (256,448,3)
+00003/0501 7 (256,448,3)
+00003/0507 7 (256,448,3)
+00003/0510 7 (256,448,3)
+00003/0517 7 (256,448,3)
+00003/0522 7 (256,448,3)
+00003/0531 7 (256,448,3)
+00003/0533 7 (256,448,3)
+00003/0534 7 (256,448,3)
+00003/0682 7 (256,448,3)
+00003/0687 7 (256,448,3)
+00003/0715 7 (256,448,3)
+00003/0742 7 (256,448,3)
+00003/0751 7 (256,448,3)
+00003/0984 7 (256,448,3)
+00004/0042 7 (256,448,3)
+00004/0165 7 (256,448,3)
+00004/0321 7 (256,448,3)
+00004/0569 7 (256,448,3)
+00004/0572 7 (256,448,3)
+00004/0619 7 (256,448,3)
+00004/0776 7 (256,448,3)
+00004/0780 7 (256,448,3)
+00004/0825 7 (256,448,3)
+00004/0832 7 (256,448,3)
+00004/0853 7 (256,448,3)
+00004/0876 7 (256,448,3)
+00004/0888 7 (256,448,3)
+00005/0015 7 (256,448,3)
+00005/0021 7 (256,448,3)
+00005/0022 7 (256,448,3)
+00005/0024 7 (256,448,3)
+00005/0026 7 (256,448,3)
+00005/0394 7 (256,448,3)
+00005/0403 7 (256,448,3)
+00005/0531 7 (256,448,3)
+00005/0546 7 (256,448,3)
+00005/0554 7 (256,448,3)
+00005/0694 7 (256,448,3)
+00005/0700 7 (256,448,3)
+00005/0740 7 (256,448,3)
+00005/0826 7 (256,448,3)
+00005/0832 7 (256,448,3)
+00005/0834 7 (256,448,3)
+00005/0943 7 (256,448,3)
+00006/0184 7 (256,448,3)
+00006/0205 7 (256,448,3)
+00006/0206 7 (256,448,3)
+00006/0211 7 (256,448,3)
+00006/0271 7 (256,448,3)
+00006/0273 7 (256,448,3)
+00006/0277 7 (256,448,3)
+00006/0283 7 (256,448,3)
+00006/0287 7 (256,448,3)
+00006/0298 7 (256,448,3)
+00006/0310 7 (256,448,3)
+00006/0356 7 (256,448,3)
+00006/0357 7 (256,448,3)
+00006/0544 7 (256,448,3)
+00006/0565 7 (256,448,3)
+00006/0569 7 (256,448,3)
+00006/0573 7 (256,448,3)
+00006/0592 7 (256,448,3)
+00006/0613 7 (256,448,3)
+00006/0633 7 (256,448,3)
+00006/0637 7 (256,448,3)
+00006/0646 7 (256,448,3)
+00006/0649 7 (256,448,3)
+00006/0655 7 (256,448,3)
+00006/0658 7 (256,448,3)
+00006/0662 7 (256,448,3)
+00006/0666 7 (256,448,3)
+00006/0673 7 (256,448,3)
+00007/0248 7 (256,448,3)
+00007/0253 7 (256,448,3)
+00007/0430 7 (256,448,3)
+00007/0434 7 (256,448,3)
+00007/0436 7 (256,448,3)
+00007/0452 7 (256,448,3)
+00007/0464 7 (256,448,3)
+00007/0470 7 (256,448,3)
+00007/0472 7 (256,448,3)
+00007/0483 7 (256,448,3)
+00007/0484 7 (256,448,3)
+00007/0493 7 (256,448,3)
+00007/0508 7 (256,448,3)
+00007/0514 7 (256,448,3)
+00007/0697 7 (256,448,3)
+00007/0698 7 (256,448,3)
+00007/0744 7 (256,448,3)
+00007/0775 7 (256,448,3)
+00007/0786 7 (256,448,3)
+00007/0790 7 (256,448,3)
+00007/0800 7 (256,448,3)
+00007/0833 7 (256,448,3)
+00007/0867 7 (256,448,3)
+00007/0879 7 (256,448,3)
+00007/0899 7 (256,448,3)
+00008/0251 7 (256,448,3)
+00008/0322 7 (256,448,3)
+00008/0971 7 (256,448,3)
+00008/0976 7 (256,448,3)
+00009/0016 7 (256,448,3)
+00009/0036 7 (256,448,3)
+00009/0037 7 (256,448,3)
+00009/0609 7 (256,448,3)
+00009/0812 7 (256,448,3)
+00009/0821 7 (256,448,3)
+00009/0947 7 (256,448,3)
+00009/0952 7 (256,448,3)
+00009/0955 7 (256,448,3)
+00009/0970 7 (256,448,3)
+00010/0072 7 (256,448,3)
+00010/0074 7 (256,448,3)
+00010/0079 7 (256,448,3)
+00010/0085 7 (256,448,3)
+00010/0139 7 (256,448,3)
+00010/0140 7 (256,448,3)
+00010/0183 7 (256,448,3)
+00010/0200 7 (256,448,3)
+00010/0223 7 (256,448,3)
+00010/0305 7 (256,448,3)
+00010/0323 7 (256,448,3)
+00010/0338 7 (256,448,3)
+00010/0342 7 (256,448,3)
+00010/0350 7 (256,448,3)
+00010/0356 7 (256,448,3)
+00010/0362 7 (256,448,3)
+00010/0366 7 (256,448,3)
+00010/0375 7 (256,448,3)
+00010/0404 7 (256,448,3)
+00010/0407 7 (256,448,3)
+00010/0414 7 (256,448,3)
+00010/0418 7 (256,448,3)
+00010/0429 7 (256,448,3)
+00010/0557 7 (256,448,3)
+00010/0564 7 (256,448,3)
+00010/0733 7 (256,448,3)
+00010/0935 7 (256,448,3)
+00010/0939 7 (256,448,3)
+00010/0943 7 (256,448,3)
+00011/0242 7 (256,448,3)
+00011/0259 7 (256,448,3)
+00011/0263 7 (256,448,3)
+00011/0266 7 (256,448,3)
+00011/0278 7 (256,448,3)
+00011/0890 7 (256,448,3)
+00011/0894 7 (256,448,3)
+00011/0903 7 (256,448,3)
+00011/0906 7 (256,448,3)
+00011/0913 7 (256,448,3)
+00012/0011 7 (256,448,3)
+00012/0014 7 (256,448,3)
+00012/0126 7 (256,448,3)
+00012/0127 7 (256,448,3)
+00012/0526 7 (256,448,3)
+00012/0551 7 (256,448,3)
+00012/0896 7 (256,448,3)
+00012/0910 7 (256,448,3)
+00012/0915 7 (256,448,3)
+00013/0167 7 (256,448,3)
+00013/0794 7 (256,448,3)
+00013/0807 7 (256,448,3)
+00013/0846 7 (256,448,3)
+00013/0882 7 (256,448,3)
+00013/0889 7 (256,448,3)
+00013/0910 7 (256,448,3)
+00013/0913 7 (256,448,3)
+00013/0924 7 (256,448,3)
+00013/0931 7 (256,448,3)
+00013/0944 7 (256,448,3)
+00013/0955 7 (256,448,3)
+00013/0962 7 (256,448,3)
+00013/0969 7 (256,448,3)
+00014/0012 7 (256,448,3)
+00014/0025 7 (256,448,3)
+00014/0473 7 (256,448,3)
+00014/0499 7 (256,448,3)
+00014/0524 7 (256,448,3)
+00014/0739 7 (256,448,3)
+00014/0753 7 (256,448,3)
+00014/0771 7 (256,448,3)
+00014/0832 7 (256,448,3)
+00014/0836 7 (256,448,3)
+00014/0838 7 (256,448,3)
+00014/0839 7 (256,448,3)
+00014/0843 7 (256,448,3)
+00014/0846 7 (256,448,3)
+00014/0849 7 (256,448,3)
+00014/0859 7 (256,448,3)
+00014/0880 7 (256,448,3)
+00014/0906 7 (256,448,3)
+00015/0030 7 (256,448,3)
+00015/0067 7 (256,448,3)
+00015/0084 7 (256,448,3)
+00015/0190 7 (256,448,3)
+00015/0575 7 (256,448,3)
+00015/0784 7 (256,448,3)
+00015/0855 7 (256,448,3)
+00015/0904 7 (256,448,3)
+00015/0914 7 (256,448,3)
+00015/0936 7 (256,448,3)
+00015/0939 7 (256,448,3)
+00015/0943 7 (256,448,3)
+00015/0957 7 (256,448,3)
+00016/0131 7 (256,448,3)
+00016/0173 7 (256,448,3)
+00016/0320 7 (256,448,3)
+00016/0328 7 (256,448,3)
+00016/0334 7 (256,448,3)
+00016/0338 7 (256,448,3)
+00016/0339 7 (256,448,3)
+00016/0345 7 (256,448,3)
+00016/0365 7 (256,448,3)
+00016/0584 7 (256,448,3)
+00016/0634 7 (256,448,3)
+00017/0342 7 (256,448,3)
+00017/0346 7 (256,448,3)
+00017/0350 7 (256,448,3)
+00017/0766 7 (256,448,3)
+00017/0786 7 (256,448,3)
+00017/0911 7 (256,448,3)
+00017/0914 7 (256,448,3)
+00018/0217 7 (256,448,3)
+00018/0258 7 (256,448,3)
+00018/0307 7 (256,448,3)
+00018/0480 7 (256,448,3)
+00018/0491 7 (256,448,3)
+00018/0994 7 (256,448,3)
+00018/0995 7 (256,448,3)
+00018/0997 7 (256,448,3)
+00018/1000 7 (256,448,3)
+00019/0007 7 (256,448,3)
+00019/0016 7 (256,448,3)
+00019/0026 7 (256,448,3)
+00019/0030 7 (256,448,3)
+00019/0086 7 (256,448,3)
+00019/0089 7 (256,448,3)
+00019/0111 7 (256,448,3)
+00019/0285 7 (256,448,3)
+00019/0415 7 (256,448,3)
+00019/0434 7 (256,448,3)
+00019/0437 7 (256,448,3)
+00019/0568 7 (256,448,3)
+00019/0570 7 (256,448,3)
+00019/0591 7 (256,448,3)
+00019/0596 7 (256,448,3)
+00019/0603 7 (256,448,3)
+00019/0607 7 (256,448,3)
+00019/0637 7 (256,448,3)
+00019/0644 7 (256,448,3)
+00019/0647 7 (256,448,3)
+00019/0787 7 (256,448,3)
+00019/0993 7 (256,448,3)
+00019/0998 7 (256,448,3)
+00021/0232 7 (256,448,3)
+00021/0255 7 (256,448,3)
+00021/0646 7 (256,448,3)
+00021/0653 7 (256,448,3)
+00021/0657 7 (256,448,3)
+00021/0668 7 (256,448,3)
+00021/0672 7 (256,448,3)
+00021/0725 7 (256,448,3)
+00021/0750 7 (256,448,3)
+00021/0764 7 (256,448,3)
+00021/0821 7 (256,448,3)
+00022/0192 7 (256,448,3)
+00022/0391 7 (256,448,3)
+00022/0514 7 (256,448,3)
+00022/0567 7 (256,448,3)
+00022/0674 7 (256,448,3)
+00022/0686 7 (256,448,3)
+00022/0700 7 (256,448,3)
+00023/0020 7 (256,448,3)
+00023/0024 7 (256,448,3)
+00023/0025 7 (256,448,3)
+00023/0042 7 (256,448,3)
+00023/0050 7 (256,448,3)
+00023/0094 7 (256,448,3)
+00023/0107 7 (256,448,3)
+00023/0635 7 (256,448,3)
+00023/0698 7 (256,448,3)
+00023/0774 7 (256,448,3)
+00023/0795 7 (256,448,3)
+00023/0821 7 (256,448,3)
+00023/0839 7 (256,448,3)
+00023/0846 7 (256,448,3)
+00023/0869 7 (256,448,3)
+00023/0879 7 (256,448,3)
+00023/0887 7 (256,448,3)
+00023/0899 7 (256,448,3)
+00023/0910 7 (256,448,3)
+00023/0920 7 (256,448,3)
+00023/0929 7 (256,448,3)
+00023/0941 7 (256,448,3)
+00023/0942 7 (256,448,3)
+00023/0952 7 (256,448,3)
+00024/0066 7 (256,448,3)
+00024/0072 7 (256,448,3)
+00024/0080 7 (256,448,3)
+00024/0093 7 (256,448,3)
+00024/0107 7 (256,448,3)
+00024/0262 7 (256,448,3)
+00024/0283 7 (256,448,3)
+00024/0294 7 (256,448,3)
+00024/0296 7 (256,448,3)
+00024/0304 7 (256,448,3)
+00024/0315 7 (256,448,3)
+00024/0322 7 (256,448,3)
+00024/0648 7 (256,448,3)
+00024/0738 7 (256,448,3)
+00024/0743 7 (256,448,3)
+00025/0542 7 (256,448,3)
+00025/0769 7 (256,448,3)
+00025/0984 7 (256,448,3)
+00025/0985 7 (256,448,3)
+00025/0989 7 (256,448,3)
+00025/0991 7 (256,448,3)
+00026/0009 7 (256,448,3)
+00026/0013 7 (256,448,3)
+00026/0020 7 (256,448,3)
+00026/0021 7 (256,448,3)
+00026/0025 7 (256,448,3)
+00026/0135 7 (256,448,3)
+00026/0200 7 (256,448,3)
+00026/0297 7 (256,448,3)
+00026/0306 7 (256,448,3)
+00026/0444 7 (256,448,3)
+00026/0450 7 (256,448,3)
+00026/0453 7 (256,448,3)
+00026/0464 7 (256,448,3)
+00026/0486 7 (256,448,3)
+00026/0773 7 (256,448,3)
+00026/0785 7 (256,448,3)
+00026/0836 7 (256,448,3)
+00026/0838 7 (256,448,3)
+00026/0848 7 (256,448,3)
+00026/0885 7 (256,448,3)
+00026/0893 7 (256,448,3)
+00026/0939 7 (256,448,3)
+00026/0942 7 (256,448,3)
+00027/0092 7 (256,448,3)
+00027/0112 7 (256,448,3)
+00027/0115 7 (256,448,3)
+00027/0143 7 (256,448,3)
+00027/0175 7 (256,448,3)
+00027/0179 7 (256,448,3)
+00027/0183 7 (256,448,3)
+00027/0197 7 (256,448,3)
+00027/0199 7 (256,448,3)
+00027/0300 7 (256,448,3)
+00028/0015 7 (256,448,3)
+00028/0032 7 (256,448,3)
+00028/0048 7 (256,448,3)
+00028/0068 7 (256,448,3)
+00028/0219 7 (256,448,3)
+00028/0606 7 (256,448,3)
+00028/0626 7 (256,448,3)
+00028/0748 7 (256,448,3)
+00028/0764 7 (256,448,3)
+00028/0772 7 (256,448,3)
+00028/0780 7 (256,448,3)
+00028/0926 7 (256,448,3)
+00028/0947 7 (256,448,3)
+00028/0962 7 (256,448,3)
+00029/0085 7 (256,448,3)
+00029/0281 7 (256,448,3)
+00029/0284 7 (256,448,3)
+00029/0288 7 (256,448,3)
+00029/0294 7 (256,448,3)
+00029/0364 7 (256,448,3)
+00029/0369 7 (256,448,3)
+00029/0421 7 (256,448,3)
+00029/0425 7 (256,448,3)
+00029/0550 7 (256,448,3)
+00030/0014 7 (256,448,3)
+00030/0101 7 (256,448,3)
+00030/0143 7 (256,448,3)
+00030/0351 7 (256,448,3)
+00030/0356 7 (256,448,3)
+00030/0371 7 (256,448,3)
+00030/0484 7 (256,448,3)
+00030/0492 7 (256,448,3)
+00030/0503 7 (256,448,3)
+00030/0682 7 (256,448,3)
+00030/0696 7 (256,448,3)
+00030/0735 7 (256,448,3)
+00030/0737 7 (256,448,3)
+00030/0868 7 (256,448,3)
+00031/0161 7 (256,448,3)
+00031/0180 7 (256,448,3)
+00031/0194 7 (256,448,3)
+00031/0253 7 (256,448,3)
+00031/0293 7 (256,448,3)
+00031/0466 7 (256,448,3)
+00031/0477 7 (256,448,3)
+00031/0549 7 (256,448,3)
+00031/0600 7 (256,448,3)
+00031/0617 7 (256,448,3)
+00031/0649 7 (256,448,3)
+00032/0015 7 (256,448,3)
+00032/0020 7 (256,448,3)
+00032/0023 7 (256,448,3)
+00032/0048 7 (256,448,3)
+00032/0056 7 (256,448,3)
+00032/0872 7 (256,448,3)
+00033/0069 7 (256,448,3)
+00033/0073 7 (256,448,3)
+00033/0078 7 (256,448,3)
+00033/0079 7 (256,448,3)
+00033/0086 7 (256,448,3)
+00033/0088 7 (256,448,3)
+00033/0091 7 (256,448,3)
+00033/0096 7 (256,448,3)
+00033/0607 7 (256,448,3)
+00033/0613 7 (256,448,3)
+00033/0616 7 (256,448,3)
+00033/0619 7 (256,448,3)
+00033/0626 7 (256,448,3)
+00033/0628 7 (256,448,3)
+00033/0637 7 (256,448,3)
+00033/0686 7 (256,448,3)
+00033/0842 7 (256,448,3)
+00034/0261 7 (256,448,3)
+00034/0265 7 (256,448,3)
+00034/0269 7 (256,448,3)
+00034/0275 7 (256,448,3)
+00034/0286 7 (256,448,3)
+00034/0294 7 (256,448,3)
+00034/0431 7 (256,448,3)
+00034/0577 7 (256,448,3)
+00034/0685 7 (256,448,3)
+00034/0687 7 (256,448,3)
+00034/0703 7 (256,448,3)
+00034/0715 7 (256,448,3)
+00034/0935 7 (256,448,3)
+00034/0943 7 (256,448,3)
+00034/0963 7 (256,448,3)
+00034/0979 7 (256,448,3)
+00034/0990 7 (256,448,3)
+00035/0129 7 (256,448,3)
+00035/0153 7 (256,448,3)
+00035/0156 7 (256,448,3)
+00035/0474 7 (256,448,3)
+00035/0507 7 (256,448,3)
+00035/0532 7 (256,448,3)
+00035/0560 7 (256,448,3)
+00035/0572 7 (256,448,3)
+00035/0587 7 (256,448,3)
+00035/0588 7 (256,448,3)
+00035/0640 7 (256,448,3)
+00035/0654 7 (256,448,3)
+00035/0655 7 (256,448,3)
+00035/0737 7 (256,448,3)
+00035/0843 7 (256,448,3)
+00035/0932 7 (256,448,3)
+00035/0957 7 (256,448,3)
+00036/0029 7 (256,448,3)
+00036/0266 7 (256,448,3)
+00036/0276 7 (256,448,3)
+00036/0310 7 (256,448,3)
+00036/0314 7 (256,448,3)
+00036/0320 7 (256,448,3)
+00036/0333 7 (256,448,3)
+00036/0348 7 (256,448,3)
+00036/0357 7 (256,448,3)
+00036/0360 7 (256,448,3)
+00036/0368 7 (256,448,3)
+00036/0371 7 (256,448,3)
+00036/0378 7 (256,448,3)
+00036/0391 7 (256,448,3)
+00036/0440 7 (256,448,3)
+00036/0731 7 (256,448,3)
+00036/0733 7 (256,448,3)
+00036/0741 7 (256,448,3)
+00036/0743 7 (256,448,3)
+00036/0927 7 (256,448,3)
+00036/0931 7 (256,448,3)
+00036/0933 7 (256,448,3)
+00036/0938 7 (256,448,3)
+00036/0944 7 (256,448,3)
+00036/0946 7 (256,448,3)
+00036/0951 7 (256,448,3)
+00036/0953 7 (256,448,3)
+00036/0963 7 (256,448,3)
+00036/0964 7 (256,448,3)
+00036/0981 7 (256,448,3)
+00036/0991 7 (256,448,3)
+00037/0072 7 (256,448,3)
+00037/0079 7 (256,448,3)
+00037/0132 7 (256,448,3)
+00037/0135 7 (256,448,3)
+00037/0137 7 (256,448,3)
+00037/0141 7 (256,448,3)
+00037/0229 7 (256,448,3)
+00037/0234 7 (256,448,3)
+00037/0239 7 (256,448,3)
+00037/0242 7 (256,448,3)
+00037/0254 7 (256,448,3)
+00037/0269 7 (256,448,3)
+00037/0276 7 (256,448,3)
+00037/0279 7 (256,448,3)
+00037/0286 7 (256,448,3)
+00037/0345 7 (256,448,3)
+00037/0449 7 (256,448,3)
+00037/0450 7 (256,448,3)
+00037/0820 7 (256,448,3)
+00037/0824 7 (256,448,3)
+00037/0859 7 (256,448,3)
+00037/0899 7 (256,448,3)
+00037/0906 7 (256,448,3)
+00038/0535 7 (256,448,3)
+00038/0572 7 (256,448,3)
+00038/0675 7 (256,448,3)
+00038/0731 7 (256,448,3)
+00038/0732 7 (256,448,3)
+00038/0744 7 (256,448,3)
+00038/0755 7 (256,448,3)
+00039/0002 7 (256,448,3)
+00039/0013 7 (256,448,3)
+00039/0247 7 (256,448,3)
+00039/0489 7 (256,448,3)
+00039/0504 7 (256,448,3)
+00039/0558 7 (256,448,3)
+00039/0686 7 (256,448,3)
+00039/0727 7 (256,448,3)
+00039/0769 7 (256,448,3)
+00040/0081 7 (256,448,3)
+00040/0082 7 (256,448,3)
+00040/0402 7 (256,448,3)
+00040/0407 7 (256,448,3)
+00040/0408 7 (256,448,3)
+00040/0410 7 (256,448,3)
+00040/0411 7 (256,448,3)
+00040/0412 7 (256,448,3)
+00040/0413 7 (256,448,3)
+00040/0415 7 (256,448,3)
+00040/0421 7 (256,448,3)
+00040/0422 7 (256,448,3)
+00040/0426 7 (256,448,3)
+00040/0438 7 (256,448,3)
+00040/0439 7 (256,448,3)
+00040/0440 7 (256,448,3)
+00040/0443 7 (256,448,3)
+00040/0457 7 (256,448,3)
+00040/0459 7 (256,448,3)
+00040/0725 7 (256,448,3)
+00040/0727 7 (256,448,3)
+00040/0936 7 (256,448,3)
+00040/0959 7 (256,448,3)
+00040/0964 7 (256,448,3)
+00040/0968 7 (256,448,3)
+00040/0974 7 (256,448,3)
+00040/0978 7 (256,448,3)
+00040/0979 7 (256,448,3)
+00040/0989 7 (256,448,3)
+00040/0993 7 (256,448,3)
+00040/0994 7 (256,448,3)
+00040/0997 7 (256,448,3)
+00041/0001 7 (256,448,3)
+00041/0007 7 (256,448,3)
+00041/0019 7 (256,448,3)
+00041/0040 7 (256,448,3)
+00041/0350 7 (256,448,3)
+00041/0357 7 (256,448,3)
+00041/0393 7 (256,448,3)
+00041/0890 7 (256,448,3)
+00041/0909 7 (256,448,3)
+00041/0915 7 (256,448,3)
+00041/0933 7 (256,448,3)
+00042/0017 7 (256,448,3)
+00042/0332 7 (256,448,3)
+00042/0346 7 (256,448,3)
+00042/0350 7 (256,448,3)
+00042/0356 7 (256,448,3)
+00042/0382 7 (256,448,3)
+00042/0389 7 (256,448,3)
+00042/0539 7 (256,448,3)
+00042/0546 7 (256,448,3)
+00042/0550 7 (256,448,3)
+00042/0553 7 (256,448,3)
+00042/0555 7 (256,448,3)
+00042/0560 7 (256,448,3)
+00042/0570 7 (256,448,3)
+00043/0119 7 (256,448,3)
+00043/0122 7 (256,448,3)
+00043/0168 7 (256,448,3)
+00043/0274 7 (256,448,3)
+00043/0304 7 (256,448,3)
+00043/0731 7 (256,448,3)
+00043/0735 7 (256,448,3)
+00043/0739 7 (256,448,3)
+00043/0740 7 (256,448,3)
+00044/0212 7 (256,448,3)
+00044/0432 7 (256,448,3)
+00044/0934 7 (256,448,3)
+00044/0940 7 (256,448,3)
+00044/0987 7 (256,448,3)
+00045/0004 7 (256,448,3)
+00045/0009 7 (256,448,3)
+00045/0011 7 (256,448,3)
+00045/0019 7 (256,448,3)
+00045/0023 7 (256,448,3)
+00045/0289 7 (256,448,3)
+00045/0760 7 (256,448,3)
+00045/0779 7 (256,448,3)
+00045/0816 7 (256,448,3)
+00045/0820 7 (256,448,3)
+00046/0132 7 (256,448,3)
+00046/0350 7 (256,448,3)
+00046/0356 7 (256,448,3)
+00046/0357 7 (256,448,3)
+00046/0379 7 (256,448,3)
+00046/0410 7 (256,448,3)
+00046/0412 7 (256,448,3)
+00046/0481 7 (256,448,3)
+00046/0497 7 (256,448,3)
+00046/0510 7 (256,448,3)
+00046/0515 7 (256,448,3)
+00046/0529 7 (256,448,3)
+00046/0544 7 (256,448,3)
+00046/0545 7 (256,448,3)
+00046/0552 7 (256,448,3)
+00046/0559 7 (256,448,3)
+00046/0589 7 (256,448,3)
+00046/0642 7 (256,448,3)
+00046/0724 7 (256,448,3)
+00046/0758 7 (256,448,3)
+00046/0930 7 (256,448,3)
+00046/0953 7 (256,448,3)
+00047/0013 7 (256,448,3)
+00047/0014 7 (256,448,3)
+00047/0017 7 (256,448,3)
+00047/0076 7 (256,448,3)
+00047/0151 7 (256,448,3)
+00047/0797 7 (256,448,3)
+00048/0014 7 (256,448,3)
+00048/0021 7 (256,448,3)
+00048/0026 7 (256,448,3)
+00048/0030 7 (256,448,3)
+00048/0039 7 (256,448,3)
+00048/0045 7 (256,448,3)
+00048/0049 7 (256,448,3)
+00048/0145 7 (256,448,3)
+00048/0188 7 (256,448,3)
+00048/0302 7 (256,448,3)
+00048/0361 7 (256,448,3)
+00048/0664 7 (256,448,3)
+00048/0672 7 (256,448,3)
+00048/0681 7 (256,448,3)
+00048/0689 7 (256,448,3)
+00048/0690 7 (256,448,3)
+00048/0691 7 (256,448,3)
+00048/0711 7 (256,448,3)
+00049/0085 7 (256,448,3)
+00049/0810 7 (256,448,3)
+00049/0858 7 (256,448,3)
+00049/0865 7 (256,448,3)
+00049/0871 7 (256,448,3)
+00049/0903 7 (256,448,3)
+00049/0928 7 (256,448,3)
+00050/0092 7 (256,448,3)
+00050/0101 7 (256,448,3)
+00050/0108 7 (256,448,3)
+00050/0112 7 (256,448,3)
+00050/0120 7 (256,448,3)
+00050/0128 7 (256,448,3)
+00050/0383 7 (256,448,3)
+00050/0395 7 (256,448,3)
+00050/0405 7 (256,448,3)
+00050/0632 7 (256,448,3)
+00050/0648 7 (256,448,3)
+00050/0649 7 (256,448,3)
+00050/0659 7 (256,448,3)
+00050/0699 7 (256,448,3)
+00050/0708 7 (256,448,3)
+00050/0716 7 (256,448,3)
+00050/0758 7 (256,448,3)
+00050/0761 7 (256,448,3)
+00051/0572 7 (256,448,3)
+00052/0163 7 (256,448,3)
+00052/0242 7 (256,448,3)
+00052/0260 7 (256,448,3)
+00052/0322 7 (256,448,3)
+00052/0333 7 (256,448,3)
+00052/0806 7 (256,448,3)
+00052/0813 7 (256,448,3)
+00052/0821 7 (256,448,3)
+00052/0830 7 (256,448,3)
+00052/0914 7 (256,448,3)
+00052/0923 7 (256,448,3)
+00052/0959 7 (256,448,3)
+00053/0288 7 (256,448,3)
+00053/0290 7 (256,448,3)
+00053/0323 7 (256,448,3)
+00053/0337 7 (256,448,3)
+00053/0340 7 (256,448,3)
+00053/0437 7 (256,448,3)
+00053/0595 7 (256,448,3)
+00053/0739 7 (256,448,3)
+00053/0761 7 (256,448,3)
+00054/0014 7 (256,448,3)
+00054/0017 7 (256,448,3)
+00054/0178 7 (256,448,3)
+00054/0183 7 (256,448,3)
+00054/0196 7 (256,448,3)
+00054/0205 7 (256,448,3)
+00054/0214 7 (256,448,3)
+00054/0289 7 (256,448,3)
+00054/0453 7 (256,448,3)
+00054/0498 7 (256,448,3)
+00054/0502 7 (256,448,3)
+00054/0514 7 (256,448,3)
+00054/0773 7 (256,448,3)
+00055/0001 7 (256,448,3)
+00055/0115 7 (256,448,3)
+00055/0118 7 (256,448,3)
+00055/0171 7 (256,448,3)
+00055/0214 7 (256,448,3)
+00055/0354 7 (256,448,3)
+00055/0449 7 (256,448,3)
+00055/0473 7 (256,448,3)
+00055/0649 7 (256,448,3)
+00055/0800 7 (256,448,3)
+00055/0803 7 (256,448,3)
+00055/0990 7 (256,448,3)
+00056/0041 7 (256,448,3)
+00056/0120 7 (256,448,3)
+00056/0293 7 (256,448,3)
+00056/0357 7 (256,448,3)
+00056/0506 7 (256,448,3)
+00056/0561 7 (256,448,3)
+00056/0567 7 (256,448,3)
+00056/0575 7 (256,448,3)
+00057/0175 7 (256,448,3)
+00057/0495 7 (256,448,3)
+00057/0498 7 (256,448,3)
+00057/0506 7 (256,448,3)
+00057/0612 7 (256,448,3)
+00057/0620 7 (256,448,3)
+00057/0623 7 (256,448,3)
+00057/0635 7 (256,448,3)
+00057/0773 7 (256,448,3)
+00057/0778 7 (256,448,3)
+00057/0867 7 (256,448,3)
+00057/0976 7 (256,448,3)
+00057/0980 7 (256,448,3)
+00057/0985 7 (256,448,3)
+00057/0992 7 (256,448,3)
+00058/0009 7 (256,448,3)
+00058/0076 7 (256,448,3)
+00058/0078 7 (256,448,3)
+00058/0279 7 (256,448,3)
+00058/0283 7 (256,448,3)
+00058/0286 7 (256,448,3)
+00058/0350 7 (256,448,3)
+00058/0380 7 (256,448,3)
+00061/0132 7 (256,448,3)
+00061/0141 7 (256,448,3)
+00061/0156 7 (256,448,3)
+00061/0159 7 (256,448,3)
+00061/0168 7 (256,448,3)
+00061/0170 7 (256,448,3)
+00061/0186 7 (256,448,3)
+00061/0219 7 (256,448,3)
+00061/0227 7 (256,448,3)
+00061/0238 7 (256,448,3)
+00061/0256 7 (256,448,3)
+00061/0303 7 (256,448,3)
+00061/0312 7 (256,448,3)
+00061/0313 7 (256,448,3)
+00061/0325 7 (256,448,3)
+00061/0367 7 (256,448,3)
+00061/0369 7 (256,448,3)
+00061/0387 7 (256,448,3)
+00061/0396 7 (256,448,3)
+00061/0486 7 (256,448,3)
+00061/0895 7 (256,448,3)
+00061/0897 7 (256,448,3)
+00062/0846 7 (256,448,3)
+00063/0156 7 (256,448,3)
+00063/0184 7 (256,448,3)
+00063/0191 7 (256,448,3)
+00063/0334 7 (256,448,3)
+00063/0350 7 (256,448,3)
+00063/0499 7 (256,448,3)
+00063/0878 7 (256,448,3)
+00064/0004 7 (256,448,3)
+00064/0264 7 (256,448,3)
+00064/0735 7 (256,448,3)
+00064/0738 7 (256,448,3)
+00065/0105 7 (256,448,3)
+00065/0169 7 (256,448,3)
+00065/0305 7 (256,448,3)
+00065/0324 7 (256,448,3)
+00065/0353 7 (256,448,3)
+00065/0520 7 (256,448,3)
+00065/0533 7 (256,448,3)
+00065/0545 7 (256,448,3)
+00065/0551 7 (256,448,3)
+00065/0568 7 (256,448,3)
+00065/0603 7 (256,448,3)
+00065/0884 7 (256,448,3)
+00065/0988 7 (256,448,3)
+00066/0002 7 (256,448,3)
+00066/0011 7 (256,448,3)
+00066/0031 7 (256,448,3)
+00066/0037 7 (256,448,3)
+00066/0136 7 (256,448,3)
+00066/0137 7 (256,448,3)
+00066/0150 7 (256,448,3)
+00066/0166 7 (256,448,3)
+00066/0178 7 (256,448,3)
+00066/0357 7 (256,448,3)
+00066/0428 7 (256,448,3)
+00066/0483 7 (256,448,3)
+00066/0600 7 (256,448,3)
+00066/0863 7 (256,448,3)
+00066/0873 7 (256,448,3)
+00066/0875 7 (256,448,3)
+00066/0899 7 (256,448,3)
+00067/0020 7 (256,448,3)
+00067/0025 7 (256,448,3)
+00067/0132 7 (256,448,3)
+00067/0492 7 (256,448,3)
+00067/0726 7 (256,448,3)
+00067/0734 7 (256,448,3)
+00067/0744 7 (256,448,3)
+00067/0754 7 (256,448,3)
+00067/0779 7 (256,448,3)
+00068/0078 7 (256,448,3)
+00068/0083 7 (256,448,3)
+00068/0113 7 (256,448,3)
+00068/0117 7 (256,448,3)
+00068/0121 7 (256,448,3)
+00068/0206 7 (256,448,3)
+00068/0261 7 (256,448,3)
+00068/0321 7 (256,448,3)
+00068/0354 7 (256,448,3)
+00068/0380 7 (256,448,3)
+00068/0419 7 (256,448,3)
+00068/0547 7 (256,448,3)
+00068/0561 7 (256,448,3)
+00068/0565 7 (256,448,3)
+00068/0583 7 (256,448,3)
+00068/0599 7 (256,448,3)
+00068/0739 7 (256,448,3)
+00068/0743 7 (256,448,3)
+00068/0754 7 (256,448,3)
+00068/0812 7 (256,448,3)
+00069/0178 7 (256,448,3)
+00070/0025 7 (256,448,3)
+00070/0030 7 (256,448,3)
+00070/0036 7 (256,448,3)
+00070/0042 7 (256,448,3)
+00070/0078 7 (256,448,3)
+00070/0079 7 (256,448,3)
+00070/0362 7 (256,448,3)
+00071/0195 7 (256,448,3)
+00071/0210 7 (256,448,3)
+00071/0211 7 (256,448,3)
+00071/0221 7 (256,448,3)
+00071/0352 7 (256,448,3)
+00071/0354 7 (256,448,3)
+00071/0366 7 (256,448,3)
+00071/0454 7 (256,448,3)
+00071/0464 7 (256,448,3)
+00071/0487 7 (256,448,3)
+00071/0502 7 (256,448,3)
+00071/0561 7 (256,448,3)
+00071/0676 7 (256,448,3)
+00071/0808 7 (256,448,3)
+00071/0813 7 (256,448,3)
+00071/0836 7 (256,448,3)
+00072/0286 7 (256,448,3)
+00072/0290 7 (256,448,3)
+00072/0298 7 (256,448,3)
+00072/0302 7 (256,448,3)
+00072/0333 7 (256,448,3)
+00072/0590 7 (256,448,3)
+00072/0793 7 (256,448,3)
+00072/0803 7 (256,448,3)
+00072/0833 7 (256,448,3)
+00073/0049 7 (256,448,3)
+00073/0050 7 (256,448,3)
+00073/0388 7 (256,448,3)
+00073/0480 7 (256,448,3)
+00073/0485 7 (256,448,3)
+00073/0611 7 (256,448,3)
+00073/0616 7 (256,448,3)
+00073/0714 7 (256,448,3)
+00073/0724 7 (256,448,3)
+00073/0730 7 (256,448,3)
+00074/0034 7 (256,448,3)
+00074/0228 7 (256,448,3)
+00074/0239 7 (256,448,3)
+00074/0275 7 (256,448,3)
+00074/0527 7 (256,448,3)
+00074/0620 7 (256,448,3)
+00074/0764 7 (256,448,3)
+00074/0849 7 (256,448,3)
+00074/0893 7 (256,448,3)
+00075/0333 7 (256,448,3)
+00075/0339 7 (256,448,3)
+00075/0347 7 (256,448,3)
+00075/0399 7 (256,448,3)
+00075/0478 7 (256,448,3)
+00075/0494 7 (256,448,3)
+00075/0678 7 (256,448,3)
+00075/0688 7 (256,448,3)
+00075/0706 7 (256,448,3)
+00075/0709 7 (256,448,3)
+00075/0748 7 (256,448,3)
+00075/0769 7 (256,448,3)
+00075/0777 7 (256,448,3)
+00075/0781 7 (256,448,3)
+00076/0151 7 (256,448,3)
+00076/0159 7 (256,448,3)
+00076/0164 7 (256,448,3)
+00076/0265 7 (256,448,3)
+00076/0269 7 (256,448,3)
+00076/0433 7 (256,448,3)
+00076/0813 7 (256,448,3)
+00076/0817 7 (256,448,3)
+00076/0818 7 (256,448,3)
+00076/0827 7 (256,448,3)
+00076/0874 7 (256,448,3)
+00076/0880 7 (256,448,3)
+00076/0891 7 (256,448,3)
+00076/0894 7 (256,448,3)
+00076/0909 7 (256,448,3)
+00076/0913 7 (256,448,3)
+00076/0926 7 (256,448,3)
+00076/0962 7 (256,448,3)
+00076/0973 7 (256,448,3)
+00076/0986 7 (256,448,3)
+00077/0617 7 (256,448,3)
+00077/0623 7 (256,448,3)
+00077/0628 7 (256,448,3)
+00077/0629 7 (256,448,3)
+00077/0631 7 (256,448,3)
+00077/0639 7 (256,448,3)
+00077/0982 7 (256,448,3)
+00077/0984 7 (256,448,3)
+00077/0995 7 (256,448,3)
+00077/0998 7 (256,448,3)
+00078/0001 7 (256,448,3)
+00078/0015 7 (256,448,3)
+00078/0157 7 (256,448,3)
+00078/0161 7 (256,448,3)
+00078/0175 7 (256,448,3)
+00078/0178 7 (256,448,3)
+00078/0189 7 (256,448,3)
+00078/0192 7 (256,448,3)
+00078/0229 7 (256,448,3)
+00078/0237 7 (256,448,3)
+00078/0241 7 (256,448,3)
+00078/0249 7 (256,448,3)
+00078/0251 7 (256,448,3)
+00078/0254 7 (256,448,3)
+00078/0258 7 (256,448,3)
+00078/0311 7 (256,448,3)
+00078/0603 7 (256,448,3)
+00078/0607 7 (256,448,3)
+00078/0824 7 (256,448,3)
+00079/0045 7 (256,448,3)
+00079/0048 7 (256,448,3)
+00079/0054 7 (256,448,3)
+00080/0050 7 (256,448,3)
+00080/0488 7 (256,448,3)
+00080/0494 7 (256,448,3)
+00080/0496 7 (256,448,3)
+00080/0499 7 (256,448,3)
+00080/0502 7 (256,448,3)
+00080/0510 7 (256,448,3)
+00080/0534 7 (256,448,3)
+00080/0558 7 (256,448,3)
+00080/0571 7 (256,448,3)
+00080/0709 7 (256,448,3)
+00080/0882 7 (256,448,3)
+00081/0322 7 (256,448,3)
+00081/0428 7 (256,448,3)
+00081/0700 7 (256,448,3)
+00081/0706 7 (256,448,3)
+00081/0707 7 (256,448,3)
+00081/0937 7 (256,448,3)
+00082/0021 7 (256,448,3)
+00082/0424 7 (256,448,3)
+00082/0794 7 (256,448,3)
+00082/0807 7 (256,448,3)
+00082/0810 7 (256,448,3)
+00082/0824 7 (256,448,3)
+00083/0129 7 (256,448,3)
+00083/0131 7 (256,448,3)
+00083/0249 7 (256,448,3)
+00083/0250 7 (256,448,3)
+00083/0656 7 (256,448,3)
+00083/0812 7 (256,448,3)
+00083/0819 7 (256,448,3)
+00083/0824 7 (256,448,3)
+00083/0827 7 (256,448,3)
+00083/0841 7 (256,448,3)
+00083/0963 7 (256,448,3)
+00084/0047 7 (256,448,3)
+00084/0319 7 (256,448,3)
+00084/0334 7 (256,448,3)
+00084/0363 7 (256,448,3)
+00084/0493 7 (256,448,3)
+00084/0655 7 (256,448,3)
+00084/0752 7 (256,448,3)
+00084/0813 7 (256,448,3)
+00084/0886 7 (256,448,3)
+00084/0948 7 (256,448,3)
+00084/0976 7 (256,448,3)
+00085/0512 7 (256,448,3)
+00085/0641 7 (256,448,3)
+00085/0653 7 (256,448,3)
+00085/0655 7 (256,448,3)
+00085/0697 7 (256,448,3)
+00085/0698 7 (256,448,3)
+00085/0700 7 (256,448,3)
+00085/0703 7 (256,448,3)
+00085/0705 7 (256,448,3)
+00085/0709 7 (256,448,3)
+00085/0713 7 (256,448,3)
+00085/0739 7 (256,448,3)
+00085/0750 7 (256,448,3)
+00085/0763 7 (256,448,3)
+00085/0765 7 (256,448,3)
+00085/0769 7 (256,448,3)
+00085/0863 7 (256,448,3)
+00085/0868 7 (256,448,3)
+00085/0927 7 (256,448,3)
+00085/0936 7 (256,448,3)
+00085/0965 7 (256,448,3)
+00085/0969 7 (256,448,3)
+00085/0974 7 (256,448,3)
+00085/0981 7 (256,448,3)
+00085/0982 7 (256,448,3)
+00085/1000 7 (256,448,3)
+00086/0003 7 (256,448,3)
+00086/0009 7 (256,448,3)
+00086/0011 7 (256,448,3)
+00086/0028 7 (256,448,3)
+00086/0032 7 (256,448,3)
+00086/0034 7 (256,448,3)
+00086/0035 7 (256,448,3)
+00086/0042 7 (256,448,3)
+00086/0064 7 (256,448,3)
+00086/0066 7 (256,448,3)
+00086/0095 7 (256,448,3)
+00086/0099 7 (256,448,3)
+00086/0101 7 (256,448,3)
+00086/0104 7 (256,448,3)
+00086/0115 7 (256,448,3)
+00086/0116 7 (256,448,3)
+00086/0284 7 (256,448,3)
+00086/0291 7 (256,448,3)
+00086/0295 7 (256,448,3)
+00086/0302 7 (256,448,3)
+00086/0318 7 (256,448,3)
+00086/0666 7 (256,448,3)
+00086/0797 7 (256,448,3)
+00086/0851 7 (256,448,3)
+00086/0855 7 (256,448,3)
+00086/0874 7 (256,448,3)
+00086/0878 7 (256,448,3)
+00086/0881 7 (256,448,3)
+00086/0883 7 (256,448,3)
+00086/0896 7 (256,448,3)
+00086/0899 7 (256,448,3)
+00086/0903 7 (256,448,3)
+00086/0989 7 (256,448,3)
+00087/0008 7 (256,448,3)
+00087/0429 7 (256,448,3)
+00087/0511 7 (256,448,3)
+00088/0241 7 (256,448,3)
+00088/0319 7 (256,448,3)
+00088/0323 7 (256,448,3)
+00088/0411 7 (256,448,3)
+00088/0427 7 (256,448,3)
+00088/0452 7 (256,448,3)
+00088/0463 7 (256,448,3)
+00088/0476 7 (256,448,3)
+00088/0496 7 (256,448,3)
+00088/0559 7 (256,448,3)
+00089/0058 7 (256,448,3)
+00089/0061 7 (256,448,3)
+00089/0069 7 (256,448,3)
+00089/0077 7 (256,448,3)
+00089/0096 7 (256,448,3)
+00089/0099 7 (256,448,3)
+00089/0100 7 (256,448,3)
+00089/0211 7 (256,448,3)
+00089/0380 7 (256,448,3)
+00089/0381 7 (256,448,3)
+00089/0384 7 (256,448,3)
+00089/0390 7 (256,448,3)
+00089/0393 7 (256,448,3)
+00089/0394 7 (256,448,3)
+00089/0395 7 (256,448,3)
+00089/0406 7 (256,448,3)
+00089/0410 7 (256,448,3)
+00089/0412 7 (256,448,3)
+00089/0703 7 (256,448,3)
+00089/0729 7 (256,448,3)
+00089/0930 7 (256,448,3)
+00089/0952 7 (256,448,3)
+00090/0062 7 (256,448,3)
+00090/0101 7 (256,448,3)
+00090/0213 7 (256,448,3)
+00090/0216 7 (256,448,3)
+00090/0268 7 (256,448,3)
+00090/0406 7 (256,448,3)
+00090/0411 7 (256,448,3)
+00090/0442 7 (256,448,3)
+00090/0535 7 (256,448,3)
+00090/0542 7 (256,448,3)
+00090/0571 7 (256,448,3)
+00090/0934 7 (256,448,3)
+00090/0938 7 (256,448,3)
+00090/0947 7 (256,448,3)
+00091/0066 7 (256,448,3)
+00091/0448 7 (256,448,3)
+00091/0451 7 (256,448,3)
+00091/0454 7 (256,448,3)
+00091/0457 7 (256,448,3)
+00091/0467 7 (256,448,3)
+00091/0470 7 (256,448,3)
+00091/0477 7 (256,448,3)
+00091/0583 7 (256,448,3)
+00091/0981 7 (256,448,3)
+00091/0994 7 (256,448,3)
+00092/0112 7 (256,448,3)
+00092/0119 7 (256,448,3)
+00092/0129 7 (256,448,3)
+00092/0146 7 (256,448,3)
+00092/0149 7 (256,448,3)
+00092/0608 7 (256,448,3)
+00092/0643 7 (256,448,3)
+00092/0646 7 (256,448,3)
+00092/0766 7 (256,448,3)
+00092/0768 7 (256,448,3)
+00092/0779 7 (256,448,3)
+00093/0081 7 (256,448,3)
+00093/0085 7 (256,448,3)
+00093/0135 7 (256,448,3)
+00093/0241 7 (256,448,3)
+00093/0277 7 (256,448,3)
+00093/0283 7 (256,448,3)
+00093/0320 7 (256,448,3)
+00093/0598 7 (256,448,3)
+00094/0159 7 (256,448,3)
+00094/0253 7 (256,448,3)
+00094/0265 7 (256,448,3)
+00094/0267 7 (256,448,3)
+00094/0269 7 (256,448,3)
+00094/0281 7 (256,448,3)
+00094/0293 7 (256,448,3)
+00094/0404 7 (256,448,3)
+00094/0593 7 (256,448,3)
+00094/0612 7 (256,448,3)
+00094/0638 7 (256,448,3)
+00094/0656 7 (256,448,3)
+00094/0668 7 (256,448,3)
+00094/0786 7 (256,448,3)
+00094/0870 7 (256,448,3)
+00094/0897 7 (256,448,3)
+00094/0900 7 (256,448,3)
+00094/0944 7 (256,448,3)
+00094/0946 7 (256,448,3)
+00094/0952 7 (256,448,3)
+00094/0969 7 (256,448,3)
+00094/0973 7 (256,448,3)
+00094/0981 7 (256,448,3)
+00095/0088 7 (256,448,3)
+00095/0125 7 (256,448,3)
+00095/0130 7 (256,448,3)
+00095/0142 7 (256,448,3)
+00095/0151 7 (256,448,3)
+00095/0180 7 (256,448,3)
+00095/0192 7 (256,448,3)
+00095/0194 7 (256,448,3)
+00095/0195 7 (256,448,3)
+00095/0204 7 (256,448,3)
+00095/0245 7 (256,448,3)
+00095/0315 7 (256,448,3)
+00095/0321 7 (256,448,3)
+00095/0324 7 (256,448,3)
+00095/0327 7 (256,448,3)
+00095/0730 7 (256,448,3)
+00095/0731 7 (256,448,3)
+00095/0741 7 (256,448,3)
+00095/0948 7 (256,448,3)
+00096/0407 7 (256,448,3)
+00096/0420 7 (256,448,3)
+00096/0435 7 (256,448,3)
+00096/0682 7 (256,448,3)
+00096/0865 7 (256,448,3)

basicsr/data/meta_info/meta_info_Vimeo90K_test_slow_GT.txt

@@ -0,0 +1,1613 @@
+00001/0266 7 (256,448,3)
+00001/0268 7 (256,448,3)
+00001/0275 7 (256,448,3)
+00001/0278 7 (256,448,3)
+00001/0287 7 (256,448,3)
+00001/0291 7 (256,448,3)
+00001/0627 7 (256,448,3)
+00001/0636 7 (256,448,3)
+00001/0804 7 (256,448,3)
+00001/0837 7 (256,448,3)
+00001/0849 7 (256,448,3)
+00001/0851 7 (256,448,3)
+00001/0852 7 (256,448,3)
+00001/0986 7 (256,448,3)
+00001/0991 7 (256,448,3)
+00002/0007 7 (256,448,3)
+00002/0008 7 (256,448,3)
+00002/0016 7 (256,448,3)
+00002/0036 7 (256,448,3)
+00002/0091 7 (256,448,3)
+00002/0093 7 (256,448,3)
+00002/0209 7 (256,448,3)
+00002/0235 7 (256,448,3)
+00002/0236 7 (256,448,3)
+00002/0241 7 (256,448,3)
+00002/0466 7 (256,448,3)
+00002/0504 7 (256,448,3)
+00002/0960 7 (256,448,3)
+00002/0961 7 (256,448,3)
+00002/0964 7 (256,448,3)
+00003/0007 7 (256,448,3)
+00003/0069 7 (256,448,3)
+00003/0345 7 (256,448,3)
+00003/0347 7 (256,448,3)
+00003/0372 7 (256,448,3)
+00003/0525 7 (256,448,3)
+00003/0652 7 (256,448,3)
+00003/0667 7 (256,448,3)
+00003/0669 7 (256,448,3)
+00003/0706 7 (256,448,3)
+00003/0713 7 (256,448,3)
+00003/0721 7 (256,448,3)
+00003/0747 7 (256,448,3)
+00003/0829 7 (256,448,3)
+00003/0916 7 (256,448,3)
+00003/0918 7 (256,448,3)
+00003/0924 7 (256,448,3)
+00003/0926 7 (256,448,3)
+00003/0927 7 (256,448,3)
+00004/0288 7 (256,448,3)
+00004/0303 7 (256,448,3)
+00004/0307 7 (256,448,3)
+00004/0628 7 (256,448,3)
+00004/0713 7 (256,448,3)
+00004/0715 7 (256,448,3)
+00004/0719 7 (256,448,3)
+00004/0727 7 (256,448,3)
+00004/0821 7 (256,448,3)
+00005/0006 7 (256,448,3)
+00005/0007 7 (256,448,3)
+00005/0012 7 (256,448,3)
+00005/0013 7 (256,448,3)
+00005/0040 7 (256,448,3)
+00005/0055 7 (256,448,3)
+00005/0119 7 (256,448,3)
+00005/0130 7 (256,448,3)
+00005/0185 7 (256,448,3)
+00005/0198 7 (256,448,3)
+00005/0270 7 (256,448,3)
+00005/0541 7 (256,448,3)
+00005/0560 7 (256,448,3)
+00005/0660 7 (256,448,3)
+00005/0682 7 (256,448,3)
+00005/0683 7 (256,448,3)
+00005/0688 7 (256,448,3)
+00005/0706 7 (256,448,3)
+00005/0728 7 (256,448,3)
+00005/0732 7 (256,448,3)
+00005/0739 7 (256,448,3)
+00005/0804 7 (256,448,3)
+00005/0805 7 (256,448,3)
+00005/0827 7 (256,448,3)
+00005/0828 7 (256,448,3)
+00005/0857 7 (256,448,3)
+00005/0861 7 (256,448,3)
+00005/0862 7 (256,448,3)
+00005/0868 7 (256,448,3)
+00005/0872 7 (256,448,3)
+00005/0933 7 (256,448,3)
+00005/0958 7 (256,448,3)
+00005/0960 7 (256,448,3)
+00006/0087 7 (256,448,3)
+00006/0090 7 (256,448,3)
+00006/0351 7 (256,448,3)
+00006/0353 7 (256,448,3)
+00006/0558 7 (256,448,3)
+00006/0588 7 (256,448,3)
+00006/0619 7 (256,448,3)
+00006/0621 7 (256,448,3)
+00006/0748 7 (256,448,3)
+00006/0796 7 (256,448,3)
+00006/0805 7 (256,448,3)
+00006/0807 7 (256,448,3)
+00007/0236 7 (256,448,3)
+00007/0240 7 (256,448,3)
+00007/0243 7 (256,448,3)
+00007/0246 7 (256,448,3)
+00007/0247 7 (256,448,3)
+00007/0252 7 (256,448,3)
+00007/0322 7 (256,448,3)
+00007/0458 7 (256,448,3)
+00007/0492 7 (256,448,3)
+00007/0658 7 (256,448,3)
+00007/0717 7 (256,448,3)
+00007/0722 7 (256,448,3)
+00007/0725 7 (256,448,3)
+00007/0740 7 (256,448,3)
+00007/0748 7 (256,448,3)
+00007/0749 7 (256,448,3)
+00007/0759 7 (256,448,3)
+00007/0772 7 (256,448,3)
+00007/0783 7 (256,448,3)
+00007/0787 7 (256,448,3)
+00007/0883 7 (256,448,3)
+00008/0033 7 (256,448,3)
+00008/0035 7 (256,448,3)
+00008/0091 7 (256,448,3)
+00008/0154 7 (256,448,3)
+00008/0966 7 (256,448,3)
+00008/0987 7 (256,448,3)
+00009/0108 7 (256,448,3)
+00009/0607 7 (256,448,3)
+00009/0668 7 (256,448,3)
+00009/0683 7 (256,448,3)
+00009/0941 7 (256,448,3)
+00009/0949 7 (256,448,3)
+00009/0962 7 (256,448,3)
+00009/0972 7 (256,448,3)
+00009/0974 7 (256,448,3)
+00010/0014 7 (256,448,3)
+00010/0018 7 (256,448,3)
+00010/0043 7 (256,448,3)
+00010/0099 7 (256,448,3)
+00010/0252 7 (256,448,3)
+00010/0296 7 (256,448,3)
+00010/0413 7 (256,448,3)
+00010/0422 7 (256,448,3)
+00010/0516 7 (256,448,3)
+00010/0525 7 (256,448,3)
+00010/0556 7 (256,448,3)
+00010/0701 7 (256,448,3)
+00010/0740 7 (256,448,3)
+00010/0772 7 (256,448,3)
+00010/0831 7 (256,448,3)
+00010/0925 7 (256,448,3)
+00011/0013 7 (256,448,3)
+00011/0016 7 (256,448,3)
+00011/0017 7 (256,448,3)
+00011/0249 7 (256,448,3)
+00011/0826 7 (256,448,3)
+00011/0827 7 (256,448,3)
+00011/0831 7 (256,448,3)
+00011/0833 7 (256,448,3)
+00011/0835 7 (256,448,3)
+00011/0998 7 (256,448,3)
+00012/0023 7 (256,448,3)
+00012/0024 7 (256,448,3)
+00012/0027 7 (256,448,3)
+00012/0037 7 (256,448,3)
+00012/0444 7 (256,448,3)
+00012/0445 7 (256,448,3)
+00012/0451 7 (256,448,3)
+00012/0461 7 (256,448,3)
+00012/0521 7 (256,448,3)
+00012/0758 7 (256,448,3)
+00012/0760 7 (256,448,3)
+00012/0771 7 (256,448,3)
+00012/0903 7 (256,448,3)
+00012/0909 7 (256,448,3)
+00013/0581 7 (256,448,3)
+00013/0786 7 (256,448,3)
+00013/0789 7 (256,448,3)
+00013/0791 7 (256,448,3)
+00013/0798 7 (256,448,3)
+00013/0802 7 (256,448,3)
+00013/0820 7 (256,448,3)
+00013/0850 7 (256,448,3)
+00013/0854 7 (256,448,3)
+00013/0894 7 (256,448,3)
+00013/0919 7 (256,448,3)
+00013/0999 7 (256,448,3)
+00014/0001 7 (256,448,3)
+00014/0014 7 (256,448,3)
+00014/0018 7 (256,448,3)
+00014/0244 7 (256,448,3)
+00014/0475 7 (256,448,3)
+00014/0483 7 (256,448,3)
+00014/0680 7 (256,448,3)
+00014/0700 7 (256,448,3)
+00014/0701 7 (256,448,3)
+00014/0706 7 (256,448,3)
+00014/0712 7 (256,448,3)
+00014/0713 7 (256,448,3)
+00014/0717 7 (256,448,3)
+00014/0719 7 (256,448,3)
+00014/0728 7 (256,448,3)
+00014/0734 7 (256,448,3)
+00014/0736 7 (256,448,3)
+00014/0738 7 (256,448,3)
+00014/0742 7 (256,448,3)
+00014/0745 7 (256,448,3)
+00014/0746 7 (256,448,3)
+00014/0750 7 (256,448,3)
+00014/0769 7 (256,448,3)
+00014/0774 7 (256,448,3)
+00014/0781 7 (256,448,3)
+00014/0782 7 (256,448,3)
+00014/0852 7 (256,448,3)
+00014/0853 7 (256,448,3)
+00014/0855 7 (256,448,3)
+00014/0867 7 (256,448,3)
+00014/0876 7 (256,448,3)
+00014/0881 7 (256,448,3)
+00014/0890 7 (256,448,3)
+00014/0914 7 (256,448,3)
+00015/0033 7 (256,448,3)
+00015/0113 7 (256,448,3)
+00015/0125 7 (256,448,3)
+00015/0185 7 (256,448,3)
+00015/0194 7 (256,448,3)
+00015/0202 7 (256,448,3)
+00015/0312 7 (256,448,3)
+00015/0688 7 (256,448,3)
+00015/0698 7 (256,448,3)
+00015/0788 7 (256,448,3)
+00015/0854 7 (256,448,3)
+00015/0863 7 (256,448,3)
+00015/0864 7 (256,448,3)
+00015/0918 7 (256,448,3)
+00015/0931 7 (256,448,3)
+00016/0276 7 (256,448,3)
+00016/0301 7 (256,448,3)
+00016/0306 7 (256,448,3)
+00016/0324 7 (256,448,3)
+00016/0362 7 (256,448,3)
+00016/0364 7 (256,448,3)
+00016/0370 7 (256,448,3)
+00016/0378 7 (256,448,3)
+00016/0379 7 (256,448,3)
+00016/0402 7 (256,448,3)
+00016/0405 7 (256,448,3)
+00016/0418 7 (256,448,3)
+00016/0419 7 (256,448,3)
+00016/0435 7 (256,448,3)
+00016/0501 7 (256,448,3)
+00016/0561 7 (256,448,3)
+00016/0562 7 (256,448,3)
+00016/0569 7 (256,448,3)
+00016/0591 7 (256,448,3)
+00016/0599 7 (256,448,3)
+00016/0711 7 (256,448,3)
+00016/0713 7 (256,448,3)
+00016/0813 7 (256,448,3)
+00016/0953 7 (256,448,3)
+00016/0960 7 (256,448,3)
+00016/0961 7 (256,448,3)
+00017/0519 7 (256,448,3)
+00017/0523 7 (256,448,3)
+00017/0588 7 (256,448,3)
+00017/0608 7 (256,448,3)
+00017/0609 7 (256,448,3)
+00017/0719 7 (256,448,3)
+00017/0721 7 (256,448,3)
+00017/0727 7 (256,448,3)
+00017/0728 7 (256,448,3)
+00017/0769 7 (256,448,3)
+00017/0775 7 (256,448,3)
+00017/0787 7 (256,448,3)
+00017/0797 7 (256,448,3)
+00018/0043 7 (256,448,3)
+00018/0206 7 (256,448,3)
+00018/0209 7 (256,448,3)
+00018/0211 7 (256,448,3)
+00018/0216 7 (256,448,3)
+00018/0220 7 (256,448,3)
+00018/0221 7 (256,448,3)
+00018/0252 7 (256,448,3)
+00018/0260 7 (256,448,3)
+00018/0331 7 (256,448,3)
+00018/0333 7 (256,448,3)
+00018/0447 7 (256,448,3)
+00018/0523 7 (256,448,3)
+00019/0014 7 (256,448,3)
+00019/0015 7 (256,448,3)
+00019/0019 7 (256,448,3)
+00019/0049 7 (256,448,3)
+00019/0109 7 (256,448,3)
+00019/0114 7 (256,448,3)
+00019/0125 7 (256,448,3)
+00019/0137 7 (256,448,3)
+00019/0140 7 (256,448,3)
+00019/0148 7 (256,448,3)
+00019/0153 7 (256,448,3)
+00019/0155 7 (256,448,3)
+00019/0158 7 (256,448,3)
+00019/0159 7 (256,448,3)
+00019/0160 7 (256,448,3)
+00019/0162 7 (256,448,3)
+00019/0279 7 (256,448,3)
+00019/0282 7 (256,448,3)
+00019/0409 7 (256,448,3)
+00019/0427 7 (256,448,3)
+00019/0430 7 (256,448,3)
+00019/0545 7 (256,448,3)
+00019/0555 7 (256,448,3)
+00019/0558 7 (256,448,3)
+00019/0650 7 (256,448,3)
+00019/0681 7 (256,448,3)
+00019/0747 7 (256,448,3)
+00019/0748 7 (256,448,3)
+00019/0749 7 (256,448,3)
+00019/0752 7 (256,448,3)
+00019/0768 7 (256,448,3)
+00019/0772 7 (256,448,3)
+00019/0773 7 (256,448,3)
+00019/0777 7 (256,448,3)
+00019/0795 7 (256,448,3)
+00019/0806 7 (256,448,3)
+00019/0815 7 (256,448,3)
+00019/0840 7 (256,448,3)
+00019/0844 7 (256,448,3)
+00019/0848 7 (256,448,3)
+00019/0853 7 (256,448,3)
+00019/0863 7 (256,448,3)
+00019/0888 7 (256,448,3)
+00019/0894 7 (256,448,3)
+00019/0901 7 (256,448,3)
+00019/0995 7 (256,448,3)
+00021/0030 7 (256,448,3)
+00021/0035 7 (256,448,3)
+00021/0039 7 (256,448,3)
+00021/0041 7 (256,448,3)
+00021/0044 7 (256,448,3)
+00021/0045 7 (256,448,3)
+00021/0264 7 (256,448,3)
+00021/0330 7 (256,448,3)
+00021/0332 7 (256,448,3)
+00021/0333 7 (256,448,3)
+00021/0336 7 (256,448,3)
+00021/0337 7 (256,448,3)
+00021/0338 7 (256,448,3)
+00021/0343 7 (256,448,3)
+00021/0472 7 (256,448,3)
+00021/0667 7 (256,448,3)
+00021/0731 7 (256,448,3)
+00021/0779 7 (256,448,3)
+00021/0805 7 (256,448,3)
+00021/0814 7 (256,448,3)
+00021/0818 7 (256,448,3)
+00021/0874 7 (256,448,3)
+00022/0008 7 (256,448,3)
+00022/0010 7 (256,448,3)
+00022/0231 7 (256,448,3)
+00022/0323 7 (256,448,3)
+00022/0337 7 (256,448,3)
+00022/0359 7 (256,448,3)
+00022/0377 7 (256,448,3)
+00022/0378 7 (256,448,3)
+00022/0385 7 (256,448,3)
+00022/0393 7 (256,448,3)
+00022/0424 7 (256,448,3)
+00022/0582 7 (256,448,3)
+00022/0583 7 (256,448,3)
+00022/0605 7 (256,448,3)
+00022/0632 7 (256,448,3)
+00022/0633 7 (256,448,3)
+00022/0666 7 (256,448,3)
+00022/0671 7 (256,448,3)
+00022/0673 7 (256,448,3)
+00022/0702 7 (256,448,3)
+00022/0852 7 (256,448,3)
+00022/0853 7 (256,448,3)
+00022/0971 7 (256,448,3)
+00023/0037 7 (256,448,3)
+00023/0224 7 (256,448,3)
+00023/0308 7 (256,448,3)
+00023/0393 7 (256,448,3)
+00023/0633 7 (256,448,3)
+00023/0637 7 (256,448,3)
+00023/0638 7 (256,448,3)
+00023/0770 7 (256,448,3)
+00023/0786 7 (256,448,3)
+00023/0898 7 (256,448,3)
+00024/0247 7 (256,448,3)
+00024/0251 7 (256,448,3)
+00024/0267 7 (256,448,3)
+00024/0288 7 (256,448,3)
+00024/0530 7 (256,448,3)
+00024/0569 7 (256,448,3)
+00024/0587 7 (256,448,3)
+00024/0730 7 (256,448,3)
+00024/0736 7 (256,448,3)
+00024/0742 7 (256,448,3)
+00024/0832 7 (256,448,3)
+00024/0936 7 (256,448,3)
+00025/0044 7 (256,448,3)
+00025/0047 7 (256,448,3)
+00025/0540 7 (256,448,3)
+00025/0552 7 (256,448,3)
+00025/0554 7 (256,448,3)
+00025/0559 7 (256,448,3)
+00025/0572 7 (256,448,3)
+00025/0576 7 (256,448,3)
+00025/0699 7 (256,448,3)
+00025/0709 7 (256,448,3)
+00025/0743 7 (256,448,3)
+00025/0767 7 (256,448,3)
+00025/0780 7 (256,448,3)
+00025/0782 7 (256,448,3)
+00025/0784 7 (256,448,3)
+00025/0791 7 (256,448,3)
+00025/0889 7 (256,448,3)
+00025/0890 7 (256,448,3)
+00025/0894 7 (256,448,3)
+00025/0896 7 (256,448,3)
+00025/0898 7 (256,448,3)
+00025/0905 7 (256,448,3)
+00025/0999 7 (256,448,3)
+00026/0003 7 (256,448,3)
+00026/0005 7 (256,448,3)
+00026/0011 7 (256,448,3)
+00026/0017 7 (256,448,3)
+00026/0036 7 (256,448,3)
+00026/0129 7 (256,448,3)
+00026/0131 7 (256,448,3)
+00026/0161 7 (256,448,3)
+00026/0177 7 (256,448,3)
+00026/0178 7 (256,448,3)
+00026/0180 7 (256,448,3)
+00026/0298 7 (256,448,3)
+00026/0307 7 (256,448,3)
+00026/0308 7 (256,448,3)
+00026/0312 7 (256,448,3)
+00026/0352 7 (256,448,3)
+00026/0440 7 (256,448,3)
+00026/0706 7 (256,448,3)
+00026/0708 7 (256,448,3)
+00026/0715 7 (256,448,3)
+00026/0769 7 (256,448,3)
+00026/0777 7 (256,448,3)
+00026/0779 7 (256,448,3)
+00026/0789 7 (256,448,3)
+00026/0924 7 (256,448,3)
+00026/0928 7 (256,448,3)
+00026/0932 7 (256,448,3)
+00026/0935 7 (256,448,3)
+00027/0118 7 (256,448,3)
+00027/0121 7 (256,448,3)
+00027/0155 7 (256,448,3)
+00027/0168 7 (256,448,3)
+00027/0196 7 (256,448,3)
+00027/0289 7 (256,448,3)
+00027/0294 7 (256,448,3)
+00027/0803 7 (256,448,3)
+00028/0016 7 (256,448,3)
+00028/0045 7 (256,448,3)
+00028/0063 7 (256,448,3)
+00028/0601 7 (256,448,3)
+00028/0638 7 (256,448,3)
+00028/0733 7 (256,448,3)
+00028/0736 7 (256,448,3)
+00028/0741 7 (256,448,3)
+00028/0753 7 (256,448,3)
+00028/0770 7 (256,448,3)
+00028/0771 7 (256,448,3)
+00028/0777 7 (256,448,3)
+00028/0950 7 (256,448,3)
+00028/0951 7 (256,448,3)
+00029/0048 7 (256,448,3)
+00029/0060 7 (256,448,3)
+00029/0362 7 (256,448,3)
+00029/0399 7 (256,448,3)
+00029/0404 7 (256,448,3)
+00029/0412 7 (256,448,3)
+00029/0416 7 (256,448,3)
+00029/0418 7 (256,448,3)
+00029/0428 7 (256,448,3)
+00030/0131 7 (256,448,3)
+00030/0135 7 (256,448,3)
+00030/0150 7 (256,448,3)
+00030/0245 7 (256,448,3)
+00030/0339 7 (256,448,3)
+00030/0472 7 (256,448,3)
+00030/0482 7 (256,448,3)
+00030/0500 7 (256,448,3)
+00030/0501 7 (256,448,3)
+00030/0697 7 (256,448,3)
+00030/0707 7 (256,448,3)
+00030/0733 7 (256,448,3)
+00030/0743 7 (256,448,3)
+00030/0747 7 (256,448,3)
+00030/0754 7 (256,448,3)
+00030/0755 7 (256,448,3)
+00030/0759 7 (256,448,3)
+00030/0762 7 (256,448,3)
+00030/0764 7 (256,448,3)
+00030/0767 7 (256,448,3)
+00030/0794 7 (256,448,3)
+00030/0796 7 (256,448,3)
+00030/0799 7 (256,448,3)
+00030/0814 7 (256,448,3)
+00030/0823 7 (256,448,3)
+00030/0829 7 (256,448,3)
+00030/0833 7 (256,448,3)
+00030/0848 7 (256,448,3)
+00030/0853 7 (256,448,3)
+00030/0861 7 (256,448,3)
+00031/0182 7 (256,448,3)
+00031/0275 7 (256,448,3)
+00031/0279 7 (256,448,3)
+00031/0555 7 (256,448,3)
+00031/0648 7 (256,448,3)
+00031/0663 7 (256,448,3)
+00031/0680 7 (256,448,3)
+00031/0880 7 (256,448,3)
+00031/0922 7 (256,448,3)
+00031/0925 7 (256,448,3)
+00031/0928 7 (256,448,3)
+00032/0025 7 (256,448,3)
+00032/0377 7 (256,448,3)
+00032/0378 7 (256,448,3)
+00032/0382 7 (256,448,3)
+00032/0384 7 (256,448,3)
+00032/0386 7 (256,448,3)
+00032/0389 7 (256,448,3)
+00032/0391 7 (256,448,3)
+00032/0393 7 (256,448,3)
+00032/0492 7 (256,448,3)
+00032/0497 7 (256,448,3)
+00032/0505 7 (256,448,3)
+00032/0523 7 (256,448,3)
+00032/0542 7 (256,448,3)
+00032/0544 7 (256,448,3)
+00032/0712 7 (256,448,3)
+00032/0847 7 (256,448,3)
+00032/0850 7 (256,448,3)
+00032/0875 7 (256,448,3)
+00033/0062 7 (256,448,3)
+00033/0063 7 (256,448,3)
+00033/0098 7 (256,448,3)
+00033/0101 7 (256,448,3)
+00033/0105 7 (256,448,3)
+00033/0114 7 (256,448,3)
+00033/0432 7 (256,448,3)
+00033/0441 7 (256,448,3)
+00033/0606 7 (256,448,3)
+00033/0611 7 (256,448,3)
+00033/0634 7 (256,448,3)
+00033/0787 7 (256,448,3)
+00033/0792 7 (256,448,3)
+00033/0802 7 (256,448,3)
+00033/0825 7 (256,448,3)
+00033/0835 7 (256,448,3)
+00034/0249 7 (256,448,3)
+00034/0253 7 (256,448,3)
+00034/0254 7 (256,448,3)
+00034/0282 7 (256,448,3)
+00034/0318 7 (256,448,3)
+00034/0319 7 (256,448,3)
+00034/0323 7 (256,448,3)
+00034/0336 7 (256,448,3)
+00034/0348 7 (256,448,3)
+00034/0356 7 (256,448,3)
+00034/0379 7 (256,448,3)
+00034/0387 7 (256,448,3)
+00034/0575 7 (256,448,3)
+00034/0608 7 (256,448,3)
+00034/0663 7 (256,448,3)
+00034/0811 7 (256,448,3)
+00034/0812 7 (256,448,3)
+00034/0946 7 (256,448,3)
+00034/0948 7 (256,448,3)
+00034/0950 7 (256,448,3)
+00035/0204 7 (256,448,3)
+00035/0243 7 (256,448,3)
+00035/0308 7 (256,448,3)
+00035/0465 7 (256,448,3)
+00035/0478 7 (256,448,3)
+00035/0523 7 (256,448,3)
+00035/0540 7 (256,448,3)
+00035/0544 7 (256,448,3)
+00035/0556 7 (256,448,3)
+00035/0568 7 (256,448,3)
+00035/0570 7 (256,448,3)
+00035/0609 7 (256,448,3)
+00035/0643 7 (256,448,3)
+00035/0644 7 (256,448,3)
+00035/0645 7 (256,448,3)
+00035/0646 7 (256,448,3)
+00035/0650 7 (256,448,3)
+00035/0661 7 (256,448,3)
+00035/0724 7 (256,448,3)
+00035/0725 7 (256,448,3)
+00035/0850 7 (256,448,3)
+00035/0863 7 (256,448,3)
+00035/0870 7 (256,448,3)
+00035/0951 7 (256,448,3)
+00036/0038 7 (256,448,3)
+00036/0062 7 (256,448,3)
+00036/0423 7 (256,448,3)
+00036/0737 7 (256,448,3)
+00036/0750 7 (256,448,3)
+00036/0751 7 (256,448,3)
+00036/0754 7 (256,448,3)
+00036/0929 7 (256,448,3)
+00037/0085 7 (256,448,3)
+00037/0113 7 (256,448,3)
+00037/0130 7 (256,448,3)
+00037/0153 7 (256,448,3)
+00037/0169 7 (256,448,3)
+00037/0263 7 (256,448,3)
+00037/0272 7 (256,448,3)
+00037/0273 7 (256,448,3)
+00037/0275 7 (256,448,3)
+00037/0280 7 (256,448,3)
+00037/0399 7 (256,448,3)
+00037/0456 7 (256,448,3)
+00037/0853 7 (256,448,3)
+00037/0855 7 (256,448,3)
+00037/0856 7 (256,448,3)
+00037/0857 7 (256,448,3)
+00037/0925 7 (256,448,3)
+00037/0947 7 (256,448,3)
+00038/0148 7 (256,448,3)
+00038/0533 7 (256,448,3)
+00038/0534 7 (256,448,3)
+00038/0560 7 (256,448,3)
+00038/0562 7 (256,448,3)
+00038/0566 7 (256,448,3)
+00038/0578 7 (256,448,3)
+00038/0652 7 (256,448,3)
+00038/0674 7 (256,448,3)
+00038/0685 7 (256,448,3)
+00038/0686 7 (256,448,3)
+00038/0692 7 (256,448,3)
+00038/0736 7 (256,448,3)
+00039/0035 7 (256,448,3)
+00039/0105 7 (256,448,3)
+00039/0109 7 (256,448,3)
+00039/0121 7 (256,448,3)
+00039/0128 7 (256,448,3)
+00039/0129 7 (256,448,3)
+00039/0132 7 (256,448,3)
+00039/0137 7 (256,448,3)
+00039/0157 7 (256,448,3)
+00039/0496 7 (256,448,3)
+00039/0502 7 (256,448,3)
+00039/0526 7 (256,448,3)
+00039/0529 7 (256,448,3)
+00039/0682 7 (256,448,3)
+00039/0690 7 (256,448,3)
+00039/0693 7 (256,448,3)
+00039/0703 7 (256,448,3)
+00039/0725 7 (256,448,3)
+00039/0734 7 (256,448,3)
+00040/0518 7 (256,448,3)
+00040/0728 7 (256,448,3)
+00040/0774 7 (256,448,3)
+00040/0812 7 (256,448,3)
+00040/0818 7 (256,448,3)
+00040/0827 7 (256,448,3)
+00040/0914 7 (256,448,3)
+00040/0917 7 (256,448,3)
+00040/0918 7 (256,448,3)
+00040/0924 7 (256,448,3)
+00040/0925 7 (256,448,3)
+00041/0004 7 (256,448,3)
+00041/0006 7 (256,448,3)
+00041/0013 7 (256,448,3)
+00041/0059 7 (256,448,3)
+00041/0110 7 (256,448,3)
+00041/0291 7 (256,448,3)
+00041/0366 7 (256,448,3)
+00041/0388 7 (256,448,3)
+00041/0434 7 (256,448,3)
+00041/0436 7 (256,448,3)
+00041/0450 7 (256,448,3)
+00041/0457 7 (256,448,3)
+00041/0460 7 (256,448,3)
+00041/0468 7 (256,448,3)
+00041/0471 7 (256,448,3)
+00041/0474 7 (256,448,3)
+00041/0809 7 (256,448,3)
+00041/0844 7 (256,448,3)
+00041/0858 7 (256,448,3)
+00041/0874 7 (256,448,3)
+00041/0876 7 (256,448,3)
+00042/0020 7 (256,448,3)
+00042/0205 7 (256,448,3)
+00042/0206 7 (256,448,3)
+00042/0432 7 (256,448,3)
+00042/0563 7 (256,448,3)
+00042/0569 7 (256,448,3)
+00042/0575 7 (256,448,3)
+00042/0576 7 (256,448,3)
+00042/0888 7 (256,448,3)
+00042/0892 7 (256,448,3)
+00042/0943 7 (256,448,3)
+00042/0944 7 (256,448,3)
+00043/0126 7 (256,448,3)
+00043/0130 7 (256,448,3)
+00043/0136 7 (256,448,3)
+00043/0233 7 (256,448,3)
+00043/0235 7 (256,448,3)
+00043/0237 7 (256,448,3)
+00043/0277 7 (256,448,3)
+00043/0301 7 (256,448,3)
+00043/0302 7 (256,448,3)
+00043/0303 7 (256,448,3)
+00043/0308 7 (256,448,3)
+00043/0309 7 (256,448,3)
+00043/0314 7 (256,448,3)
+00043/0713 7 (256,448,3)
+00043/0715 7 (256,448,3)
+00043/0923 7 (256,448,3)
+00044/0095 7 (256,448,3)
+00044/0255 7 (256,448,3)
+00044/0864 7 (256,448,3)
+00044/0892 7 (256,448,3)
+00044/0898 7 (256,448,3)
+00044/0993 7 (256,448,3)
+00044/0995 7 (256,448,3)
+00044/0997 7 (256,448,3)
+00045/0001 7 (256,448,3)
+00045/0006 7 (256,448,3)
+00045/0269 7 (256,448,3)
+00045/0276 7 (256,448,3)
+00045/0280 7 (256,448,3)
+00045/0281 7 (256,448,3)
+00045/0282 7 (256,448,3)
+00045/0284 7 (256,448,3)
+00045/0550 7 (256,448,3)
+00045/0571 7 (256,448,3)
+00045/0629 7 (256,448,3)
+00045/0631 7 (256,448,3)
+00045/0659 7 (256,448,3)
+00045/0693 7 (256,448,3)
+00045/0807 7 (256,448,3)
+00045/0810 7 (256,448,3)
+00045/0826 7 (256,448,3)
+00045/0849 7 (256,448,3)
+00045/0946 7 (256,448,3)
+00045/0987 7 (256,448,3)
+00045/0990 7 (256,448,3)
+00046/0104 7 (256,448,3)
+00046/0477 7 (256,448,3)
+00046/0490 7 (256,448,3)
+00046/0491 7 (256,448,3)
+00046/0509 7 (256,448,3)
+00046/0513 7 (256,448,3)
+00046/0603 7 (256,448,3)
+00046/0723 7 (256,448,3)
+00046/0744 7 (256,448,3)
+00046/0746 7 (256,448,3)
+00046/0750 7 (256,448,3)
+00046/0852 7 (256,448,3)
+00046/0927 7 (256,448,3)
+00046/0928 7 (256,448,3)
+00046/0929 7 (256,448,3)
+00046/0931 7 (256,448,3)
+00046/0936 7 (256,448,3)
+00046/0939 7 (256,448,3)
+00046/0947 7 (256,448,3)
+00046/0948 7 (256,448,3)
+00046/0950 7 (256,448,3)
+00046/0955 7 (256,448,3)
+00046/0961 7 (256,448,3)
+00047/0023 7 (256,448,3)
+00047/0029 7 (256,448,3)
+00047/0035 7 (256,448,3)
+00047/0058 7 (256,448,3)
+00047/0061 7 (256,448,3)
+00047/0065 7 (256,448,3)
+00047/0068 7 (256,448,3)
+00047/0072 7 (256,448,3)
+00047/0074 7 (256,448,3)
+00047/0148 7 (256,448,3)
+00047/0594 7 (256,448,3)
+00047/0782 7 (256,448,3)
+00047/0787 7 (256,448,3)
+00047/0860 7 (256,448,3)
+00047/0889 7 (256,448,3)
+00047/0893 7 (256,448,3)
+00047/0894 7 (256,448,3)
+00047/0902 7 (256,448,3)
+00047/0975 7 (256,448,3)
+00047/0995 7 (256,448,3)
+00048/0033 7 (256,448,3)
+00048/0113 7 (256,448,3)
+00048/0115 7 (256,448,3)
+00048/0120 7 (256,448,3)
+00048/0129 7 (256,448,3)
+00048/0136 7 (256,448,3)
+00048/0327 7 (256,448,3)
+00048/0329 7 (256,448,3)
+00048/0341 7 (256,448,3)
+00048/0343 7 (256,448,3)
+00048/0345 7 (256,448,3)
+00048/0346 7 (256,448,3)
+00048/0355 7 (256,448,3)
+00048/0359 7 (256,448,3)
+00048/0363 7 (256,448,3)
+00048/0378 7 (256,448,3)
+00048/0386 7 (256,448,3)
+00048/0387 7 (256,448,3)
+00048/0388 7 (256,448,3)
+00048/0428 7 (256,448,3)
+00048/0439 7 (256,448,3)
+00048/0507 7 (256,448,3)
+00048/0510 7 (256,448,3)
+00048/0512 7 (256,448,3)
+00048/0514 7 (256,448,3)
+00048/0539 7 (256,448,3)
+00048/0542 7 (256,448,3)
+00048/0544 7 (256,448,3)
+00048/0631 7 (256,448,3)
+00048/0632 7 (256,448,3)
+00048/0636 7 (256,448,3)
+00048/0640 7 (256,448,3)
+00048/0644 7 (256,448,3)
+00048/0653 7 (256,448,3)
+00048/0655 7 (256,448,3)
+00048/0658 7 (256,448,3)
+00048/0667 7 (256,448,3)
+00048/0688 7 (256,448,3)
+00048/0708 7 (256,448,3)
+00049/0005 7 (256,448,3)
+00049/0074 7 (256,448,3)
+00049/0077 7 (256,448,3)
+00049/0084 7 (256,448,3)
+00049/0516 7 (256,448,3)
+00049/0800 7 (256,448,3)
+00049/0900 7 (256,448,3)
+00050/0607 7 (256,448,3)
+00050/0661 7 (256,448,3)
+00050/0665 7 (256,448,3)
+00050/0685 7 (256,448,3)
+00050/0711 7 (256,448,3)
+00051/0068 7 (256,448,3)
+00051/0069 7 (256,448,3)
+00051/0076 7 (256,448,3)
+00051/0569 7 (256,448,3)
+00051/0801 7 (256,448,3)
+00051/0927 7 (256,448,3)
+00051/0945 7 (256,448,3)
+00051/0952 7 (256,448,3)
+00051/0976 7 (256,448,3)
+00051/0985 7 (256,448,3)
+00052/0012 7 (256,448,3)
+00052/0015 7 (256,448,3)
+00052/0052 7 (256,448,3)
+00052/0056 7 (256,448,3)
+00052/0060 7 (256,448,3)
+00052/0157 7 (256,448,3)
+00052/0265 7 (256,448,3)
+00052/0788 7 (256,448,3)
+00052/0790 7 (256,448,3)
+00052/0793 7 (256,448,3)
+00052/0816 7 (256,448,3)
+00052/0824 7 (256,448,3)
+00052/0918 7 (256,448,3)
+00052/0933 7 (256,448,3)
+00052/0947 7 (256,448,3)
+00053/0232 7 (256,448,3)
+00053/0277 7 (256,448,3)
+00053/0362 7 (256,448,3)
+00053/0577 7 (256,448,3)
+00053/0609 7 (256,448,3)
+00053/0612 7 (256,448,3)
+00053/0628 7 (256,448,3)
+00053/0629 7 (256,448,3)
+00053/0633 7 (256,448,3)
+00053/0659 7 (256,448,3)
+00053/0667 7 (256,448,3)
+00053/0671 7 (256,448,3)
+00053/0797 7 (256,448,3)
+00053/0804 7 (256,448,3)
+00053/0807 7 (256,448,3)
+00053/0952 7 (256,448,3)
+00053/0970 7 (256,448,3)
+00053/0981 7 (256,448,3)
+00053/0999 7 (256,448,3)
+00054/0003 7 (256,448,3)
+00054/0013 7 (256,448,3)
+00054/0020 7 (256,448,3)
+00054/0022 7 (256,448,3)
+00054/0023 7 (256,448,3)
+00054/0044 7 (256,448,3)
+00054/0051 7 (256,448,3)
+00054/0063 7 (256,448,3)
+00054/0065 7 (256,448,3)
+00054/0145 7 (256,448,3)
+00054/0153 7 (256,448,3)
+00054/0203 7 (256,448,3)
+00054/0325 7 (256,448,3)
+00054/0445 7 (256,448,3)
+00054/0448 7 (256,448,3)
+00054/0456 7 (256,448,3)
+00054/0457 7 (256,448,3)
+00054/0519 7 (256,448,3)
+00054/0524 7 (256,448,3)
+00054/0530 7 (256,448,3)
+00054/0532 7 (256,448,3)
+00054/0535 7 (256,448,3)
+00054/0574 7 (256,448,3)
+00054/0760 7 (256,448,3)
+00054/0767 7 (256,448,3)
+00054/0837 7 (256,448,3)
+00055/0011 7 (256,448,3)
+00055/0109 7 (256,448,3)
+00055/0111 7 (256,448,3)
+00055/0117 7 (256,448,3)
+00055/0119 7 (256,448,3)
+00055/0182 7 (256,448,3)
+00055/0192 7 (256,448,3)
+00055/0193 7 (256,448,3)
+00055/0200 7 (256,448,3)
+00055/0204 7 (256,448,3)
+00055/0207 7 (256,448,3)
+00055/0212 7 (256,448,3)
+00055/0213 7 (256,448,3)
+00055/0348 7 (256,448,3)
+00055/0423 7 (256,448,3)
+00055/0427 7 (256,448,3)
+00055/0456 7 (256,448,3)
+00055/0489 7 (256,448,3)
+00055/0689 7 (256,448,3)
+00055/0753 7 (256,448,3)
+00055/0802 7 (256,448,3)
+00055/0844 7 (256,448,3)
+00055/0850 7 (256,448,3)
+00055/0982 7 (256,448,3)
+00055/0993 7 (256,448,3)
+00056/0113 7 (256,448,3)
+00056/0148 7 (256,448,3)
+00056/0151 7 (256,448,3)
+00056/0316 7 (256,448,3)
+00056/0379 7 (256,448,3)
+00056/0380 7 (256,448,3)
+00056/0385 7 (256,448,3)
+00056/0505 7 (256,448,3)
+00056/0579 7 (256,448,3)
+00057/0254 7 (256,448,3)
+00057/0264 7 (256,448,3)
+00057/0272 7 (256,448,3)
+00057/0403 7 (256,448,3)
+00057/0501 7 (256,448,3)
+00057/0503 7 (256,448,3)
+00057/0884 7 (256,448,3)
+00058/0026 7 (256,448,3)
+00058/0029 7 (256,448,3)
+00058/0104 7 (256,448,3)
+00058/0124 7 (256,448,3)
+00058/0162 7 (256,448,3)
+00058/0288 7 (256,448,3)
+00058/0289 7 (256,448,3)
+00058/0323 7 (256,448,3)
+00058/0328 7 (256,448,3)
+00058/0329 7 (256,448,3)
+00058/0337 7 (256,448,3)
+00058/0367 7 (256,448,3)
+00058/0383 7 (256,448,3)
+00058/0395 7 (256,448,3)
+00060/0178 7 (256,448,3)
+00060/0182 7 (256,448,3)
+00061/0001 7 (256,448,3)
+00061/0003 7 (256,448,3)
+00061/0006 7 (256,448,3)
+00061/0443 7 (256,448,3)
+00061/0586 7 (256,448,3)
+00061/0587 7 (256,448,3)
+00061/0774 7 (256,448,3)
+00061/0789 7 (256,448,3)
+00061/0815 7 (256,448,3)
+00061/0817 7 (256,448,3)
+00061/0826 7 (256,448,3)
+00061/0829 7 (256,448,3)
+00061/0830 7 (256,448,3)
+00061/0832 7 (256,448,3)
+00061/0833 7 (256,448,3)
+00061/0836 7 (256,448,3)
+00061/0837 7 (256,448,3)
+00061/0839 7 (256,448,3)
+00061/0843 7 (256,448,3)
+00061/0849 7 (256,448,3)
+00061/0859 7 (256,448,3)
+00061/0861 7 (256,448,3)
+00061/0868 7 (256,448,3)
+00061/0877 7 (256,448,3)
+00061/0889 7 (256,448,3)
+00061/0905 7 (256,448,3)
+00062/0115 7 (256,448,3)
+00062/0118 7 (256,448,3)
+00062/0125 7 (256,448,3)
+00062/0134 7 (256,448,3)
+00062/0142 7 (256,448,3)
+00062/0400 7 (256,448,3)
+00062/0457 7 (256,448,3)
+00062/0459 7 (256,448,3)
+00062/0560 7 (256,448,3)
+00062/0650 7 (256,448,3)
+00062/0655 7 (256,448,3)
+00062/0715 7 (256,448,3)
+00062/0847 7 (256,448,3)
+00062/0905 7 (256,448,3)
+00062/0981 7 (256,448,3)
+00063/0177 7 (256,448,3)
+00063/0230 7 (256,448,3)
+00063/0253 7 (256,448,3)
+00063/0257 7 (256,448,3)
+00063/0326 7 (256,448,3)
+00063/0530 7 (256,448,3)
+00063/0677 7 (256,448,3)
+00063/0759 7 (256,448,3)
+00063/0761 7 (256,448,3)
+00063/0777 7 (256,448,3)
+00063/0842 7 (256,448,3)
+00063/0900 7 (256,448,3)
+00064/0014 7 (256,448,3)
+00064/0028 7 (256,448,3)
+00064/0029 7 (256,448,3)
+00064/0030 7 (256,448,3)
+00064/0037 7 (256,448,3)
+00064/0044 7 (256,448,3)
+00064/0280 7 (256,448,3)
+00064/0285 7 (256,448,3)
+00064/0286 7 (256,448,3)
+00064/0291 7 (256,448,3)
+00064/0300 7 (256,448,3)
+00064/0303 7 (256,448,3)
+00064/0308 7 (256,448,3)
+00064/0314 7 (256,448,3)
+00064/0316 7 (256,448,3)
+00064/0317 7 (256,448,3)
+00064/0323 7 (256,448,3)
+00064/0435 7 (256,448,3)
+00064/0733 7 (256,448,3)
+00064/0848 7 (256,448,3)
+00064/0868 7 (256,448,3)
+00064/0888 7 (256,448,3)
+00064/0898 7 (256,448,3)
+00065/0116 7 (256,448,3)
+00065/0121 7 (256,448,3)
+00065/0122 7 (256,448,3)
+00065/0124 7 (256,448,3)
+00065/0125 7 (256,448,3)
+00065/0126 7 (256,448,3)
+00065/0136 7 (256,448,3)
+00065/0146 7 (256,448,3)
+00065/0147 7 (256,448,3)
+00065/0163 7 (256,448,3)
+00065/0170 7 (256,448,3)
+00065/0175 7 (256,448,3)
+00065/0176 7 (256,448,3)
+00065/0180 7 (256,448,3)
+00065/0184 7 (256,448,3)
+00065/0186 7 (256,448,3)
+00065/0332 7 (256,448,3)
+00065/0343 7 (256,448,3)
+00065/0365 7 (256,448,3)
+00065/0393 7 (256,448,3)
+00065/0394 7 (256,448,3)
+00065/0442 7 (256,448,3)
+00065/0459 7 (256,448,3)
+00065/0462 7 (256,448,3)
+00065/0476 7 (256,448,3)
+00065/0483 7 (256,448,3)
+00065/0590 7 (256,448,3)
+00065/0593 7 (256,448,3)
+00065/0595 7 (256,448,3)
+00065/0774 7 (256,448,3)
+00065/0947 7 (256,448,3)
+00065/0985 7 (256,448,3)
+00065/0986 7 (256,448,3)
+00066/0015 7 (256,448,3)
+00066/0043 7 (256,448,3)
+00066/0131 7 (256,448,3)
+00066/0157 7 (256,448,3)
+00066/0169 7 (256,448,3)
+00066/0374 7 (256,448,3)
+00066/0382 7 (256,448,3)
+00066/0481 7 (256,448,3)
+00066/0482 7 (256,448,3)
+00066/0491 7 (256,448,3)
+00066/0493 7 (256,448,3)
+00066/0494 7 (256,448,3)
+00066/0496 7 (256,448,3)
+00066/0680 7 (256,448,3)
+00066/0700 7 (256,448,3)
+00066/0887 7 (256,448,3)
+00066/0910 7 (256,448,3)
+00066/0918 7 (256,448,3)
+00067/0024 7 (256,448,3)
+00067/0059 7 (256,448,3)
+00067/0408 7 (256,448,3)
+00067/0414 7 (256,448,3)
+00067/0417 7 (256,448,3)
+00067/0419 7 (256,448,3)
+00067/0423 7 (256,448,3)
+00067/0441 7 (256,448,3)
+00067/0467 7 (256,448,3)
+00067/0471 7 (256,448,3)
+00067/0487 7 (256,448,3)
+00067/0494 7 (256,448,3)
+00067/0497 7 (256,448,3)
+00067/0513 7 (256,448,3)
+00067/0521 7 (256,448,3)
+00068/0111 7 (256,448,3)
+00068/0123 7 (256,448,3)
+00068/0126 7 (256,448,3)
+00068/0129 7 (256,448,3)
+00068/0270 7 (256,448,3)
+00068/0330 7 (256,448,3)
+00068/0407 7 (256,448,3)
+00068/0428 7 (256,448,3)
+00068/0544 7 (256,448,3)
+00068/0635 7 (256,448,3)
+00068/0637 7 (256,448,3)
+00068/0736 7 (256,448,3)
+00068/0738 7 (256,448,3)
+00068/0747 7 (256,448,3)
+00068/0748 7 (256,448,3)
+00068/0749 7 (256,448,3)
+00068/0762 7 (256,448,3)
+00068/0815 7 (256,448,3)
+00068/0981 7 (256,448,3)
+00068/0982 7 (256,448,3)
+00069/0187 7 (256,448,3)
+00069/0191 7 (256,448,3)
+00070/0001 7 (256,448,3)
+00070/0003 7 (256,448,3)
+00070/0340 7 (256,448,3)
+00070/0341 7 (256,448,3)
+00070/0342 7 (256,448,3)
+00070/0347 7 (256,448,3)
+00070/0372 7 (256,448,3)
+00070/0383 7 (256,448,3)
+00070/0389 7 (256,448,3)
+00070/0728 7 (256,448,3)
+00070/0813 7 (256,448,3)
+00070/0814 7 (256,448,3)
+00070/0823 7 (256,448,3)
+00070/0840 7 (256,448,3)
+00070/0843 7 (256,448,3)
+00070/0861 7 (256,448,3)
+00071/0111 7 (256,448,3)
+00071/0138 7 (256,448,3)
+00071/0143 7 (256,448,3)
+00071/0150 7 (256,448,3)
+00071/0508 7 (256,448,3)
+00071/0514 7 (256,448,3)
+00071/0550 7 (256,448,3)
+00071/0556 7 (256,448,3)
+00071/0600 7 (256,448,3)
+00071/0665 7 (256,448,3)
+00071/0670 7 (256,448,3)
+00071/0672 7 (256,448,3)
+00071/0673 7 (256,448,3)
+00071/0705 7 (256,448,3)
+00071/0706 7 (256,448,3)
+00071/0707 7 (256,448,3)
+00071/0774 7 (256,448,3)
+00071/0799 7 (256,448,3)
+00071/0814 7 (256,448,3)
+00071/0816 7 (256,448,3)
+00071/0819 7 (256,448,3)
+00071/0823 7 (256,448,3)
+00071/0828 7 (256,448,3)
+00071/0830 7 (256,448,3)
+00071/0839 7 (256,448,3)
+00071/0841 7 (256,448,3)
+00072/0192 7 (256,448,3)
+00072/0194 7 (256,448,3)
+00072/0197 7 (256,448,3)
+00072/0199 7 (256,448,3)
+00072/0285 7 (256,448,3)
+00072/0586 7 (256,448,3)
+00072/0795 7 (256,448,3)
+00072/0811 7 (256,448,3)
+00072/0812 7 (256,448,3)
+00072/0824 7 (256,448,3)
+00072/0831 7 (256,448,3)
+00072/0835 7 (256,448,3)
+00072/0837 7 (256,448,3)
+00072/0841 7 (256,448,3)
+00072/0962 7 (256,448,3)
+00073/0296 7 (256,448,3)
+00073/0299 7 (256,448,3)
+00073/0300 7 (256,448,3)
+00073/0301 7 (256,448,3)
+00073/0427 7 (256,448,3)
+00073/0428 7 (256,448,3)
+00073/0494 7 (256,448,3)
+00073/0615 7 (256,448,3)
+00073/0620 7 (256,448,3)
+00073/0624 7 (256,448,3)
+00073/0979 7 (256,448,3)
+00074/0226 7 (256,448,3)
+00074/0250 7 (256,448,3)
+00074/0284 7 (256,448,3)
+00074/0503 7 (256,448,3)
+00074/0614 7 (256,448,3)
+00074/0629 7 (256,448,3)
+00074/0762 7 (256,448,3)
+00074/0765 7 (256,448,3)
+00074/0900 7 (256,448,3)
+00074/0908 7 (256,448,3)
+00075/0352 7 (256,448,3)
+00075/0360 7 (256,448,3)
+00075/0361 7 (256,448,3)
+00075/0365 7 (256,448,3)
+00075/0383 7 (256,448,3)
+00075/0384 7 (256,448,3)
+00075/0386 7 (256,448,3)
+00075/0407 7 (256,448,3)
+00075/0410 7 (256,448,3)
+00075/0412 7 (256,448,3)
+00075/0413 7 (256,448,3)
+00075/0459 7 (256,448,3)
+00075/0504 7 (256,448,3)
+00075/0515 7 (256,448,3)
+00075/0518 7 (256,448,3)
+00075/0567 7 (256,448,3)
+00075/0681 7 (256,448,3)
+00075/0693 7 (256,448,3)
+00075/0728 7 (256,448,3)
+00075/0731 7 (256,448,3)
+00075/0804 7 (256,448,3)
+00075/0974 7 (256,448,3)
+00075/0975 7 (256,448,3)
+00075/0983 7 (256,448,3)
+00075/0997 7 (256,448,3)
+00076/0006 7 (256,448,3)
+00076/0007 7 (256,448,3)
+00076/0011 7 (256,448,3)
+00076/0013 7 (256,448,3)
+00076/0014 7 (256,448,3)
+00076/0027 7 (256,448,3)
+00076/0029 7 (256,448,3)
+00076/0037 7 (256,448,3)
+00076/0041 7 (256,448,3)
+00076/0055 7 (256,448,3)
+00076/0071 7 (256,448,3)
+00076/0172 7 (256,448,3)
+00076/0275 7 (256,448,3)
+00076/0286 7 (256,448,3)
+00076/0467 7 (256,448,3)
+00076/0481 7 (256,448,3)
+00076/0527 7 (256,448,3)
+00076/0895 7 (256,448,3)
+00076/0896 7 (256,448,3)
+00076/0906 7 (256,448,3)
+00076/0924 7 (256,448,3)
+00076/0964 7 (256,448,3)
+00076/0984 7 (256,448,3)
+00077/0317 7 (256,448,3)
+00077/0322 7 (256,448,3)
+00077/0333 7 (256,448,3)
+00077/0334 7 (256,448,3)
+00077/0480 7 (256,448,3)
+00077/0488 7 (256,448,3)
+00077/0490 7 (256,448,3)
+00077/0582 7 (256,448,3)
+00077/0586 7 (256,448,3)
+00077/0969 7 (256,448,3)
+00078/0007 7 (256,448,3)
+00078/0011 7 (256,448,3)
+00078/0153 7 (256,448,3)
+00078/0289 7 (256,448,3)
+00078/0312 7 (256,448,3)
+00078/0492 7 (256,448,3)
+00078/0580 7 (256,448,3)
+00078/0595 7 (256,448,3)
+00078/0814 7 (256,448,3)
+00078/0950 7 (256,448,3)
+00078/0955 7 (256,448,3)
+00079/0060 7 (256,448,3)
+00079/0067 7 (256,448,3)
+00080/0216 7 (256,448,3)
+00080/0308 7 (256,448,3)
+00080/0504 7 (256,448,3)
+00080/0552 7 (256,448,3)
+00080/0576 7 (256,448,3)
+00080/0583 7 (256,448,3)
+00080/0837 7 (256,448,3)
+00080/0839 7 (256,448,3)
+00080/0871 7 (256,448,3)
+00080/0877 7 (256,448,3)
+00080/0880 7 (256,448,3)
+00080/0969 7 (256,448,3)
+00080/0973 7 (256,448,3)
+00080/0980 7 (256,448,3)
+00081/0202 7 (256,448,3)
+00081/0203 7 (256,448,3)
+00081/0210 7 (256,448,3)
+00081/0268 7 (256,448,3)
+00081/0281 7 (256,448,3)
+00081/0283 7 (256,448,3)
+00081/0317 7 (256,448,3)
+00081/0327 7 (256,448,3)
+00082/0018 7 (256,448,3)
+00082/0025 7 (256,448,3)
+00082/0089 7 (256,448,3)
+00082/0140 7 (256,448,3)
+00082/0442 7 (256,448,3)
+00082/0465 7 (256,448,3)
+00082/0473 7 (256,448,3)
+00082/0481 7 (256,448,3)
+00082/0492 7 (256,448,3)
+00082/0495 7 (256,448,3)
+00082/0497 7 (256,448,3)
+00082/0502 7 (256,448,3)
+00082/0504 7 (256,448,3)
+00082/0506 7 (256,448,3)
+00082/0507 7 (256,448,3)
+00082/0510 7 (256,448,3)
+00082/0519 7 (256,448,3)
+00082/0523 7 (256,448,3)
+00082/0588 7 (256,448,3)
+00082/0597 7 (256,448,3)
+00082/0632 7 (256,448,3)
+00082/0751 7 (256,448,3)
+00082/0767 7 (256,448,3)
+00082/0771 7 (256,448,3)
+00082/0790 7 (256,448,3)
+00082/0804 7 (256,448,3)
+00082/0823 7 (256,448,3)
+00083/0052 7 (256,448,3)
+00083/0056 7 (256,448,3)
+00083/0113 7 (256,448,3)
+00083/0114 7 (256,448,3)
+00083/0122 7 (256,448,3)
+00083/0137 7 (256,448,3)
+00083/0270 7 (256,448,3)
+00083/0295 7 (256,448,3)
+00083/0303 7 (256,448,3)
+00083/0308 7 (256,448,3)
+00083/0586 7 (256,448,3)
+00083/0592 7 (256,448,3)
+00083/0640 7 (256,448,3)
+00083/0648 7 (256,448,3)
+00083/0654 7 (256,448,3)
+00083/0662 7 (256,448,3)
+00083/0666 7 (256,448,3)
+00083/0668 7 (256,448,3)
+00083/0669 7 (256,448,3)
+00083/0675 7 (256,448,3)
+00083/0679 7 (256,448,3)
+00083/0681 7 (256,448,3)
+00083/0682 7 (256,448,3)
+00083/0694 7 (256,448,3)
+00083/0695 7 (256,448,3)
+00083/0697 7 (256,448,3)
+00083/0704 7 (256,448,3)
+00083/0713 7 (256,448,3)
+00083/0721 7 (256,448,3)
+00083/0855 7 (256,448,3)
+00084/0109 7 (256,448,3)
+00084/0113 7 (256,448,3)
+00084/0306 7 (256,448,3)
+00084/0442 7 (256,448,3)
+00084/0669 7 (256,448,3)
+00084/0679 7 (256,448,3)
+00084/0685 7 (256,448,3)
+00084/0691 7 (256,448,3)
+00084/0768 7 (256,448,3)
+00084/0817 7 (256,448,3)
+00085/0027 7 (256,448,3)
+00085/0035 7 (256,448,3)
+00085/0038 7 (256,448,3)
+00085/0223 7 (256,448,3)
+00085/0233 7 (256,448,3)
+00085/0281 7 (256,448,3)
+00085/0287 7 (256,448,3)
+00085/0313 7 (256,448,3)
+00085/0521 7 (256,448,3)
+00085/0848 7 (256,448,3)
+00085/0855 7 (256,448,3)
+00085/0865 7 (256,448,3)
+00085/0952 7 (256,448,3)
+00085/0964 7 (256,448,3)
+00085/0973 7 (256,448,3)
+00085/0986 7 (256,448,3)
+00085/0993 7 (256,448,3)
+00086/0070 7 (256,448,3)
+00086/0075 7 (256,448,3)
+00086/0094 7 (256,448,3)
+00086/0103 7 (256,448,3)
+00086/0112 7 (256,448,3)
+00086/0288 7 (256,448,3)
+00086/0576 7 (256,448,3)
+00086/0580 7 (256,448,3)
+00086/0584 7 (256,448,3)
+00086/0599 7 (256,448,3)
+00086/0600 7 (256,448,3)
+00086/0602 7 (256,448,3)
+00086/0612 7 (256,448,3)
+00086/0629 7 (256,448,3)
+00086/0655 7 (256,448,3)
+00086/0679 7 (256,448,3)
+00086/0694 7 (256,448,3)
+00086/0695 7 (256,448,3)
+00086/0701 7 (256,448,3)
+00086/0760 7 (256,448,3)
+00086/0786 7 (256,448,3)
+00086/0845 7 (256,448,3)
+00086/0868 7 (256,448,3)
+00086/0889 7 (256,448,3)
+00086/0891 7 (256,448,3)
+00086/0927 7 (256,448,3)
+00086/0938 7 (256,448,3)
+00086/0946 7 (256,448,3)
+00086/0963 7 (256,448,3)
+00086/0969 7 (256,448,3)
+00087/0023 7 (256,448,3)
+00087/0029 7 (256,448,3)
+00087/0144 7 (256,448,3)
+00087/0148 7 (256,448,3)
+00087/0159 7 (256,448,3)
+00087/0174 7 (256,448,3)
+00087/0283 7 (256,448,3)
+00087/0284 7 (256,448,3)
+00087/0294 7 (256,448,3)
+00087/0296 7 (256,448,3)
+00087/0498 7 (256,448,3)
+00087/0502 7 (256,448,3)
+00087/0532 7 (256,448,3)
+00087/0557 7 (256,448,3)
+00087/0559 7 (256,448,3)
+00087/0574 7 (256,448,3)
+00087/0577 7 (256,448,3)
+00088/0006 7 (256,448,3)
+00088/0268 7 (256,448,3)
+00088/0320 7 (256,448,3)
+00088/0412 7 (256,448,3)
+00088/0431 7 (256,448,3)
+00088/0432 7 (256,448,3)
+00088/0465 7 (256,448,3)
+00088/0507 7 (256,448,3)
+00088/0565 7 (256,448,3)
+00088/0629 7 (256,448,3)
+00088/0831 7 (256,448,3)
+00088/0836 7 (256,448,3)
+00088/0972 7 (256,448,3)
+00088/0974 7 (256,448,3)
+00088/0980 7 (256,448,3)
+00089/0067 7 (256,448,3)
+00089/0244 7 (256,448,3)
+00089/0404 7 (256,448,3)
+00089/0416 7 (256,448,3)
+00089/0419 7 (256,448,3)
+00089/0428 7 (256,448,3)
+00089/0712 7 (256,448,3)
+00089/0713 7 (256,448,3)
+00089/0723 7 (256,448,3)
+00089/0727 7 (256,448,3)
+00089/0770 7 (256,448,3)
+00089/0809 7 (256,448,3)
+00089/0811 7 (256,448,3)
+00089/0888 7 (256,448,3)
+00089/0898 7 (256,448,3)
+00089/0903 7 (256,448,3)
+00089/0907 7 (256,448,3)
+00089/0911 7 (256,448,3)
+00089/0915 7 (256,448,3)
+00089/0926 7 (256,448,3)
+00089/0955 7 (256,448,3)
+00090/0027 7 (256,448,3)
+00090/0028 7 (256,448,3)
+00090/0032 7 (256,448,3)
+00090/0038 7 (256,448,3)
+00090/0076 7 (256,448,3)
+00090/0081 7 (256,448,3)
+00090/0086 7 (256,448,3)
+00090/0119 7 (256,448,3)
+00090/0258 7 (256,448,3)
+00090/0261 7 (256,448,3)
+00090/0447 7 (256,448,3)
+00090/0498 7 (256,448,3)
+00090/0514 7 (256,448,3)
+00090/0523 7 (256,448,3)
+00090/0530 7 (256,448,3)
+00090/0540 7 (256,448,3)
+00090/0548 7 (256,448,3)
+00090/0565 7 (256,448,3)
+00090/0578 7 (256,448,3)
+00090/0580 7 (256,448,3)
+00090/0581 7 (256,448,3)
+00090/0780 7 (256,448,3)
+00090/0940 7 (256,448,3)
+00090/0984 7 (256,448,3)
+00091/0023 7 (256,448,3)
+00091/0051 7 (256,448,3)
+00091/0317 7 (256,448,3)
+00091/0320 7 (256,448,3)
+00091/0582 7 (256,448,3)
+00091/0585 7 (256,448,3)
+00091/0588 7 (256,448,3)
+00091/0601 7 (256,448,3)
+00091/0602 7 (256,448,3)
+00091/0603 7 (256,448,3)
+00091/0634 7 (256,448,3)
+00091/0693 7 (256,448,3)
+00091/0741 7 (256,448,3)
+00091/0966 7 (256,448,3)
+00091/0973 7 (256,448,3)
+00091/0985 7 (256,448,3)
+00092/0007 7 (256,448,3)
+00092/0132 7 (256,448,3)
+00092/0270 7 (256,448,3)
+00092/0296 7 (256,448,3)
+00092/0611 7 (256,448,3)
+00092/0625 7 (256,448,3)
+00092/0627 7 (256,448,3)
+00092/0651 7 (256,448,3)
+00092/0652 7 (256,448,3)
+00092/0910 7 (256,448,3)
+00093/0075 7 (256,448,3)
+00093/0078 7 (256,448,3)
+00093/0100 7 (256,448,3)
+00093/0132 7 (256,448,3)
+00093/0133 7 (256,448,3)
+00093/0176 7 (256,448,3)
+00093/0177 7 (256,448,3)
+00093/0178 7 (256,448,3)
+00093/0181 7 (256,448,3)
+00093/0183 7 (256,448,3)
+00093/0184 7 (256,448,3)
+00093/0286 7 (256,448,3)
+00093/0304 7 (256,448,3)
+00093/0305 7 (256,448,3)
+00093/0319 7 (256,448,3)
+00093/0324 7 (256,448,3)
+00093/0325 7 (256,448,3)
+00093/0327 7 (256,448,3)
+00093/0331 7 (256,448,3)
+00093/0444 7 (256,448,3)
+00093/0450 7 (256,448,3)
+00093/0593 7 (256,448,3)
+00094/0032 7 (256,448,3)
+00094/0057 7 (256,448,3)
+00094/0139 7 (256,448,3)
+00094/0206 7 (256,448,3)
+00094/0211 7 (256,448,3)
+00094/0215 7 (256,448,3)
+00094/0218 7 (256,448,3)
+00094/0257 7 (256,448,3)
+00094/0329 7 (256,448,3)
+00094/0331 7 (256,448,3)
+00094/0332 7 (256,448,3)
+00094/0369 7 (256,448,3)
+00094/0370 7 (256,448,3)
+00094/0383 7 (256,448,3)
+00094/0385 7 (256,448,3)
+00094/0387 7 (256,448,3)
+00094/0399 7 (256,448,3)
+00094/0605 7 (256,448,3)
+00094/0648 7 (256,448,3)
+00094/0649 7 (256,448,3)
+00094/0759 7 (256,448,3)
+00094/0800 7 (256,448,3)
+00094/0894 7 (256,448,3)
+00094/0896 7 (256,448,3)
+00095/0089 7 (256,448,3)
+00095/0108 7 (256,448,3)
+00095/0109 7 (256,448,3)
+00095/0114 7 (256,448,3)
+00095/0128 7 (256,448,3)
+00095/0133 7 (256,448,3)
+00095/0150 7 (256,448,3)
+00095/0153 7 (256,448,3)
+00095/0154 7 (256,448,3)
+00095/0196 7 (256,448,3)
+00095/0209 7 (256,448,3)
+00095/0228 7 (256,448,3)
+00095/0230 7 (256,448,3)
+00095/0231 7 (256,448,3)
+00095/0242 7 (256,448,3)
+00095/0243 7 (256,448,3)
+00095/0253 7 (256,448,3)
+00095/0280 7 (256,448,3)
+00095/0281 7 (256,448,3)
+00095/0283 7 (256,448,3)
+00095/0314 7 (256,448,3)
+00095/0868 7 (256,448,3)
+00095/0894 7 (256,448,3)
+00096/0062 7 (256,448,3)
+00096/0347 7 (256,448,3)
+00096/0348 7 (256,448,3)
+00096/0359 7 (256,448,3)
+00096/0363 7 (256,448,3)
+00096/0373 7 (256,448,3)
+00096/0378 7 (256,448,3)
+00096/0387 7 (256,448,3)
+00096/0395 7 (256,448,3)
+00096/0396 7 (256,448,3)
+00096/0404 7 (256,448,3)
+00096/0653 7 (256,448,3)
+00096/0668 7 (256,448,3)
+00096/0679 7 (256,448,3)
+00096/0729 7 (256,448,3)
+00096/0736 7 (256,448,3)
+00096/0823 7 (256,448,3)

basicsr/data/paired_image_dataset.py

@@ -0,0 +1,374 @@
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.data_util import (paired_paths_from_folder,
+                                    paired_DP_paths_from_folder,
+                                    paired_paths_from_lmdb,
+                                    paired_paths_from_meta_info_file)
+from basicsr.data.transforms import augment, paired_random_crop, paired_random_crop_DP, random_augmentation
+from basicsr.utils import FileClient, imfrombytes, img2tensor, padding, padding_DP, imfrombytesDP
+
+import random
+import numpy as np
+import torch
+import cv2
+
+class Dataset_PairedImage(data.Dataset):
+    """Paired image dataset for image restoration.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and
+    GT image pairs.
+
+    There are three modes:
+    1. 'lmdb': Use lmdb files.
+        If opt['io_backend'] == lmdb.
+    2. 'meta_info_file': Use meta information file to generate paths.
+        If opt['io_backend'] != lmdb and opt['meta_info_file'] is not None.
+    3. 'folder': Scan folders to generate paths.
+        The rest.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            filename_tmpl (str): Template for each filename. Note that the
+                template excludes the file extension. Default: '{}'.
+            gt_size (int): Cropped patched size for gt patches.
+            geometric_augs (bool): Use geometric augmentations.
+
+            scale (bool): Scale, which will be added automatically.
+            phase (str): 'train' or 'val'.
+    """
+
+    def __init__(self, opt):
+        super(Dataset_PairedImage, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+        
+        self.gt_folder, self.lq_folder = opt['dataroot_gt'], opt['dataroot_lq']
+        if 'filename_tmpl' in opt:
+            self.filename_tmpl = opt['filename_tmpl']
+        else:
+            self.filename_tmpl = '{}'
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.lq_folder, self.gt_folder]
+            self.io_backend_opt['client_keys'] = ['lq', 'gt']
+            self.paths = paired_paths_from_lmdb(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'])
+        elif 'meta_info_file' in self.opt and self.opt[
+                'meta_info_file'] is not None:
+            self.paths = paired_paths_from_meta_info_file(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+                self.opt['meta_info_file'], self.filename_tmpl)
+        else:
+            self.paths = paired_paths_from_folder(
+                [self.lq_folder, self.gt_folder], ['lq', 'gt'],
+                self.filename_tmpl)
+
+        if self.opt['phase'] == 'train':
+            self.geometric_augs = opt['geometric_augs']
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+        index = index % len(self.paths)
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        gt_path = self.paths[index]['gt_path']
+        img_bytes = self.file_client.get(gt_path, 'gt')
+        try:
+            img_gt = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path))
+
+        lq_path = self.paths[index]['lq_path']
+        img_bytes = self.file_client.get(lq_path, 'lq')
+        try:
+            img_lq = imfrombytes(img_bytes, float32=True)
+        except:
+            raise Exception("lq path {} not working".format(lq_path))
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # padding
+            img_gt, img_lq = padding(img_gt, img_lq, gt_size)
+
+            # random crop
+            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale,
+                                                gt_path)
+
+            # flip, rotation augmentations
+            if self.geometric_augs:
+                img_gt, img_lq = random_augmentation(img_gt, img_lq)
+            
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+        label = self.get_label(lq_path,)
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': lq_path,
+            'gt_path': gt_path,
+            'label': label
+        }
+    def get_label(self, lq_path):
+        img_name = lq_path.split("/")[-1]
+        if "im_" in img_name:
+            return 0
+        elif '.jpg' in img_name:
+            return 1
+        elif 'rain' in img_name:
+            return 2
+        else:
+            return 4
+         
+    def __len__(self):
+        return len(self.paths)
+
+class Dataset_GaussianDenoising(data.Dataset):
+    """Paired image dataset for image restoration.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and
+    GT image pairs.
+
+    There are three modes:
+    1. 'lmdb': Use lmdb files.
+        If opt['io_backend'] == lmdb.
+    2. 'meta_info_file': Use meta information file to generate paths.
+        If opt['io_backend'] != lmdb and opt['meta_info_file'] is not None.
+    3. 'folder': Scan folders to generate paths.
+        The rest.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            gt_size (int): Cropped patched size for gt patches.
+            use_flip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h
+                and w for implementation).
+
+            scale (bool): Scale, which will be added automatically.
+            phase (str): 'train' or 'val'.
+    """
+
+    def __init__(self, opt):
+        super(Dataset_GaussianDenoising, self).__init__()
+        self.opt = opt
+
+        if self.opt['phase'] == 'train':
+            self.sigma_type  = opt['sigma_type']
+            self.sigma_range = opt['sigma_range']
+            assert self.sigma_type in ['constant', 'random', 'choice']
+        else:
+            self.sigma_test = opt['sigma_test']
+        self.in_ch = opt['in_ch']
+
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None        
+
+        self.gt_folder = opt['dataroot_gt']
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.gt_folder]
+            self.io_backend_opt['client_keys'] = ['gt']
+            self.paths = paths_from_lmdb(self.gt_folder)
+        elif 'meta_info_file' in self.opt:
+            with open(self.opt['meta_info_file'], 'r') as fin:
+                self.paths = [
+                    osp.join(self.gt_folder,
+                             line.split(' ')[0]) for line in fin
+                ]
+        else:
+            self.paths = sorted(list(scandir(self.gt_folder, full_path=True)))
+
+        if self.opt['phase'] == 'train':
+            self.geometric_augs = self.opt['geometric_augs']
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+        index = index % len(self.paths)
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        gt_path = self.paths[index]['gt_path']
+        img_bytes = self.file_client.get(gt_path, 'gt')
+
+        if self.in_ch == 3:
+            try:
+                img_gt = imfrombytes(img_bytes, float32=True)
+            except:
+                raise Exception("gt path {} not working".format(gt_path))
+
+            img_gt = cv2.cvtColor(img_gt, cv2.COLOR_BGR2RGB)
+        else:
+            try:
+                img_gt = imfrombytes(img_bytes, flag='grayscale', float32=True)
+            except:
+                raise Exception("gt path {} not working".format(gt_path))
+
+            img_gt = np.expand_dims(img_gt, axis=2)
+        img_lq = img_gt.copy()
+
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # padding
+            img_gt, img_lq = padding(img_gt, img_lq, gt_size)
+
+            # random crop
+            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale,
+                                                gt_path)
+            # flip, rotation
+            if self.geometric_augs:
+                img_gt, img_lq = random_augmentation(img_gt, img_lq)
+
+            img_gt, img_lq = img2tensor([img_gt, img_lq],
+                                        bgr2rgb=False,
+                                        float32=True)
+
+
+            if self.sigma_type == 'constant':
+                sigma_value = self.sigma_range
+            elif self.sigma_type == 'random':
+                sigma_value = random.uniform(self.sigma_range[0], self.sigma_range[1])
+            elif self.sigma_type == 'choice':
+                sigma_value = random.choice(self.sigma_range)
+
+            noise_level = torch.FloatTensor([sigma_value])/255.0
+            # noise_level_map = torch.ones((1, img_lq.size(1), img_lq.size(2))).mul_(noise_level).float()
+            noise = torch.randn(img_lq.size()).mul_(noise_level).float()
+            img_lq.add_(noise)
+
+        else:            
+            np.random.seed(seed=0)
+            img_lq += np.random.normal(0, self.sigma_test/255.0, img_lq.shape)
+            # noise_level_map = torch.ones((1, img_lq.shape[0], img_lq.shape[1])).mul_(self.sigma_test/255.0).float()
+
+            img_gt, img_lq = img2tensor([img_gt, img_lq],
+                            bgr2rgb=False,
+                            float32=True)
+
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': gt_path,
+            'gt_path': gt_path
+        }
+
+    def __len__(self):
+        return len(self.paths)
+
+class Dataset_DefocusDeblur_DualPixel_16bit(data.Dataset):
+    def __init__(self, opt):
+        super(Dataset_DefocusDeblur_DualPixel_16bit, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+        
+        self.gt_folder, self.lqL_folder, self.lqR_folder = opt['dataroot_gt'], opt['dataroot_lqL'], opt['dataroot_lqR']
+        if 'filename_tmpl' in opt:
+            self.filename_tmpl = opt['filename_tmpl']
+        else:
+            self.filename_tmpl = '{}'
+
+        self.paths = paired_DP_paths_from_folder(
+            [self.lqL_folder, self.lqR_folder, self.gt_folder], ['lqL', 'lqR', 'gt'],
+            self.filename_tmpl)
+
+        if self.opt['phase'] == 'train':
+            self.geometric_augs = self.opt['geometric_augs']
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        scale = self.opt['scale']
+        index = index % len(self.paths)
+        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
+        # image range: [0, 1], float32.
+        gt_path = self.paths[index]['gt_path']
+        img_bytes = self.file_client.get(gt_path, 'gt')
+        try:
+            img_gt = imfrombytesDP(img_bytes, float32=True)
+        except:
+            raise Exception("gt path {} not working".format(gt_path))
+
+        lqL_path = self.paths[index]['lqL_path']
+        img_bytes = self.file_client.get(lqL_path, 'lqL')
+        try:
+            img_lqL = imfrombytesDP(img_bytes, float32=True)
+        except:
+            raise Exception("lqL path {} not working".format(lqL_path))
+
+        lqR_path = self.paths[index]['lqR_path']
+        img_bytes = self.file_client.get(lqR_path, 'lqR')
+        try:
+            img_lqR = imfrombytesDP(img_bytes, float32=True)
+        except:
+            raise Exception("lqR path {} not working".format(lqR_path))
+
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # padding
+            img_lqL, img_lqR, img_gt = padding_DP(img_lqL, img_lqR, img_gt, gt_size)
+
+            # random crop
+            img_lqL, img_lqR, img_gt = paired_random_crop_DP(img_lqL, img_lqR, img_gt, gt_size, scale, gt_path)
+            
+            # flip, rotation            
+            if self.geometric_augs:
+                img_lqL, img_lqR, img_gt = random_augmentation(img_lqL, img_lqR, img_gt)
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_lqL, img_lqR, img_gt = img2tensor([img_lqL, img_lqR, img_gt],
+                                    bgr2rgb=True,
+                                    float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lqL, self.mean, self.std, inplace=True)
+            normalize(img_lqR, self.mean, self.std, inplace=True)
+            normalize(img_gt, self.mean, self.std, inplace=True)
+
+        img_lq = torch.cat([img_lqL, img_lqR], 0)
+        
+        return {
+            'lq': img_lq,
+            'gt': img_gt,
+            'lq_path': lqL_path,
+            'gt_path': gt_path
+        }
+
+    def __len__(self):
+        return len(self.paths)

basicsr/data/prefetch_dataloader.py

@@ -0,0 +1,126 @@
+import queue as Queue
+import threading
+import torch
+from torch.utils.data import DataLoader
+
+
+class PrefetchGenerator(threading.Thread):
+    """A general prefetch generator.
+
+    Ref:
+    https://stackoverflow.com/questions/7323664/python-generator-pre-fetch
+
+    Args:
+        generator: Python generator.
+        num_prefetch_queue (int): Number of prefetch queue.
+    """
+
+    def __init__(self, generator, num_prefetch_queue):
+        threading.Thread.__init__(self)
+        self.queue = Queue.Queue(num_prefetch_queue)
+        self.generator = generator
+        self.daemon = True
+        self.start()
+
+    def run(self):
+        for item in self.generator:
+            self.queue.put(item)
+        self.queue.put(None)
+
+    def __next__(self):
+        next_item = self.queue.get()
+        if next_item is None:
+            raise StopIteration
+        return next_item
+
+    def __iter__(self):
+        return self
+
+
+class PrefetchDataLoader(DataLoader):
+    """Prefetch version of dataloader.
+
+    Ref:
+    https://github.com/IgorSusmelj/pytorch-styleguide/issues/5#
+
+    TODO:
+    Need to test on single gpu and ddp (multi-gpu). There is a known issue in
+    ddp.
+
+    Args:
+        num_prefetch_queue (int): Number of prefetch queue.
+        kwargs (dict): Other arguments for dataloader.
+    """
+
+    def __init__(self, num_prefetch_queue, **kwargs):
+        self.num_prefetch_queue = num_prefetch_queue
+        super(PrefetchDataLoader, self).__init__(**kwargs)
+
+    def __iter__(self):
+        return PrefetchGenerator(super().__iter__(), self.num_prefetch_queue)
+
+
+class CPUPrefetcher():
+    """CPU prefetcher.
+
+    Args:
+        loader: Dataloader.
+    """
+
+    def __init__(self, loader):
+        self.ori_loader = loader
+        self.loader = iter(loader)
+
+    def next(self):
+        try:
+            return next(self.loader)
+        except StopIteration:
+            return None
+
+    def reset(self):
+        self.loader = iter(self.ori_loader)
+
+
+class CUDAPrefetcher():
+    """CUDA prefetcher.
+
+    Ref:
+    https://github.com/NVIDIA/apex/issues/304#
+
+    It may consums more GPU memory.
+
+    Args:
+        loader: Dataloader.
+        opt (dict): Options.
+    """
+
+    def __init__(self, loader, opt):
+        self.ori_loader = loader
+        self.loader = iter(loader)
+        self.opt = opt
+        self.stream = torch.cuda.Stream()
+        self.device = torch.device('cuda' if opt['num_gpu'] != 0 else 'cpu')
+        self.preload()
+
+    def preload(self):
+        try:
+            self.batch = next(self.loader)  # self.batch is a dict
+        except StopIteration:
+            self.batch = None
+            return None
+        # put tensors to gpu
+        with torch.cuda.stream(self.stream):
+            for k, v in self.batch.items():
+                if torch.is_tensor(v):
+                    self.batch[k] = self.batch[k].to(
+                        device=self.device, non_blocking=True)
+
+    def next(self):
+        torch.cuda.current_stream().wait_stream(self.stream)
+        batch = self.batch
+        self.preload()
+        return batch
+
+    def reset(self):
+        self.loader = iter(self.ori_loader)
+        self.preload()

basicsr/data/single_image_dataset.py

@@ -0,0 +1,67 @@
+from os import path as osp
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.data_util import paths_from_lmdb
+from basicsr.utils import FileClient, imfrombytes, img2tensor, scandir
+
+
+class SingleImageDataset(data.Dataset):
+    """Read only lq images in the test phase.
+
+    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc).
+
+    There are two modes:
+    1. 'meta_info_file': Use meta information file to generate paths.
+    2. 'folder': Scan folders to generate paths.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_lq (str): Data root path for lq.
+            meta_info_file (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+    """
+
+    def __init__(self, opt):
+        super(SingleImageDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        self.mean = opt['mean'] if 'mean' in opt else None
+        self.std = opt['std'] if 'std' in opt else None
+        self.lq_folder = opt['dataroot_lq']
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = [self.lq_folder]
+            self.io_backend_opt['client_keys'] = ['lq']
+            self.paths = paths_from_lmdb(self.lq_folder)
+        elif 'meta_info_file' in self.opt:
+            with open(self.opt['meta_info_file'], 'r') as fin:
+                self.paths = [
+                    osp.join(self.lq_folder,
+                             line.split(' ')[0]) for line in fin
+                ]
+        else:
+            self.paths = sorted(list(scandir(self.lq_folder, full_path=True)))
+
+    def __getitem__(self, index):
+        if self.file_client is None:
+            self.file_client = FileClient(
+                self.io_backend_opt.pop('type'), **self.io_backend_opt)
+
+        # load lq image
+        lq_path = self.paths[index]
+        img_bytes = self.file_client.get(lq_path, 'lq')
+        img_lq = imfrombytes(img_bytes, float32=True)
+
+        # TODO: color space transform
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_lq = img2tensor(img_lq, bgr2rgb=True, float32=True)
+        # normalize
+        if self.mean is not None or self.std is not None:
+            normalize(img_lq, self.mean, self.std, inplace=True)
+        return {'lq': img_lq, 'lq_path': lq_path}
+
+    def __len__(self):
+        return len(self.paths)

basicsr/data/transforms.py

@@ -0,0 +1,275 @@
+import cv2
+import random
+import numpy as np
+
+def mod_crop(img, scale):
+    """Mod crop images, used during testing.
+
+    Args:
+        img (ndarray): Input image.
+        scale (int): Scale factor.
+
+    Returns:
+        ndarray: Result image.
+    """
+    img = img.copy()
+    if img.ndim in (2, 3):
+        h, w = img.shape[0], img.shape[1]
+        h_remainder, w_remainder = h % scale, w % scale
+        img = img[:h - h_remainder, :w - w_remainder, ...]
+    else:
+        raise ValueError(f'Wrong img ndim: {img.ndim}.')
+    return img
+
+def paired_random_crop(img_gts, img_lqs, lq_patch_size, scale, gt_path):
+    """Paired random crop.
+
+    It crops lists of lq and gt images with corresponding locations.
+
+    Args:
+        img_gts (list[ndarray] | ndarray): GT images. Note that all images
+            should have the same shape. If the input is an ndarray, it will
+            be transformed to a list containing itself.
+        img_lqs (list[ndarray] | ndarray): LQ images. Note that all images
+            should have the same shape. If the input is an ndarray, it will
+            be transformed to a list containing itself.
+        lq_patch_size (int): LQ patch size.
+        scale (int): Scale factor.
+        gt_path (str): Path to ground-truth.
+
+    Returns:
+        list[ndarray] | ndarray: GT images and LQ images. If returned results
+            only have one element, just return ndarray.
+    """
+
+    if not isinstance(img_gts, list):
+        img_gts = [img_gts]
+    if not isinstance(img_lqs, list):
+        img_lqs = [img_lqs]
+
+    h_lq, w_lq, _ = img_lqs[0].shape
+    h_gt, w_gt, _ = img_gts[0].shape
+    gt_patch_size = int(lq_patch_size * scale)
+
+    if h_gt != h_lq * scale or w_gt != w_lq * scale:
+        raise ValueError(
+            f'Scale mismatches. GT ({h_gt}, {w_gt}) is not {scale}x ',
+            f'multiplication of LQ ({h_lq}, {w_lq}).')
+    if h_lq < lq_patch_size or w_lq < lq_patch_size:
+        raise ValueError(f'LQ ({h_lq}, {w_lq}) is smaller than patch size '
+                         f'({lq_patch_size}, {lq_patch_size}). '
+                         f'Please remove {gt_path}.')
+
+    # randomly choose top and left coordinates for lq patch
+    top = random.randint(0, h_lq - lq_patch_size)
+    left = random.randint(0, w_lq - lq_patch_size)
+
+    # crop lq patch
+    img_lqs = [
+        v[top:top + lq_patch_size, left:left + lq_patch_size, ...]
+        for v in img_lqs
+    ]
+
+    # crop corresponding gt patch
+    top_gt, left_gt = int(top * scale), int(left * scale)
+    img_gts = [
+        v[top_gt:top_gt + gt_patch_size, left_gt:left_gt + gt_patch_size, ...]
+        for v in img_gts
+    ]
+    if len(img_gts) == 1:
+        img_gts = img_gts[0]
+    if len(img_lqs) == 1:
+        img_lqs = img_lqs[0]
+    return img_gts, img_lqs
+
+def paired_random_crop_DP(img_lqLs, img_lqRs, img_gts, gt_patch_size, scale, gt_path):
+    if not isinstance(img_gts, list):
+        img_gts = [img_gts]
+    if not isinstance(img_lqLs, list):
+        img_lqLs = [img_lqLs]
+    if not isinstance(img_lqRs, list):
+        img_lqRs = [img_lqRs]
+
+    h_lq, w_lq, _ = img_lqLs[0].shape
+    h_gt, w_gt, _ = img_gts[0].shape
+    lq_patch_size = gt_patch_size // scale
+
+    if h_gt != h_lq * scale or w_gt != w_lq * scale:
+        raise ValueError(
+            f'Scale mismatches. GT ({h_gt}, {w_gt}) is not {scale}x ',
+            f'multiplication of LQ ({h_lq}, {w_lq}).')
+    if h_lq < lq_patch_size or w_lq < lq_patch_size:
+        raise ValueError(f'LQ ({h_lq}, {w_lq}) is smaller than patch size '
+                         f'({lq_patch_size}, {lq_patch_size}). '
+                         f'Please remove {gt_path}.')
+
+    # randomly choose top and left coordinates for lq patch
+    top = random.randint(0, h_lq - lq_patch_size)
+    left = random.randint(0, w_lq - lq_patch_size)
+
+    # crop lq patch
+    img_lqLs = [
+        v[top:top + lq_patch_size, left:left + lq_patch_size, ...]
+        for v in img_lqLs
+    ]
+
+    img_lqRs = [
+        v[top:top + lq_patch_size, left:left + lq_patch_size, ...]
+        for v in img_lqRs
+    ]
+
+    # crop corresponding gt patch
+    top_gt, left_gt = int(top * scale), int(left * scale)
+    img_gts = [
+        v[top_gt:top_gt + gt_patch_size, left_gt:left_gt + gt_patch_size, ...]
+        for v in img_gts
+    ]
+    if len(img_gts) == 1:
+        img_gts = img_gts[0]
+    if len(img_lqLs) == 1:
+        img_lqLs = img_lqLs[0]
+    if len(img_lqRs) == 1:
+        img_lqRs = img_lqRs[0]
+    return img_lqLs, img_lqRs, img_gts
+
+
+def augment(imgs, hflip=True, rotation=True, flows=None, return_status=False):
+    """Augment: horizontal flips OR rotate (0, 90, 180, 270 degrees).
+
+    We use vertical flip and transpose for rotation implementation.
+    All the images in the list use the same augmentation.
+
+    Args:
+        imgs (list[ndarray] | ndarray): Images to be augmented. If the input
+            is an ndarray, it will be transformed to a list.
+        hflip (bool): Horizontal flip. Default: True.
+        rotation (bool): Ratotation. Default: True.
+        flows (list[ndarray]: Flows to be augmented. If the input is an
+            ndarray, it will be transformed to a list.
+            Dimension is (h, w, 2). Default: None.
+        return_status (bool): Return the status of flip and rotation.
+            Default: False.
+
+    Returns:
+        list[ndarray] | ndarray: Augmented images and flows. If returned
+            results only have one element, just return ndarray.
+
+    """
+    hflip = hflip and random.random() < 0.5
+    vflip = rotation and random.random() < 0.5
+    rot90 = rotation and random.random() < 0.5
+
+    def _augment(img):
+        if hflip:  # horizontal
+            cv2.flip(img, 1, img)
+        if vflip:  # vertical
+            cv2.flip(img, 0, img)
+        if rot90:
+            img = img.transpose(1, 0, 2)
+        return img
+
+    def _augment_flow(flow):
+        if hflip:  # horizontal
+            cv2.flip(flow, 1, flow)
+            flow[:, :, 0] *= -1
+        if vflip:  # vertical
+            cv2.flip(flow, 0, flow)
+            flow[:, :, 1] *= -1
+        if rot90:
+            flow = flow.transpose(1, 0, 2)
+            flow = flow[:, :, [1, 0]]
+        return flow
+
+    if not isinstance(imgs, list):
+        imgs = [imgs]
+    imgs = [_augment(img) for img in imgs]
+    if len(imgs) == 1:
+        imgs = imgs[0]
+
+    if flows is not None:
+        if not isinstance(flows, list):
+            flows = [flows]
+        flows = [_augment_flow(flow) for flow in flows]
+        if len(flows) == 1:
+            flows = flows[0]
+        return imgs, flows
+    else:
+        if return_status:
+            return imgs, (hflip, vflip, rot90)
+        else:
+            return imgs
+
+
+def img_rotate(img, angle, center=None, scale=1.0):
+    """Rotate image.
+
+    Args:
+        img (ndarray): Image to be rotated.
+        angle (float): Rotation angle in degrees. Positive values mean
+            counter-clockwise rotation.
+        center (tuple[int]): Rotation center. If the center is None,
+            initialize it as the center of the image. Default: None.
+        scale (float): Isotropic scale factor. Default: 1.0.
+    """
+    (h, w) = img.shape[:2]
+
+    if center is None:
+        center = (w // 2, h // 2)
+
+    matrix = cv2.getRotationMatrix2D(center, angle, scale)
+    rotated_img = cv2.warpAffine(img, matrix, (w, h))
+    return rotated_img
+
+def data_augmentation(image, mode):
+    """
+    Performs data augmentation of the input image
+    Input:
+        image: a cv2 (OpenCV) image
+        mode: int. Choice of transformation to apply to the image
+                0 - no transformation
+                1 - flip up and down
+                2 - rotate counterwise 90 degree
+                3 - rotate 90 degree and flip up and down
+                4 - rotate 180 degree
+                5 - rotate 180 degree and flip
+                6 - rotate 270 degree
+                7 - rotate 270 degree and flip
+    """
+    if mode == 0:
+        # original
+        out = image
+    elif mode == 1:
+        # flip up and down
+        out = np.flipud(image)
+    elif mode == 2:
+        # rotate counterwise 90 degree
+        out = np.rot90(image)
+    elif mode == 3:
+        # rotate 90 degree and flip up and down
+        out = np.rot90(image)
+        out = np.flipud(out)
+    elif mode == 4:
+        # rotate 180 degree
+        out = np.rot90(image, k=2)
+    elif mode == 5:
+        # rotate 180 degree and flip
+        out = np.rot90(image, k=2)
+        out = np.flipud(out)
+    elif mode == 6:
+        # rotate 270 degree
+        out = np.rot90(image, k=3)
+    elif mode == 7:
+        # rotate 270 degree and flip
+        out = np.rot90(image, k=3)
+        out = np.flipud(out)
+    else:
+        raise Exception('Invalid choice of image transformation')
+
+    return out
+
+def random_augmentation(*args):
+    out = []
+    flag_aug = random.randint(0,7)
+    for data in args:
+        out.append(data_augmentation(data, flag_aug).copy())
+    return out

basicsr/data/video_test_dataset.py

@@ -0,0 +1,325 @@
+import glob
+import torch
+from os import path as osp
+from torch.utils import data as data
+
+from basicsr.data.data_util import (duf_downsample, generate_frame_indices,
+                                    read_img_seq)
+from basicsr.utils import get_root_logger, scandir
+
+
+class VideoTestDataset(data.Dataset):
+    """Video test dataset.
+
+    Supported datasets: Vid4, REDS4, REDSofficial.
+    More generally, it supports testing dataset with following structures:
+
+    dataroot
+    ├── subfolder1
+        ├── frame000
+        ├── frame001
+        ├── ...
+    ├── subfolder1
+        ├── frame000
+        ├── frame001
+        ├── ...
+    ├── ...
+
+    For testing datasets, there is no need to prepare LMDB files.
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            io_backend (dict): IO backend type and other kwarg.
+            cache_data (bool): Whether to cache testing datasets.
+            name (str): Dataset name.
+            meta_info_file (str): The path to the file storing the list of test
+                folders. If not provided, all the folders in the dataroot will
+                be used.
+            num_frame (int): Window size for input frames.
+            padding (str): Padding mode.
+    """
+
+    def __init__(self, opt):
+        super(VideoTestDataset, self).__init__()
+        self.opt = opt
+        self.cache_data = opt['cache_data']
+        self.gt_root, self.lq_root = opt['dataroot_gt'], opt['dataroot_lq']
+        self.data_info = {
+            'lq_path': [],
+            'gt_path': [],
+            'folder': [],
+            'idx': [],
+            'border': []
+        }
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        assert self.io_backend_opt[
+            'type'] != 'lmdb', 'No need to use lmdb during validation/test.'
+
+        logger = get_root_logger()
+        logger.info(f'Generate data info for VideoTestDataset - {opt["name"]}')
+        self.imgs_lq, self.imgs_gt = {}, {}
+        if 'meta_info_file' in opt:
+            with open(opt['meta_info_file'], 'r') as fin:
+                subfolders = [line.split(' ')[0] for line in fin]
+                subfolders_lq = [
+                    osp.join(self.lq_root, key) for key in subfolders
+                ]
+                subfolders_gt = [
+                    osp.join(self.gt_root, key) for key in subfolders
+                ]
+        else:
+            subfolders_lq = sorted(glob.glob(osp.join(self.lq_root, '*')))
+            subfolders_gt = sorted(glob.glob(osp.join(self.gt_root, '*')))
+
+        if opt['name'].lower() in ['vid4', 'reds4', 'redsofficial']:
+            for subfolder_lq, subfolder_gt in zip(subfolders_lq,
+                                                  subfolders_gt):
+                # get frame list for lq and gt
+                subfolder_name = osp.basename(subfolder_lq)
+                img_paths_lq = sorted(
+                    list(scandir(subfolder_lq, full_path=True)))
+                img_paths_gt = sorted(
+                    list(scandir(subfolder_gt, full_path=True)))
+
+                max_idx = len(img_paths_lq)
+                assert max_idx == len(img_paths_gt), (
+                    f'Different number of images in lq ({max_idx})'
+                    f' and gt folders ({len(img_paths_gt)})')
+
+                self.data_info['lq_path'].extend(img_paths_lq)
+                self.data_info['gt_path'].extend(img_paths_gt)
+                self.data_info['folder'].extend([subfolder_name] * max_idx)
+                for i in range(max_idx):
+                    self.data_info['idx'].append(f'{i}/{max_idx}')
+                border_l = [0] * max_idx
+                for i in range(self.opt['num_frame'] // 2):
+                    border_l[i] = 1
+                    border_l[max_idx - i - 1] = 1
+                self.data_info['border'].extend(border_l)
+
+                # cache data or save the frame list
+                if self.cache_data:
+                    logger.info(
+                        f'Cache {subfolder_name} for VideoTestDataset...')
+                    self.imgs_lq[subfolder_name] = read_img_seq(img_paths_lq)
+                    self.imgs_gt[subfolder_name] = read_img_seq(img_paths_gt)
+                else:
+                    self.imgs_lq[subfolder_name] = img_paths_lq
+                    self.imgs_gt[subfolder_name] = img_paths_gt
+        else:
+            raise ValueError(
+                f'Non-supported video test dataset: {type(opt["name"])}')
+
+    def __getitem__(self, index):
+        folder = self.data_info['folder'][index]
+        idx, max_idx = self.data_info['idx'][index].split('/')
+        idx, max_idx = int(idx), int(max_idx)
+        border = self.data_info['border'][index]
+        lq_path = self.data_info['lq_path'][index]
+
+        select_idx = generate_frame_indices(
+            idx, max_idx, self.opt['num_frame'], padding=self.opt['padding'])
+
+        if self.cache_data:
+            imgs_lq = self.imgs_lq[folder].index_select(
+                0, torch.LongTensor(select_idx))
+            img_gt = self.imgs_gt[folder][idx]
+        else:
+            img_paths_lq = [self.imgs_lq[folder][i] for i in select_idx]
+            imgs_lq = read_img_seq(img_paths_lq)
+            img_gt = read_img_seq([self.imgs_gt[folder][idx]])
+            img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': folder,  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/99
+            'border': border,  # 1 for border, 0 for non-border
+            'lq_path': lq_path  # center frame
+        }
+
+    def __len__(self):
+        return len(self.data_info['gt_path'])
+
+
+class VideoTestVimeo90KDataset(data.Dataset):
+    """Video test dataset for Vimeo90k-Test dataset.
+
+    It only keeps the center frame for testing.
+    For testing datasets, there is no need to prepare LMDB files.
+
+    Args:
+        opt (dict): Config for train dataset. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            dataroot_lq (str): Data root path for lq.
+            io_backend (dict): IO backend type and other kwarg.
+            cache_data (bool): Whether to cache testing datasets.
+            name (str): Dataset name.
+            meta_info_file (str): The path to the file storing the list of test
+                folders. If not provided, all the folders in the dataroot will
+                be used.
+            num_frame (int): Window size for input frames.
+            padding (str): Padding mode.
+    """
+
+    def __init__(self, opt):
+        super(VideoTestVimeo90KDataset, self).__init__()
+        self.opt = opt
+        self.cache_data = opt['cache_data']
+        if self.cache_data:
+            raise NotImplementedError(
+                'cache_data in Vimeo90K-Test dataset is not implemented.')
+        self.gt_root, self.lq_root = opt['dataroot_gt'], opt['dataroot_lq']
+        self.data_info = {
+            'lq_path': [],
+            'gt_path': [],
+            'folder': [],
+            'idx': [],
+            'border': []
+        }
+        neighbor_list = [
+            i + (9 - opt['num_frame']) // 2 for i in range(opt['num_frame'])
+        ]
+
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+        assert self.io_backend_opt[
+            'type'] != 'lmdb', 'No need to use lmdb during validation/test.'
+
+        logger = get_root_logger()
+        logger.info(f'Generate data info for VideoTestDataset - {opt["name"]}')
+        with open(opt['meta_info_file'], 'r') as fin:
+            subfolders = [line.split(' ')[0] for line in fin]
+        for idx, subfolder in enumerate(subfolders):
+            gt_path = osp.join(self.gt_root, subfolder, 'im4.png')
+            self.data_info['gt_path'].append(gt_path)
+            lq_paths = [
+                osp.join(self.lq_root, subfolder, f'im{i}.png')
+                for i in neighbor_list
+            ]
+            self.data_info['lq_path'].append(lq_paths)
+            self.data_info['folder'].append('vimeo90k')
+            self.data_info['idx'].append(f'{idx}/{len(subfolders)}')
+            self.data_info['border'].append(0)
+
+    def __getitem__(self, index):
+        lq_path = self.data_info['lq_path'][index]
+        gt_path = self.data_info['gt_path'][index]
+        imgs_lq = read_img_seq(lq_path)
+        img_gt = read_img_seq([gt_path])
+        img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': self.data_info['folder'][index],  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/843
+            'border': self.data_info['border'][index],  # 0 for non-border
+            'lq_path': lq_path[self.opt['num_frame'] // 2]  # center frame
+        }
+
+    def __len__(self):
+        return len(self.data_info['gt_path'])
+
+
+class VideoTestDUFDataset(VideoTestDataset):
+    """ Video test dataset for DUF dataset.
+
+    Args:
+        opt (dict): Config for train dataset.
+            Most of keys are the same as VideoTestDataset.
+            It has the follwing extra keys:
+
+            use_duf_downsampling (bool): Whether to use duf downsampling to
+                generate low-resolution frames.
+            scale (bool): Scale, which will be added automatically.
+    """
+
+    def __getitem__(self, index):
+        folder = self.data_info['folder'][index]
+        idx, max_idx = self.data_info['idx'][index].split('/')
+        idx, max_idx = int(idx), int(max_idx)
+        border = self.data_info['border'][index]
+        lq_path = self.data_info['lq_path'][index]
+
+        select_idx = generate_frame_indices(
+            idx, max_idx, self.opt['num_frame'], padding=self.opt['padding'])
+
+        if self.cache_data:
+            if self.opt['use_duf_downsampling']:
+                # read imgs_gt to generate low-resolution frames
+                imgs_lq = self.imgs_gt[folder].index_select(
+                    0, torch.LongTensor(select_idx))
+                imgs_lq = duf_downsample(
+                    imgs_lq, kernel_size=13, scale=self.opt['scale'])
+            else:
+                imgs_lq = self.imgs_lq[folder].index_select(
+                    0, torch.LongTensor(select_idx))
+            img_gt = self.imgs_gt[folder][idx]
+        else:
+            if self.opt['use_duf_downsampling']:
+                img_paths_lq = [self.imgs_gt[folder][i] for i in select_idx]
+                # read imgs_gt to generate low-resolution frames
+                imgs_lq = read_img_seq(
+                    img_paths_lq,
+                    require_mod_crop=True,
+                    scale=self.opt['scale'])
+                imgs_lq = duf_downsample(
+                    imgs_lq, kernel_size=13, scale=self.opt['scale'])
+            else:
+                img_paths_lq = [self.imgs_lq[folder][i] for i in select_idx]
+                imgs_lq = read_img_seq(img_paths_lq)
+            img_gt = read_img_seq([self.imgs_gt[folder][idx]],
+                                  require_mod_crop=True,
+                                  scale=self.opt['scale'])
+            img_gt.squeeze_(0)
+
+        return {
+            'lq': imgs_lq,  # (t, c, h, w)
+            'gt': img_gt,  # (c, h, w)
+            'folder': folder,  # folder name
+            'idx': self.data_info['idx'][index],  # e.g., 0/99
+            'border': border,  # 1 for border, 0 for non-border
+            'lq_path': lq_path  # center frame
+        }
+
+
+class VideoRecurrentTestDataset(VideoTestDataset):
+    """Video test dataset for recurrent architectures, which takes LR video
+    frames as input and output corresponding HR video frames.
+
+    Args:
+        Same as VideoTestDataset.
+        Unused opt:
+            padding (str): Padding mode.
+
+    """
+
+    def __init__(self, opt):
+        super(VideoRecurrentTestDataset, self).__init__(opt)
+        # Find unique folder strings
+        self.folders = sorted(list(set(self.data_info['folder'])))
+
+    def __getitem__(self, index):
+        folder = self.folders[index]
+
+        if self.cache_data:
+            imgs_lq = self.imgs_lq[folder]
+            imgs_gt = self.imgs_gt[folder]
+        else:
+            raise NotImplementedError('Without cache_data is not implemented.')
+
+        return {
+            'lq': imgs_lq,
+            'gt': imgs_gt,
+            'folder': folder,
+        }
+
+    def __len__(self):
+        return len(self.folders)

basicsr/metrics/__init__.py

@@ -0,0 +1,4 @@
+from .niqe import calculate_niqe
+from .psnr_ssim import calculate_psnr, calculate_ssim
+
+__all__ = ['calculate_psnr', 'calculate_ssim', 'calculate_niqe']

basicsr/metrics/fid.py

@@ -0,0 +1,102 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from scipy import linalg
+from tqdm import tqdm
+
+from basicsr.models.archs.inception import InceptionV3
+
+
+def load_patched_inception_v3(device='cuda',
+                              resize_input=True,
+                              normalize_input=False):
+    # we may not resize the input, but in [rosinality/stylegan2-pytorch] it
+    # does resize the input.
+    inception = InceptionV3([3],
+                            resize_input=resize_input,
+                            normalize_input=normalize_input)
+    inception = nn.DataParallel(inception).eval().to(device)
+    return inception
+
+
+@torch.no_grad()
+def extract_inception_features(data_generator,
+                               inception,
+                               len_generator=None,
+                               device='cuda'):
+    """Extract inception features.
+
+    Args:
+        data_generator (generator): A data generator.
+        inception (nn.Module): Inception model.
+        len_generator (int): Length of the data_generator to show the
+            progressbar. Default: None.
+        device (str): Device. Default: cuda.
+
+    Returns:
+        Tensor: Extracted features.
+    """
+    if len_generator is not None:
+        pbar = tqdm(total=len_generator, unit='batch', desc='Extract')
+    else:
+        pbar = None
+    features = []
+
+    for data in data_generator:
+        if pbar:
+            pbar.update(1)
+        data = data.to(device)
+        feature = inception(data)[0].view(data.shape[0], -1)
+        features.append(feature.to('cpu'))
+    if pbar:
+        pbar.close()
+    features = torch.cat(features, 0)
+    return features
+
+
+def calculate_fid(mu1, sigma1, mu2, sigma2, eps=1e-6):
+    """Numpy implementation of the Frechet Distance.
+
+    The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)
+    and X_2 ~ N(mu_2, C_2) is
+        d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
+    Stable version by Dougal J. Sutherland.
+
+    Args:
+        mu1 (np.array): The sample mean over activations.
+        sigma1 (np.array): The covariance matrix over activations for
+            generated samples.
+        mu2 (np.array): The sample mean over activations, precalculated on an
+               representative data set.
+        sigma2 (np.array): The covariance matrix over activations,
+            precalculated on an representative data set.
+
+    Returns:
+        float: The Frechet Distance.
+    """
+    assert mu1.shape == mu2.shape, 'Two mean vectors have different lengths'
+    assert sigma1.shape == sigma2.shape, (
+        'Two covariances have different dimensions')
+
+    cov_sqrt, _ = linalg.sqrtm(sigma1 @ sigma2, disp=False)
+
+    # Product might be almost singular
+    if not np.isfinite(cov_sqrt).all():
+        print('Product of cov matrices is singular. Adding {eps} to diagonal '
+              'of cov estimates')
+        offset = np.eye(sigma1.shape[0]) * eps
+        cov_sqrt = linalg.sqrtm((sigma1 + offset) @ (sigma2 + offset))
+
+    # Numerical error might give slight imaginary component
+    if np.iscomplexobj(cov_sqrt):
+        if not np.allclose(np.diagonal(cov_sqrt).imag, 0, atol=1e-3):
+            m = np.max(np.abs(cov_sqrt.imag))
+            raise ValueError(f'Imaginary component {m}')
+        cov_sqrt = cov_sqrt.real
+
+    mean_diff = mu1 - mu2
+    mean_norm = mean_diff @ mean_diff
+    trace = np.trace(sigma1) + np.trace(sigma2) - 2 * np.trace(cov_sqrt)
+    fid = mean_norm + trace
+
+    return fid

basicsr/metrics/metric_util.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+from basicsr.utils.matlab_functions import bgr2ycbcr
+
+
+def reorder_image(img, input_order='HWC'):
+    """Reorder images to 'HWC' order.
+
+    If the input_order is (h, w), return (h, w, 1);
+    If the input_order is (c, h, w), return (h, w, c);
+    If the input_order is (h, w, c), return as it is.
+
+    Args:
+        img (ndarray): Input image.
+        input_order (str): Whether the input order is 'HWC' or 'CHW'.
+            If the input image shape is (h, w), input_order will not have
+            effects. Default: 'HWC'.
+
+    Returns:
+        ndarray: reordered image.
+    """
+
+    if input_order not in ['HWC', 'CHW']:
+        raise ValueError(
+            f'Wrong input_order {input_order}. Supported input_orders are '
+            "'HWC' and 'CHW'")
+    if len(img.shape) == 2:
+        img = img[..., None]
+    if input_order == 'CHW':
+        img = img.transpose(1, 2, 0)
+    return img
+
+
+def to_y_channel(img):
+    """Change to Y channel of YCbCr.
+
+    Args:
+        img (ndarray): Images with range [0, 255].
+
+    Returns:
+        (ndarray): Images with range [0, 255] (float type) without round.
+    """
+    img = img.astype(np.float32) / 255.
+    if img.ndim == 3 and img.shape[2] == 3:
+        img = bgr2ycbcr(img, y_only=True)
+        img = img[..., None]
+    return img * 255.

basicsr/metrics/niqe.py

@@ -0,0 +1,205 @@
+import cv2
+import math
+import numpy as np
+from scipy.ndimage.filters import convolve
+from scipy.special import gamma
+
+from basicsr.metrics.metric_util import reorder_image, to_y_channel
+
+
+def estimate_aggd_param(block):
+    """Estimate AGGD (Asymmetric Generalized Gaussian Distribution) paramters.
+
+    Args:
+        block (ndarray): 2D Image block.
+
+    Returns:
+        tuple: alpha (float), beta_l (float) and beta_r (float) for the AGGD
+            distribution (Estimating the parames in Equation 7 in the paper).
+    """
+    block = block.flatten()
+    gam = np.arange(0.2, 10.001, 0.001)  # len = 9801
+    gam_reciprocal = np.reciprocal(gam)
+    r_gam = np.square(gamma(gam_reciprocal * 2)) / (
+        gamma(gam_reciprocal) * gamma(gam_reciprocal * 3))
+
+    left_std = np.sqrt(np.mean(block[block < 0]**2))
+    right_std = np.sqrt(np.mean(block[block > 0]**2))
+    gammahat = left_std / right_std
+    rhat = (np.mean(np.abs(block)))**2 / np.mean(block**2)
+    rhatnorm = (rhat * (gammahat**3 + 1) *
+                (gammahat + 1)) / ((gammahat**2 + 1)**2)
+    array_position = np.argmin((r_gam - rhatnorm)**2)
+
+    alpha = gam[array_position]
+    beta_l = left_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    beta_r = right_std * np.sqrt(gamma(1 / alpha) / gamma(3 / alpha))
+    return (alpha, beta_l, beta_r)
+
+
+def compute_feature(block):
+    """Compute features.
+
+    Args:
+        block (ndarray): 2D Image block.
+
+    Returns:
+        list: Features with length of 18.
+    """
+    feat = []
+    alpha, beta_l, beta_r = estimate_aggd_param(block)
+    feat.extend([alpha, (beta_l + beta_r) / 2])
+
+    # distortions disturb the fairly regular structure of natural images.
+    # This deviation can be captured by analyzing the sample distribution of
+    # the products of pairs of adjacent coefficients computed along
+    # horizontal, vertical and diagonal orientations.
+    shifts = [[0, 1], [1, 0], [1, 1], [1, -1]]
+    for i in range(len(shifts)):
+        shifted_block = np.roll(block, shifts[i], axis=(0, 1))
+        alpha, beta_l, beta_r = estimate_aggd_param(block * shifted_block)
+        # Eq. 8
+        mean = (beta_r - beta_l) * (gamma(2 / alpha) / gamma(1 / alpha))
+        feat.extend([alpha, mean, beta_l, beta_r])
+    return feat
+
+
+def niqe(img,
+         mu_pris_param,
+         cov_pris_param,
+         gaussian_window,
+         block_size_h=96,
+         block_size_w=96):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+
+    Ref: Making a "Completely Blind" Image Quality Analyzer.
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+
+    Note that we do not include block overlap height and width, since they are
+    always 0 in the official implementation.
+
+    For good performance, it is advisable by the official implemtation to
+    divide the distorted image in to the same size patched as used for the
+    construction of multivariate Gaussian model.
+
+    Args:
+        img (ndarray): Input image whose quality needs to be computed. The
+            image must be a gray or Y (of YCbCr) image with shape (h, w).
+            Range [0, 255] with float type.
+        mu_pris_param (ndarray): Mean of a pre-defined multivariate Gaussian
+            model calculated on the pristine dataset.
+        cov_pris_param (ndarray): Covariance of a pre-defined multivariate
+            Gaussian model calculated on the pristine dataset.
+        gaussian_window (ndarray): A 7x7 Gaussian window used for smoothing the
+            image.
+        block_size_h (int): Height of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+        block_size_w (int): Width of the blocks in to which image is divided.
+            Default: 96 (the official recommended value).
+    """
+    assert img.ndim == 2, (
+        'Input image must be a gray or Y (of YCbCr) image with shape (h, w).')
+    # crop image
+    h, w = img.shape
+    num_block_h = math.floor(h / block_size_h)
+    num_block_w = math.floor(w / block_size_w)
+    img = img[0:num_block_h * block_size_h, 0:num_block_w * block_size_w]
+
+    distparam = []  # dist param is actually the multiscale features
+    for scale in (1, 2):  # perform on two scales (1, 2)
+        mu = convolve(img, gaussian_window, mode='nearest')
+        sigma = np.sqrt(
+            np.abs(
+                convolve(np.square(img), gaussian_window, mode='nearest') -
+                np.square(mu)))
+        # normalize, as in Eq. 1 in the paper
+        img_nomalized = (img - mu) / (sigma + 1)
+
+        feat = []
+        for idx_w in range(num_block_w):
+            for idx_h in range(num_block_h):
+                # process ecah block
+                block = img_nomalized[idx_h * block_size_h //
+                                      scale:(idx_h + 1) * block_size_h //
+                                      scale, idx_w * block_size_w //
+                                      scale:(idx_w + 1) * block_size_w //
+                                      scale]
+                feat.append(compute_feature(block))
+
+        distparam.append(np.array(feat))
+        # TODO: matlab bicubic downsample with anti-aliasing
+        # for simplicity, now we use opencv instead, which will result in
+        # a slight difference.
+        if scale == 1:
+            h, w = img.shape
+            img = cv2.resize(
+                img / 255., (w // 2, h // 2), interpolation=cv2.INTER_LINEAR)
+            img = img * 255.
+
+    distparam = np.concatenate(distparam, axis=1)
+
+    # fit a MVG (multivariate Gaussian) model to distorted patch features
+    mu_distparam = np.nanmean(distparam, axis=0)
+    # use nancov. ref: https://ww2.mathworks.cn/help/stats/nancov.html
+    distparam_no_nan = distparam[~np.isnan(distparam).any(axis=1)]
+    cov_distparam = np.cov(distparam_no_nan, rowvar=False)
+
+    # compute niqe quality, Eq. 10 in the paper
+    invcov_param = np.linalg.pinv((cov_pris_param + cov_distparam) / 2)
+    quality = np.matmul(
+        np.matmul((mu_pris_param - mu_distparam), invcov_param),
+        np.transpose((mu_pris_param - mu_distparam)))
+    quality = np.sqrt(quality)
+
+    return quality
+
+
+def calculate_niqe(img, crop_border, input_order='HWC', convert_to='y'):
+    """Calculate NIQE (Natural Image Quality Evaluator) metric.
+
+    Ref: Making a "Completely Blind" Image Quality Analyzer.
+    This implementation could produce almost the same results as the official
+    MATLAB codes: http://live.ece.utexas.edu/research/quality/niqe_release.zip
+
+    We use the official params estimated from the pristine dataset.
+    We use the recommended block size (96, 96) without overlaps.
+
+    Args:
+        img (ndarray): Input image whose quality needs to be computed.
+            The input image must be in range [0, 255] with float/int type.
+            The input_order of image can be 'HW' or 'HWC' or 'CHW'. (BGR order)
+            If the input order is 'HWC' or 'CHW', it will be converted to gray
+            or Y (of YCbCr) image according to the ``convert_to`` argument.
+        crop_border (int): Cropped pixels in each edge of an image. These
+            pixels are not involved in the metric calculation.
+        input_order (str): Whether the input order is 'HW', 'HWC' or 'CHW'.
+            Default: 'HWC'.
+        convert_to (str): Whether coverted to 'y' (of MATLAB YCbCr) or 'gray'.
+            Default: 'y'.
+
+    Returns:
+        float: NIQE result.
+    """
+
+    # we use the official params estimated from the pristine dataset.
+    niqe_pris_params = np.load('basicsr/metrics/niqe_pris_params.npz')
+    mu_pris_param = niqe_pris_params['mu_pris_param']
+    cov_pris_param = niqe_pris_params['cov_pris_param']
+    gaussian_window = niqe_pris_params['gaussian_window']
+
+    img = img.astype(np.float32)
+    if input_order != 'HW':
+        img = reorder_image(img, input_order=input_order)
+        if convert_to == 'y':
+            img = to_y_channel(img)
+        elif convert_to == 'gray':
+            img = cv2.cvtColor(img / 255., cv2.COLOR_BGR2GRAY) * 255.
+        img = np.squeeze(img)
+
+    if crop_border != 0:
+        img = img[crop_border:-crop_border, crop_border:-crop_border]
+
+    niqe_result = niqe(img, mu_pris_param, cov_pris_param, gaussian_window)
+
+    return niqe_result

basicsr/metrics/psnr_ssim.py

@@ -0,0 +1,303 @@
+import cv2
+import numpy as np
+
+from basicsr.metrics.metric_util import reorder_image, to_y_channel
+import skimage.metrics
+import torch
+
+
+def calculate_psnr(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False):
+    """Calculate PSNR (Peak Signal-to-Noise Ratio).
+
+    Ref: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
+
+    Args:
+        img1 (ndarray/tensor): Images with range [0, 255]/[0, 1].
+        img2 (ndarray/tensor): Images with range [0, 255]/[0, 1].
+        crop_border (int): Cropped pixels in each edge of an image. These
+            pixels are not involved in the PSNR calculation.
+        input_order (str): Whether the input order is 'HWC' or 'CHW'.
+            Default: 'HWC'.
+        test_y_channel (bool): Test on Y channel of YCbCr. Default: False.
+
+    Returns:
+        float: psnr result.
+    """
+
+    assert img1.shape == img2.shape, (
+        f'Image shapes are differnet: {img1.shape}, {img2.shape}.')
+    if input_order not in ['HWC', 'CHW']:
+        raise ValueError(
+            f'Wrong input_order {input_order}. Supported input_orders are '
+            '"HWC" and "CHW"')
+    if type(img1) == torch.Tensor:
+        if len(img1.shape) == 4:
+            img1 = img1.squeeze(0)
+        img1 = img1.detach().cpu().numpy().transpose(1,2,0)
+    if type(img2) == torch.Tensor:
+        if len(img2.shape) == 4:
+            img2 = img2.squeeze(0)
+        img2 = img2.detach().cpu().numpy().transpose(1,2,0)
+        
+    img1 = reorder_image(img1, input_order=input_order)
+    img2 = reorder_image(img2, input_order=input_order)
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    if crop_border != 0:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+    if test_y_channel:
+        img1 = to_y_channel(img1)
+        img2 = to_y_channel(img2)
+
+    mse = np.mean((img1 - img2)**2)
+    if mse == 0:
+        return float('inf')
+    max_value = 1. if img1.max() <= 1 else 255.
+    return 20. * np.log10(max_value / np.sqrt(mse))
+
+
+def _ssim(img1, img2):
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (ndarray): Images with range [0, 255] with order 'HWC'.
+        img2 (ndarray): Images with range [0, 255] with order 'HWC'.
+
+    Returns:
+        float: ssim result.
+    """
+
+    C1 = (0.01 * 255)**2
+    C2 = (0.03 * 255)**2
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+
+    mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]
+    mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) *
+                (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                       (sigma1_sq + sigma2_sq + C2))
+    return ssim_map.mean()
+
+def prepare_for_ssim(img, k):
+    import torch
+    with torch.no_grad():
+        img = torch.from_numpy(img).unsqueeze(0).unsqueeze(0).float()
+        conv = torch.nn.Conv2d(1, 1, k, stride=1, padding=k//2, padding_mode='reflect')
+        conv.weight.requires_grad = False
+        conv.weight[:, :, :, :] = 1. / (k * k)
+
+        img = conv(img)
+
+        img = img.squeeze(0).squeeze(0)
+        img = img[0::k, 0::k]
+    return img.detach().cpu().numpy()
+
+def prepare_for_ssim_rgb(img, k):
+    import torch
+    with torch.no_grad():
+        img = torch.from_numpy(img).float() #HxWx3
+
+        conv = torch.nn.Conv2d(1, 1, k, stride=1, padding=k // 2, padding_mode='reflect')
+        conv.weight.requires_grad = False
+        conv.weight[:, :, :, :] = 1. / (k * k)
+
+        new_img = []
+
+        for i in range(3):
+            new_img.append(conv(img[:, :, i].unsqueeze(0).unsqueeze(0)).squeeze(0).squeeze(0)[0::k, 0::k])
+
+    return torch.stack(new_img, dim=2).detach().cpu().numpy()
+
+def _3d_gaussian_calculator(img, conv3d):
+    out = conv3d(img.unsqueeze(0).unsqueeze(0)).squeeze(0).squeeze(0)
+    return out
+
+def _generate_3d_gaussian_kernel():
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    window = np.outer(kernel, kernel.transpose())
+    kernel_3 = cv2.getGaussianKernel(11, 1.5)
+    kernel = torch.tensor(np.stack([window * k for k in kernel_3], axis=0))
+    conv3d = torch.nn.Conv3d(1, 1, (11, 11, 11), stride=1, padding=(5, 5, 5), bias=False, padding_mode='replicate')
+    conv3d.weight.requires_grad = False
+    conv3d.weight[0, 0, :, :, :] = kernel
+    return conv3d
+
+def _ssim_3d(img1, img2, max_value):
+    assert len(img1.shape) == 3 and len(img2.shape) == 3
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (ndarray): Images with range [0, 255]/[0, 1] with order 'HWC'.
+        img2 (ndarray): Images with range [0, 255]/[0, 1] with order 'HWC'.
+
+    Returns:
+        float: ssim result.
+    """
+    C1 = (0.01 * max_value) ** 2
+    C2 = (0.03 * max_value) ** 2
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    kernel = _generate_3d_gaussian_kernel().cuda()
+
+    img1 = torch.tensor(img1).float().cuda()
+    img2 = torch.tensor(img2).float().cuda()
+
+
+    mu1 = _3d_gaussian_calculator(img1, kernel)
+    mu2 = _3d_gaussian_calculator(img2, kernel)
+
+    mu1_sq = mu1 ** 2
+    mu2_sq = mu2 ** 2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = _3d_gaussian_calculator(img1 ** 2, kernel) - mu1_sq
+    sigma2_sq = _3d_gaussian_calculator(img2 ** 2, kernel) - mu2_sq
+    sigma12 = _3d_gaussian_calculator(img1*img2, kernel) - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) *
+                (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                       (sigma1_sq + sigma2_sq + C2))
+    return float(ssim_map.mean())
+
+def _ssim_cly(img1, img2):
+    assert len(img1.shape) == 2 and len(img2.shape) == 2
+    """Calculate SSIM (structural similarity) for one channel images.
+
+    It is called by func:`calculate_ssim`.
+
+    Args:
+        img1 (ndarray): Images with range [0, 255] with order 'HWC'.
+        img2 (ndarray): Images with range [0, 255] with order 'HWC'.
+
+    Returns:
+        float: ssim result.
+    """
+
+    C1 = (0.01 * 255)**2
+    C2 = (0.03 * 255)**2
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    kernel = cv2.getGaussianKernel(11, 1.5)
+    # print(kernel)
+    window = np.outer(kernel, kernel.transpose())
+
+    bt = cv2.BORDER_REPLICATE
+
+    mu1 = cv2.filter2D(img1, -1, window, borderType=bt)
+    mu2 = cv2.filter2D(img2, -1, window,borderType=bt)
+
+    mu1_sq = mu1**2
+    mu2_sq = mu2**2
+    mu1_mu2 = mu1 * mu2
+    sigma1_sq = cv2.filter2D(img1**2, -1, window, borderType=bt) - mu1_sq
+    sigma2_sq = cv2.filter2D(img2**2, -1, window, borderType=bt) - mu2_sq
+    sigma12 = cv2.filter2D(img1 * img2, -1, window, borderType=bt) - mu1_mu2
+
+    ssim_map = ((2 * mu1_mu2 + C1) *
+                (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
+                                       (sigma1_sq + sigma2_sq + C2))
+    return ssim_map.mean()
+
+
+def calculate_ssim(img1,
+                   img2,
+                   crop_border,
+                   input_order='HWC',
+                   test_y_channel=False):
+    """Calculate SSIM (structural similarity).
+
+    Ref:
+    Image quality assessment: From error visibility to structural similarity
+
+    The results are the same as that of the official released MATLAB code in
+    https://ece.uwaterloo.ca/~z70wang/research/ssim/.
+
+    For three-channel images, SSIM is calculated for each channel and then
+    averaged.
+
+    Args:
+        img1 (ndarray): Images with range [0, 255].
+        img2 (ndarray): Images with range [0, 255].
+        crop_border (int): Cropped pixels in each edge of an image. These
+            pixels are not involved in the SSIM calculation.
+        input_order (str): Whether the input order is 'HWC' or 'CHW'.
+            Default: 'HWC'.
+        test_y_channel (bool): Test on Y channel of YCbCr. Default: False.
+
+    Returns:
+        float: ssim result.
+    """
+
+    assert img1.shape == img2.shape, (
+        f'Image shapes are differnet: {img1.shape}, {img2.shape}.')
+    if input_order not in ['HWC', 'CHW']:
+        raise ValueError(
+            f'Wrong input_order {input_order}. Supported input_orders are '
+            '"HWC" and "CHW"')
+
+    if type(img1) == torch.Tensor:
+        if len(img1.shape) == 4:
+            img1 = img1.squeeze(0)
+        img1 = img1.detach().cpu().numpy().transpose(1,2,0)
+    if type(img2) == torch.Tensor:
+        if len(img2.shape) == 4:
+            img2 = img2.squeeze(0)
+        img2 = img2.detach().cpu().numpy().transpose(1,2,0)
+
+    img1 = reorder_image(img1, input_order=input_order)
+    img2 = reorder_image(img2, input_order=input_order)
+
+    img1 = img1.astype(np.float64)
+    img2 = img2.astype(np.float64)
+
+    if crop_border != 0:
+        img1 = img1[crop_border:-crop_border, crop_border:-crop_border, ...]
+        img2 = img2[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+    if test_y_channel:
+        img1 = to_y_channel(img1)
+        img2 = to_y_channel(img2)
+        return _ssim_cly(img1[..., 0], img2[..., 0])
+
+
+    ssims = []
+    # ssims_before = []
+
+    # skimage_before = skimage.metrics.structural_similarity(img1, img2, data_range=255., multichannel=True)
+    # print('.._skimage',
+    #       skimage.metrics.structural_similarity(img1, img2, data_range=255., multichannel=True))
+    max_value = 1 if img1.max() <= 1 else 255
+    with torch.no_grad():
+        final_ssim = _ssim_3d(img1, img2, max_value)
+        ssims.append(final_ssim)
+
+    # for i in range(img1.shape[2]):
+    #     ssims_before.append(_ssim(img1, img2))
+
+    # print('..ssim mean , new {:.4f}  and before {:.4f} .... skimage before {:.4f}'.format(np.array(ssims).mean(), np.array(ssims_before).mean(), skimage_before))
+        # ssims.append(skimage.metrics.structural_similarity(img1[..., i], img2[..., i], multichannel=False))
+
+    return np.array(ssims).mean()

basicsr/models/__init__.py

@@ -0,0 +1,42 @@
+import importlib
+from os import path as osp
+
+from basicsr.utils import get_root_logger, scandir
+
+# automatically scan and import model modules
+# scan all the files under the 'models' folder and collect files ending with
+# '_model.py'
+model_folder = osp.dirname(osp.abspath(__file__))
+model_filenames = [
+    osp.splitext(osp.basename(v))[0] for v in scandir(model_folder)
+    if v.endswith('_model.py')
+]
+# import all the model modules
+_model_modules = [
+    importlib.import_module(f'basicsr.models.{file_name}')
+    for file_name in model_filenames
+]
+
+
+def create_model(opt):
+    """Create model.
+
+    Args:
+        opt (dict): Configuration. It constains:
+            model_type (str): Model type.
+    """
+    model_type = opt['model_type']
+
+    # dynamic instantiation
+    for module in _model_modules:
+        model_cls = getattr(module, model_type, None)
+        if model_cls is not None:
+            break
+    if model_cls is None:
+        raise ValueError(f'Model {model_type} is not found.')
+
+    model = model_cls(opt)
+
+    logger = get_root_logger()
+    logger.info(f'Model [{model.__class__.__name__}] is created.')
+    return model