Delete generate_lowresolution.py

generate_lowresolution.py

@@ -1,537 +0,0 @@
-import argparse
-import glob
-import os
-from PIL import Image
-
-import cv2
-import math
-import numpy as np
-import os
-import os.path as osp
-import random
-import time
-import torch
-from tqdm import tqdm
-
-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 torch.utils import data as data
-from torchvision.transforms.functional import center_crop
-import torchvision.transforms as T
-from torchvision.utils import save_image
-
-from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
-from basicsr.data.transforms import paired_random_crop
-from basicsr.utils import DiffJPEG, USMSharp
-from basicsr.utils.img_process_util import filter2D
-from basicsr.utils.registry import MODEL_REGISTRY
-from collections import OrderedDict
-from torch.nn import functional as F
-
-cfg = {
-    # dataset info.
-    "name": "DF2K+OST",
-    "type": "RealESRGANDataset",
-    "dataroot_gt": "/home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution",
-    "meta_train": [
-                "DIV2K/metas/DIV2K_train_HR.list",
-                "Flickr2K/metas/Flickr2K.list",
-                "OST/metas/OST.list",
-    ],               
-    "meta_test": ["DIV2K/metas/DIV2K_valid_HR.list"],
-
-    # the first degradation process
-    "resize_prob": [0.2, 0.7, 0.1],  # up, down, keep
-    "resize_range": [0.15, 1.5],
-    "gaussian_noise_prob": 0.5,
-    "noise_range": [1, 30],
-    "poisson_scale_range": [0.05, 3],
-    "gray_noise_prob": 0.4,
-    "jpeg_range": [30, 95],
-
-    "blur_kernel_size": 21,
-    "kernel_list": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
-    "kernel_prob": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
-    "sinc_prob": 0.1,
-    "blur_sigma": [0.2, 3],
-    "betag_range": [0.5, 4],
-    "betap_range": [1, 2],
-
-    # the second degradation process
-    "second_blur_prob": 0.8,
-    "resize_prob2": [0.3, 0.4, 0.3],  # up, down, keep
-    "resize_range2": [0.3, 1.2],
-    "gaussian_noise_prob2": 0.5,
-    "noise_range2": [1, 25],
-    "poisson_scale_range2": [0.05, 2.5],
-    "gray_noise_prob2": 0.4,
-    "jpeg_range2": [30, 95],
-
-    "blur_kernel_size2": 21,
-    "kernel_list2": ['iso', 'aniso', 'generalized_iso', 'generalized_aniso', 'plateau_iso', 'plateau_aniso'],
-    "kernel_prob2": [0.45, 0.25, 0.12, 0.03, 0.12, 0.03],
-    "sinc_prob2": 0.1,
-    "blur_sigma2": [0.2, 1.5],
-    "betag_range2": [0.5, 4],
-    "betap_range2": [1, 2],
-
-    "final_sinc_prob": 0.8,
-
-    "gt_size": 512,
-    "keep_ratio": True,
-    "use_hflip": True,
-    "use_rot": False,
-
-    # data loader
-    "use_shuffle": True,
-    "num_worker_per_gpu": 5,
-    "batch_size_per_gpu": 12,
-    "dataset_enlarge_ratio": 1,
-    "prefetch_mode": None,
-}
-
-def set_seed(seed=42):
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    torch.cuda.manual_seed(seed)
-    torch.cuda.manual_seed_all(seed)
-
-    torch.backends.cudnn.deterministic = True
-    torch.backends.cudnn.benchmark = False
-
-@DATASET_REGISTRY.register()
-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, train=True):
-        super(RealESRGANDataset, self).__init__()
-        self.opt = opt
-        self.file_client = None
-
-        # kernel define
-        self.data_rt = opt['dataroot_gt']
-
-        # dataload
-        self.train = train
-        if self.train:
-            self.metas = opt['meta_train']
-        else:
-            self.metas = opt['meta_test']
-
-        self.paths = []
-        for meta in self.metas:
-            with open(os.path.join(self.data_rt, meta)) as fin:
-                self.paths += [line.strip().split(' ')[1] for line in fin]
-
-        # Hyperparameter of Degradation
-        # 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_range = [2 * v + 1 for v in range(3, 11)]  # kernel size ranges from 7 to 21
-        # TODO: kernel range is now hard-coded, should be in the configure file
-        self.pulse_tensor = torch.zeros(21, 21).float()  # convolving with pulse tensor brings no blurry effect
-        self.pulse_tensor[10, 10] = 1
-
-        self.device = torch.cuda.current_device()
-        self.jpeger = DiffJPEG(differentiable=False).to(self.device)  # simulate JPEG compression artifacts
-        self.usm_sharpener = USMSharp().to(self.device)  # do usm sharpening
-        self.resize = opt['gt_size']
-        self.keep_ratio = opt['keep_ratio']
-
-        # function
-        self.crop = T.RandomCrop((self.resize, self.resize))
-        self.flip = T.RandomHorizontalFlip()
-        self.transform = T.Compose(
-            [
-                # T.ToDtype(torch.float32, scale=True),  # only support for torch 2.++
-                T.ToTensor(),
-            ]
-        )
-
-    def __getitem__(self, index):
-        # -------------------------------- Load gt images -------------------------------- #
-        gt_path = self.paths[index]
-        img_gt = Image.open(gt_path).convert("RGB")
-
-        # -------------------------------- Image Process --------------------------------
-        # resize
-        h, w = img_gt.height, img_gt.width
-        if self.keep_ratio:
-            ratio = self.resize / min(h, w)
-            h_new, w_new = round(h * ratio * 1.2), round(w * ratio * 1.2)
-            img_gt = img_gt.resize((w_new, h_new), resample=Image.LANCZOS)
-        else:
-            img_gt = img_gt.resize((self.resize, self.resize), resample=Image.LANCZOS)
-        # crop and 
-        img_gt = self.crop(img_gt)
-        # flip (only for train)
-        if self.train:
-            img_gt = self.flip(img_gt)
-        # transform to tensor
-        img_gt = self.transform(img_gt).to(torch.float32)
-
-        # -------------------------------- Generate Kernels --------------------------------
-        kernel, kernel2, sinc_kernel = self.generate_kernel()
-
-        # ------------------------- Generate Low Resolutino Sample -------------------------
-        lq, hq = self.generate_lr({
-                "gt": img_gt.unsqueeze(0),
-                "kernel1": kernel,
-                "kernel2": kernel2,
-                "sinc_kernel": sinc_kernel,
-            })
-
-        return lq, hq, gt_path
-
-    def generate_kernel(self, ):
-        # ------------------------ Generate kernels (used in the first degradation) ------------------------ #
-        kernel_size = random.choice(self.kernel_range)
-        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 = (21 - kernel_size) // 2
-        kernel = np.pad(kernel, ((pad_size, pad_size), (pad_size, pad_size)))
-        kernel = torch.FloatTensor(kernel)
-
-        # ------------------------ Generate kernels (used in the second degradation) ------------------------ #
-        kernel_size = random.choice(self.kernel_range)
-        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 = (21 - kernel_size) // 2
-        kernel2 = np.pad(kernel2, ((pad_size, pad_size), (pad_size, pad_size)))
-        kernel2 = torch.FloatTensor(kernel2)
-        
-        # ------------------------------------- the final sinc kernel ------------------------------------- #
-        if np.random.uniform() < self.opt['final_sinc_prob']:
-            kernel_size = random.choice(self.kernel_range)
-            omega_c = np.random.uniform(np.pi / 3, np.pi)
-            sinc_kernel = circular_lowpass_kernel(omega_c, kernel_size, pad_to=21)
-            sinc_kernel = torch.FloatTensor(sinc_kernel)
-        else:
-            sinc_kernel = self.pulse_tensor
-        return kernel, kernel2, sinc_kernel
-
-    def generate_lr(self, data):
-        """Accept data from dataloader, and then add two-order degradations to obtain LQ images.
-        """
-        # training data synthesis
-        self.gt = data['gt'].to(self.device)
-        self.gt_usm = self.usm_sharpener(self.gt)
-
-        self.kernel1 = data['kernel1'].to(self.device)
-        self.kernel2 = data['kernel2'].to(self.device)
-        self.sinc_kernel = data['sinc_kernel'].to(self.device)
-
-        ori_h, ori_w = self.gt.size()[2:4]
-
-        # ----------------------- The first degradation process ----------------------- #
-        # blur
-        out = filter2D(self.gt_usm, self.kernel1)
-        # random resize
-        updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob'])[0]
-        if updown_type == 'up':
-            scale = np.random.uniform(1, self.opt['resize_range'][1])
-        elif updown_type == 'down':
-            scale = np.random.uniform(self.opt['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 = self.opt['gray_noise_prob']
-        if np.random.uniform() < self.opt['gaussian_noise_prob']:
-            out = random_add_gaussian_noise_pt(
-                out, sigma_range=self.opt['noise_range'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-        else:
-            out = random_add_poisson_noise_pt(
-                out,
-                scale_range=self.opt['poisson_scale_range'],
-                gray_prob=gray_noise_prob,
-                clip=True,
-                rounds=False)
-        # JPEG compression
-        jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['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 np.random.uniform() < self.opt['second_blur_prob']:
-            out = filter2D(out, self.kernel2)
-        # random resize
-        updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob2'])[0]
-        if updown_type == 'up':
-            scale = np.random.uniform(1, self.opt['resize_range2'][1])
-        elif updown_type == 'down':
-            scale = np.random.uniform(self.opt['resize_range2'][0], 1)
-        else:
-            scale = 1
-        mode = random.choice(['area', 'bilinear', 'bicubic'])
-        out = F.interpolate(
-            out, size=(int(ori_h * scale), int(ori_w * scale)), mode=mode)
-        # add noise
-        gray_noise_prob = self.opt['gray_noise_prob2']
-        if np.random.uniform() < self.opt['gaussian_noise_prob2']:
-            out = random_add_gaussian_noise_pt(
-                out, sigma_range=self.opt['noise_range2'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-        else:
-            out = random_add_poisson_noise_pt(
-                out,
-                scale_range=self.opt['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 np.random.uniform() < 0.5:
-            # resize back + the final sinc filter
-            mode = random.choice(['area', 'bilinear', 'bicubic'])
-            out = F.interpolate(out, size=(ori_h, ori_w), mode=mode)
-            out = filter2D(out, self.sinc_kernel)
-            # JPEG compression
-            jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['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_(*self.opt['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, ori_w), mode=mode)
-            out = filter2D(out, self.sinc_kernel)
-
-        # clamp and round
-        lq = torch.clamp((out * 255.0).round(), 0, 255) / 255.
-        lq = lq.contiguous()  # for the warning: grad and param do not obey the gradient layout contract
-
-        hq = self.usm_sharpener(self.gt)
-        return lq[0], hq[0] 
-
-    def __len__(self):
-        return len(self.paths)
-
-def real_esrgan_sampler():
-    """
-    Generate multi-scale versions for GT images with LANCZOS resampling.
-    It is now used for DF2K dataset (DIV2K + Flickr 2K)
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--num_samples', type=int, default=3, help='train: one to many')
-    args = parser.parse_args()
-
-    # generate training dataset
-    dataset = RealESRGANDataset(cfg, train=True)
-    data_dl = data.DataLoader( 
-        dataset,
-        batch_size = 1
-    )
-    print("Train Data:", dataset.data_rt, len(data_dl))
-    for number in range(args.num_samples):
-        print("="*100)
-        print(f"Generate round {number}...")
-
-        meta_info = {}
-        for sample in tqdm(data_dl):
-            lq, hq, path = sample
-            # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
-            file_name = os.path.basename(path[0])
-            gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
-            if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
-                hq_folder = gt_folder.replace("HR", f"pair/SR{number+1}/HR")
-                lq_folder = gt_folder.replace("HR", f"pair/SR{number+1}/LR")
-            else:
-                hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/SR{number+1}"), "HR/")
-                lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/SR{number+1}"), "LR/")
-
-            os.makedirs(hq_folder, exist_ok=True)
-            os.makedirs(lq_folder, exist_ok=True)
-
-            hq_path = os.path.join(hq_folder, file_name)
-            lq_path = os.path.join(lq_folder, file_name)
-
-            save_image(hq[0], hq_path)
-            save_image(lq[0], lq_path)
-
-            dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
-            if dset not in meta_info:
-                meta_info[dset] = [(lq_path, hq_path)]
-            else:
-                meta_info[dset].append((lq_path, hq_path))
-
-        for dset, dlist in meta_info.items():
-            with open(os.path.join(dataset.data_rt,'{}/metas/{}_train_SR{}.list'.format(dset, dset, number+1)), 'w') as fp:
-                for item in dlist:
-                    fp.write('{} {} {}\n'.format(item[0], item[1], None))
-            print(os.path.join(dataset.data_rt,'{}/metas/{}_train_SR{}.list'.format(dset, dset, number+1)), len(dlist))
-
-
-    # generate testing dataset
-    dataset = RealESRGANDataset(cfg, train=False)
-    data_dl = data.DataLoader( 
-        dataset,
-        batch_size = 1
-    )
-    print("Test Data:", dataset.data_rt, len(data_dl))
-    print("="*100)
-    print(f"Generate round {number}...")
-
-    meta_info = {}
-    for sample in tqdm(data_dl):
-        lq, hq, path = sample
-        # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/0098.png
-        file_name = os.path.basename(path[0])
-        gt_folder = os.path.dirname(path[0]) # /home/CORP/hsiang.chen/Project/Datasets/IR/SuperResolution/DIV2K/DIV2K_train_HR/
-        if "DIV2K_train_HR" in gt_folder or "DIV2K_valid_HR" in gt_folder:
-            hq_folder = gt_folder.replace("HR", f"pair/SR/HR")
-            lq_folder = gt_folder.replace("HR", f"pair/SR/LR")
-        else:
-            hq_folder = os.path.join(gt_folder.replace("images", f"images_pair/SR"), "HR/")
-            lq_folder = os.path.join(gt_folder.replace("images", f"images_pair/SR"), "LR/")
-
-        os.makedirs(hq_folder, exist_ok=True)
-        os.makedirs(lq_folder, exist_ok=True)
-
-        hq_path = os.path.join(hq_folder, file_name)
-        lq_path = os.path.join(lq_folder, file_name)
-
-        save_image(hq[0], hq_path)
-        save_image(lq[0], lq_path)
-
-        dset = os.path.relpath(gt_folder, dataset.data_rt).split("/")[0]
-        if dset not in meta_info:
-            meta_info[dset] = [(lq_path, hq_path)]
-        else:
-            meta_info[dset].append((lq_path, hq_path))
-
-    for dset, dlist in meta_info.items():
-        with open(os.path.join(dataset.data_rt,'{}/metas/{}_valid_SR.list'.format(dset, dset)), 'w') as fp:
-            for item in dlist:
-                fp.write('{} {} {}\n'.format(item[0], item[1], None))
-        print(os.path.join(dataset.data_rt,'{}/metas/{}_valid_SR.list'.format(dset, dset)), len(dlist))
-
-def simple_multiscale():
-    """
-    Generate multi-scale versions for GT images with LANCZOS resampling.
-    It is now used for DF2K dataset (DIV2K + Flickr 2K)
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--input', type=str, default='DIV2K/DIV2K_train_HR', help='Input folder')
-    parser.add_argument('--output', type=str, default='DIV2K/DIV2K_train_multiscale', help='Output folder')
-    args = parser.parse_args()
-    os.makedirs(args.output, exist_ok=True)
-
-    # For DF2K, we consider the following three scales,
-    # and the smallest image whose shortest edge is 400
-    scale_list = [0.75, 0.5, 1 / 3]
-    shortest_edge = 400
-
-    path_list = sorted(glob.glob(os.path.join(args.input, '*')))
-    for path in path_list:
-        basename = os.path.splitext(os.path.basename(path))[0]
-
-        img = Image.open(path)
-        width, height = img.size
-        for idx, scale in enumerate(scale_list):
-            print(f'\t{scale:.2f}')
-            rlt = img.resize((int(width * scale), int(height * scale)), resample=Image.LANCZOS)
-            rlt = rlt.resize((width, height), resample=Image.NEAREST)
-            rlt.save(os.path.join(args.output, f'{basename}T{idx}.png'))
-
-        # save the smallest image which the shortest edge is 400
-        if width < height:
-            ratio = height / width
-            width = shortest_edge
-            height = int(width * ratio)
-        else:
-            ratio = width / height
-            height = shortest_edge
-            width = int(height * ratio)
-        rlt = img.resize((int(width), int(height)), resample=Image.LANCZOS)
-        rlt = rlt.resize(img.size, resample=Image.NEAREST)
-        rlt.save(os.path.join(args.output, f'{basename}T{idx+1}.png'))
-
-
-if __name__ == '__main__':
-    set_seed(1229)
-    # simple version
-    # simple_multiscale()
-    
-    # Real-ESRGAN for data generation
-    real_esrgan_sampler()
-
-# python 2_generate_lowresolution.py --num_samples 3