def get_cbsd68_dataset(cfg):
#
# -- extract --
#
# -- misc --
root = cfg.dataset.root
noise_info = cfg.noise_params[cfg.noise_type]
dynamic_info = cfg.dynamic
isize = return_optional(cfg, "frame_size", None)
# -- samples --
nsamples = return_optional(cfg, "nsamples", 0)
tr_nsamples = return_optional(cfg, "tr_nsamples", nsamples)
val_nsamples = return_optional(cfg, "val_nsamples", nsamples)
te_nsamples = return_optional(cfg, "te_nsamples", nsamples)
# -- setup paths --
root = Path(root) / Path("./template/images/")
# -- create objcs --
data = edict()
data.tr = Template(root, "train", isize, tr_nsamples, noise_params,
dynamic_info)
data.val = Template(root, "val", isize, val_samples, noise_params,
dynamic_info)
data.test = Template(root, "test", isize, te_samples, noise_params,
dynamic_info)
# -- create loader --
loader = get_loader(cfg, data, cfg.batch_size)
return data, loader
def get_bss_batch_loader(cfg, bss):
data = edict()
data.te = WrapperBSSDataset(bss)
data.tr, data.val = data.te, data.te
drop_last = cfg.drop_last['te']
cfg.drop_last['te'] = False
loader = get_loader(cfg, data, cfg.bss_batch_size, None)
cfg.drop_last['te'] = drop_last
return loader.te
def load_image_dataset_default(cfg):
noise_fxn, dynamic_fxn = transforms_from_cfg(cfg)
data, loader = load_dataset(cfg, 'denoising')
# -- wrapped --
wdata = edict({})
for key, value in data.items():
wdata[key] = WrapperDataset(value, noise_fxn, dynamic_fxn)
wloader = get_loader(cfg, wdata, cfg.batch_size, None)
return wdata, wloader
def get_kitti_dataset(cfg,mode):
root = cfg.dataset.root
root = Path(root)/Path("kitti")
data = edict()
batch_size = cfg.batch_size
rtype = 'dict' if cfg.dataset.dict_loader else 'list'
if mode == "dynamic":
edition = "2015"
nframes = cfg.nframes
noise_info = cfg.noise_params
data.tr = KITTI(root,"train",edition,nframes,noise_info)
data.val = KITTI(root,"val",edition,nframes,noise_info)
data.te = KITTI(root,"test",edition,nframes,noise_info)
else: raise ValueError(f"Unknown KITTI mode {mode}")
loader = get_loader(cfg,data,batch_size,mode)
return data,loader
def load_image_dataset(cfg):
# -- sims from cfg --
noise_fxn, dynamic_fxn = transforms_from_cfg(cfg)
# -- cfg copy without noise --
cfg_copy = copy.deepcopy(cfg)
cfg_copy.noise_params.ntype = 'none'
cfg_copy.noise_params['none'] = {}
data, loader = load_dataset(cfg_copy, 'denoising')
# -- wrapped --
wdata = edict({})
for key, value in data.items():
wdata[key] = WrapperDataset(value, noise_fxn, dynamic_fxn)
wloader = get_loader(cfg, wdata, cfg.batch_size, None)
return wdata, wloader
def get_bsdBurst_dataset(cfg, mode):
# -- select root path --
root = cfg.dataset.root
if mode in ["real_motion", "dynamic"]:
root = Path(root) / Path("./bsdBurst/data/")
elif mode == "synth_motion":
root = Path(root) / Path("./bsdBurst/BSDBursts/")
else:
raise ValueError(f"Unknown BSDBurst mode {mode}")
# -- create dataset obj --
data = edict()
data.tr = BSDBurst(root, cfg.noise_params, cfg.frame_size, cfg.nframes)
data.val, data.te = data.tr, data.tr
# -- get and return loader --
loader = get_loader(cfg, data, cfg.batch_size, mode)
return data, loader
def load_resample_dataset(cfg, records, use_wrapper=True):
# -- sims from cfg --
noise_fxn, dynamic_fxn = transforms_from_cfg(cfg)
# -- cfg copy without noise --
cfg_copy = copy.deepcopy(cfg)
cfg_copy.noise_params.ntype = 'none'
cfg_copy.noise_params['none'] = {}
data, loader = load_dataset(cfg_copy, cfg_copy.dataset.mode)
full_image_index = return_optional(cfg_copy.dataset, 'full_image_index', 2)
# -- wrapped --
wdata = edict({})
for key, value in data.items():
if use_wrapper:
wrapper = WrapperDataset(value, noise_fxn, dynamic_fxn,
full_image_index)
else:
wrapper = value
wdata[key] = ResampleWrapperDataset(wrapper, records[key])
wloader = get_loader(cfg, wdata, cfg.batch_size, None)
return wdata, wloader
def get_burst_with_flow_kitti_dataset(cfg, mode):
root = cfg.dataset.root
root = Path(root) / Path("kitti")
data = edict()
batch_size = cfg.batch_size
rtype = 'dict' if cfg.dataset.dict_loader else 'list'
nnf_K = 3
nnf_ps = 3
nnf_exists = return_optional(cfg.dataset, 'nnf_exists', True)
crop = cfg.frame_size
if isinstance(crop, int):
print("WARNING: the [cfg.frame_size] parameter is just an int.")
path_resize = (1224, 370)
load_resize = crop #(256, 128)
resizes = edict({'path': path_resize, 'load': load_resize})
if mode == "dynamic":
edition = "2015"
nframes = cfg.nframes
noise_info = cfg.noise_params
data.tr = BurstWithFlowKITTI(root, "train", edition, nframes,
noise_info, crop, resizes, nnf_K, nnf_ps,
nnf_exists)
data.val = BurstWithFlowKITTI(root, "val", edition, nframes,
noise_info, crop, resizes, nnf_K, nnf_ps,
nnf_exists)
data.te = BurstWithFlowKITTI(root, "test", edition, nframes,
noise_info, crop, resizes, nnf_K, nnf_ps,
nnf_exists)
else:
raise ValueError(f"Unknown KITTI mode {mode}")
# for split in data:
# print(split,len(data[split]))
loader = get_loader(cfg, data, batch_size, mode)
return data, loader
def get_set8_dataset(cfg):
#
# -- extract --
#
# -- noise and dyanmics --
noise_info = cfg.noise_params
isize = return_optional(cfg, "frame_size", None)
nframes = return_optional(cfg, "nframes", None)
ps = return_optional(cfg.dataset, "patchsize", 3)
tr_split = return_optional(cfg, "train_split", "train") # alt = ["all"]
# -- samples --
nsamples = return_optional(cfg, "nsamples", 0)
tr_nsamples = return_optional(cfg, "tr_nsamples", nsamples)
val_nsamples = return_optional(cfg, "val_nsamples", nsamples)
te_nsamples = return_optional(cfg, "te_nsamples", nsamples)
# -- setup paths --
iroot = IMAGE_PATH
froot = FLOW_PATH
sroot = IMAGE_SETS
# -- create objcs --
data = edict()
data.tr = SET8(iroot, froot, sroot, tr_split, isize, ps, tr_nsamples,
nframes, noise_info)
data.val = SET8(iroot, froot, sroot, "val", isize, ps, val_nsamples,
nframes, noise_info)
data.te = SET8(iroot, froot, sroot, "test", isize, ps, te_nsamples,
nframes, noise_info)
# -- create loader --
loader = get_loader(cfg, data, cfg.batch_size)
return data, loader
def get_burst_kitti_dataset(cfg, mode):
root = cfg.dataset.root
root = Path(root) / Path("kitti")
data = edict()
batch_size = cfg.batch_size
rtype = 'dict' if cfg.dataset.dict_loader else 'list'
nnf_K = 3
nnf_ps = 3
nnf_exists = return_optional(cfg.dataset, 'nnf_exists', True)
if mode in ["dynamic", "denoising"]:
edition = "2015"
nframes = cfg.nframes
noise_info = cfg.noise_params
data.tr = BurstKITTI(root, "train", edition, nframes, noise_info,
nnf_K, nnf_ps, nnf_exists)
data.val = BurstKITTI(root, "val", edition, nframes, noise_info, nnf_K,
nnf_ps, nnf_exists)
data.te = BurstKITTI(root, "test", edition, nframes, noise_info, nnf_K,
nnf_ps, nnf_exists)
else:
raise ValueError(f"Unknown KITTI mode {mode}")
loader = get_loader(cfg, data, batch_size, mode)
return data, loader
def get_cbsd68_dataset(cfg):
#
# -- extract --
#
# -- noise and dyanmics --
noise_info = cfg.noise_params
dynamic_info = cfg.dynamic_info
isize = return_optional(cfg, "frame_size", None)
# -- samples --
nsamples = return_optional(cfg, "nsamples", 0)
tr_nsamples = return_optional(cfg, "tr_nsamples", nsamples)
val_nsamples = return_optional(cfg, "val_nsamples", nsamples)
te_nsamples = return_optional(cfg, "te_nsamples", nsamples)
# -- setup paths --
root = IMAGE_PATH
# -- checks / re-assignments --
dynamic_info.frame_size = isize
# -- create objcs --
data = edict()
data.tr = CBSD68(root, "train", isize, tr_nsamples, noise_info,
dynamic_info)
data.val = CBSD68(root, "val", isize, val_nsamples, noise_info,
dynamic_info)
data.te = CBSD68(root, "test", isize, te_nsamples, noise_info,
dynamic_info)
# -- create loader --
loader = get_loader(cfg, data, cfg.batch_size)
return data, loader
