first commit

LICENSE

@@ -0,0 +1,35 @@
+S-Lab License 1.0
+
+Copyright 2024 S-Lab
+
+Redistribution and use for non-commercial purpose in source and 
+binary forms, with or without modification, are permitted provided 
+that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in 
+   the documentation and/or other materials provided with the 
+   distribution.
+
+3. Neither the name of the copyright holder nor the names of its 
+   contributors may be used to endorse or promote products derived 
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+In the event that redistribution and/or use for commercial purpose in 
+source or binary forms, with or without modification is required, 
+please contact the contributor(s) of the work.

README.md

@@ -5,6 +5,9 @@ colorFrom: green
 colorTo: purple
 sdk: gradio
 sdk_version: 5.8.0
+python_version: 3.10
+suggested_storage: small
+models: OAOA/InvSR
 app_file: app.py
 pinned: false
 license: other

app.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+# Power by Zongsheng Yue 2024-12-11 17:17:41
+
+import spaces
+import warnings
+warnings.filterwarnings("ignore")
+
+import argparse
+import numpy as np
+import gradio as gr
+from pathlib import Path
+from omegaconf import OmegaConf
+from sampler_invsr import InvSamplerSR
+
+from utils import util_common
+from utils import util_image
+from basicsr.utils.download_util import load_file_from_url
+
+def get_configs(num_steps=1, chopping_size=128, seed=12345):
+    configs = OmegaConf.load("./configs/sample-sd-turbo.yaml")
+
+    if num_steps == 1:
+        configs.timesteps = [200,]
+    elif num_steps == 2:
+        configs.timesteps = [200, 100]
+    elif num_steps == 3:
+        configs.timesteps = [200, 100, 50]
+    elif num_steps == 4:
+        configs.timesteps = [200, 150, 100, 50]
+    elif num_steps == 5:
+        configs.timesteps = [250, 200, 150, 100, 50]
+    else:
+        assert num_steps <= 250
+        configs.timesteps = np.linspace(
+            start=250, stop=0, num=num_steps, endpoint=False, dtype=np.int64()
+        ).tolist()
+    print(f'Setting timesteps for inference: {configs.timesteps}')
+
+    # path to save noise predictor
+    started_ckpt_path = "noise_predictor_sd_turbo_v5.pth"
+    # started_ckpt_dir = "./weights"
+    # util_common.mkdir(started_ckpt_dir, delete=False, parents=True)
+    # started_ckpt_path = Path(started_ckpt_dir) / started_ckpt_name
+    # if not started_ckpt_path.exists():
+        # load_file_from_url(
+            # url="https://huggingface.co/OAOA/InvSR/resolve/main/noise_predictor_sd_turbo_v5.pth",
+            # model_dir=started_ckpt_dir,
+            # progress=True,
+            # file_name=started_ckpt_name,
+        # )
+    configs.model_start.ckpt_path = started_ckpt_path
+
+    configs.bs = 1
+    configs.seed = 12345
+    configs.basesr.chopping.pch_size = chopping_size
+
+    return configs
+
+@spaces.GPU
+def predict(in_path, num_steps=1, chopping_size=128, seed=12345):
+    configs = get_configs(num_steps=num_steps, chopping_size=chopping_size, seed=12345)
+
+    sampler = InvSamplerSR(configs)
+
+    out_dir = Path('invsr_output')
+    if not out_dir.exists():
+        out_dir.mkdir()
+    sampler.inference(in_path, out_path=out_dir, bs=1)
+
+    out_path = out_dir / f"{Path(in_path).stem}.png"
+    assert out_path.exists(), 'Super-resolution failed!'
+    im_sr = util_image.imread(out_path, chn="rgb", dtype="uint8")
+
+    return im_sr, str(out_path)
+
+title = "Arbitrary-steps Image Super-resolution via Diffusion Inversion"
+description = r"""
+<b>Official Gradio demo</b> for <a href='https://github.com/zsyOAOA/InvSR' target='_blank'><b>Arbitrary-steps Image Super-resolution via Diffuion Inversion</b></a>.<br>
+🔥 InvSR is an image super-resolution method via Diffusion Inversion, supporting arbitrary sampling steps.<br>
+"""
+article = r"""
+If you've found InvSR useful for your research or projects, please show your support by ⭐ the <a href='https://github.com/zsyOAOA/InvSR' target='_blank'>Github Repo</a>. Thanks!
+[![GitHub Stars](https://img.shields.io/github/stars/zsyOAOA/InvSR?affiliations=OWNER&color=green&style=social)](https://github.com/zsyOAOA/InvSR)
+
+---
+If our work is useful for your research, please consider citing:
+```bibtex
+@article{yue2024InvSR,
+  title={Arbitrary-steps Image Super-resolution via Diffusion Inversion},
+  author={Yue, Zongsheng and Kang, Liao and Loy, Chen Change},
+  journal = {arXiv preprint arXiv:2412.09013},
+  year={2024},
+}
+```
+
+📋 **License**
+
+This project is licensed under <a rel="license" href="https://github.com/zsyOAOA/InvSR/blob/master/LICENSE">S-Lab License 1.0</a>.
+Redistribution and use for non-commercial purposes should follow this license.
+
+📧 **Contact**
+
+If you have any questions, please feel free to contact me via <b>[email protected]</b>.
+![visitors](https://visitor-badge.laobi.icu/badge?page_id=zsyOAOA/InvSR)
+"""
+demo = gr.Interface(
+    fn=predict,
+    inputs=[
+        gr.Image(type="filepath", label="Input: Low Quality Image"),
+        gr.Dropdown(
+            choices=[1,2,3,4,5],
+            value=1,
+            label="Number of steps",
+            ),
+        gr.Dropdown(
+            choices=[128, 256],
+            value=128,
+            label="Chopping size",
+            ),
+        gr.Number(value=12345, precision=0, label="Ranom seed")
+    ],
+    outputs=[
+        gr.Image(type="numpy", label="Output: High Quality Image"),
+        gr.File(label="Download the output")
+    ],
+    title=title,
+    description=description,
+    article=article,
+    examples=[
+        ['./testdata/RealSet80/29.jpg',  3, 128, 12345],
+        ['./testdata/RealSet80/32.jpg',  1, 128, 12345],
+        ['./testdata/RealSet80/0030.jpg',  1, 128, 12345],
+        ['./testdata/RealSet80/2684538-PH.jpg', 1, 128, 12345],
+        ['./testdata/RealSet80/oldphoto6.png', 1, 128, 12345],
+      ]
+    )
+
+demo.queue(max_size=5)
+demo.launch(share=True)
+

basicsr/__init__.py

@@ -0,0 +1,4 @@
+# https://github.com/xinntao/BasicSR
+# flake8: noqa
+from .data import *
+from .utils import *

basicsr/data/__init__.py

@@ -0,0 +1,101 @@
+import importlib
+import numpy as np
+import random
+import torch
+import torch.utils.data
+from copy import deepcopy
+from functools import partial
+from os import path as osp
+
+from basicsr.data.prefetch_dataloader import PrefetchDataLoader
+from basicsr.utils import get_root_logger, scandir
+from basicsr.utils.dist_util import get_dist_info
+from basicsr.utils.registry import DATASET_REGISTRY
+
+__all__ = ['build_dataset', 'build_dataloader']
+
+# automatically scan and import dataset modules for registry
+# 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'basicsr.data.{file_name}') for file_name in dataset_filenames]
+
+
+def build_dataset(dataset_opt):
+    """Build dataset from options.
+
+    Args:
+        dataset_opt (dict): Configuration for dataset. It must contain:
+            name (str): Dataset name.
+            type (str): Dataset type.
+    """
+    dataset_opt = deepcopy(dataset_opt)
+    dataset = DATASET_REGISTRY.get(dataset_opt['type'])(dataset_opt)
+    logger = get_root_logger()
+    logger.info(f'Dataset [{dataset.__class__.__name__}] - {dataset_opt["name"]} is built.')
+    return dataset
+
+
+def build_dataloader(dataset, dataset_opt, num_gpu=1, dist=False, sampler=None, seed=None):
+    """Build 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)
+    dataloader_args['persistent_workers'] = dataset_opt.get('persistent_workers', 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: 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,48 @@
+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,315 @@
+import cv2
+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, return_imgname=False):
+    """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.
+        return_imgname(bool): Whether return image names. Default False.
+
+    Returns:
+        Tensor: size (t, c, h, w), RGB, [0, 1].
+        list[str]: Returned image name list.
+    """
+    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)
+
+    if return_imgname:
+        imgnames = [osp.splitext(osp.basename(path))[0] for path in img_paths]
+        return imgs, imgnames
+    else:
+        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, f'The len of keys should be 2 with [input_key, gt_key]. 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, f'The len of keys should be 2 with [input_key, gt_key]. 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.strip().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, f'The len of keys should be 2 with [input_key, gt_key]. 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 gt_path in gt_paths:
+        basename, ext = osp.splitext(osp.basename(gt_path))
+        input_name = f'{filename_tmpl.format(basename)}{ext}'
+        input_path = osp.join(input_folder, input_name)
+        assert input_name in input_paths, f'{input_name} is not in {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 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/degradations.py

@@ -0,0 +1,765 @@
+import cv2
+import math
+import numpy as np
+import random
+import torch
+from scipy import special
+from scipy.stats import multivariate_normal
+# from torchvision.transforms.functional_tensor import rgb_to_grayscale
+from torchvision.transforms.functional import rgb_to_grayscale
+
+# -------------------------------------------------------------------- #
+# --------------------------- blur kernels --------------------------- #
+# -------------------------------------------------------------------- #
+
+
+# --------------------------- util functions --------------------------- #
+def sigma_matrix2(sig_x, sig_y, theta):
+    """Calculate the rotated sigma matrix (two dimensional matrix).
+
+    Args:
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+
+    Returns:
+        ndarray: Rotated sigma matrix.
+    """
+    d_matrix = np.array([[sig_x**2, 0], [0, sig_y**2]])
+    u_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+    return np.dot(u_matrix, np.dot(d_matrix, u_matrix.T))
+
+
+def mesh_grid(kernel_size):
+    """Generate the mesh grid, centering at zero.
+
+    Args:
+        kernel_size (int):
+
+    Returns:
+        xy (ndarray): with the shape (kernel_size, kernel_size, 2)
+        xx (ndarray): with the shape (kernel_size, kernel_size)
+        yy (ndarray): with the shape (kernel_size, kernel_size)
+    """
+    ax = np.arange(-kernel_size // 2 + 1., kernel_size // 2 + 1.)
+    xx, yy = np.meshgrid(ax, ax)
+    xy = np.hstack((xx.reshape((kernel_size * kernel_size, 1)), yy.reshape(kernel_size * kernel_size,
+                                                                           1))).reshape(kernel_size, kernel_size, 2)
+    return xy, xx, yy
+
+
+def pdf2(sigma_matrix, grid):
+    """Calculate PDF of the bivariate Gaussian distribution.
+
+    Args:
+        sigma_matrix (ndarray): with the shape (2, 2)
+        grid (ndarray): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size.
+
+    Returns:
+        kernel (ndarrray): un-normalized kernel.
+    """
+    inverse_sigma = np.linalg.inv(sigma_matrix)
+    kernel = np.exp(-0.5 * np.sum(np.dot(grid, inverse_sigma) * grid, 2))
+    return kernel
+
+
+def cdf2(d_matrix, grid):
+    """Calculate the CDF of the standard bivariate Gaussian distribution.
+        Used in skewed Gaussian distribution.
+
+    Args:
+        d_matrix (ndarrasy): skew matrix.
+        grid (ndarray): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size.
+
+    Returns:
+        cdf (ndarray): skewed cdf.
+    """
+    rv = multivariate_normal([0, 0], [[1, 0], [0, 1]])
+    grid = np.dot(grid, d_matrix)
+    cdf = rv.cdf(grid)
+    return cdf
+
+
+def bivariate_Gaussian(kernel_size, sig_x, sig_y, theta, grid=None, isotropic=True):
+    """Generate a bivariate isotropic or anisotropic Gaussian kernel.
+
+    In the isotropic mode, only `sig_x` is used. `sig_y` and `theta` is ignored.
+
+    Args:
+        kernel_size (int):
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+        grid (ndarray, optional): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size. Default: None
+        isotropic (bool):
+
+    Returns:
+        kernel (ndarray): normalized kernel.
+    """
+    if grid is None:
+        grid, _, _ = mesh_grid(kernel_size)
+    if isotropic:
+        sigma_matrix = np.array([[sig_x**2, 0], [0, sig_x**2]])
+    else:
+        sigma_matrix = sigma_matrix2(sig_x, sig_y, theta)
+    kernel = pdf2(sigma_matrix, grid)
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+
+def bivariate_generalized_Gaussian(kernel_size, sig_x, sig_y, theta, beta, grid=None, isotropic=True):
+    """Generate a bivariate generalized Gaussian kernel.
+
+    ``Paper: Parameter Estimation For Multivariate Generalized Gaussian Distributions``
+
+    In the isotropic mode, only `sig_x` is used. `sig_y` and `theta` is ignored.
+
+    Args:
+        kernel_size (int):
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+        beta (float): shape parameter, beta = 1 is the normal distribution.
+        grid (ndarray, optional): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size. Default: None
+
+    Returns:
+        kernel (ndarray): normalized kernel.
+    """
+    if grid is None:
+        grid, _, _ = mesh_grid(kernel_size)
+    if isotropic:
+        sigma_matrix = np.array([[sig_x**2, 0], [0, sig_x**2]])
+    else:
+        sigma_matrix = sigma_matrix2(sig_x, sig_y, theta)
+    inverse_sigma = np.linalg.inv(sigma_matrix)
+    kernel = np.exp(-0.5 * np.power(np.sum(np.dot(grid, inverse_sigma) * grid, 2), beta))
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+
+def bivariate_plateau(kernel_size, sig_x, sig_y, theta, beta, grid=None, isotropic=True):
+    """Generate a plateau-like anisotropic kernel.
+
+    1 / (1+x^(beta))
+
+    Reference: https://stats.stackexchange.com/questions/203629/is-there-a-plateau-shaped-distribution
+
+    In the isotropic mode, only `sig_x` is used. `sig_y` and `theta` is ignored.
+
+    Args:
+        kernel_size (int):
+        sig_x (float):
+        sig_y (float):
+        theta (float): Radian measurement.
+        beta (float): shape parameter, beta = 1 is the normal distribution.
+        grid (ndarray, optional): generated by :func:`mesh_grid`,
+            with the shape (K, K, 2), K is the kernel size. Default: None
+
+    Returns:
+        kernel (ndarray): normalized kernel.
+    """
+    if grid is None:
+        grid, _, _ = mesh_grid(kernel_size)
+    if isotropic:
+        sigma_matrix = np.array([[sig_x**2, 0], [0, sig_x**2]])
+    else:
+        sigma_matrix = sigma_matrix2(sig_x, sig_y, theta)
+    inverse_sigma = np.linalg.inv(sigma_matrix)
+    kernel = np.reciprocal(np.power(np.sum(np.dot(grid, inverse_sigma) * grid, 2), beta) + 1)
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+
+def random_bivariate_Gaussian(kernel_size,
+                              sigma_x_range,
+                              sigma_y_range,
+                              rotation_range,
+                              noise_range=None,
+                              isotropic=True):
+    """Randomly generate bivariate isotropic or anisotropic Gaussian kernels.
+
+    In the isotropic mode, only `sigma_x_range` is used. `sigma_y_range` and `rotation_range` is ignored.
+
+    Args:
+        kernel_size (int):
+        sigma_x_range (tuple): [0.6, 5]
+        sigma_y_range (tuple): [0.6, 5]
+        rotation range (tuple): [-math.pi, math.pi]
+        noise_range(tuple, optional): multiplicative kernel noise,
+            [0.75, 1.25]. Default: None
+
+    Returns:
+        kernel (ndarray):
+    """
+    assert kernel_size % 2 == 1, 'Kernel size must be an odd number.'
+    assert sigma_x_range[0] < sigma_x_range[1], 'Wrong sigma_x_range.'
+    sigma_x = np.random.uniform(sigma_x_range[0], sigma_x_range[1])
+    if isotropic is False:
+        assert sigma_y_range[0] < sigma_y_range[1], 'Wrong sigma_y_range.'
+        assert rotation_range[0] < rotation_range[1], 'Wrong rotation_range.'
+        sigma_y = np.random.uniform(sigma_y_range[0], sigma_y_range[1])
+        rotation = np.random.uniform(rotation_range[0], rotation_range[1])
+    else:
+        sigma_y = sigma_x
+        rotation = 0
+
+    kernel = bivariate_Gaussian(kernel_size, sigma_x, sigma_y, rotation, isotropic=isotropic)
+
+    # add multiplicative noise
+    if noise_range is not None:
+        assert noise_range[0] < noise_range[1], 'Wrong noise range.'
+        noise = np.random.uniform(noise_range[0], noise_range[1], size=kernel.shape)
+        kernel = kernel * noise
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+
+def random_bivariate_generalized_Gaussian(kernel_size,
+                                          sigma_x_range,
+                                          sigma_y_range,
+                                          rotation_range,
+                                          beta_range,
+                                          noise_range=None,
+                                          isotropic=True):
+    """Randomly generate bivariate generalized Gaussian kernels.
+
+    In the isotropic mode, only `sigma_x_range` is used. `sigma_y_range` and `rotation_range` is ignored.
+
+    Args:
+        kernel_size (int):
+        sigma_x_range (tuple): [0.6, 5]
+        sigma_y_range (tuple): [0.6, 5]
+        rotation range (tuple): [-math.pi, math.pi]
+        beta_range (tuple): [0.5, 8]
+        noise_range(tuple, optional): multiplicative kernel noise,
+            [0.75, 1.25]. Default: None
+
+    Returns:
+        kernel (ndarray):
+    """
+    assert kernel_size % 2 == 1, 'Kernel size must be an odd number.'
+    assert sigma_x_range[0] < sigma_x_range[1], 'Wrong sigma_x_range.'
+    sigma_x = np.random.uniform(sigma_x_range[0], sigma_x_range[1])
+    if isotropic is False:
+        assert sigma_y_range[0] < sigma_y_range[1], 'Wrong sigma_y_range.'
+        assert rotation_range[0] < rotation_range[1], 'Wrong rotation_range.'
+        sigma_y = np.random.uniform(sigma_y_range[0], sigma_y_range[1])
+        rotation = np.random.uniform(rotation_range[0], rotation_range[1])
+    else:
+        sigma_y = sigma_x
+        rotation = 0
+
+    # assume beta_range[0] < 1 < beta_range[1]
+    if np.random.uniform() < 0.5:
+        beta = np.random.uniform(beta_range[0], 1)
+    else:
+        beta = np.random.uniform(1, beta_range[1])
+
+    kernel = bivariate_generalized_Gaussian(kernel_size, sigma_x, sigma_y, rotation, beta, isotropic=isotropic)
+
+    # add multiplicative noise
+    if noise_range is not None:
+        assert noise_range[0] < noise_range[1], 'Wrong noise range.'
+        noise = np.random.uniform(noise_range[0], noise_range[1], size=kernel.shape)
+        kernel = kernel * noise
+    kernel = kernel / np.sum(kernel)
+    return kernel
+
+
+def random_bivariate_plateau(kernel_size,
+                             sigma_x_range,
+                             sigma_y_range,
+                             rotation_range,
+                             beta_range,
+                             noise_range=None,
+                             isotropic=True):
+    """Randomly generate bivariate plateau kernels.
+
+    In the isotropic mode, only `sigma_x_range` is used. `sigma_y_range` and `rotation_range` is ignored.
+
+    Args:
+        kernel_size (int):
+        sigma_x_range (tuple): [0.6, 5]
+        sigma_y_range (tuple): [0.6, 5]
+        rotation range (tuple): [-math.pi/2, math.pi/2]
+        beta_range (tuple): [1, 4]
+        noise_range(tuple, optional): multiplicative kernel noise,
+            [0.75, 1.25]. Default: None
+
+    Returns:
+        kernel (ndarray):
+    """
+    assert kernel_size % 2 == 1, 'Kernel size must be an odd number.'
+    assert sigma_x_range[0] < sigma_x_range[1], 'Wrong sigma_x_range.'
+    sigma_x = np.random.uniform(sigma_x_range[0], sigma_x_range[1])
+    if isotropic is False:
+        assert sigma_y_range[0] < sigma_y_range[1], 'Wrong sigma_y_range.'
+        assert rotation_range[0] < rotation_range[1], 'Wrong rotation_range.'
+        sigma_y = np.random.uniform(sigma_y_range[0], sigma_y_range[1])
+        rotation = np.random.uniform(rotation_range[0], rotation_range[1])
+    else:
+        sigma_y = sigma_x
+        rotation = 0
+
+    # TODO: this may be not proper
+    if np.random.uniform() < 0.5:
+        beta = np.random.uniform(beta_range[0], 1)
+    else:
+        beta = np.random.uniform(1, beta_range[1])
+
+    kernel = bivariate_plateau(kernel_size, sigma_x, sigma_y, rotation, beta, isotropic=isotropic)
+    # add multiplicative noise
+    if noise_range is not None:
+        assert noise_range[0] < noise_range[1], 'Wrong noise range.'
+        noise = np.random.uniform(noise_range[0], noise_range[1], size=kernel.shape)
+        kernel = kernel * noise
+    kernel = kernel / np.sum(kernel)
+
+    return kernel
+
+
+def random_mixed_kernels(kernel_list,
+                         kernel_prob,
+                         kernel_size=21,
+                         sigma_x_range=(0.6, 5),
+                         sigma_y_range=(0.6, 5),
+                         rotation_range=(-math.pi, math.pi),
+                         betag_range=(0.5, 8),
+                         betap_range=(0.5, 8),
+                         noise_range=None):
+    """Randomly generate mixed kernels.
+
+    Args:
+        kernel_list (tuple): a list name of kernel types,
+            support ['iso', 'aniso', 'skew', 'generalized', 'plateau_iso',
+            'plateau_aniso']
+        kernel_prob (tuple): corresponding kernel probability for each
+            kernel type
+        kernel_size (int):
+        sigma_x_range (tuple): [0.6, 5]
+        sigma_y_range (tuple): [0.6, 5]
+        rotation range (tuple): [-math.pi, math.pi]
+        beta_range (tuple): [0.5, 8]
+        noise_range(tuple, optional): multiplicative kernel noise,
+            [0.75, 1.25]. Default: None
+
+    Returns:
+        kernel (ndarray):
+    """
+    kernel_type = random.choices(kernel_list, kernel_prob)[0]
+    if kernel_type == 'iso':
+        kernel = random_bivariate_Gaussian(
+            kernel_size, sigma_x_range, sigma_y_range, rotation_range, noise_range=noise_range, isotropic=True)
+    elif kernel_type == 'aniso':
+        kernel = random_bivariate_Gaussian(
+            kernel_size, sigma_x_range, sigma_y_range, rotation_range, noise_range=noise_range, isotropic=False)
+    elif kernel_type == 'generalized_iso':
+        kernel = random_bivariate_generalized_Gaussian(
+            kernel_size,
+            sigma_x_range,
+            sigma_y_range,
+            rotation_range,
+            betag_range,
+            noise_range=noise_range,
+            isotropic=True)
+    elif kernel_type == 'generalized_aniso':
+        kernel = random_bivariate_generalized_Gaussian(
+            kernel_size,
+            sigma_x_range,
+            sigma_y_range,
+            rotation_range,
+            betag_range,
+            noise_range=noise_range,
+            isotropic=False)
+    elif kernel_type == 'plateau_iso':
+        kernel = random_bivariate_plateau(
+            kernel_size, sigma_x_range, sigma_y_range, rotation_range, betap_range, noise_range=None, isotropic=True)
+    elif kernel_type == 'plateau_aniso':
+        kernel = random_bivariate_plateau(
+            kernel_size, sigma_x_range, sigma_y_range, rotation_range, betap_range, noise_range=None, isotropic=False)
+    return kernel
+
+
+np.seterr(divide='ignore', invalid='ignore')
+
+
+def circular_lowpass_kernel(cutoff, kernel_size, pad_to=0):
+    """2D sinc filter
+
+    Reference: https://dsp.stackexchange.com/questions/58301/2-d-circularly-symmetric-low-pass-filter
+
+    Args:
+        cutoff (float): cutoff frequency in radians (pi is max)
+        kernel_size (int): horizontal and vertical size, must be odd.
+        pad_to (int): pad kernel size to desired size, must be odd or zero.
+    """
+    assert kernel_size % 2 == 1, 'Kernel size must be an odd number.'
+    kernel = np.fromfunction(
+        lambda x, y: cutoff * special.j1(cutoff * np.sqrt(
+            (x - (kernel_size - 1) / 2)**2 + (y - (kernel_size - 1) / 2)**2)) / (2 * np.pi * np.sqrt(
+                (x - (kernel_size - 1) / 2)**2 + (y - (kernel_size - 1) / 2)**2)), [kernel_size, kernel_size])
+    kernel[(kernel_size - 1) // 2, (kernel_size - 1) // 2] = cutoff**2 / (4 * np.pi)
+    kernel = kernel / np.sum(kernel)
+    if pad_to > kernel_size:
+        pad_size = (pad_to - kernel_size) // 2
+        kernel = np.pad(kernel, ((pad_size, pad_size), (pad_size, pad_size)))
+    return kernel
+
+
+# ------------------------------------------------------------- #
+# --------------------------- noise --------------------------- #
+# ------------------------------------------------------------- #
+
+# ----------------------- Gaussian Noise ----------------------- #
+
+
+def generate_gaussian_noise(img, sigma=10, gray_noise=False):
+    """Generate Gaussian noise.
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        sigma (float): Noise scale (measured in range 255). Default: 10.
+
+    Returns:
+        (Numpy array): Returned noisy image, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    if gray_noise:
+        noise = np.float32(np.random.randn(*(img.shape[0:2]))) * sigma / 255.
+        noise = np.expand_dims(noise, axis=2).repeat(3, axis=2)
+    else:
+        noise = np.float32(np.random.randn(*(img.shape))) * sigma / 255.
+    return noise
+
+
+def add_gaussian_noise(img, sigma=10, clip=True, rounds=False, gray_noise=False):
+    """Add Gaussian noise.
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        sigma (float): Noise scale (measured in range 255). Default: 10.
+
+    Returns:
+        (Numpy array): Returned noisy image, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    noise = generate_gaussian_noise(img, sigma, gray_noise)
+    out = img + noise
+    if clip and rounds:
+        out = np.clip((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = np.clip(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+def generate_gaussian_noise_pt(img, sigma=10, gray_noise=0):
+    """Add Gaussian noise (PyTorch version).
+
+    Args:
+        img (Tensor): Shape (b, c, h, w), range[0, 1], float32.
+        scale (float | Tensor): Noise scale. Default: 1.0.
+
+    Returns:
+        (Tensor): Returned noisy image, shape (b, c, h, w), range[0, 1],
+            float32.
+    """
+    b, _, h, w = img.size()
+    if not isinstance(sigma, (float, int)):
+        sigma = sigma.view(img.size(0), 1, 1, 1)
+    if isinstance(gray_noise, (float, int)):
+        cal_gray_noise = gray_noise > 0
+    else:
+        gray_noise = gray_noise.view(b, 1, 1, 1)
+        cal_gray_noise = torch.sum(gray_noise) > 0
+
+    if cal_gray_noise:
+        noise_gray = torch.randn(*img.size()[2:4], dtype=img.dtype, device=img.device) * sigma / 255.
+        noise_gray = noise_gray.view(b, 1, h, w)
+
+    # always calculate color noise
+    noise = torch.randn(*img.size(), dtype=img.dtype, device=img.device) * sigma / 255.
+
+    if cal_gray_noise:
+        noise = noise * (1 - gray_noise) + noise_gray * gray_noise
+    return noise
+
+
+def add_gaussian_noise_pt(img, sigma=10, gray_noise=0, clip=True, rounds=False):
+    """Add Gaussian noise (PyTorch version).
+
+    Args:
+        img (Tensor): Shape (b, c, h, w), range[0, 1], float32.
+        scale (float | Tensor): Noise scale. Default: 1.0.
+
+    Returns:
+        (Tensor): Returned noisy image, shape (b, c, h, w), range[0, 1],
+            float32.
+    """
+    noise = generate_gaussian_noise_pt(img, sigma, gray_noise)
+    out = img + noise
+    if clip and rounds:
+        out = torch.clamp((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = torch.clamp(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+# ----------------------- Random Gaussian Noise ----------------------- #
+def random_generate_gaussian_noise(img, sigma_range=(0, 10), gray_prob=0):
+    sigma = np.random.uniform(sigma_range[0], sigma_range[1])
+    if np.random.uniform() < gray_prob:
+        gray_noise = True
+    else:
+        gray_noise = False
+    return generate_gaussian_noise(img, sigma, gray_noise)
+
+
+def random_add_gaussian_noise(img, sigma_range=(0, 1.0), gray_prob=0, clip=True, rounds=False):
+    noise = random_generate_gaussian_noise(img, sigma_range, gray_prob)
+    out = img + noise
+    if clip and rounds:
+        out = np.clip((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = np.clip(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+def random_generate_gaussian_noise_pt(img, sigma_range=(0, 10), gray_prob=0):
+    sigma = torch.rand(
+        img.size(0), dtype=img.dtype, device=img.device) * (sigma_range[1] - sigma_range[0]) + sigma_range[0]
+    gray_noise = torch.rand(img.size(0), dtype=img.dtype, device=img.device)
+    gray_noise = (gray_noise < gray_prob).float()
+    return generate_gaussian_noise_pt(img, sigma, gray_noise)
+
+
+def random_add_gaussian_noise_pt(img, sigma_range=(0, 1.0), gray_prob=0, clip=True, rounds=False):
+    noise = random_generate_gaussian_noise_pt(img, sigma_range, gray_prob)
+    out = img + noise
+    if clip and rounds:
+        out = torch.clamp((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = torch.clamp(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+# ----------------------- Poisson (Shot) Noise ----------------------- #
+
+
+def generate_poisson_noise(img, scale=1.0, gray_noise=False):
+    """Generate poisson noise.
+
+    Reference: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/noise.py#L37-L219
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        scale (float): Noise scale. Default: 1.0.
+        gray_noise (bool): Whether generate gray noise. Default: False.
+
+    Returns:
+        (Numpy array): Returned noisy image, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    if gray_noise:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    # round and clip image for counting vals correctly
+    img = np.clip((img * 255.0).round(), 0, 255) / 255.
+    vals = len(np.unique(img))
+    vals = 2**np.ceil(np.log2(vals))
+    out = np.float32(np.random.poisson(img * vals) / float(vals))
+    noise = out - img
+    if gray_noise:
+        noise = np.repeat(noise[:, :, np.newaxis], 3, axis=2)
+    return noise * scale
+
+
+def add_poisson_noise(img, scale=1.0, clip=True, rounds=False, gray_noise=False):
+    """Add poisson noise.
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        scale (float): Noise scale. Default: 1.0.
+        gray_noise (bool): Whether generate gray noise. Default: False.
+
+    Returns:
+        (Numpy array): Returned noisy image, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    noise = generate_poisson_noise(img, scale, gray_noise)
+    out = img + noise
+    if clip and rounds:
+        out = np.clip((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = np.clip(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+def generate_poisson_noise_pt(img, scale=1.0, gray_noise=0):
+    """Generate a batch of poisson noise (PyTorch version)
+
+    Args:
+        img (Tensor): Input image, shape (b, c, h, w), range [0, 1], float32.
+        scale (float | Tensor): Noise scale. Number or Tensor with shape (b).
+            Default: 1.0.
+        gray_noise (float | Tensor): 0-1 number or Tensor with shape (b).
+            0 for False, 1 for True. Default: 0.
+
+    Returns:
+        (Tensor): Returned noisy image, shape (b, c, h, w), range[0, 1],
+            float32.
+    """
+    b, _, h, w = img.size()
+    if isinstance(gray_noise, (float, int)):
+        cal_gray_noise = gray_noise > 0
+    else:
+        gray_noise = gray_noise.view(b, 1, 1, 1)
+        cal_gray_noise = torch.sum(gray_noise) > 0
+    if cal_gray_noise:
+        img_gray = rgb_to_grayscale(img, num_output_channels=1)
+        # round and clip image for counting vals correctly
+        img_gray = torch.clamp((img_gray * 255.0).round(), 0, 255) / 255.
+        # use for-loop to get the unique values for each sample
+        vals_list = [len(torch.unique(img_gray[i, :, :, :])) for i in range(b)]
+        vals_list = [2**np.ceil(np.log2(vals)) for vals in vals_list]
+        vals = img_gray.new_tensor(vals_list).view(b, 1, 1, 1)
+        out = torch.poisson(img_gray * vals) / vals
+        noise_gray = out - img_gray
+        noise_gray = noise_gray.expand(b, 3, h, w)
+
+    # always calculate color noise
+    # round and clip image for counting vals correctly
+    img = torch.clamp((img * 255.0).round(), 0, 255) / 255.
+    # use for-loop to get the unique values for each sample
+    vals_list = [len(torch.unique(img[i, :, :, :])) for i in range(b)]
+    vals_list = [2**np.ceil(np.log2(vals)) for vals in vals_list]
+    vals = img.new_tensor(vals_list).view(b, 1, 1, 1)
+    out = torch.poisson(img * vals) / vals
+    noise = out - img
+    if cal_gray_noise:
+        noise = noise * (1 - gray_noise) + noise_gray * gray_noise
+    if not isinstance(scale, (float, int)):
+        scale = scale.view(b, 1, 1, 1)
+    return noise * scale
+
+
+def add_poisson_noise_pt(img, scale=1.0, clip=True, rounds=False, gray_noise=0):
+    """Add poisson noise to a batch of images (PyTorch version).
+
+    Args:
+        img (Tensor): Input image, shape (b, c, h, w), range [0, 1], float32.
+        scale (float | Tensor): Noise scale. Number or Tensor with shape (b).
+            Default: 1.0.
+        gray_noise (float | Tensor): 0-1 number or Tensor with shape (b).
+            0 for False, 1 for True. Default: 0.
+
+    Returns:
+        (Tensor): Returned noisy image, shape (b, c, h, w), range[0, 1],
+            float32.
+    """
+    noise = generate_poisson_noise_pt(img, scale, gray_noise)
+    out = img + noise
+    if clip and rounds:
+        out = torch.clamp((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = torch.clamp(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+# ----------------------- Random Poisson (Shot) Noise ----------------------- #
+
+
+def random_generate_poisson_noise(img, scale_range=(0, 1.0), gray_prob=0):
+    scale = np.random.uniform(scale_range[0], scale_range[1])
+    if np.random.uniform() < gray_prob:
+        gray_noise = True
+    else:
+        gray_noise = False
+    return generate_poisson_noise(img, scale, gray_noise)
+
+
+def random_add_poisson_noise(img, scale_range=(0, 1.0), gray_prob=0, clip=True, rounds=False):
+    noise = random_generate_poisson_noise(img, scale_range, gray_prob)
+    out = img + noise
+    if clip and rounds:
+        out = np.clip((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = np.clip(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+def random_generate_poisson_noise_pt(img, scale_range=(0, 1.0), gray_prob=0):
+    scale = torch.rand(
+        img.size(0), dtype=img.dtype, device=img.device) * (scale_range[1] - scale_range[0]) + scale_range[0]
+    gray_noise = torch.rand(img.size(0), dtype=img.dtype, device=img.device)
+    gray_noise = (gray_noise < gray_prob).float()
+    return generate_poisson_noise_pt(img, scale, gray_noise)
+
+
+def random_add_poisson_noise_pt(img, scale_range=(0, 1.0), gray_prob=0, clip=True, rounds=False):
+    noise = random_generate_poisson_noise_pt(img, scale_range, gray_prob)
+    out = img + noise
+    if clip and rounds:
+        out = torch.clamp((out * 255.0).round(), 0, 255) / 255.
+    elif clip:
+        out = torch.clamp(out, 0, 1)
+    elif rounds:
+        out = (out * 255.0).round() / 255.
+    return out
+
+
+# ------------------------------------------------------------------------ #
+# --------------------------- JPEG compression --------------------------- #
+# ------------------------------------------------------------------------ #
+
+
+def add_jpg_compression(img, quality=90):
+    """Add JPG compression artifacts.
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        quality (float): JPG compression quality. 0 for lowest quality, 100 for
+            best quality. Default: 90.
+
+    Returns:
+        (Numpy array): Returned image after JPG, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    img = np.clip(img, 0, 1)
+    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), int(quality)]
+    _, encimg = cv2.imencode('.jpg', img * 255., encode_param)
+    img = np.float32(cv2.imdecode(encimg, 1)) / 255.
+    return img
+
+
+def random_add_jpg_compression(img, quality_range=(90, 100)):
+    """Randomly add JPG compression artifacts.
+
+    Args:
+        img (Numpy array): Input image, shape (h, w, c), range [0, 1], float32.
+        quality_range (tuple[float] | list[float]): JPG compression quality
+            range. 0 for lowest quality, 100 for best quality.
+            Default: (90, 100).
+
+    Returns:
+        (Numpy array): Returned image after JPG, shape (h, w, c), range[0, 1],
+            float32.
+    """
+    quality = np.random.uniform(quality_range[0], quality_range[1])
+    return add_jpg_compression(img, quality)

basicsr/data/ffhq_dataset.py

@@ -0,0 +1,80 @@
+import random
+import time
+from os import path as osp
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.transforms import augment
+from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
+from basicsr.utils.registry import DATASET_REGISTRY
+
+
+@DATASET_REGISTRY.register()
+class FFHQDataset(data.Dataset):
+    """FFHQ dataset for StyleGAN.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            io_backend (dict): IO backend type and other kwarg.
+            mean (list | tuple): Image mean.
+            std (list | tuple): Image std.
+            use_hflip (bool): Whether to horizontally flip.
+
+    """
+
+    def __init__(self, opt):
+        super(FFHQDataset, self).__init__()
+        self.opt = opt
+        # file client (io backend)
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+
+        self.gt_folder = opt['dataroot_gt']
+        self.mean = opt['mean']
+        self.std = opt['std']
+
+        if self.io_backend_opt['type'] == 'lmdb':
+            self.io_backend_opt['db_paths'] = self.gt_folder
+            if not self.gt_folder.endswith('.lmdb'):
+                raise ValueError("'dataroot_gt' should end with '.lmdb', but received {self.gt_folder}")
+            with open(osp.join(self.gt_folder, 'meta_info.txt')) as fin:
+                self.paths = [line.split('.')[0] for line in fin]
+        else:
+            # FFHQ has 70000 images in total
+            self.paths = [osp.join(self.gt_folder, f'{v:08d}.png') for v in range(70000)]
+
+    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 gt image
+        gt_path = self.paths[index]
+        # avoid errors caused by high latency in reading files
+        retry = 3
+        while retry > 0:
+            try:
+                img_bytes = self.file_client.get(gt_path)
+            except Exception as e:
+                logger = get_root_logger()
+                logger.warning(f'File client error: {e}, remaining retry times: {retry - 1}')
+                # change another file to read
+                index = random.randint(0, self.__len__())
+                gt_path = self.paths[index]
+                time.sleep(1)  # sleep 1s for occasional server congestion
+            else:
+                break
+            finally:
+                retry -= 1
+        img_gt = imfrombytes(img_bytes, float32=True)
+
+        # random horizontal flip
+        img_gt = augment(img_gt, hflip=self.opt['use_hflip'], rotation=False)
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt = img2tensor(img_gt, bgr2rgb=True, float32=True)
+        # normalize
+        normalize(img_gt, self.mean, self.std, inplace=True)
+        return {'gt': img_gt, 'gt_path': gt_path}
+
+    def __len__(self):
+        return len(self.paths)

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,106 @@
+from torch.utils import data as data
+from torchvision.transforms.functional import normalize
+
+from basicsr.data.data_util import paired_paths_from_folder, paired_paths_from_lmdb, paired_paths_from_meta_info_file
+from basicsr.data.transforms import augment, paired_random_crop
+from basicsr.utils import FileClient, bgr2ycbcr, imfrombytes, img2tensor
+from basicsr.utils.registry import DATASET_REGISTRY
+
+
+@DATASET_REGISTRY.register()
+class PairedImageDataset(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.
+        use_hflip (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(PairedImageDataset, 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)
+
+    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']
+
+        # 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')
+        img_gt = imfrombytes(img_bytes, float32=True)
+        lq_path = self.paths[index]['lq_path']
+        img_bytes = self.file_client.get(lq_path, 'lq')
+        img_lq = imfrombytes(img_bytes, float32=True)
+
+        # augmentation for training
+        if self.opt['phase'] == 'train':
+            gt_size = self.opt['gt_size']
+            # random crop
+            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale, gt_path)
+            # flip, rotation
+            img_gt, img_lq = augment([img_gt, img_lq], self.opt['use_hflip'], self.opt['use_rot'])
+
+        # color space transform
+        if 'color' in self.opt and self.opt['color'] == 'y':
+            img_gt = bgr2ycbcr(img_gt, y_only=True)[..., None]
+            img_lq = bgr2ycbcr(img_lq, y_only=True)[..., None]
+
+        # crop the unmatched GT images during validation or testing, especially for SR benchmark datasets
+        # TODO: It is better to update the datasets, rather than force to crop
+        if self.opt['phase'] != 'train':
+            img_gt = img_gt[0:img_lq.shape[0] * scale, 0:img_lq.shape[1] * scale, :]
+
+        # 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)
+
+        return {'lq': img_lq, 'gt': img_gt, 'lq_path': lq_path, 'gt_path': gt_path}
+
+    def __len__(self):
+        return len(self.paths)

basicsr/data/prefetch_dataloader.py

@@ -0,0 +1,122 @@
+import queue as Queue
+import threading
+import torch
+from torch.utils.data import DataLoader
+
+
+class PrefetchGenerator(threading.Thread):
+    """A general prefetch generator.
+
+    Reference: 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.
+
+    Reference: 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.
+
+    Reference: https://github.com/NVIDIA/apex/issues/304#
+
+    It may consume 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/realesrgan_dataset.py

@@ -0,0 +1,384 @@
+import cv2
+import math
+import numpy as np
+import os
+import os.path as osp
+import random
+import time
+import torch
+from pathlib import Path
+
+import albumentations
+
+import torch.nn.functional as F
+from torch.utils import data as data
+
+from basicsr.utils import DiffJPEG
+from basicsr.data.degradations import circular_lowpass_kernel, random_mixed_kernels
+from basicsr.data.transforms import augment
+from basicsr.utils import FileClient, get_root_logger, imfrombytes, img2tensor
+from basicsr.utils.registry import DATASET_REGISTRY
+from basicsr.utils.img_process_util import filter2D
+from basicsr.data.transforms import paired_random_crop, random_crop
+from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
+
+from utils import util_image
+
+def readline_txt(txt_file):
+    txt_file = [txt_file, ] if isinstance(txt_file, str) else txt_file
+    out = []
+    for txt_file_current in txt_file:
+        with open(txt_file_current, 'r') as ff:
+            out.extend([x[:-1] for x in ff.readlines()])
+
+    return out
+
+@DATASET_REGISTRY.register(suffix='basicsr')
+class RealESRGANDataset(data.Dataset):
+    """Dataset used for Real-ESRGAN model:
+    Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data.
+
+    It loads gt (Ground-Truth) images, and augments them.
+    It also generates blur kernels and sinc kernels for generating low-quality images.
+    Note that the low-quality images are processed in tensors on GPUS for faster processing.
+
+    Args:
+        opt (dict): Config for train datasets. It contains the following keys:
+            dataroot_gt (str): Data root path for gt.
+            meta_info (str): Path for meta information file.
+            io_backend (dict): IO backend type and other kwarg.
+            use_hflip (bool): Use horizontal flips.
+            use_rot (bool): Use rotation (use vertical flip and transposing h and w for implementation).
+            Please see more options in the codes.
+    """
+
+    def __init__(self, opt, mode='training'):
+        super(RealESRGANDataset, self).__init__()
+        self.opt = opt
+        self.file_client = None
+        self.io_backend_opt = opt['io_backend']
+
+        # file client (lmdb io backend)
+        self.image_paths = []
+        self.text_paths = []
+        self.moment_paths = []
+        if opt.get('data_source', None) is not None:
+            for ii in range(len(opt['data_source'])):
+                configs = opt['data_source'].get(f'source{ii+1}')
+                root_path = Path(configs.root_path)
+                im_folder = root_path / configs.image_path
+                im_ext = configs.im_ext
+                image_stems = sorted([x.stem for x in im_folder.glob(f"*.{im_ext}")])
+                if configs.get('length', None) is not None:
+                    assert configs.length < len(image_stems)
+                    image_stems = image_stems[:configs.length]
+
+                if configs.get("text_path", None) is not None:
+                    text_folder = root_path / configs.text_path
+                    text_stems = [x.stem for x in text_folder.glob("*.txt")]
+                    image_stems = sorted(list(set(image_stems).intersection(set(text_stems))))
+                    self.text_paths.extend([str(text_folder / f"{x}.txt") for x in image_stems])
+                else:
+                    self.text_paths.extend([None, ] * len(image_stems))
+
+                self.image_paths.extend([str(im_folder / f"{x}.{im_ext}") for x in image_stems])
+
+                if configs.get("moment_path", None) is not None:
+                    moment_folder = root_path / configs.moment_path
+                    self.moment_paths.extend([str(moment_folder / f"{x}.npy") for x in image_stems])
+                else:
+                    self.moment_paths.extend([None, ] * len(image_stems))
+
+        # blur settings for the first degradation
+        self.blur_kernel_size = opt['blur_kernel_size']
+        self.kernel_list = opt['kernel_list']
+        self.kernel_prob = opt['kernel_prob']  # a list for each kernel probability
+        self.blur_sigma = opt['blur_sigma']
+        self.betag_range = opt['betag_range']  # betag used in generalized Gaussian blur kernels
+        self.betap_range = opt['betap_range']  # betap used in plateau blur kernels
+        self.sinc_prob = opt['sinc_prob']  # the probability for sinc filters
+
+        # blur settings for the second degradation
+        self.blur_kernel_size2 = opt['blur_kernel_size2']
+        self.kernel_list2 = opt['kernel_list2']
+        self.kernel_prob2 = opt['kernel_prob2']
+        self.blur_sigma2 = opt['blur_sigma2']
+        self.betag_range2 = opt['betag_range2']
+        self.betap_range2 = opt['betap_range2']
+        self.sinc_prob2 = opt['sinc_prob2']
+
+        # a final sinc filter
+        self.final_sinc_prob = opt['final_sinc_prob']
+
+        self.kernel_range1 = [x for x in range(3, opt['blur_kernel_size'], 2)]  # kernel size ranges from 7 to 21
+        self.kernel_range2 = [x for x in range(3, opt['blur_kernel_size2'], 2)]  # kernel size ranges from 7 to 21
+        # TODO: kernel range is now hard-coded, should be in the configure file
+        # convolving with pulse tensor brings no blurry effect
+        self.pulse_tensor = torch.zeros(opt['blur_kernel_size2'], opt['blur_kernel_size2']).float()
+        self.pulse_tensor[opt['blur_kernel_size2']//2, opt['blur_kernel_size2']//2] = 1
+
+        self.mode = mode
+
+    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 gt images -------------------------------- #
+        # Shape: (h, w, c); channel order: BGR; image range: [0, 1], float32.
+        gt_path = self.image_paths[index]
+        # avoid errors caused by high latency in reading files
+        retry = 3
+        while retry > 0:
+            try:
+                img_bytes = self.file_client.get(gt_path, 'gt')
+                img_gt = imfrombytes(img_bytes, float32=True)
+            except:
+                index = random.randint(0, self.__len__())
+                gt_path = self.image_paths[index]
+                time.sleep(1)  # sleep 1s for occasional server congestion
+            finally:
+                retry -= 1
+        if self.mode == 'testing':
+            if not hasattr(self, 'test_aug'):
+                self.test_aug = albumentations.Compose([
+                    albumentations.SmallestMaxSize(
+                        max_size=self.opt['gt_size'],
+                        interpolation=cv2.INTER_AREA,
+                        ),
+                    albumentations.CenterCrop(self.opt['gt_size'], self.opt['gt_size']),
+                    ])
+            img_gt = self.test_aug(image=img_gt)['image']
+        elif self.mode == 'training':
+            # -------------------- Do augmentation for training: flip, rotation -------------------- #
+            if self.opt['use_hflip'] or self.opt['use_rot']:
+                img_gt = augment(img_gt, self.opt['use_hflip'], self.opt['use_rot'])
+
+            h, w = img_gt.shape[0:2]
+            gt_size = self.opt['gt_size']
+
+            # resize or pad
+            if not self.opt['random_crop']:
+                if not min(h, w) == gt_size:
+                    if not hasattr(self, 'smallest_resizer'):
+                        self.smallest_resizer = util_image.SmallestMaxSize(
+                            max_size=gt_size, pass_resize=False,
+                        )
+                    img_gt = self.smallest_resizer(img_gt)
+
+                # center crop
+                if not hasattr(self, 'center_cropper'):
+                    self.center_cropper = albumentations.CenterCrop(gt_size, gt_size)
+                img_gt = self.center_cropper(image=img_gt)['image']
+            else:
+                img_gt = random_crop(img_gt, self.opt['gt_size'])
+        else:
+            raise ValueError(f'Unexpected value {self.mode} for mode parameter')
+
+        # ------------------------ Generate kernels (used in the first degradation) ------------------------ #
+        kernel_size = random.choice(self.kernel_range1)
+        if np.random.uniform() < self.opt['sinc_prob']:
+            # this sinc filter setting is for kernels ranging from [7, 21]
+            if kernel_size < 13:
+                omega_c = np.random.uniform(np.pi / 3, np.pi)
+            else:
+                omega_c = np.random.uniform(np.pi / 5, np.pi)
+            kernel = circular_lowpass_kernel(omega_c, kernel_size, pad_to=False)
+        else:
+            kernel = random_mixed_kernels(
+                self.kernel_list,
+                self.kernel_prob,
+                kernel_size,
+                self.blur_sigma,
+                self.blur_sigma, [-math.pi, math.pi],
+                self.betag_range,
+                self.betap_range,
+                noise_range=None)
+        # pad kernel
+        pad_size = (self.blur_kernel_size - kernel_size) // 2
+        kernel = np.pad(kernel, ((pad_size, pad_size), (pad_size, pad_size)))
+
+        # ------------------------ Generate kernels (used in the second degradation) ------------------------ #
+        kernel_size = random.choice(self.kernel_range2)
+        if np.random.uniform() < self.opt['sinc_prob2']:
+            if kernel_size < 13:
+                omega_c = np.random.uniform(np.pi / 3, np.pi)
+            else:
+                omega_c = np.random.uniform(np.pi / 5, np.pi)
+            kernel2 = circular_lowpass_kernel(omega_c, kernel_size, pad_to=False)
+        else:
+            kernel2 = random_mixed_kernels(
+                self.kernel_list2,
+                self.kernel_prob2,
+                kernel_size,
+                self.blur_sigma2,
+                self.blur_sigma2, [-math.pi, math.pi],
+                self.betag_range2,
+                self.betap_range2,
+                noise_range=None)
+
+        # pad kernel
+        pad_size = (self.blur_kernel_size2 - kernel_size) // 2
+        kernel2 = np.pad(kernel2, ((pad_size, pad_size), (pad_size, pad_size)))
+
+        # ------------------------------------- the final sinc kernel ------------------------------------- #
+        if np.random.uniform() < self.opt['final_sinc_prob']:
+            kernel_size = random.choice(self.kernel_range2)
+            omega_c = np.random.uniform(np.pi / 3, np.pi)
+            sinc_kernel = circular_lowpass_kernel(omega_c, kernel_size, pad_to=self.blur_kernel_size2)
+            sinc_kernel = torch.FloatTensor(sinc_kernel)
+        else:
+            sinc_kernel = self.pulse_tensor
+
+        # BGR to RGB, HWC to CHW, numpy to tensor
+        img_gt = img2tensor([img_gt], bgr2rgb=True, float32=True)[0]
+        kernel = torch.FloatTensor(kernel)
+        kernel2 = torch.FloatTensor(kernel2)
+
+        if self.text_paths[index] is None or self.opt['random_crop']:
+            prompt = ""
+        else:
+            with open(self.text_paths[index], 'r') as ff:
+                prompt = ff.read()
+            if self.opt.max_token_length is not None:
+                prompt = prompt[:self.opt.max_token_length]
+
+        return_d = {
+                'gt': img_gt,
+                'gt_path': gt_path,
+                'txt': prompt,
+                'kernel1': kernel,
+                'kernel2': kernel2,
+                'sinc_kernel': sinc_kernel,
+                }
+        if self.moment_paths[index] is not None and (not self.opt['random_crop']):
+            return_d['gt_moment'] = np.load(self.moment_paths[index])
+
+        return return_d
+
+    def __len__(self):
+        return len(self.image_paths)
+
+    def degrade_fun(self, conf_degradation, im_gt, kernel1, kernel2, sinc_kernel):
+        if not hasattr(self, 'jpeger'):
+            self.jpeger = DiffJPEG(differentiable=False)  # simulate JPEG compression artifacts
+
+        ori_h, ori_w = im_gt.size()[2:4]
+        sf = conf_degradation.sf
+
+        # ----------------------- The first degradation process ----------------------- #
+        # blur
+        out = filter2D(im_gt, kernel1)
+        # random resize
+        updown_type = random.choices(
+                ['up', 'down', 'keep'],
+                conf_degradation['resize_prob'],
+                )[0]
+        if updown_type == 'up':
+            scale = random.uniform(1, conf_degradation['resize_range'][1])
+        elif updown_type == 'down':
+            scale = random.uniform(conf_degradation['resize_range'][0], 1)
+        else:
+            scale = 1
+        mode = random.choice(['area', 'bilinear', 'bicubic'])
+        out = F.interpolate(out, scale_factor=scale, mode=mode)
+        # add noise
+        gray_noise_prob = conf_degradation['gray_noise_prob']
+        if random.random() < conf_degradation['gaussian_noise_prob']:
+            out = random_add_gaussian_noise_pt(
+                out,
+                sigma_range=conf_degradation['noise_range'],
+                clip=True,
+                rounds=False,
+                gray_prob=gray_noise_prob,
+                )
+        else:
+            out = random_add_poisson_noise_pt(
+                out,
+                scale_range=conf_degradation['poisson_scale_range'],
+                gray_prob=gray_noise_prob,
+                clip=True,
+                rounds=False)
+        # JPEG compression
+        jpeg_p = out.new_zeros(out.size(0)).uniform_(*conf_degradation['jpeg_range'])
+        out = torch.clamp(out, 0, 1)  # clamp to [0, 1], otherwise JPEGer will result in unpleasant artifacts
+        out = self.jpeger(out, quality=jpeg_p)
+
+        # ----------------------- The second degradation process ----------------------- #
+        # blur
+        if random.random() < conf_degradation['second_order_prob']:
+            if random.random() < conf_degradation['second_blur_prob']:
+                out = filter2D(out, kernel2)
+            # random resize
+            updown_type = random.choices(
+                    ['up', 'down', 'keep'],
+                    conf_degradation['resize_prob2'],
+                    )[0]
+            if updown_type == 'up':
+                scale = random.uniform(1, conf_degradation['resize_range2'][1])
+            elif updown_type == 'down':
+                scale = random.uniform(conf_degradation['resize_range2'][0], 1)
+            else:
+                scale = 1
+            mode = random.choice(['area', 'bilinear', 'bicubic'])
+            out = F.interpolate(
+                    out,
+                    size=(int(ori_h / sf * scale), int(ori_w / sf * scale)),
+                    mode=mode,
+                    )
+            # add noise
+            gray_noise_prob = conf_degradation['gray_noise_prob2']
+            if random.random() < conf_degradation['gaussian_noise_prob2']:
+                out = random_add_gaussian_noise_pt(
+                    out,
+                    sigma_range=conf_degradation['noise_range2'],
+                    clip=True,
+                    rounds=False,
+                    gray_prob=gray_noise_prob,
+                    )
+            else:
+                out = random_add_poisson_noise_pt(
+                    out,
+                    scale_range=conf_degradation['poisson_scale_range2'],
+                    gray_prob=gray_noise_prob,
+                    clip=True,
+                    rounds=False,
+                    )
+
+        # JPEG compression + the final sinc filter
+        # We also need to resize images to desired sizes. We group [resize back + sinc filter] together
+        # as one operation.
+        # We consider two orders:
+        #   1. [resize back + sinc filter] + JPEG compression
+        #   2. JPEG compression + [resize back + sinc filter]
+        # Empirically, we find other combinations (sinc + JPEG + Resize) will introduce twisted lines.
+        if random.random() < 0.5:
+            # resize back + the final sinc filter
+            mode = random.choice(['area', 'bilinear', 'bicubic'])
+            out = F.interpolate(
+                    out,
+                    size=(ori_h // sf, ori_w // sf),
+                    mode=mode,
+                    )
+            out = filter2D(out, sinc_kernel)
+            # JPEG compression
+            jpeg_p = out.new_zeros(out.size(0)).uniform_(*conf_degradation['jpeg_range2'])
+            out = torch.clamp(out, 0, 1)
+            out = self.jpeger(out, quality=jpeg_p)
+        else:
+            # JPEG compression
+            jpeg_p = out.new_zeros(out.size(0)).uniform_(*conf_degradation['jpeg_range2'])
+            out = torch.clamp(out, 0, 1)
+            out = self.jpeger(out, quality=jpeg_p)
+            # resize back + the final sinc filter
+            mode = random.choice(['area', 'bilinear', 'bicubic'])
+            out = F.interpolate(
+                    out,
+                    size=(ori_h // sf, ori_w // sf),
+                    mode=mode,
+                    )
+            out = filter2D(out, sinc_kernel)
+
+        # clamp and round
+        im_lq = torch.clamp((out * 255.0).round(), 0, 255) / 255.
+
+        return {'lq':im_lq.contiguous(), 'gt':im_gt}