def __getitem__(self, index):
"""Return a data point and its metadata information.
Parameters:
index -- a random integer for data indexing
Returns:
a dictionary of data with their names. It usually contains the data itself and its metadata information.
Step 1: get a random image path: e.g., path = self.image_paths[index]
Step 2: load your data from the disk: e.g., image = Image.open(path).convert('RGB').
Step 3: convert your data to a PyTorch tensor. You can use helpder functions such as self.transform. e.g., data = self.transform(image)
Step 4: return a data point as a dictionary.
"""
sketch_path, photo_path = self.image_pair_paths[
index] # supposed to be strings
sketch = Image.open(sketch_path).convert(
'RGB'
) # needs to be a tensor (TODO: should be 'L' not 'RGB', but need to debug why that breaks)
photo = Image.open(photo_path).convert('RGB') # needs to be a tensor
transform_params = get_params(self.opt, sketch.size)
crop_start_x = random.randint(0,
self.opt.load_size - self.opt.crop_size)
crop_start_y = random.randint(0,
self.opt.load_size - self.opt.crop_size)
transform_params['crop_pos'] = (crop_start_x, crop_start_y)
transform_params['flip'] = random.choice([True, False])
sketch_transform = get_transform(self.opt,
transform_params,
grayscale=(self.input_nc == 1))
photo_transform = get_transform(self.opt,
transform_params,
grayscale=(self.output_nc == 1))
sketch = sketch_transform(sketch)
photo = photo_transform(photo)
return {
'sketch': sketch,
'photo': photo,
'sketch_path': sketch_path,
'photo_path': photo_path
}
def __getitem__(self, index):
# Label Image
label_path = self.label_paths[index]
label = Image.open(label_path)
params = get_params(self.opt, label.size)
transform_label = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
label_tensor[label_tensor ==
255] = self.opt.label_nc # 'unknown' is opt.label_nc
# input image (real images)
image_path = self.image_paths[index]
image = Image.open(image_path)
image = image.convert('RGB')
transform_image = get_transform(self.opt, params)
image_tensor = transform_image(image)
# if using instance maps
if self.opt.no_instance:
instance_tensor = 0
else:
instance_path = self.instance_paths[index]
instance = Image.open(instance_path)
if instance.mode == 'L':
instance_tensor = transform_label(instance) * 255
instance_tensor = instance_tensor.long()
else:
instance_tensor = transform_label(instance)
input_dict = {
'label': label_tensor,
'instance': instance_tensor,
'image': image_tensor,
'path': image_path,
}
# Give subclasses a chance to modify the final output
self.postprocess(input_dict)
return input_dict
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size)
'''if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('RGB'))
#else:'''
transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
A_tensor = transform_A(A) * 255.0
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
if self.opt.isTrain:
B_path = self.B_paths[index]
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
C_path = "/scratch/train_numbered/train_B/"+ 'img_081663.png'
C = Image.open(C_path).convert('RGB')
transform_C = get_transform(self.opt, params)
C_tensor = transform_C(C)
D_Tensor = torch.cat((A_tensor, C_tensor), 0)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_A(inst)
if self.opt.load_features:
feat_path = self.feat_paths[index]
feat = Image.open(feat_path).convert('RGB')
norm = normalize()
feat_tensor = norm(transform_A(feat))
input_dict = {'label': D_Tensor, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': A_path}
return input_dict
def __getitem__(self, index):
# Label Image
label_path = self.label_paths[index]
label = Image.open(label_path)
# print(label_path)
params = get_params(self.opt, label.size)
transform_label = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
label_tensor[label_tensor ==
255] = self.opt.label_nc # 'unknown' is opt.label_nc
image_path = self.image_paths[index]
assert self.paths_match(label_path, image_path), \
"The label_path %s and image_path %s don't match." % \
(label_path, image_path)
image = Image.open(image_path)
image = image.convert('RGB')
transform_image = get_transform(self.opt, params)
image_tensor = transform_image(image)
# if using instance maps
if self.opt.no_instance:
instance_tensor = 0
else:
instance_path = self.instance_paths[index]
instance = Image.open(instance_path)
if instance.mode == 'L':
instance_tensor = transform_label(instance) * 255
instance_tensor = instance_tensor.long()
else:
instance_tensor = transform_label(instance)
input_dict = {
'label': label_tensor,
'instance': instance_tensor,
'image': image_tensor,
'path': image_path,
}
self.postprocess(input_dict)
return input_dict
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
AR_path = self.AR_paths[index]
A = Image.open(A_path)
AR = Image.open(AR_path)
if self.opt.isTrain:
A_path_inter_1 = self.A_paths_inter_1[index]
A_path_inter_2 = self.A_paths_inter_2[index]
A_inter_1 = Image.open(A_path_inter_1)
A_inter_2 = Image.open(A_path_inter_2)
params = get_params(self.opt, A.size)
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('RGB'))
if self.opt.isTrain:
A_inter_1_tensor = transform_A(A_inter_1.convert('RGB'))
A_inter_2_tensor = transform_A(A_inter_2.convert('RGB'))
AR_tensor = transform_A(AR.convert('RGB'))
else:
transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
A_tensor = transform_A(A) * 255.0
if self.opt.isTrain:
A_inter_1_tensor = transform_A(A_inter_1) * 255.0
A_inter_2_tensor = transform_A(A_inter_2) * 255.0
AR_tensor = transform_A(AR) * 255.0
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
B_path = self.B_paths[index]
BR_path = self.BR_paths[index]
B = Image.open(B_path).convert('RGB')
BR = Image.open(BR_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
BR_tensor = transform_B(BR)
if self.opt.isTrain:
input_dict = {'inter_label_1': A_inter_1_tensor, 'label': A_tensor, 'inter_label_2': A_inter_2_tensor, 'label_ref': AR_tensor, 'image': B_tensor, 'image_ref': BR_tensor, 'path': A_path, 'path_ref': AR_path}
else:
input_dict = {'label': A_tensor, 'label_ref': AR_tensor, 'image': B_tensor, 'image_ref': BR_tensor, 'path': A_path, 'path_ref': AR_path}
return input_dict
def __getitem__old(self, index):
"""Return a data point and its metadata information.
Parameters:
index - - a random integer for data indexing
Returns a dictionary that contains A, B, A_paths and B_paths
A (tensor) - - an image in the input domain
B (tensor) - - its corresponding image in the target domain
A_paths (str) - - image paths
B_paths (str) - - image paths (same as A_paths)
"""
# read a image given a random integer index
AB_path = self.AB_paths[index]
cv2_img = cv2.imread(AB_path, cv2.IMREAD_COLOR | cv2.IMREAD_ANYDEPTH)
#float_img = cv2_img.astype(float)
#AB = Image.fromarray(float_img)
#AB = Image.open(AB_path).convert('RGB')
AB = Image.open(AB_path).convert('RGB')
# print(img.getextrema());
nparr = np.array(AB)
max_val = np.amax(nparr)
#
# split AB image into A and B
w, h = AB.size
w2 = int(w / 2)
A = AB.crop((0, 0, w2, h))
B = AB.crop((w2, 0, w, h))
# apply the same transform to both A and B
transform_params = get_params(self.opt, A.size)
A_transform = get_transform(self.opt,
transform_params,
grayscale=(self.input_nc == 1))
B_transform = get_transform(self.opt,
transform_params,
grayscale=(self.output_nc == 1))
A = A_transform(A)
B = B_transform(B)
return {'A': A, 'B': B, 'A_paths': AB_path, 'B_paths': AB_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)
self.dir_A = os.path.join(
opt.dataroot,
opt.data_type + 'A') # create a path '/path/to/data/trainA' : RGB
self.dir_B = os.path.join(
opt.dataroot, opt.data_type +
'B') # create a path '/path/to/data/trainB': Thermal
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))
if 'M' in opt.loss_type:
if opt.data_type == 'train':
gps_name = 'AM09_gps.txt'
else:
gps_name = 'AM05_gps.txt'
with open(os.path.join('./datasets', gps_name), 'r') as fp:
gps = [[
float(x.rstrip().split()[0]),
float(x.rstrip().split()[1])
] for x in fp.readlines()]
gps = np.array(gps)
gps = np.float32(gps)
import sklearn.metrics as skm
Distance = skm.pairwise_distances(gps, gps)
D = (Distance > opt.mt_neg)
self.DM = D
self.DV = Distance
else:
self.DM = None
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size)
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('RGB'))
else:
transform_A = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
A_tensor = transform_A(A) * 255.0
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
#if self.opt.isTrain:# or self.opt.use_encoded_image:
B_path = self.B_paths[index]
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_A(inst)
if self.opt.load_features:
feat_path = self.feat_paths[index]
feat = Image.open(feat_path).convert('RGB')
norm = normalize()
feat_tensor = norm(transform_A(feat))
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'feat': feat_tensor,
'path': A_path
}
return input_dict
def load_label(self, path, params):
label = Image.open(path)
transform_label = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
label_tensor[label_tensor ==
255] = self.opt.label_nc # 'unknown' is opt.label_nc
return label_tensor.unsqueeze(0)
def __getitem__(self, index): # The specific operations in getitem are the key operations of this class
### input A (label maps) # Read label map
### input A (label maps)
A_path = self.A_paths[index] # Get image path
# A = Image.open(self.dir_A +'/' + A_path) # First read an image
A = Image.open(A_path)
params = get_params(self.opt, A.size) # According to the input opt ​​and size, return random parameters
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
tmp = A.convert('RGB')
A_tensor = transform_A(tmp)
else:
transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
A_tensor = transform_A(A) * 255.0 # To preprocess the data, after to_tensor operation, multiply by 255
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images) ### input B (real images) # Then read in the real image B
if self.opt.isTrain or self.opt.use_encoded_image:
B_path = self.B_paths[index] # B = Image.open(self.dir_B + '/' + B_path).convert('RGB')
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
### if using instance maps ### if using instance maps # Then read in the instance, and then it will be processed into an edge map, which is consistent with the description in the paper.
if not self.opt.no_instance: # no_instance default value is true
inst_path = self.inst_paths[index] # inst = Image.open(self.dir_inst + '/' + inst_path)
inst = Image.open(inst_path)
inst_tensor = transform_A(inst) # Same as semantic processing 0-1
if self.opt.load_features: # Note that the role of self.opt.load_features is to read the pre-calculated features of each category. There are 10 categories in the paper, which are formed by clustering. But the default is not implemented. I personally read the thesis and knew nothing about this part. I will study it later if there is demand.
feat_path = self.feat_paths[index]
feat = Image.open(feat_path).convert('RGB')
norm = normalize()
feat_tensor = norm(transform_A(feat))
input_dict = {'label': A_tensor, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': A_path}
return input_dict # Return a dictionary recording the above read and processed data set.
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.fineSize = opt.fineSize
self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A')
self.A_paths = make_dataset(self.dir_A)
self.A_paths = sorted(self.A_paths)
self.A_size = len(self.A_paths)
self.transform = get_transform(opt)
self.nintrm = opt.nintrm
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
# self.dir_A = os.path.join(opt.dataroot, 'cyclegan')
self.dir_A = '/home/jwang/cycada_feature/cyclegan/data/cifar10/images'
# self.dir_B = os.path.join(opt.dataroot, 'cityscapes/leftImg8bit/test')
self.dir_B = '/mrtstorage/users/jwang/cyclegta5'
self.A_paths = make_dataset(self.dir_A)
self.B_paths = make_dataset(self.dir_B)
self.A_paths = sorted(self.A_paths)
self.B_paths = sorted(self.B_paths)
self.A_size = len(self.A_paths)
self.B_size = len(self.B_paths)
# self.transform = get_transform(opt)
self.A_transform = get_transform(opt)
opt.resize_or_crop = 'resize_and_crop'
self.B_transform = get_transform(opt)
def __getitem__(self, index):
self.A, self.B, self.I, seq_idx = self.update_frame_idx(
self.A_paths, index)
tG = self.opt.n_frames_G
A_img = Image.open(self.A_paths[seq_idx][0]).convert('RGB')
params = get_img_params(self.opt, A_img.size)
transform_scaleB = get_transform(self.opt, params)
transform_scaleA = get_transform(
self.opt, params, method=Image.NEAREST,
normalize=False) if self.A_is_label else transform_scaleB
frame_range = list(range(tG)) if self.A is None else [tG - 1]
for i in frame_range:
A_path = self.A_paths[seq_idx][self.frame_idx + i]
Ai = self.get_image(A_path,
transform_scaleA,
is_label=self.A_is_label)
self.A = concat_frame(self.A, Ai, tG)
if self.use_real:
B_path = self.B_paths[seq_idx][self.frame_idx + i]
Bi = self.get_image(B_path, transform_scaleB)
self.B = concat_frame(self.B, Bi, tG)
else:
self.B = 0
if self.opt.use_instance:
I_path = self.I_paths[seq_idx][self.frame_idx + i]
Ii = self.get_image(I_path, transform_scaleA) * 255.0
self.I = concat_frame(self.I, Ii, tG)
else:
self.I = 0
self.frame_idx += 1
return_list = {
'A': self.A,
'B': self.B,
'inst': self.I,
'A_path': A_path,
'change_seq': self.change_seq
}
return return_list
def __getitem__(self, index):
# Label Image
label_path = self.label_paths[index]
label = Image.open(label_path)
params = get_params(self.opt, label.size)
transform_label = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
label_tensor = transform_label(label) * 255.0
label_tensor[label_tensor == 255] = self.opt.label_nc # 'unknown' is opt.label_nc
# input image (real images)
image_path = self.image_paths[index]
assert self.paths_match(
label_path, image_path
), "The label_path %s and image_path %s don't match." % (label_path, image_path)
image = Image.open(image_path)
image = image.convert("RGB")
transform_image = get_transform(self.opt, params)
image_tensor = transform_image(image)
# if using instance maps
if self.opt.no_instance:
instance_tensor = 0
else:
instance_path = self.instance_paths[index]
instance = Image.open(instance_path)
if instance.mode == "L":
instance_tensor = transform_label(instance) * 255
instance_tensor = instance_tensor.long()
else:
instance_tensor = transform_label(instance)
input_dict = {
"label": label_tensor,
"instance": instance_tensor,
"image": image_tensor,
"path": image_path,
}
# Give subclasses a chance to modify the final output
self.postprocess(input_dict)
return input_dict
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(
"/home/robot/andrewk/RobotTeleop/pilot_scripts/canonical_no_shift_priv_info",
opt.phase + 'canonical')
self.dir_random = os.path.join(opt.dataroot, opt.phase + 'random')
#self.dir_real = os.path.join(opt.dataroot, opt.phase + 'real')
self.dir_seg = os.path.join(opt.dataroot, opt.phase + 'segmentation')
self.dir_depth = os.path.join(opt.dataroot, opt.phase + 'depth')
#self.real_states = np.load(os.path.join(opt.dataroot, opt.phase + 'real_states.npy'))
#self.dir_canonical_pi = '/home/robot/andrewk/RobotTeleop/pilot_scripts/priv_info' # np.load(os.path.join(opt.dataroot, opt.phase + '_canonical_pi.npy'))
self.dir_canonical_pi = '/home/robot/andrewk/RobotTeleop/pilot_scripts/canonical_no_shift_priv_info'
self.canonical_pi_paths = [
pth for pth in os.listdir(self.dir_canonical_pi) if '.npy' in pth
]
self.canonical_paths = sorted(
make_dataset(self.dir_canonical, opt.max_dataset_size))[::-1]
self.random_paths = sorted(
make_dataset(self.dir_random, opt.max_dataset_size))[::-1]
#self.real_paths = sorted(make_dataset(self.dir_#real, opt.max_dataset_size))
self.seg_paths = sorted(
make_dataset(self.dir_seg, opt.max_dataset_size))[::-1]
self.depth_paths = sorted(
make_dataset(self.dir_depth, opt.max_dataset_size))[::-1]
self.canonical_size = len(self.canonical_paths)
self.random_size = len(self.random_paths)
#self.real_size = len(self.real_paths)
self.seg_size = len(self.seg_paths)
self.depth_size = len(self.depth_paths)
self.index = 0
#assert self.canonical_size == self.random_size == self.seg_size == self.depth_size, 'Dataset sizes are not the same'
self.transform_rgb = get_transform(self.opt, grayscale=False)
self.transform_grayscale = get_transform(self.opt, grayscale=True)
def get_parsing_label_tensor(parsing_path, opt):
label = Image.open(parsing_path)
params = get_params(opt, label.size)
transform_label = get_transform(opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
return label_tensor
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_P = os.path.join(opt.dataroot, opt.phase) #person images
self.dir_K = os.path.join(opt.dataroot, opt.phase + 'K') #keypoints
print(self.dir_P, self.dir_K)
self.init_categories(opt.pairLst)
self.transform = get_transform(opt)
def __init__(self, opt):
super(UnalignedDataset, self).__init__()
self.opt = opt
self.transform = get_transform(opt)
datapath = os.path.join(opt.dataroot, opt.phase + '*')
self.dirs = sorted(glob.glob(datapath))
self.paths = [sorted(make_dataset(d)) for d in self.dirs]
self.sizes = [len(p) for p in self.paths]
def __getitem__(self, index):
"""Return a data point and its metadata information.
Parameters:
index - - a random integer for data indexing
Returns a dictionary that contains A, B, A_paths and B_paths
A (tensor) - - an image in the input domain
B (tensor) - - its corresponding image in the target domain
A_paths (str) - - image paths
B_paths (str) - - image paths (same as A_paths)
true_label (str) - - true label of B image
"""
# read a image given a random integer index
AB_path = self.AB_paths[index]
AB = Image.open(AB_path).convert('RGB')
# split AB image into A and B
w, h = AB.size
w2 = int(w / 2)
A = AB.crop((0, 0, w2, h))
B = AB.crop((w2, 0, w, h))
# apply the same transform to both A and B
transform_params = get_params(self.opt, A.size)
A_transform = get_transform(self.opt,
transform_params,
grayscale=(self.input_nc == 1))
B_transform = get_transform(self.opt,
transform_params,
grayscale=(self.output_nc == 1))
A = A_transform(A)
B = B_transform(B)
# print(self.true_labels[AB_path])
return {
'A': A,
'B': B,
'A_paths': AB_path,
'B_paths': AB_path,
'true_label': self.true_labels[AB_path],
'labels_dict': self.true_labels
}
def __init__(self, opt):
super(UnalignedDataset, self).__init__()
self.opt = opt
self.transform = get_transform(opt)
datapath = os.path.join(opt.dataroot, opt.phase + '*')
self.dirs = sorted(glob.glob(datapath))
self.paths = [sorted(make_dataset(d)) for d in self.dirs]
self.sizes = [len(p) for p in self.paths]
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot)
self.A_paths = make_dataset(self.dir_A)
self.A_paths = sorted(self.A_paths)
self.transform = get_transform(opt)
def __getitem__(self, index):
"""Return a data point and its metadata information.
Parameters:
index - - a random integer for data indexing
Returns a dictionary that contains A, B, A_paths and B_paths
A (tensor) - - an image in the input domain
B (tensor) - - its corresponding image in the target domain
A_paths (str) - - image paths
B_paths (str) - - image paths (same as A_paths)
"""
# Read one image from each set given a random integer index.
A_path = self.A_paths[index % self.A_size]
if self.opt.serial_batches:
index_BC = index % self.BC_size
else: # Randomize the index for the second set to avoid fixed pairs (A, (B,C)).
index_BC = random.randint(0, self.BC_size - 1)
BC_path = self.BC_paths[index_BC]
A_img = Image.open(A_path).convert('RGB')
# Split {B,C} image into B and C.
BC_img = Image.open(BC_path).convert('RGB')
w, h = BC_img.size
w2 = int(w / 2)
B_img = BC_img.crop((0, 0, w2, h))
C_img = BC_img.crop((w2, 0, w, h))
# Apply image transformations, using the same transform both for B and C.
A_transform = get_transform(self.opt, grayscale=(self.input_nc == 1))
transform_params_BC = get_params(self.opt, B_img.size)
B_transform = get_transform(self.opt,
transform_params_BC,
grayscale=(self.output_nc == 1))
C_transform = get_transform(self.opt,
transform_params_BC,
grayscale=(self.output_nc == 1))
A = A_transform(A_img)
B = B_transform(B_img)
C = C_transform(C_img)
return {'A': A, 'B': B, 'C': C, 'A_paths': A_path, 'BC_paths': BC_path}
def classify(model, inputs):
opt = model['opt']
model = model['model']
img = inputs['image']
# Preprocess
transform = get_transform(opt, img.size)
label = transform(img).unsqueeze(0)
generated = model.inference(label, torch.tensor([0]))
output = util.tensor2im(generated.data[0])
return {'image': output}
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))
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))
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot, opt.phase)
self.dir_B = os.path.join(opt.dataroot, opt.phase + 'annot')
self.A_paths = sorted(make_dataset(self.dir_A))
self.B_paths = sorted(make_dataset(self.dir_B))
self.transform = get_transform(opt)
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot)
self.A_paths = make_dataset(self.dir_A)
self.A_paths = sorted(self.A_paths)
self.transform = get_transform(opt)
def __init__(self, opt):
BaseDataset.__init__(self, opt)
with open(opt.dataroot+'.csv', newline='') as f:
lines = f.readlines()
self.A_paths = []
for line in lines:
line = line.rstrip('\r\n')
self.A_paths.append(line)
self.transform_rgb = get_transform(opt, grayscale=False)
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_P = os.path.join(opt.dataroot,
opt.phase + '_in') #person images
self.dir_K_in = os.path.join(opt.dataroot,
opt.phase + '_inK') #keypoints
self.dir_K_out = os.path.join(opt.dataroot, opt.phase + '_outK')
self.init_categories(opt.pairLst)
self.transform = get_transform(opt)
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_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 = get_transform(opt, grayscale=(input_nc == 1)) # if nc == 1, we convert RGB to grayscale image
self.transform_B = get_transform(opt, grayscale=(output_nc == 1)) # if nc == 1, we convert RGB to grayscale image
def __getitem__(self, index):
### input A (label maps)
edges_path, edges_im = None, None
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size, A)
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_img = A.convert('RGB')
A_tensor = transform_A(A_img)
if self.opt.apply_binary_threshold == 1:
ones = torch.ones_like(A_tensor)
minus_ones = torch.ones_like(A_tensor)*-1
A_tensor = torch.where(A_tensor>=self.opt.edge_threshold, ones,minus_ones)
else:
transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
A_tensor = transform_A(A) * 255.0
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
if self.opt.isTrain or self.opt.use_encoded_image:
B_path = self.B_paths[index]
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_A(inst)
if self.opt.load_features:
feat_path = self.feat_paths[index]
feat = Image.open(feat_path).convert('RGB')
norm = normalize()
feat_tensor = norm(transform_A(feat))
input_dict = {'label': A_tensor, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': A_path}
return input_dict
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_styled = os.path.join(opt.dataroot) # create a path '/path/to/data/trainA' self.styled_paths = sorted(make_dataset(self.dir_styled, opt.max_dataset_size)) # load images from '/path/to/data/trainA' self.styled_size = len(self.styled_paths) # get the size of dataset A self.input_nc = self.opt.input_nc # get the number of channels of input image self.output_nc = self.opt.output_nc # get the number of channels of output image if self.input_nc == 1: self.transform = get_transform(self.opt, grayscale=True) else: self.transform = get_transform(self.opt) self.imsize = opt.crop_size
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_P = os.path.join(opt.dataroot, opt.phase) #person images
self.dir_K = os.path.join(opt.dataroot, opt.phase + 'K') #keypoints
self.dir_SP = opt.dirSem #semantic
self.SP_input_nc = opt.SP_input_nc
self.init_categories(opt.pairLst)
self.transform = get_transform(opt)
def initialize(self, opt):
self.opt = opt
self.root = opt.dataroot
self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A')
self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B')
self.A_paths = make_dataset(self.dir_A)
self.B_paths = make_dataset(self.dir_B)
self.A_paths = sorted(self.A_paths)
self.B_paths = sorted(self.B_paths)
self.A_size = len(self.A_paths)
self.B_size = len(self.B_paths)
self.transform = get_transform(opt)
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size)
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('RGB'))
else:
transform_A = get_transform(self.opt, params, method=Image.NEAREST, normalize=False)
A_tensor = transform_A(A) * 255.0
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
if self.opt.isTrain:
B_path = self.B_paths[index]
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_A(inst)
if self.opt.load_features:
feat_path = self.feat_paths[index]
feat = Image.open(feat_path).convert('RGB')
norm = normalize()
feat_tensor = norm(transform_A(feat))
input_dict = {'label': A_tensor, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': A_path}
return input_dict
