视频超分、图像超分常用数据集Vimeo90K的下载及处理

最新推荐文章于 2024-06-03 19:42:55 发布
最新推荐文章于 2024-06-03 19:42:55 发布
阅读量8.1k 收藏 19
点赞数 8
分类专栏： 数据集 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyrobot01/article/details/119892702
版权

vimeo90k数据集下载链接：

http://toflow.csail.mit.edu/

下载时点击最下方的训练集测试集一起下载即可，共计82G.数据集中已经划分了训练集和测试集，并给出了划分的txt以及4倍下采样后的图像。

在视频超分中，常常需要将图像转存为lmdb格式，该格式下运行速度更快，并且是依赖于缓存的。下面提供了将vimeo90K数据转换为lmdb格式的代码：create_lmdb.py

"""Create lmdb files for [General images (291 images/DIV2K) | Vimeo90K | REDS] training datasets"""

import sys
import os.path as osp
import glob
import pickle
from multiprocessing import Pool
import numpy as np
import lmdb
import cv2

sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
import data.util as data_util  # noqa: E402
import utils.util as util  # noqa: E402


def main():
    dataset = 'vimeo90k'  # vimeo90K | REDS | general (e.g., DIV2K, 291) | DIV2K_demo |test
    mode = 'GT'  # used for vimeo90k and REDS datasets
    # vimeo90k: GT | LR | flow
    # REDS: train_sharp, train_sharp_bicubic, train_blur_bicubic, train_blur, train_blur_comp
    #       train_sharp_flowx4
    if dataset == 'vimeo90k':
        vimeo90k(mode)
    elif dataset == 'REDS':
        REDS(mode)
    elif dataset == 'general':
        opt = {}
        opt['img_folder'] = '../../datasets/DIV2K/DIV2K800_sub'
        opt['lmdb_save_path'] = '../../datasets/DIV2K/DIV2K800_sub.lmdb'
        opt['name'] = 'DIV2K800_sub_GT'
        general_image_folder(opt)
    elif dataset == 'DIV2K':
        opt = {}
        ## GT
        opt['img_folder'] = '../../datasets/DIV2K_train_HR_sub'
        opt['lmdb_save_path'] = '../../datasets/DIV2K_train_HR_sub.lmdb'
        opt['name'] = 'DIV2K'
        general_image_folder(opt)
        ## LR
        opt['img_folder'] = '../../datasets/DIV2K/DIV2K_train_LR_bicubic/X4_sub'
        opt['lmdb_save_path'] = '../../datasets/DIV2K/imdb/DIV2K_train_LR_bicubic_X4_sub.lmdb'
        opt['name'] = 'DIV2Kx4'
        # general_image_folder(opt)
    elif dataset == 'test':
        test_lmdb('../../datasets/REDS/train_sharp_wval.lmdb', 'REDS')


def read_image_worker(path, key):
    img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    return (key, img)


def general_image_folder(opt):
    """Create lmdb for general image folders
    Users should define the keys, such as: '0321_s035' for DIV2K sub-images
    If all the images have the same resolution, it will only store one copy of resolution info.
        Otherwise, it will store every resolution info.
    """
    #### configurations
    read_all_imgs = False  # whether real all images to memory with multiprocessing
    # Set False for use limited memory
    BATCH = 5000  # After BATCH images, lmdb commits, if read_all_imgs = False
    n_thread = 40
    ########################################################
    img_folder = opt['img_folder']
    lmdb_save_path = opt['lmdb_save_path']
    meta_info = {'name': opt['name']}
    if not lmdb_save_path.endswith('.lmdb'):
        raise ValueError("lmdb_save_path must end with \'lmdb\'.")
    if osp.exists(lmdb_save_path):
        print('Folder [{:s}] already exists. Exit...'.format(lmdb_save_path))
        sys.exit(1)

    #### read all the image paths to a list
    print('Reading image path list ...')
    all_img_list = sorted(glob.glob(osp.join(img_folder, '*')))
    keys = []
    for img_path in all_img_list:
        keys.append(osp.splitext(osp.basename(img_path))[0])

    if read_all_imgs:
        #### read all images to memory (multiprocessing)
        dataset = {}  # store all image data. list cannot keep the order, use dict
        print('Read images with multiprocessing, #thread: {} ...'.format(n_thread))
        pbar = util.ProgressBar(len(all_img_list))

        def mycallback(arg):
            '''get the image data and update pbar'''
            key = arg[0]
            dataset[key] = arg[1]
            pbar.update('Reading {}'.format(key))

        pool = Pool(n_thread)
        for path, key in zip(all_img_list, keys):
            pool.apply_async(read_image_worker, args=(path, key), callback=mycallback)
        pool.close()
        pool.join()
        print('Finish reading {} images.\nWrite lmdb...'.format(len(all_img_list)))

    #### create lmdb environment
    data_size_per_img = cv2.imread(all_img_list[0], cv2.IMREAD_UNCHANGED).nbytes
    print('data size per image is: ', data_size_per_img)
    data_size = data_size_per_img * len(all_img_list)
    env = lmdb.open(lmdb_save_path, map_size=data_size * 10)

    #### write data to lmdb
    pbar = util.ProgressBar(len(all_img_list))
    txn = env.begin(write=True)
    resolutions = []
    for idx, (path, key) in enumerate(zip(all_img_list, keys)):
        pbar.update('Write {}'.format(key))
        key_byte = key.encode('ascii')
        data = dataset[key] if read_all_imgs else cv2.imread(path, cv2.IMREAD_UNCHANGED)
        if data.ndim == 2:
            H, W = data.shape
            C = 1
        else:
            H, W, C = data.shape
        txn.put(key_byte, data)
        resolutions.append('{:d}_{:d}_{:d}'.format(C, H, W))
        if not read_all_imgs and idx % BATCH == 0:
            txn.commit()
            txn = env.begin(write=True)
    txn.commit()
    env.close()
    print('Finish writing lmdb.')

    #### create meta information
    # check whether all the images are the same size
    assert len(keys) == len(resolutions)
    if len(set(resolutions)) <= 1:
        meta_info['resolution'] = [resolutions[0]]
        meta_info['keys'] = keys
        print('All images have the same resolution. Simplify the meta info.')
    else:
        meta_info['resolution'] = resolutions
        meta_info['keys'] = keys
        print('Not all images have the same resolution. Save meta info for each image.')

    pickle.dump(meta_info, open(osp.join(lmdb_save_path, 'meta_info.pkl'), "wb"))
    print('Finish creating lmdb meta info.')


def vimeo90k(mode):
    """Create lmdb for the Vimeo90K dataset, each image with a fixed size
    GT: [3, 256, 448]
        Now only need the 4th frame, e.g., 00001_0001_4
    LR: [3, 64, 112]
        1st - 7th frames, e.g., 00001_0001_1, ..., 00001_0001_7
    key:
        Use the folder and subfolder names, w/o the frame index, e.g., 00001_0001

    flow: downsampled flow: [3, 360, 320], keys: 00001_0001_4_[p3, p2, p1, n1, n2, n3]
        Each flow is calculated with GT images by PWCNet and then downsampled by 1/4
        Flow map is quantized by mmcv and saved in png format
    """
    print(mode)
    #### configurations
    read_all_imgs = False  # whether real all images to memory with multiprocessing
    # Set False for use limited memory
    BATCH = 5000  # After BATCH images, lmdb commits, if read_all_imgs = False
    if mode == 'GT':
        img_folder = 'datasets/Vimeo90Kdata/vimeo_triplet/sequences'
        lmdb_save_path = 'datasets/Vimeo90Kdata/vimeo90k_train_GT.lmdb'
        txt_file = 'datasets/Vimeo90Kdata/vimeo_triplet/tri_trainlist.txt'
        H_dst, W_dst = 256, 448
    elif mode == 'LR':
        img_folder = 'datasets/Vimeo90Kdata/vimeo_triplet/LR_x4'
        lmdb_save_path = 'datasets/Vimeo90Kdata/vimeo_triplet/vimeo90k_train_LR7frames.lmdb'
        txt_file = 'datasets/Vimeo90Kdata/vimeo_triplet/tri_trainlist.txt'
        H_dst, W_dst = 64, 112
    elif mode == 'flow':
        img_folder = 'datasets/Vimeo90Kdata/vimeo_triplet/sequences_flowx4'
        lmdb_save_path = 'datasets/Vimeo90Kdata/vimeo90k_train_flowx4.lmdb'
        txt_file = 'datasets/Vimeo90Kdata/vimeo_triplet/tri_trainlist.txt'
        H_dst, W_dst = 128, 112
    else:
        raise ValueError('Wrong dataset mode: {}'.format(mode))
    n_thread = 40
    ########################################################
    if not lmdb_save_path.endswith('.lmdb'):
        raise ValueError("lmdb_save_path must end with \'lmdb\'.")
    if osp.exists(lmdb_save_path):
        print('Folder [{:s}] already exists. Exit...'.format(lmdb_save_path))
        sys.exit(1)

    #### read all the image paths to a list
    print('Reading image path list ...')
    with open(txt_file) as f:
        train_l = f.readlines()
        train_l = [v.strip() for v in train_l]
    all_img_list = []
    keys = []
    for line in train_l:
        folder = line.split('/')[0]
        sub_folder = line.split('/')[1]
        all_img_list.extend(glob.glob(osp.join(img_folder, folder, sub_folder, '*')))
        if mode == 'flow':
            for j in range(1, 4):
                keys.append('{}_{}_4_n{}'.format(folder, sub_folder, j))
                keys.append('{}_{}_4_p{}'.format(folder, sub_folder, j))
        else:
            for j in range(7):
                keys.append('{}_{}_{}'.format(folder, sub_folder, j + 1))
    all_img_list = sorted(all_img_list)
    keys = sorted(keys)

    # This is only for super resolution
    # if mode == 'GT':  # only read the 4th frame for the GT mode
    #     print('Only keep the 4th frame.')
    #     all_img_list = [v for v in all_img_list if v.endswith('im4.png')]
    #     keys = [v for v in keys if v.endswith('_4')]

    if read_all_imgs:
        #### read all images to memory (multiprocessing)
        dataset = {}  # store all image data. list cannot keep the order, use dict
        print('Read images with multiprocessing, #thread: {} ...'.format(n_thread))
        pbar = util.ProgressBar(len(all_img_list))

        def mycallback(arg):
            """get the image data and update pbar"""
            key = arg[0]
            dataset[key] = arg[1]
            pbar.update('Reading {}'.format(key))

        pool = Pool(n_thread)
        for path, key in zip(all_img_list, keys):
            pool.apply_async(read_image_worker, args=(path, key), callback=mycallback)
        pool.close()
        pool.join()
        print('Finish reading {} images.\nWrite lmdb...'.format(len(all_img_list)))

    #### write data to lmdb
    data_size_per_img = cv2.imread(all_img_list[0], cv2.IMREAD_UNCHANGED).nbytes
    print('data size per image is: ', data_size_per_img)
    data_size = data_size_per_img * len(all_img_list)
    env = lmdb.open(lmdb_save_path, map_size=data_size * 10)
    txn = env.begin(write=True)
    pbar = util.ProgressBar(len(all_img_list))
    for idx, (path, key) in enumerate(zip(all_img_list, keys)):
        pbar.update('Write {}'.format(key))
        key_byte = key.encode('ascii')
        data = dataset[key] if read_all_imgs else cv2.imread(path, cv2.IMREAD_UNCHANGED)
        if 'flow' in mode:
            H, W = data.shape
            assert H == H_dst and W == W_dst, 'different shape.'
        else:
            H, W, C = data.shape
            assert H == H_dst and W == W_dst and C == 3, 'different shape.'
        txn.put(key_byte, data)
        if not read_all_imgs and idx % BATCH == 0:
            txn.commit()
            txn = env.begin(write=True)
    txn.commit()
    env.close()
    print('Finish writing lmdb.')

    #### create meta information
    meta_info = {}
    if mode == 'GT':
        meta_info['name'] = 'Vimeo90K_train_GT'
    elif mode == 'LR':
        meta_info['name'] = 'Vimeo90K_train_LR'
    elif mode == 'flow':
        meta_info['name'] = 'Vimeo90K_train_flowx4'
    channel = 1 if 'flow' in mode else 3
    meta_info['resolution'] = '{}_{}_{}'.format(channel, H_dst, W_dst)
    key_set = set()
    for key in keys:
        if mode == 'flow':
            a, b, _, _ = key.split('_')
        else:
            a, b, _ = key.split('_')
        key_set.add('{}_{}'.format(a, b))
    meta_info['keys'] = list(key_set)
    pickle.dump(meta_info, open(osp.join(lmdb_save_path, 'meta_info.pkl'), "wb"))
    print('Finish creating lmdb meta info.')


def REDS(mode):
    """Create lmdb for the REDS dataset, each image with a fixed size
    GT: [3, 720, 1280], key: 000_00000000
    LR: [3, 180, 320], key: 000_00000000
    key: 000_00000000

    flow: downsampled flow: [3, 360, 320], keys: 000_00000005_[p2, p1, n1, n2]
        Each flow is calculated with the GT images by PWCNet and then downsampled by 1/4
        Flow map is quantized by mmcv and saved in png format
    """
    #### configurations
    read_all_imgs = False  # whether real all images to memory with multiprocessing
    # Set False for use limited memory
    BATCH = 5000  # After BATCH images, lmdb commits, if read_all_imgs = False
    if mode == 'train_sharp':
        img_folder = '../../datasets/REDS/train_sharp'
        lmdb_save_path = '../../datasets/REDS/train_sharp_wval.lmdb'
        H_dst, W_dst = 720, 1280
    elif mode == 'train_sharp_bicubic':
        img_folder = '../../datasets/REDS/train_sharp_bicubic'
        lmdb_save_path = '../../datasets/REDS/train_sharp_bicubic_wval.lmdb'
        H_dst, W_dst = 180, 320
    elif mode == 'train_blur_bicubic':
        img_folder = '../../datasets/REDS/train_blur_bicubic'
        lmdb_save_path = '../../datasets/REDS/train_blur_bicubic_wval.lmdb'
        H_dst, W_dst = 180, 320
    elif mode == 'train_blur':
        img_folder = '../../datasets/REDS/train_blur'
        lmdb_save_path = '../../datasets/REDS/train_blur_wval.lmdb'
        H_dst, W_dst = 720, 1280
    elif mode == 'train_blur_comp':
        img_folder = '../../datasets/REDS/train_blur_comp'
        lmdb_save_path = '../../datasets/REDS/train_blur_comp_wval.lmdb'
        H_dst, W_dst = 720, 1280
    elif mode == 'train_sharp_flowx4':
        img_folder = '../../datasets/REDS/train_sharp_flowx4'
        lmdb_save_path = '../../datasets/REDS/train_sharp_flowx4.lmdb'
        H_dst, W_dst = 360, 320
    n_thread = 40
    ########################################################
    if not lmdb_save_path.endswith('.lmdb'):
        raise ValueError("lmdb_save_path must end with \'lmdb\'.")
    if osp.exists(lmdb_save_path):
        print('Folder [{:s}] already exists. Exit...'.format(lmdb_save_path))
        sys.exit(1)

    #### read all the image paths to a list
    print('Reading image path list ...')
    all_img_list = data_util._get_paths_from_images(img_folder)
    keys = []
    for img_path in all_img_list:
        split_rlt = img_path.split('/')
        folder = split_rlt[-2]
        img_name = split_rlt[-1].split('.png')[0]
        keys.append(folder + '_' + img_name)

    if read_all_imgs:
        #### read all images to memory (multiprocessing)
        dataset = {}  # store all image data. list cannot keep the order, use dict
        print('Read images with multiprocessing, #thread: {} ...'.format(n_thread))
        pbar = util.ProgressBar(len(all_img_list))

        def mycallback(arg):
            '''get the image data and update pbar'''
            key = arg[0]
            dataset[key] = arg[1]
            pbar.update('Reading {}'.format(key))

        pool = Pool(n_thread)
        for path, key in zip(all_img_list, keys):
            pool.apply_async(read_image_worker, args=(path, key), callback=mycallback)
        pool.close()
        pool.join()
        print('Finish reading {} images.\nWrite lmdb...'.format(len(all_img_list)))

    #### create lmdb environment
    data_size_per_img = cv2.imread(all_img_list[0], cv2.IMREAD_UNCHANGED).nbytes
    print('data size per image is: ', data_size_per_img)
    data_size = data_size_per_img * len(all_img_list)
    env = lmdb.open(lmdb_save_path, map_size=data_size * 10)

    #### write data to lmdb
    pbar = util.ProgressBar(len(all_img_list))
    txn = env.begin(write=True)
    for idx, (path, key) in enumerate(zip(all_img_list, keys)):
        pbar.update('Write {}'.format(key))
        key_byte = key.encode('ascii')
        data = dataset[key] if read_all_imgs else cv2.imread(path, cv2.IMREAD_UNCHANGED)
        if 'flow' in mode:
            H, W = data.shape
            assert H == H_dst and W == W_dst, 'different shape.'
        else:
            H, W, C = data.shape
            assert H == H_dst and W == W_dst and C == 3, 'different shape.'
        txn.put(key_byte, data)
        if not read_all_imgs and idx % BATCH == 0:
            txn.commit()
            txn = env.begin(write=True)
    txn.commit()
    env.close()
    print('Finish writing lmdb.')

    #### create meta information
    meta_info = {}
    meta_info['name'] = 'REDS_{}_wval'.format(mode)
    channel = 1 if 'flow' in mode else 3
    meta_info['resolution'] = '{}_{}_{}'.format(channel, H_dst, W_dst)
    meta_info['keys'] = keys
    pickle.dump(meta_info, open(osp.join(lmdb_save_path, 'meta_info.pkl'), "wb"))
    print('Finish creating lmdb meta info.')


def test_lmdb(dataroot, dataset='REDS'):
    env = lmdb.open(dataroot, readonly=True, lock=False, readahead=False, meminit=False)
    meta_info = pickle.load(open(osp.join(dataroot, 'meta_info.pkl'), "rb"))
    print('Name: ', meta_info['name'])
    print('Resolution: ', meta_info['resolution'])
    print('# keys: ', len(meta_info['keys']))
    # read one image
    if dataset == 'vimeo90k':
        key = '00001_0001_4'
    else:
        key = '000_00000000'
    print('Reading {} for test.'.format(key))
    with env.begin(write=False) as txn:
        buf = txn.get(key.encode('ascii'))
    img_flat = np.frombuffer(buf, dtype=np.uint8)
    C, H, W = [int(s) for s in meta_info['resolution'].split('_')]
    img = img_flat.reshape(H, W, C)
    cv2.imwrite('test.png', img)


if __name__ == "__main__":
    main()

使用时仅需修改main函数中的mode为GT 或者LR，然后将vimeo90函数中的处理路径修改为自己的文件路径即可生成训练集和测试集的GT和LR的lmdb格式文件。

DZZ!!!!
关注
  • 8
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Youku-VESR Dataset 优酷视频增强和超分数据集 | 比赛数据集 |
专注于AI领域前沿技术学习与分享：目标检测、图像修复、超分重建、AI工程化
01-19 1137
Youku-VESR Dataset 优酷视频增强和超分数据集 介绍 赛题链接 Youku-VESR Dataset 优酷视频增强和超分数据集下载方式总结如下： 下载链接： https://tianchi.aliyun.com/dataset/dataDetail?dataId=39568 下载界面： data_list_20191010.csv 文件内容如下： 都是国内链接，下载速度还是 刚刚的； ...
超分辨率常用数据集(Set5, Set14, BSD100, BSDS200, BSDS300, BSDS500, 91-images,General-100,
03-18
超分辨率常用数据集,包含数据增强方法和以下数据集：Set5, Set14, BSD100, BSDS200, BSDS300, BSDS500, 91-images,General-100, Manga109, Urban100, historical
超分测试数据集-2、3、4、8倍重建
08-08
总共五个超分重建的测试数据集，BSD100、set5、set14、Sun-Hays80、Urban100；大家酌情下载就好，没有积分的话，可以私信我，我发给你们也可以的！
Video Enhancement with Task-Oriented Flow
_____
07-14 374
许多算法通过光流对齐帧，但是精确的光流估计很难，且光流通常是对特定处理视频的一种次级表示，在本文提出一种新的，这是一种自我监督、特定于具体任务的方式学习的运动表示。本文训练一种神经网络，可以训练运动估计和视频处理两部分组件，通过两者联合训练实现TOFlow，同时，构造了数据集Vimeo90K，用于低级视频处理的大规模、高质量的视频数据集TOFlow在其数据集上的性能，在这些传统视频处理任务（帧插值、去噪、去块和超分辨）中要好于光流处理。
超分辨重建——SRGAN网络训练自己数据集与推理测试（详细图文教程）
最新发布
qq_40280673的博客
06-03 1579
SRGAN通过利用生成对抗网络（GAN）来实现单图像超分辨率重建。传统的方法如基于均方误差（MSE）的优化通常会导致图像平滑且缺乏细节，而SRGAN通过引入感知损失函数（perceptual loss），使得重建的图像不仅在像素级别上更接近高分辨率图像，而且在感知质量上也更加接近真实图像。
2022.3.7 cv
lmx001206的博客
03-07 553
basicvsr 有参考RBPN这个的方法 常用的词语： BI：双三次采样 它即可以上采样，也可以下 BD：模糊下采样。同上，一般一次测试中 就用其中一个就可以 2020之前现有的超分模型都在Basicvsr文章做了对比 Basic用reds训练时，输入的时15帧。而用Vimeo-90k时7帧，但是通过了翻转，所以等同于14帧。 vimeo90k数据全是gt的，先给它四倍下采样。然后gt最后，只要最中间的那张即可。这是照着测试集来的（划分来的）。（这个gt中的第四个我也没单独拿出来，它的代码..
基于光流的视频插帧算法 TOFlow 解读教程
qq_39967751的博客
07-01 2878
​ 以TOFlow(Video Enhancement with Task-Oriented Flow) 为例介绍基于光流的视频插帧算法以及其在MMEditing中的实现。
光流插帧算法
qq_73990157的博客
03-19 1066
TOFlow (Task-Oriented Flow) 针对特定视频处理任务（如视频插帧、视频去噪、视频超分辨率）提供了一种改进的光流估计方法。这种方法通过在光流估计过程中考虑任务的特定需求，来优化光流的计算，从而提高最终视频处理任务的性能。：TOFlow不是简单地估计视频帧之间的光流，而是根据视频处理的具体任务（例如插帧、去噪或超分辨率）来优化光流的计算。这种方法允许模型更好地适应特定的视频处理需求，从而提高结果的质量。：传统的光流估计方法往往在处理边缘模糊、光照变化或运动模糊等问题时性能下降。
EDVR_Vimeo90K_SR_L.pth
06-10
开源视频增强项目EDVR 训练好的模型EDVR_Vimeo90K_SR_L Name convention EDVR_(training dataset)_(track name)_(model complexity) track name. There are four tracks in the NTIRE 2019 Challenges on Video Restoration and Enhancement: SR: super-resolution with a fixed downsampling kernel (MATLAB bicubic downsampling kernel is frequently used). Most of the previous video SR methods focus on this setting. SRblur: the inputs are also degraded with motion blur. deblur: standard deblurring (motion blur). deblurcomp: motion blur + video compression artifacts. model complexity L (Large): # of channels = 128, # of back residual blocks = 40. This setting is used in our competition submission. M (Moderate): # of channels = 64, # of back residual blocks = 10.
视频超分：RSDN（Video Super-Resolution with Recurrent Structure-Detail Network）
WangsyHebut的博客
09-26 2641
论文：视频超分与循环的结构-细节网络 文章检索出处：2020 ECCV仅供学习使用，请勿转载。 我们提出了一种新颖的循环视频超分辨率方法，它将输入分为结构组件和细节组件，这些组件被馈入到几个two-stream structure-detail 模块所组成的循环单元中。另外还引入了隐藏状态适配模块，它允许当前帧有选择的使用来自隐藏状态的信息，以增强其对外观变化和错误累计的鲁棒性。在超分辨率的性能和速度方面，变表现非常出色。...
视频超分：EDVR（EDVR: Video Restoration with Enhanced Deformable Convolutional Networks）
WangsyHebut的博客
09-28 3680
论文：EDVR：视频超分与加强的可变形卷积网络 文章检索出处： 2019 ICCV仅供学习使用，请勿转载。
RealVSR、REDs4、VideoLQ数据集
05-10
GT和LQ
REDs图像训练数据集，网盘链接分享
03-06
数据集介绍：https://seungjunnah.github.io/Datasets/reds.html 用于训练去模糊算法的数据集，包含清晰和模糊图片各24000张，包含240个场景，24000对模糊和清晰的图片。
显示youtube视频缩略图和Vimeo视频缩略图代码分享
10-26
主要介绍了显示youtube视频缩略图和Vimeo视频缩略图的代码,需要的朋友可以参考下
vimeo-private-downloader:脚本使您可以访问在Vimeo上下载私人视频
05-09
Vimeo私人视频下载器 Node.js脚本可帮助您从下载私人视频 在开始之前，请确保已安装 要检查它，请在终端node -v运行。 例如，您将看到v10.11.0 。 如果出现错误，请安装最新的 下载 要下载视频，您必须： 在“网络...
下载Vimeo优质视频-crx插件
04-02
4.云图标启动下载***所需的权限说明：* vimeo.com上的数据以捕获视频* licensor.io上的用于许可的数据*浏览器历史记录来自许可，该应用程序可以从哪个选项卡中检测视频的播放情况*管理下载以启动视频下载并检测视频...
视频超分：STVUN（Deep Space-Time Video Upsampling Networks）
WangsyHebut的博客
11-29 2316
论文：深度时空视频上采样网络 文章检索出处：2020 ECCV 代码：https://github.com/JaeYeonKang/STVUN-Pytorch问题： 解决视频在空间和时间上的联合上采样问题的一种方法是逐个独立运行VSR和FI，效率低下。在VSR中，大多数方法都包括特征提取、对齐、融合和重构四个阶段。对于FI，该过程可分为特征提取、特征插值和重构。 贡献：1. 本文提出了一种用于时空视频上采样的端到端框架（STVUN），通过共享特征提取模块和重构模块，有效地将VSR和FI合并为一个联合框架。
EDVR复现过程中的Segmentation Fault及Vimeo-90k数据集的百度盘下载
change_things的博客
07-12 5122
EDVR复现Vid4中的Segmentation FaultEDVR介绍Segmentation Fault升级gcc重新编译运行运行结果 EDVR介绍 EDVR全称是：Video Restoration with Enhanced Deformable Convolutional Networks，是CVPR 2019 Workshop NTIRE 2019的冠军。在视频超分辨率Vid4数据集上测试结果仅次于今年的ISeeBetter，只有一点点的差距。 EDVR提出了一个PCD 对齐模块和时空注意力融合
视频插帧数据集
牧野的博客
02-16 8499
Vimeo-90K Vimeo-90K是在论文Video Enhancement with Task-Oriented Flow（IJCV 2019）里提出的，数据集地址： http://toflow.csail.mit.edu/ 图源http://toflow.csail.mit.edu/ 整个数据集是从vimeo.com网站上收集的89800个视频片段上生成的，涵盖了多种场景和多种运动形态。 数据集包含两个子集，一个是“Triplet dataset”，一个是“Septuplet dataset
超分重建缺陷数据集有哪些
03-30
超分重建缺陷数据集包括但不限于以下几种： 1. 噪声图像数据集：包含噪声、模糊、低分辨率等缺陷的图像数据集，如BSD68、Set5、Set14等。 2. 单一缺陷图像数据集：包含某一种特定缺陷的图像数据集，如文本重叠、遮挡、运动模糊等。 3. 多缺陷图像数据集：包含多种缺陷的图像数据集，如Manga109、DIV2K等。 4. 视频超分重建数据集：包含视频序列的图像数据集，如Vimeo-90k、REDS等。 5. 医学图像数据集：包含医学图像的图像数据集，如LIDC-IDRI、NIH Chest X-ray等。 6. 自然场景图像数据集：包含自然场景图像的图像数据集，如COCO、ImageNet等。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DZZ!!!!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值