def CreateSingleDataset(opt):
dataset = None
from data.single_dataset import SingleDataset
dataset = SingleDataset()
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print(("dataset [%s] was created" % (dataset.name())))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
''' Gets called by CustomDatasetDataLoader.initialize(). dataset_mode is
by default unaligned. Dataset has generic structure, inputs are coming
from opts. Aligned, Unaligned are for A->B (i.e., image-to-image transfer
type problems, whereas Single is for z->A problems (and testing).
'''
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'slice':
from data.slice_dataset import SliceDataset
dataset = SliceDataset()
elif opt.dataset_mode == 'voxel':
from data.voxel_dataset import VoxelDataset
dataset = VoxelDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'unaligned_A_labeled':
from data.unaligned_A_labeled_dataset import UnalignedALabeledDataset
dataset = UnalignedALabeledDataset()
elif opt.dataset_mode == 'mnist_svhn':
from data.mnist_svhn_dataset import MnistSvhnDataset
dataset = MnistSvhnDataset()
elif opt.dataset_mode == 'svhn_mnist':
from data.svhn_mnist_dataset import SvhnMnistDataset
dataset = SvhnMnistDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'yh':
from data.yh_dataset import yhDataset
dataset = yhDataset()
elif opt.dataset_mode == 'yh_seg':
from data.yh_seg_dataset import yhSegDataset
dataset = yhSegDataset()
elif opt.dataset_mode == 'yh_seg_spleen':
from data.yh_seg_spleenonly_dataset import yhSegDatasetSpleenOnly
dataset = yhSegDatasetSpleenOnly()
elif opt.dataset_mode == 'yh_test_seg':
from data.yh_test_seg_dataset import yhTestSegDataset
dataset = yhTestSegDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'unaligned_attr':
from data.unaligned_attr_dataset import UnalignedAttrDataset
dataset = UnalignedAttrDataset()
elif opt.dataset_mode == 'unaligned_prog':
from data.unaligned_prog_dataset import UnalignedProgDataset
dataset = UnalignedProgDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'triple':
from data.triple_dataset import TripleDataset
dataset = TripleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'unaligned_A_labeled':
from data.unaligned_A_labeled_dataset import UnalignedALabeledDataset
dataset = UnalignedALabeledDataset()
elif opt.dataset_mode == 'EEG':
from data.eeg_dataset import EEGDataset
dataset = EEGDataset()
elif opt.dataset_mode == 'EEGsingle':
from data.eeg_single_dataset import EEGDataset
dataset = EEGDataset()
elif opt.dataset_mode == 'TestEEG':
from data.eeg_dataset_test import EEGDataset
dataset = EEGDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'thermal':
from data.thermal_dataset import ThermalDataset
dataset = ThermalDataset()
elif opt.dataset_mode == 'thermal_rel':
from data.thermal_rel_dataset import ThermalRelDataset
dataset = ThermalRelDataset()
elif opt.dataset_mode == 'fruxel':
from data.fruxel_dataset import FruxelDataset
dataset = FruxelDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'mat':
from data.mat_dataset import MatDataset
dataset = MatDataset()
elif opt.dataset_mode == 'singlemat':
from data.single_mat_dataset import SingleMatDataset
dataset = SingleMatDataset()
elif opt.dataset_mode == 'superpix':
from data.superpix_dataset import SuperPixDataset
dataset = SuperPixDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'alignedrandom':
from data.aligned_random_dataset import AlignedRandomDataset
dataset = AlignedRandomDataset()
elif opt.dataset_mode == 'Coco':
from data.coco_dataset import UnalignedCocoDataset
dataset = UnalignedCocoDataset()
elif opt.dataset_mode == 'CocoSeg':
from data.cocoseg_dataset import CocoSegDataset
dataset = CocoSegDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'unaligned_random_crop':
from data.unaligned_random_crop import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'pair':
from data.pair_dataset import PairDataset
dataset = PairDataset()
elif opt.dataset_mode == 'syn':
from data.syn_dataset import PairDataset
dataset = PairDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'tif':
from data.tif_dataset import TifDataset
dataset = TifDataset(opt)
elif opt.dataset_mode == 'mb':
from data.mb_dataset import MBDataset
dataset = MBDataset(opt)
elif opt.dataset_mode == 'png_withlist':
from data.png_dataset_withlist import PngDataset
dataset = PngDataset(opt)
elif opt.dataset_mode == 'png':
from data.png_dataset import PngDataset
dataset = PngDataset(opt)
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'imagelist':
from data.imagelist_dataset import ImageList
if opt.isTrain:
dataset = ImageList(root=opt.image_root, fileList=opt.train_list)
else:
dataset = ImageList(root=opt.image_root,
fileList=opt.train_list,
testPahse=True)
elif opt.dataset_mode == 'imagelist_cross_view':
from data.imagelist_dataset import ImageList_cross_view
dataset = ImageList_cross_view()
elif opt.dataset_mode == 'imglist_pts':
from data.imagelist_pts_dataset import Imglist_Pts_Dataset
dataset = Imglist_Pts_Dataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def ISTD_test(self):
opt = self.opt
opt.mask_test = '/home/balin/exper/shadow_removal/Dataset/ISTD_Dataset/test/test_B'
dataset = SingleDataset(
'/home/balin/exper/shadow_removal/Dataset/ISTD_Dataset/test/test_A',
opt)
opt.results_dir = './ISTD_b/'
self.eval_backend_output_only(dataset, opt)
def create_dataset(args):
if args.phase == 'train':
rgb_transforms, torchvision_transforms, gt_transforms = get_transform(
args)
return AlignedDataset(args.data_root, rgb_transforms,
torchvision_transforms, gt_transforms)
elif args.phase == 'test':
rgb_transforms = get_transform(args)
return SingleDataset(args.data_root, rgb_transforms)
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned_2':
from data.aligned_dataset import Aligned_2_Dataset
dataset = Aligned_2_Dataset()
elif opt.dataset_mode == 'aligned_3':
from data.aligned_dataset import Aligned_3_Dataset
dataset = Aligned_3_Dataset()
elif opt.dataset_mode == 'aligned_4':
from data.aligned_dataset import Aligned_4_Dataset
dataset = Aligned_4_Dataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'star' or opt.dataset_mode == 'n2':
from data.half_dataset import N2Dataset
dataset = N2Dataset()
elif opt.dataset_mode == 'star1' or opt.dataset_mode == 'n2t':
from data.half_dataset import N2TestDataset
dataset = N2TestDataset()
elif opt.dataset_mode == 'star2' or opt.dataset_mode == '2n':
from data.half_dataset import _2NDataset
dataset = _2NDataset()
elif opt.dataset_mode == 'single_star' or opt.dataset_mode == 'sn2t':
from data.single_dataset import SingleN2Dataset
dataset = SingleN2Dataset()
elif opt.dataset_mode == 'single_star1' or opt.dataset_mode == 'snt':
from data.single_dataset import SingleNDataset
dataset = SingleNDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'patch':
from data.patch_dataset import PatchDataset
dataset = PatchDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
# print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def modify_commandline_options(parser, is_train):
parser = SingleDataset.modify_commandline_options(parser, is_train)
parser.set_defaults(preprocess_mode='resize_and_crop')
load_size = 36 if is_train else 32
parser.set_defaults(load_size=load_size)
parser.set_defaults(crop_size=32)
parser.set_defaults(display_winsize=32)
parser.set_defaults(label_nc=1)
parser.set_defaults(contain_dontcare_label=False)
parser.add_argument(
'--image_dir',
type=str,
required=True,
help='path to the directory that contains photo images')
return parser
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'blur':
from data.blur_dataset import BlurDataset
dataset = BlurDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'multi':
from data.multi_dataset import MultiDataset
dataset = MultiDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'aligned_with_C':
from data.aligned_dataset_with_C import AlignedDatasetWithC
dataset = AlignedDatasetWithC()
elif opt.dataset_mode == 'aligned_multi_view':
from data.aligned_dataset_multi_view import AlignedDatasetMultiView
dataset = AlignedDatasetMultiView()
elif opt.dataset_mode == 'aligned_multi_view_random':
from data.aligned_dataset_multi_view_random import AlignedDatasetMultiView
dataset = AlignedDatasetMultiView()
elif opt.dataset_mode == 'aligned_depth':
from data.aligned_dataset_depth import AlignedDatasetDepth
dataset = AlignedDatasetDepth()
elif opt.dataset_mode == 'appearance_flow':
from data.appearance_flow_dataloader import AppearanceFlowDataloader
dataset = AppearanceFlowDataloader()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'unaligned_with_guidance':
from data.unaligned_dataset_with_guidance import UnalignedDatasetWithGuidance
dataset = UnalignedDatasetWithGuidance()
elif opt.dataset_mode == 'unaligned_with_label':
from data.unaligned_dataset_with_label import UnalignedDatasetWithLabel
dataset = UnalignedDatasetWithLabel()
elif opt.dataset_mode == 'unaligned_tensor_with_label':
from data.unaligned_tensor_dataset_with_label import UnalignedTensorDatasetWithLabel
dataset = UnalignedTensorDatasetWithLabel()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
# Data stored as one image concatenated along horizontal axis
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
# Data stored in different directories
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'geo':
from data.geo_dataset import GeoDataset
dataset = GeoDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
#print("================="+str(opt.dataset_mode))
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
## add 3D videodataset loader
elif opt.dataset_mode == 'v':
from data.video_data import VideoDataset
dataset = VideoDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'unaligned_landmark':
from data.unaligned_landmark_dataset import UnalignedLandmarkDataset
dataset = UnalignedLandmarkDataset()
elif opt.dataset_mode == 'aligned_heatmap2face':
from data.aligned_dataset import AlignedDatasetHeatmap2Face
dataset = AlignedDatasetHeatmap2Face()
elif opt.dataset_mode == 'aligned_boundary_detection':
from data.aligned_dataset import AlignedBoundaryDetection
dataset = AlignedBoundaryDetection()
elif opt.dataset_mode == 'aligned_boundary_detection_landmarks':
from data.aligned_dataset import AlignedBoundaryDetectionLandmark
dataset = AlignedBoundaryDetectionLandmark()
elif opt.dataset_mode == 'aligned_face2boundary2face':
from data.aligned_dataset import AlignedFace2Boudnary2Face
dataset = AlignedFace2Boudnary2Face()
elif opt.dataset_mode == 'aligned_face2face':
from data.aligned_dataset import AlignedFace2Face
dataset = AlignedFace2Face()
elif opt.dataset_mode == 'aligned_faceDataset':
from data.aligned_dataset import AlignedFaceDataset
dataset = AlignedFaceDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'reid':
from data.reid_dataset import ReidDataset
dataset = ReidDataset()
elif opt.dataset_mode == 'chokepoint':
from data.chokepoint import ChokePoint
dataset = ChokePoint()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'gopro':
from data.gopro_dataset import GoProDataset
dataset = GoProDataset()
elif opt.dataset_mode == 'gopro_multi_scale':
from data.gopro_dataset import GoProMultiScaleDataset
dataset = GoProMultiScaleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'sequential':
from data.sequential_dataset import SequentialDataset
dataset = SequentialDataset()
elif opt.dataset_mode == 'feedback':
from data.feedback_dataset import FeedbackDataset
dataset = FeedbackDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'aligned_rand':
from data.aligned_dataset_rand import AlignedDataset_Rand
dataset = AlignedDataset_Rand()
elif opt.dataset_mode == 'aligned_test':
from data.aligned_dataset_test import AlignedDataset_Test
dataset = AlignedDataset_Test()
elif opt.dataset_mode == 'unaligned_seg':
from data.unaligned_dataset_seg import UnalignedDataset_Seg
dataset = UnalignedDataset_Seg()
elif opt.dataset_mode == 'aligned_seg':
from data.aligned_dataset_seg import AlignedDataset_Seg
dataset = AlignedDataset_Seg()
elif opt.dataset_mode == 'aligned_seg_rand':
from data.aligned_dataset_seg_rand import AlignedDataset_Seg_Rand
dataset = AlignedDataset_Seg_Rand()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'aligned_resized':
from data.aligned_dataset_resized import AlignedDatasetResized
dataset = AlignedDatasetResized()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'seismic':
from data.seismic_dataset import SeismicDataset
dataset = SeismicDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'aligned_rand':
from data.aligned_dataset_rand import AlignedDataset_Rand
dataset = AlignedDataset_Rand()
elif opt.dataset_mode == 'aligned_test':
from data.aligned_dataset_test import AlignedDataset_Test
dataset = AlignedDataset_Test()
elif opt.dataset_mode == 'unaligned_seg':
from data.unaligned_dataset_seg import UnalignedDataset_Seg
dataset = UnalignedDataset_Seg()
elif opt.dataset_mode == 'aligned_seg':
from data.aligned_dataset_seg import AlignedDataset_Seg
dataset = AlignedDataset_Seg()
elif opt.dataset_mode == 'aligned_seg_rand':
from data.aligned_dataset_seg_rand import AlignedDataset_Seg_Rand
dataset = AlignedDataset_Seg_Rand()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'fivek':
from data.fivek_dataset import FiveKDataset
dataset = FiveKDataset()
elif opt.dataset_mode == 'fivek2':
from data.fivek_dataset2 import FiveKDataset2
dataset = FiveKDataset2()
elif opt.dataset_mode == 'fivek3':
from data.fivek_dataset3 import FiveKDataset3
dataset = FiveKDataset3()
elif opt.dataset_mode == 'fivek4':
from data.fivek_dataset4 import FiveKDataset4
dataset = FiveKDataset4()
elif opt.dataset_mode == 'fivek4_syn':
from data.fivek_dataset4_syn import FiveKDataset4_syn
dataset = FiveKDataset4_syn()
elif opt.dataset_mode == 'fivek_single':
from data.fivek_single import FiveKDataset_single
dataset = FiveKDataset_single()
elif opt.dataset_mode == 'ava':
from data.ava_dataset import AVADataset
dataset = AVADataset()
elif opt.dataset_mode == 'aadb':
from data.aadb_dataset import AADBDataset
dataset = AADBDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
