def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_canonical = os.path.join(opt.dataroot, opt.phase + 'canonical') # create a path '/path/to/data/trainA' self.dir_random = os.path.join(opt.dataroot, opt.phase + 'random') # create a path '/path/to/data/trainB' self.dir_seg = os.path.join(opt.dataroot, opt.phase + 'seg') # create a path '/path/to/data/trainB' self.canonical_paths = sorted(make_dataset(self.dir_canonical, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.random_paths = sorted(make_dataset(self.dir_random, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.seg_paths = sorted(make_dataset(self.dir_seg, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.canonical_size = len(self.canonical_paths) # get the size of dataset A self.random_size = len(self.random_paths) # get the size of dataset B self.seg_size = len(self.seg_paths) # get the size of dataset B assert self.canonical_size == self.random_size == self.seg_size, 'Dataset sizes are not the same' input_nc = self.opt.input_nc # get the number of channels of input image output_nc = self.opt.output_nc # get the number of channels of output image self.transform_A = get_transform(self.opt, grayscale=False) self.transform_seg = get_transform(self.opt, grayscale=True) self.transform_B = get_transform(self.opt, grayscale=False)
def __init__(self, opt, type_of_data, mydir = None): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) if mydir == None: self.dir = os.path.join(opt.dataroot, 'fashion-{}.npz'.format(type_of_data)) else: self.dir = os.path.join(mydir, 'fashion-{}.npz'.format(type_of_data)) self.type_of_data = type_of_data self.num_classes = 10 loaded = np.load(self.dir) self.inputs = loaded['inputs'].astype(np.float32) if np.max(self.inputs) > 1: self.inputs = self.inputs / 255.0 self.targets = loaded['targets'].astype(np.float32) # print(np.min(self.inputs), np.max(self.inputs)) self.num_data_points = int(self.inputs.shape[0] / self.batch_size) * self.batch_size if opt.num_batches != -1:# and trim_data: self.num_data_points = min(opt.num_batches * self.batch_size,self.num_data_points)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.A_dir = os.path.join(self.opt.dataroot, 'ct', self.opt.phase) self.B_dir = os.path.join(self.opt.dataroot, 'mri', self.opt.phase) self.A_paths = sorted(make_dataset(self.A_dir, opt.max_dataset_size)) self.B_paths = sorted(make_dataset(self.B_dir, opt.max_dataset_size)) self.A_size = len(self.A_paths) self.B_size = len(self.B_paths) transformations = [ transforms.ToTensor(), transforms.Lambda( lambda x: self.center(x, opt.mean_norm, opt.std_norm)), # transforms.RandomCrop((148,100)), RandomCropIfNecessary(1200, opt.n_downsampling) if opt.uniform_size is None else PadTo(*opt.uniform_size), # transforms.Pad((1,0,0,0), padding_mode='reflect') ] if (opt.isTrain): transformations += [ transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip() ] self.transformations = transforms.Compose(transformations)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory mask_dir = os.path.join(opt.dataroot, "mask") self.AB_paths = sorted(make_dataset( self.dir_AB, opt.max_dataset_size)) # get image paths self.dataset_len = len(self.AB_paths) assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc mask_paths = [] for ab_path in self.AB_paths: ab_name = os.path.basename(ab_path) mask_name = "{}_{}.json".format(opt.phase, ab_name.rsplit('.', 1)[0]) mask_path = os.path.join(mask_dir, mask_name) mask_paths.append(mask_path) assert os.path.isfile(mask_path) self.mask_paths = mask_paths random.seed(30)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions A few things can be done here. - save the options (have been done in BaseDataset) - get image paths and meta information of the dataset. - define the image transformation. """ # save the option and dataset root BaseDataset.__init__(self, opt) self.patch_size = opt.patch_size # set whether to perform downsampling and to include if opt.model in ['srcnn', 'srgan']: self.downsample_factor = opt.downsample_factor if hasattr(opt, 'd_condition'): self.include_original_res = opt.d_condition else: self.include_original_res = False else: self.downsample_factor = None # Check that translation is not being performed during training assert not opt.isTrain, '3D translation not defined for training mode' set_inc = opt.save_name if opt.save_name is not None else opt.phase # optionally allow for sampling from training set-connected TXM images self.save_txm_dir = os.path.join( opt.results_dir, opt.name, 'volume_txm_{}'.format( set_inc)) # save directory for TXM image patches self.save_pred_dir = os.path.join( opt.results_dir, opt.name, 'volume_pred_{}'.format( set_inc)) # save directory for translated images mkdirs([self.save_pred_dir, self.save_txm_dir]) # Get image paths and discard all but the first N for N=opt.patch_size img_dir = './images/{}/txm_full_stack/'.format( opt.phase) # original TXM image directory self.image_paths = sorted(glob.glob(img_dir + '*.tif')) if len(self.image_paths) > self.patch_size: self.image_paths = self.image_paths[:self.patch_size] # Define the default transform function from base transform funtion. opt.no_flip = True self.transform = get_transform(opt) self.length = opt.patch_size self.patch_size = opt.patch_size # Get x-y indices for sampling I_dummy = Image.open(self.image_paths[0]) self.x_ind = np.random.randint( 0, I_dummy.size[0] - opt.patch_size) if opt.x_ind is None else opt.x_ind self.y_ind = np.random.randint( 0, I_dummy.size[0] - opt.patch_size) if opt.y_ind is None else opt.y_ind
def __init__(self, opt): BaseDataset.__init__(self, opt) # 3d feature self.shapes_info = np.load(os.path.join(opt.dataroot, 'data_info', opt.dataset_name), allow_pickle=True) self.phase = opt.phase self.data_size = len(self.shapes_info) self.input_2d_path = os.path.join(opt.dataroot, 'input_data') self.input_3d_path = os.path.join(opt.dataroot, 'notexture_pool_data') self.query_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) opt.fine_size = 256 self.fine_size = opt.fine_size self.phase = opt.phase self.query_random_erase = transforms.Compose( [transforms.RandomErasing()])
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' # Shuffle dataset for good measure random.shuffle(self.A_paths) random.shuffle(self.B_paths) self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == 'BtoA' input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.transform_A = get_transform(self.opt, grayscale=(input_nc == 1)) self.transform_B = get_transform(self.opt, grayscale=(output_nc == 1)) if self.opt.backgrounds_path: self.backgrounds = sorted(make_dataset(self.opt.backgrounds_path))
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) btoA = self.opt.direction == 'BtoA' self.input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' if os.path.exists(self.dir_A): self.A_img_paths, self.A_label_paths = make_labeled_path_dataset(self.dir_A,'/paths.txt', opt.max_dataset_size) # load images from '/path/to/data/trainA/paths.txt' as well as labels else: self.A_img_paths, self.A_label_paths = make_labeled_path_dataset(opt.dataroot,'/paths.txt', opt.max_dataset_size) # load images from '/path/to/data/trainA/paths.txt' as well as labels self.A_size = len(self.A_img_paths) # get the size of dataset A if os.path.exists(self.dir_B): self.B_img_paths, self.B_label_paths = make_labeled_path_dataset(self.dir_B,'/paths.txt', opt.max_dataset_size) # load images from '/path/to/data/trainB' self.B_size = len(self.B_img_paths) # get the size of dataset B self.transform=get_transform_seg(self.opt, grayscale=(self.input_nc == 1)) self.transform_noseg=get_transform(self.opt, grayscale=(self.input_nc == 1))
def __init__(self,opt): BaseDataset.__init__(self,opt) if self.opt.isTrain: self.dir_no_label_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/unlabeldata/trainA' self.dir_no_label_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/unlabeldata/trainB' self.no_label_A_paths = sorted(make_dataset(self.dir_no_label_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.no_label_B_paths = sorted(make_dataset(self.dir_no_label_B, opt.max_dataset_size)) self.A_size = len(self.no_label_A_paths) # get the size of dataset A self.B_size = len(self.no_label_B_paths) self.dir_label = os.path.join(opt.dataroot, opt.phase) # get the image directory self.label_paths = sorted(make_dataset(self.dir_label, opt.max_dataset_size)) # get image paths self.label_size = len(self.label_paths) self.no_label_size = len(self.no_label_A_paths) assert (self.opt.load_size >= self.opt.crop_size) # crop_size should be smaller than the size of loaded image else: self.test=os.path.join(opt.dataroot,opt.phase) self.test_paths = sorted(make_dataset(self.test,opt.max_dataset_size)) self.test_size = len(self.test_paths) self.input_nc = self.opt.input_nc self.output_nc = self.opt.output_nc # self.transform = get_transform(self.opt, grayscale=(self.input_nc == 1)) self.transform_A = get_transform(self.opt, grayscale=(self.input_nc == 1)) self.transform_B = get_transform(self.opt, grayscale=(self.output_nc == 1))
def __init__(self, opt): BaseDataset.__init__(self, opt) # 2d features self.shapes_info = os.listdir(os.path.join(opt.dataroot, 'input_data')) if '.DS_Store' in self.shapes_info: self.shapes_info.remove('.DS_Store') self.shapes_info.sort() self.phase = opt.phase self.data_size = len(self.shapes_info) self.input_2d_path = os.path.join(opt.dataroot, 'input_data') self.input_3d_path = os.path.join(opt.dataroot, 'render5_black') #self.input_3d_path = '/home/dh/zdd/data/test/render5_black/' #os.path.join(opt.dataroot, 'notexture_pool_data') self.query_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) opt.fine_size = 256 self.fine_size = opt.fine_size self.phase = opt.phase
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory self.AB_paths = sorted(make_dataset( self.dir_AB, opt.max_dataset_size)) # get image paths # real_A paths self.dir_A = os.path.join(opt.dataroot, opt.phase + '/A') # real_B paths self.dir_B = os.path.join(opt.dataroot, opt.phase + '/B') # real_A self.A_paths = sorted(make_dataset(self.dir_A, opt.max_dataset_size)) # real_B self.B_paths = sorted(make_dataset(self.dir_B, opt.max_dataset_size)) assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' #TODO: BB Path if 'BBCrop' in self.opt.preprocess: self.dir_A_BB = os.path.join( opt.dataroot, opt.phase + 'A_BB') #Create a path '/path/to/data/trainA_BB' self.A_BB = make_dataset_bb(self.dir_A_BB, 'bbox_A.txt', opt.max_dataset_size) self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == 'BtoA' input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.transform_A = get_transform(self.opt, grayscale=(input_nc == 1)) self.transform_B = get_transform(self.opt, grayscale=(output_nc == 1), B=True)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions A few things can be done here. - save the options (have been done in BaseDataset) - get image paths and meta information of the dataset. - define the image transformation. """ # save the option and dataset root BaseDataset.__init__(self, opt) # define the default transform function. You can use <base_dataset.get_transform>; You can also define your custom transform function # import torchvision dataset if opt.dataset_name == 'CIFAR10': from torchvision.datasets import CIFAR10 as torchvisionlib self.transform = get_transform(opt, channels=3) elif opt.dataset_name == 'CIFAR100': from torchvision.datasets import CIFAR100 as torchvisionlib self.transform = get_transform(opt, channels=3) elif opt.dataset_name == 'FashionMNIST': from torchvision.datasets import FashionMNIST as torchvisionlib self.transform = get_transform(opt, channels=1) else: raise ValueError('torchvision_dataset import fault.') self.dataload = torchvisionlib(root = opt.download_root, transform = self.transform, download = True)
def __init__(self, opt): BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' self.dir_C = os.path.join( opt.dataroot, opt.phase + 'C' ) # create a path '/path/to/data/trainC' for lowdose image concat self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.C_paths = sorted(make_dataset( self.dir_C, opt.max_dataset_size)) # load images from '/path/to/data/trainC' self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == 'BtoA' self.opt = opt n_patches = opt.batch_size * 1000 n_images = len(self.A_paths) if n_images == 0: self.repeat = 0 else: self.repeat = max(n_patches // n_images, 1)
def __init__(self, opt): """Initialize this dataset class.""" BaseDataset.__init__(self, opt) self.im_suffix = '.png' self.image_name = opt.image_name if self.opt.phase == 'train': self.data_dir = os.path.join(self.opt.dataroot, self.opt.data_name) self.AB_paths = make_gesture_dataset( os.path.join(self.data_dir, self.opt.image_name), os.path.join(self.data_dir, self.opt.train_name), self.opt.max_dataset_size, self.opt.phase) random.seed(1234) random.shuffle(self.AB_paths) assert ( self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image else: self.data_dir = os.path.join(self.opt.dataroot, self.opt.data_name) self.AB_paths = make_gesture_dataset( os.path.join(self.data_dir, self.opt.image_name), os.path.join(self.data_dir, self.opt.test_name), self.opt.max_dataset_size, self.opt.phase) self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.A_paths = sorted(make_dataset( opt.dataroot, opt.max_dataset_size)) # get image paths assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc self.Nw = opt.Nw self.A_Images = [] for i in range(len(self.A_paths)): self.A_Images.append(Image.open(self.A_paths[i]).convert('RGB')) transform_params = get_params(self.opt, self.A_Images[i].size) self.A_transform = get_transform(self.opt, transform_params, grayscale=(self.input_nc == 1)) self.A_Images[i] = self.A_transform(self.A_Images[i]) self.image_shape = self.A_Images[0].shape
def __init__(self, opt): BaseDataset.__init__(self, opt) imglistA = 'datasets/list/%s/%s.txt' % (opt.phase + 'A', opt.dataroot) imglistB = 'datasets/list/%s/%s.txt' % (opt.phase + 'B', opt.dataroot) if not os.path.exists(imglistA) or not os.path.exists(imglistB): self.dir_A = os.path.join( opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join( opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' self.A_paths = sorted( make_dataset(self.dir_A, opt.max_dataset_size) ) # load images from '/path/to/data/trainA' self.B_paths = sorted( make_dataset(self.dir_B, opt.max_dataset_size) ) # load images from '/path/to/data/trainB' else: self.A_paths = sorted(open(imglistA, 'r').read().splitlines()) self.B_paths = sorted(open(imglistB, 'r').read().splitlines()) self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B print("A size:", self.A_size) print("B size:", self.B_size) btoA = self.opt.direction == 'BtoA' self.input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image self.output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.softmaxloc = os.path.join('style_features/styles2_sn_equal/', '1vgg19_softmax')
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_source = os.path.join(opt.dataroot, 'source') # get the image directory self.dir_target = os.path.join(opt.dataroot, 'target') # get the image directory self.dir_source_mask = os.path.join( opt.dataroot, 'source_mask') # get the image directory self.dir_target_mask = os.path.join(opt.dataroot, 'target_mask') # self.source_paths = sorted( make_dataset(self.dir_source, opt.max_dataset_size)) # get image paths self.target_paths = sorted( make_dataset(self.dir_target, opt.max_dataset_size)) # get image paths self.source_mask_paths = sorted( make_dataset(self.dir_source_mask, opt.max_dataset_size)) # get image paths self.target_mask_paths = sorted( make_dataset(self.dir_target_mask, opt.max_dataset_size)) # get image paths self.target_size = len(self.target_paths) assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc self.isTrain = opt.isTrain
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions A few things can be done here. - save the options (have been done in BaseDataset) - get image paths and meta information of the dataset. - define the image transformation. """ # save the option and dataset root BaseDataset.__init__(self, opt) self.dir_images = os.path.join( opt.dataroot, opt.phase) # get the image directory (eg ./datasets/CUHK/train) self.image_pair_paths = sorted( CuhkDataset.make_pairs_dataset(self.dir_images, opt.max_dataset_size)) # assert(self.opt.load_size >= self.opt.crop_size) # define the default transform function. We can use <base_dataset.get_transform>, or we can define our own custom transform function # self.transform = get_transform(opt) self.input_nc = 3 # if self.opt.direction == 'photo2sketch' else 1 # TODO: put this back in and get it working self.output_nc = 3 #1 if self.opt.direction == 'photo2sketch' else 3
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) # self.dir_A = opt.dataroot # create a path '/path/to/data/trainA' # self.dir_B = opt.dataroot # create a path '/path/to/data/trainB' self.dir_A = os.path.join( opt.dataroot, 'ExtremeWeather') # create a path '/path/to/data/trainA' self.dir_B = os.path.join( opt.dataroot, 'slp_resized') # create a path '/path/to/data/trainB' print(opt.dataroot) print(opt.phase) self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == 'BtoA' input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.transform_A = None self.transform_B = None
def __init__(self, opt, bw_threshold=220): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.bw_threshold = bw_threshold self.img_path = os.path.join(opt.dataroot, opt.phase, opt.wsi_name) self.img = np.load(self.img_path) print("WSI image shape", self.img.shape) if opt.bgr2rgb: self.img = cv2.cvtColor(self.img, cv2.COLOR_BGR2RGB) self.img_gray = cv2.cvtColor(self.img, cv2.COLOR_RGB2GRAY) self.img_bw = (self.img_gray >= self.bw_threshold).astype(np.uint8) self.mask = np.zeros_like(self.img_bw, dtype=np.uint8) self.img_new = np.zeros_like(self.img, dtype=np.uint32) if opt.dps == 0: opt.dps = opt.load_size input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc # self.transform = get_transform(opt, grayscale=(input_nc == 1)) self.transform = get_transform(opt, grayscale=(input_nc == 1), to_pil=True) self.init_patch_info(opt)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory self.AB_paths = [ e[1] for e in sorted(make_numbering_dataset( self.dir_AB, opt.max_dataset_size), key=lambda idx: idx[0]) ] assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc with open(opt.captions, 'rb') as f: x = pickle.load(f) train_captions, test_captions = x[0], x[1] self.captions = train_captions if opt.phase == "train" else test_captions self.ixtoword, self.wordtoix = x[2], x[3] del x, train_captions, test_captions self.n_words = len(self.ixtoword) print('Load from: ', opt.captions) self.captions_per_image = opt.captions_per_image self.text_words_num = opt.text_words_num
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_image = os.path.join( opt.dataroot, "full_images") # create a path '/path/to/data/train' self.dir_class = os.path.join(opt.dataroot, opt.class_csv) self.paths = sorted(make_dataset(self.dir_image, opt.max_dataset_size)) self.size = len(self.paths) # get the size of dataset A input_nc = self.opt.input_nc self.transform = get_transform(self.opt, grayscale=(input_nc == 1)) self.current_classes = 0 class_to_int = {} self.class_dict = {} with open(self.dir_class) as file: input_file = csv.DictReader(file) for row in input_file: filename_var = row['filename'].lower() class_var = row['class'].lower() label = class_to_int.get(class_var) if label is None: class_to_int[class_var] = self.current_classes self.current_classes += 1 label = class_to_int.get(class_var) self.class_dict[filename_var] = label
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ self.label = False BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == 'BtoA' input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.original_crop = opt.crop_size if (not self.label): self.transform_B = get_transform(self.opt, grayscale=(output_nc == 1), rotate=True) self.transform_A = get_transform(self.opt, grayscale=(input_nc == 1), rotate=False)
def __init__(self, opt): """Initialize this dataset class. Parameters: opt -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_AB = os.path.join(opt.dataroot, opt.phase) # get the image directory self.AB_paths = sorted(make_dataset( self.dir_AB, opt.max_dataset_size)) # get image paths assert (self.opt.load_size >= self.opt.crop_size ) # crop_size should be smaller than the size of loaded image input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc # we manually crop and flip in __getitem__ to make sure we apply the same crop and flip for image A and B # we disable the cropping and flipping in the function get_transform self.transform_A = get_transform(opt, grayscale=(input_nc == 1), crop=False, flip=False) self.transform_B = get_transform(opt, grayscale=(output_nc == 1), crop=False, flip=False)
def __init__(self, opt): BaseDataset.__init__(self, opt) self.sketch_file = [] self.sketch_label = [] self.sketch_path = os.path.join(opt.dataroot, 'sketch') self.render_path = os.path.join(opt.dataroot, 'render5') self.label_model = json.load( open(os.path.join(opt.dataroot, 'data_info', 'label_model.json'), 'r')) self.level_model = json.load( open(os.path.join(opt.dataroot, 'data_info', 'level_model.json'), 'r')) self.model_file = sorted(self.label_model.keys()) self.data_size = len(self.label_model) self.sketch_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # render self.render_transform = transforms.Compose([ transforms.Resize(256), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) first_char = opt.dataset_class[0] self.dir = os.path.join(opt.dataroot, 'images', opt.phase, first_char, opt.dataset_class) self.paths = sorted(make_dataset(self.dir, float("inf"))) self.A_paths = [p for p in self.paths if p[-4:] == '.jpg'] self.B_paths = [p for p in self.paths if p[-7:] == 'seg.jpg'] #self.B_paths = [p for p in self.paths if os.path.split(p)[-1][4:10] == 'merged'] assert len(self.A_paths) == len(self.B_paths) if opt.max_dataset_size != float("inf"): self.A_paths = self.A_paths[:opt.max_dataset_size] self.B_paths = self.B_paths[:opt.max_dataset_size] self.size = len(self.A_paths) btoA = self.opt.direction == 'BtoA' self.input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image self.output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') # create a path '/path/to/data/trainB' self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' # self.B_paths = sorted(make_dataset(self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.A_size = len(self.A_paths) # get the size of dataset A # self.B_size = len(self.B_paths) # get the size of dataset B # btoA = self.opt.direction == 'BtoA' # input_nc = self.opt.output_nc if btoA else self.opt.input_nc # get the number of channels of input image # output_nc = self.opt.input_nc if btoA else self.opt.output_nc # get the number of channels of output image self.transform = get_transform(self.opt, grayscale=(self.opt.input_nc == 1)) self.toTensor = transforms.ToTensor()
def __init__(self, opt): BaseDataset.__init__(self, opt) self.transform = get_transform(opt) self.celeba_id = {} with open(opt.celeba_id_list) as f: for line in f: info = line.rstrip('\n').split() self.celeba_id[info[0]] = int(info[1]) self.celeba_hq_id = {} with open(opt.celeba_hq_list) as f: f.readline() # drop the first line for line in f: line = line.rstrip('\n').split() self.celeba_hq_id[int(line[0])] = self.celeba_id[line[2]] celeba_hq_id_unique = np.sort(np.unique(list(self.celeba_hq_id.values()))) print('There is totally {} people in celeba_hq dataset'.format(len(celeba_hq_id_unique))) mapping_old2new = {} for index, old_id in enumerate(celeba_hq_id_unique): mapping_old2new[old_id] = index self.indexlist = [] for img, id in self.celeba_hq_id.items(): self.indexlist.append((img, mapping_old2new[id])) if opt.isTrain: self.indexlist = self.indexlist[:25000] random.shuffle(self.indexlist) else: self.indexlist = self.indexlist[25000:]
def __init__(self, opt): """Initialize this dataset class. Parameters: opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions """ BaseDataset.__init__(self, opt) self.dir_A = os.path.join(opt.dataroot, opt.phase + "A") # create a path '/path/to/data/trainA' self.dir_B = os.path.join(opt.dataroot, opt.phase + "B") # create a path '/path/to/data/trainB' self.A_paths = sorted(make_dataset( self.dir_A, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.B_paths = sorted(make_dataset( self.dir_B, opt.max_dataset_size)) # load images from '/path/to/data/trainB' self.A_size = len(self.A_paths) # get the size of dataset A self.B_size = len(self.B_paths) # get the size of dataset B btoA = self.opt.direction == "BtoA" input_nc = (self.opt.output_nc if btoA else self.opt.input_nc ) # get the number of channels of input image output_nc = (self.opt.input_nc if btoA else self.opt.output_nc ) # get the number of channels of output image self.transform_A = TransformWithMask(self.opt, grayscale=(input_nc == 1)) self.transform_B = TransformWithMask(self.opt, grayscale=(output_nc == 1))