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 and A_paths
A(tensor) - - an image in one domain
A_paths(str) - - the path of the image
"""
A_path = self.A_paths[index]
gtlx_path = os.path.splitext(A_path)[0] + '_lux.csv'
print('img:', A_path)
print('gxlx:', gtlx_path)
srgb_img = Image.open(A_path).convert('RGB')
gtlx_np = np.loadtxt(gtlx_path, delimiter=',')
gtlx_pil = Image.fromarray(gtlx_np)
srgb_img = self.transform(srgb_img)
gt_SH = self.transform_lux(gtlx_pil)
gt_SH = gt_SH / gt_SH.max()
mask = torch.ones_like(gt_SH)
gt_BA, brightest_20, gt_BP, gt_BC\
= util.calc_brightest(
gt_SH, mask,
nr_tap=self.opt.bp_nr_tap,
nr_sigma=self.opt.bp_nr_sigma,
spread_tap=self.opt.bp_tap,
spread_sigma=self.opt.bp_sigma
)
gt_SH = normalize(grayscale=True)(gt_SH)
mask = normalize(grayscale=True)(mask)
gt_BA = normalize(grayscale=True)(gt_BA)
gt_BP = normalize(grayscale=True)(gt_BP)
gt_BC = torch.Tensor(list(gt_BC))
srgb_img = torch.unsqueeze(srgb_img, 0) # [1, 3, 256, 256]
gt_AL = torch.zeros_like(srgb_img)
gt_SH = torch.unsqueeze(gt_SH, 0)
mask = torch.unsqueeze(mask, 0)
gt_BA = torch.unsqueeze(gt_BA, 0)
gt_BP = torch.unsqueeze(gt_BP, 0)
return {
'A': srgb_img,
'gt_AL': gt_AL,
'gt_SH': gt_SH,
'mask': mask,
'gt_BA': gt_BA,
'gt_BP': gt_BP,
'gt_BC': gt_BC,
'A_paths': A_path
}
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)
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('RGB'))
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 __getitem__(self, index):
image_tensor = ds_tensor = inst_tensor = feat_tensor = 0
### real images
#if self.opt.isTrain:
image_path = self.image_paths[index]
image = Image.open(image_path).convert('RGB')
params = get_params(self.opt, image.size)
transform_image = get_transform(self.opt, params)
image_tensor = transform_image(image)
label_tensor = 0
transform_label = 0
if not self.opt.no_seg:
### label maps
label_path = self.label_paths[index]
label = Image.open(label_path)
if self.opt.label_nc == 0:
transform_label = get_transform(self.opt, params)
label_tensor = transform_label(label.convert('RGB'))
else:
transform_label = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
image2 = Image.fromarray(util.tensor2im(image_tensor))
ds = 0
if self.opt.comp_type == 'ds':
ds = image2.resize((image2.size[0] // self.opt.alpha,
image2.size[1] // self.opt.alpha),
Image.LANCZOS)
ds = ds.resize((image2.size[0], image2.size[1]), Image.ANTIALIAS)
ds_tensor = transform_image(ds)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_label(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_label(feat))
input_dict = {
'label': label_tensor,
'inst': inst_tensor,
'image': image_tensor,
'ds': ds_tensor,
'feat': feat_tensor,
'path': image_path
}
return input_dict
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path).convert('RGB')
params = get_params(self.opt, A.size)
if self.opt.label_nc == 0:
# if self.opt.isTrain:
# A = trans.rotate(A,angle=params['degree'],fill=255)
transform_A = get_transform(self.opt, params)
A_tensor = transform_A(A.convert('L'))
# BP_path = self.BP_paths[index]
# BP = torch.from_numpy(np.load(BP_path))
# BP = F.interpolate(BP.unsqueeze(0), size=([self.opt.loadSize, self.opt.loadSize]), mode='nearest').squeeze(0) ### resize
# if self.opt.isTrain:
# BP = BP[:, params['crop_pos'][1]:params['crop_pos'][1] + self.opt.fineSize,
# params['crop_pos'][0]:params['crop_pos'][0] + self.opt.fineSize] ###crop
# if params['flip']:
# BP = par_flip(BP, 2)
#
# A_tensor = torch.cat([A_tensor, BP], 0)
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')
# B = trans.rotate(B, angle=params['degree'], fill=255)
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B.convert('L'))
### 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 __getitem__(self, index):
# To avoid using first and last image of the video
if index == 0:
index += 1
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size)
transform_A = get_transform(self.opt, params, method=Image.NEAREST,
normalize=False)
A_tensor = transform_A(A) * 255.0
### input A_previous (previous label map)
A_previous_path = self.A_paths[index-1]
A_previous = Image.open(A_previous_path)
params = get_params(self.opt, A_previous.size)
transform_A_previous = get_transform(self.opt, params, method=Image.NEAREST,
normalize=False)
A_tensor_previous = transform_A_previous(A_previous) * 255.0
B_tensor_previous = 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)
### input B_previous (previous real images)
if self.opt.isTrain:
B_previous_path = self.B_paths[index-1]
B_previous = Image.open(B_previous_path).convert('RGB')
transform_B_previous = get_transform(self.opt, params)
B_tensor_previous = transform_B_previous(B_previous)
### 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, 'previous_label': A_tensor_previous,
'inst': inst_tensor, 'image': B_tensor,
'previous_image': B_tensor_previous,
'feat': feat_tensor, 'path': A_path}
return input_dict
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
A = A.resize((640, 480), Image.ANTIALIAS)
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
B_tensor = C_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')
B = B.resize((640, 480), Image.ANTIALIAS)
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
C_path = self.C_paths[index]
C = Image.open(C_path).convert('RGB')
C = C.resize((640, 480), Image.ANTIALIAS)
transform_C = get_transform(self.opt, params)
C_tensor = transform_C(C)
### 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}
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'fixpts': C_tensor,
'feat': feat_tensor,
'path': A_path
}
return input_dict
def __getitem__(self, index):
### input A (label maps)
if index > self.dataset_size - self.clip_length:
index = 0 # it's a rare chance and won't be effecting training dynamics
A_path = self.A_paths[index:index + self.clip_length]
A = [Image.open(path) for path in A_path]
params = get_params(self.opt, A[0].size)
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params)
A_tensor = [transform_A(item.convert('RGB')) for item in A]
A_tensor = torch.stack(A_tensor, dim=0)
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:index + self.clip_length]
B = [Image.open(path).convert('RGB') for path in B_path]
transform_B = get_transform(self.opt, params)
B_tensor = [transform_B(item) for item in B]
B_tensor = torch.stack(B_tensor, dim=0)
else: # only retain first frame for testing
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 (which is never supposed to)
if not self.opt.no_instance:
inst_path = self.inst_paths[index:index + self.clip_length]
inst = [Image.open(path) for path in inst_path]
inst_tensor = [transform_A(item) for item in inst]
inst_tensor = torch.stack(inst_tensor, dim=0)
if self.opt.load_features:
feat_path = self.feat_paths[index:index + self.clip_length]
feat = [Image.open(path).convert('RGB') for path in feat_path]
norm = normalize()
feat_tensor = [norm(transform_A(item)) for item in feat]
feat_tensor = torch.stack(feat_tensor, dim=0)
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'feat': feat_tensor,
'path': A_path
}
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)
# transforms.ToTenosrは[0, 255]の値を[0, 1]にrescaleするた，255をかける
A_tensor = transform_A(A) * 255.0
print("label_map====================")
print(A_tensor.shape)
print(torch.unique(A_tensor))
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)
print("real_map=======================")
print(B_tensor.shape)
print(torch.unique(B_tensor))
### 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)
print("inst_tensor:", torch.unique(inst_tenosr))
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))
print("inst_map=======================")
print(inst_tensor.shape)
print(torch.unique(inst_tensor))
input_dict = {
"label": A_tensor,
"inst": inst_tensor,
"image": B_tensor,
"feat": feat_tensor,
"path": A_path,
}
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 # resize to 1024 * 512
B_tensor = inst_tensor = feat_tensor = labelTrain = 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)
### labelTrain semantic maps
if self.opt.isTrain:
labelTrain_path = self.labelTrain_paths[index]
labelTrain = Image.open(labelTrain_path).convert('P')
labelTrain = MyCoTransform(labelTrain)
# print(np.array(labelTrain_tensor).shape) # (1, 512, 1024)
### 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,
'labelTrain': labelTrain
}
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 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)
C_path = "/scratch/train_numbered/train_B/" + self.find_canonical_image(
B_path)
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):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
file_name = os.path.split(A_path)
file_name = os.path.splitext(file_name)[0]
add_label = int(file_name.split('_')[-1])
add_label_tensor = torch.tensor([add_label], dtype=torch.long)
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,
'add_label': add_label_tensor
}
return input_dict
def getitem(A_path, B_path, inst_path, feat_path):
### input A (label maps)
A = Image.open(A_path)
params = get_params(opt, A.size)
if opt.label_nc == 0:
transform_A = get_transform(opt, params)
A_tensor = transform_A(A.convert('RGB'))
else:
transform_A = get_transform(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)
B = Image.open(B_path).convert('RGB')
transform_B = get_transform(opt, params)
B_tensor = transform_B(B)
### if using instance maps
inst = Image.open(inst_path)
inst_tensor = transform_A(inst)
#get feat
netE = networks.define_G(opt.output_nc,
opt.feat_num,
opt.nef,
'encoder',
opt.n_downsample_E,
norm=opt.norm,
gpu_ids=opt.gpu_ids)
feat_map = netE.forward(
Variable(B_tensor[np.newaxis, :].cuda(), volatile=True),
inst_tensor[np.newaxis, :].cuda())
feat_map = nn.Upsample(scale_factor=2, mode='nearest')(feat_map)
image_numpy = util.tensor2im(feat_map.data[0])
util.save_image(image_numpy, feat_path)
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 get_features(input_dict['inst'], input_dict['feat'])
def __getitem__(self, index):
seed = time.time()
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
params = get_params(self.opt, A.size)
p = random.random()
if self.opt.label_nc == 0:
transform_A = get_transform(self.opt, params, p=p)
random.seed(seed) # apply this seed to img tranfsorms
torch.manual_seed(seed) # needed for torchvision 0.7
A_tensor = transform_A(A.convert('RGB'))
else:
transform_A = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False,
p=p)
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, p=p)
random.seed(seed) # apply this seed to img tranfsorms
torch.manual_seed(seed) # needed for torchvision 0.7
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 __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A_tensor = torch.load(A_path).permute((2, 0, 1))
# 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)
B = np.array(B, dtype=float) / 255.
B_tensor = torch.tensor(B)[:, :, :3].permute((2, 0, 1)).float()
# fig = plt.figure(1)
# ax = fig.add_subplot(111)
# ax.imshow(B_tensor[:,:1024,:].permute((1,2,0)))
# plt.show()
### 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 __getitem__(self, index):
geometry_tensor = 0
norm = normalize()
#### Before get_transform: convert to png
A_name = self.names_label[index]
### input A (label maps)
A_path = self.A_paths[index]
exr = cv2.imread(A_path, -1)
img = np.clip(exr, 0, 1)
img = img.astype(np.float32)
A_tensor = norm(toTensor(np.transpose(img, (2, 0, 1))))
if not self.opt.no_geometry:
geo_path = os.path.join(
self.dir_geo,
re.sub(r'diffuse_albedo(_\d\d)*', 'pointcloud', A_name))
geometry = cv2.imread(geo_path, cv2.IMREAD_UNCHANGED)
geo = rescale(np.copy(geometry), type=0)
geometry_tensor = norm(geo)
B_tensor = inst_tensor = feat_tensor = 0
### input B (real images)
if self.opt.isTrain or self.opt.use_encoded_image:
B_path = os.path.join(
self.dir_specular,
re.sub(r'diffuse_albedo(_\d\d)*', 'specular_unlit', A_name))
exr = cv2.imread(B_path, cv2.IMREAD_UNCHANGED)
specular = rescale(np.copy(exr), type=1)
B_tensor = norm(specular)
if not self.opt.isTrain and self.opt.loadGT:
B_path = os.path.join(
self.dir_specular,
re.sub(r'diffuse_albedo(_\d\d)*', 'specular_unlit', A_name))
exr = cv2.imread(B_path, cv2.IMREAD_UNCHANGED)
specular = rescale(np.copy(exr), type=1)
B_tensor = norm(specular)
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'feat': feat_tensor,
'path': A_path,
'geometry': geometry_tensor
}
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)
# <<<<<<< HEAD
# if self.opt.isTrain:
# B_path = self.B_paths[index]
# =======
if self.opt.isTrain or self.opt.use_encoded_image:
B_path = self.B_paths[index]
# >>>>>>> 5a2c87201c5957e2bf51d79b8acddb9cc1920b26
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 __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('L'))
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,
method=Image.NEAREST,
normalize=True)
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))
w, h = A.size
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'feat': feat_tensor,
'path': A_path,
'size': [w, h]
}
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)
import glob
canon_img_list = []
concat_img_list = []
for filename in glob.glob('/data/jl5/canon_frames/*.png'):
C = Image.open(filename).convert('RGB')
transform_C = get_transform(self.opt, params)
C_tensor = transform_C(C)
canon_img_list.append(C_tensor)
D_Tensor = torch.cat((A_tensor, C_tensor), 0)
concat_img_list.append(D_Tensor)
### 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': concat_img_list, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': A_path, 'canon': canon_img_list}
return input_dict
def __getitem__(self, index):
### label maps
label_path = self.label_paths[index]
#label = Image.open(label_path)
label = numpy.load(label_path)
label_size = (label.shape[0], label.shape[1])
params = get_params(self.opt, label_size)
if self.opt.label_nc == 0:
transform_label = get_transform(self.opt, params)
#label_tensor = transform_label(label.convert('RGB'))
label_tensor = transform_label(label)
else:
transform_label = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
label_tensor = transform_label(label) * 255.0
image_tensor = inst_tensor = feat_tensor = 0
### real images
if self.opt.isTrain:
image_path = self.image_paths[index]
image = Image.open(image_path).convert('RGB')
transform_image = get_transform(self.opt, params)
image_tensor = transform_image(image)
### if using instance maps
if not self.opt.no_instance:
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
inst_tensor = transform_label(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_label(feat))
input_dict = {
'label': label_tensor,
'inst': inst_tensor,
'image': image_tensor,
'feat': feat_tensor,
'path': label_path
}
return input_dict
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A_tensor = np.load(A_path)["arr_0"][0].transpose(2, 0, 1)
#A_tensor=self.trans(A_tensor)
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)
B = B.convert("RGB")
print(B.getextrema())
"""
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
"""
B = self.trans(B)
print(B.max())
B = self.normalize(B)
print(B.max())
#B=self.trans(self.normalize(B))
B_tensor = 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 __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).int(
) # sometimes inst_tensor is float and it crashes the dataloader
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 __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 __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 __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[0]
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
#A_tensor = torch.ones(A_tensor.shape)
Lighting_path = self.LIGHTING_paths[index]
Lighting_image = Image.open(Lighting_path)
Lighting_image = cast_PIL_to_tensor(transforms.Resize([512, 512])(Lighting_image))
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, 'lighting': Lighting_image, 'inst': inst_tensor, 'image': B_tensor,
'feat': feat_tensor, 'path': Lighting_path}
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)
### 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 __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path)
A = A.resize((640, 512), Image.BILINEAR) # for SALICON only
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
B_tensor = C_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')
# B = B.resize((80, 60), Image.BILINEAR) # for SALICON only
B = B.resize(
(160, 128), Image.BILINEAR
) # for SALICON only , the small size should be 64 so that the smallest dimention of feature is even number, for better feature alignment
# B = B.resize((320, 256), Image.BILINEAR) # for SALICON only , the small size should be 64 so that the smallest dimention of feature is even number, for better feature alignment
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
C_path = self.C_paths[index]
C = Image.open(C_path).convert('RGB')
# C = C.resize((80, 60), Image.BILINEAR) # for SALICON only
C = C.resize((160, 128), Image.BILINEAR) # for SALICON only
# C = C.resize((320, 256), Image.BILINEAR) # for SALICON only
transform_C = get_transform(self.opt, params)
C_tensor = transform_C(C)
### 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))
# print("A_tensor :", A_tensor.size())
# print("B_tensor :", B_tensor.size())
# print("C_tensor :", C_tensor.size())
# input_dict = {'label': A_tensor, 'inst': inst_tensor, 'image': B_tensor,
# 'feat': feat_tensor, 'path': A_path}
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'fixpts': C_tensor,
'feat': feat_tensor,
'path': A_path
}
return input_dict
def __getitem__(self, index):
### input A (label maps)
lpath = self.label_paths[index]
A_tensor_0 = torch.load(lpath).permute((2, 0, 1)).float()
idx_ = lpath.split('/')[-1][:12]
spath = self.opt.input_image_root + '%s_synthesized_image.jpg' % idx_
A = Image.open(spath).convert('RGB')
A = np.array(A, dtype=float) / 255.
A = A[:, :, :3]
idx = lpath.split('/')[-1].split('.')[0]
minx, maxx, miny, maxy = list(self.crop_coor[int(idx), :])
A = A[minx:maxx + 1, miny:maxy + 1, :]
A = cv2.resize(A, (128, 128))
A_tensor_1 = torch.tensor(A).permute((2, 0, 1)).float()
A_tensor = torch.cat((A_tensor_0, A_tensor_1), dim=0)
B_tensor = inst_tensor = feat_tensor = 0
lidx = lpath.split('/')[-1][:12]
sidx = spath.split('/')[-1][:12]
### input B (real images)
if self.opt.isTrain:
B_path = self.rimage_paths[index]
B = Image.open(B_path).convert('RGB')
B = np.array(B, dtype=float) / 255.
B_tensor = torch.tensor(B)[:, :, :3].permute((2, 0, 1)).float()
# fig = plt.figure(1)
# ax = fig.add_subplot(111)
# ax.imshow(B_tensor[:,:1024,:].permute((1,2,0)))
# plt.show()
ridx = B_path.split('/')[-1][:12]
assert lidx == ridx, "Wrong match"
### 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))
# print(lpath, spath, B_path)
# print(lidx, sidx )
assert lidx == sidx, "Wrong match"
# fig = plt.figure(1)
# ax = fig.add_subplot(111)
# ax.imshow(A)
# plt.show()
input_dict = {
'label': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'feat': feat_tensor,
'path': lpath
}
return input_dict
def __getitem__(self, index):
### input A (label maps)s
A_path = self.A_paths[index]
A = Image.open(A_path)
if DEBUG:
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
arr = np.array(A)
arr2txt(arr, 'src_A.txt')
print("A.size: {}, arr.shape: {}".format(A.size, arr.shape))
print("min,max,mean: ", arr.min(), arr.max(), arr.mean())
tmp_A = A.resize((64, 32), Image.NEAREST)
tmp_arr = np.array(tmp_A)
arr2txt(tmp_arr, 'resized_A.txt')
print("tmp_A.size: {}, tmp_arr.shape: {}".format(tmp_A.size, tmp_arr.shape))
print("min,max,mean: ", tmp_arr.min(), tmp_arr.max(), tmp_arr.mean())
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# cv2.imshow('show', tmp_arr)
# cv2.waitKey()
# cv2.waitKey()
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')
if DEBUG:
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
arr = np.array(B)
arr2txt(cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY), 'src_B.txt')
print("B.size: {}, arr.shape: {}".format(B.size, arr.shape))
print("min,max,mean: ", arr.min(), arr.max(), arr.mean())
tmp_B = B.resize((64, 32), Image.NEAREST)
tmp_arr = np.array(tmp_B)
arr2txt(cv2.cvtColor(tmp_arr, cv2.COLOR_RGB2GRAY), 'resized_B.txt')
print("tmp_B.size: {}, tmp_arr.shape: {}".format(tmp_B.size, tmp_arr.shape))
print("min,max,mean: ", tmp_arr.min(), tmp_arr.max(), tmp_arr.mean())
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# cv2.imshow('show', tmp_arr)
# cv2.waitKey()
transform_B = get_transform(self.opt, params)
B_tensor = transform_B(B)
### if using instance maps
if not self.opt.no_instance: # TODO: cityscapes 数据集的 train_inst 图片是使用 16位格式存的png图，Image、OpenCV 无法读这类图，可使用png读16位图
inst_path = self.inst_paths[index]
inst = Image.open(inst_path)
if DEBUG:
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
arr = np.array(inst)
arr2txt(arr, 'src_inst.txt')
print("inst.size: {}, arr.shape: {}".format(inst.size, arr.shape))
print("min,max,mean: ", arr.min(), arr.max(), arr.mean())
tmp_inst = inst.resize((64, 32), Image.NEAREST)
tmp_arr = np.array(tmp_inst)
arr2txt(tmp_arr, 'resized_inst.txt')
print("tmp_inst.size: {}, tmp_arr.shape: {}".format(tmp_inst.size, tmp_arr.shape))
print("min,max,mean: ", tmp_arr.min(), tmp_arr.max(), tmp_arr.mean())
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
# cv2.imshow('show', tmp_arr)
# cv2.waitKey()
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 __getitem__(self, index):
"""Return a data point and its metadata information.
Parameters:
index (int) -- 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
"""
# read a image given a random integer index
img_path = self.dataroot + "/intrinsics_final/images/" + self.img_paths[
index]
srgb_img = Image.open(img_path).convert('RGB')
file_name = self.img_paths[index].split('/')
R_path = self.dataroot + "/intrinsics_final/images/" + file_name[
0] + "/" + file_name[1][:-4] + "_albedo.png"
gt_AL = Image.open(R_path).convert('RGB')
mask_path = self.dataroot + "/intrinsics_final/images/" + file_name[
0] + "/" + file_name[1][:-4] + "_mask.png"
mask = Image.open(mask_path).convert('RGB')
irradiance = self.stat_dict[self.img_paths[index][:-4] + '.rgbe']
# apply the same transform to both A and B
transform_params = get_params(self.opt, srgb_img.size)
srgb_img_transform = get_transform(self.opt,
transform_params,
grayscale=False,
convert=False)
gt_AL_transform = get_transform(self.opt,
transform_params,
grayscale=False,
convert=False)
mask_transform = get_transform(self.opt,
transform_params,
grayscale=True,
convert=False)
srgb_img = srgb_img_transform(srgb_img)
gt_AL = gt_AL_transform(gt_AL)
mask = mask_transform(mask)
rgb_img = srgb_img**2.2
gt_SH = rgb_img / torch.clamp(gt_AL, min=1e-6)
# if albedo is too low, replace shading as radiance
sh_mask = torch.zeros_like(gt_SH)
sh_mask[gt_AL < 1e-6] = 1
sh_mask_inv = 1 - sh_mask
gt_SH = gt_SH * sh_mask_inv + rgb_img * sh_mask
srgb_img_gray = torch.mean(srgb_img, 0, keepdim=True)
rgb_img_gray = torch.mean(rgb_img, 0, keepdim=True)
gt_AL_gray = torch.mean(gt_AL, 0, keepdim=True)
gt_SH_gray = torch.mean(gt_SH, 0, keepdim=True)
gt_AL[gt_AL < 1e-6] = 1e-6
# gt_SH[gt_SH_gray.expand(gt_SH.size()) > 20] = 20
gt_SH[gt_SH_gray.expand(gt_SH.size()) > 1] = 1
gt_SH[gt_SH_gray.expand(gt_SH.size()) < 1e-4] = 1e-4
if not self.opt.no_mask:
mask[srgb_img_gray < 1e-6] = 0
mask[gt_AL_gray < 1e-6] = 0
mask[gt_SH_gray < 1e-4] = 0
mask[gt_SH_gray > 10] = 0
mask = 1.0 - util.erosion(1.0 - mask)
gt_BA, brightest_20, gt_BP, gt_BC\
= util.calc_brightest(
gt_SH_gray, mask,
nr_tap=self.opt.bp_nr_tap,
nr_sigma=self.opt.bp_nr_sigma,
spread_tap=self.opt.bp_tap,
spread_sigma=self.opt.bp_sigma
)
if self.opt.shading_norm:
gt_SH = gt_SH / brightest_20
if irradiance < 0.25:
srgb_img = srgb_img.cpu().numpy()
gt_SH = gt_SH.cpu().numpy()
srgb_img = denoise_tv_chambolle(srgb_img,
weight=0.05,
multichannel=True)
gt_SH = denoise_tv_chambolle(gt_SH, weight=0.1, multichannel=True)
srgb_img = torch.from_numpy(srgb_img)
gt_SH = torch.from_numpy(gt_SH)
srgb_img = normalize()(srgb_img)
gt_AL = normalize()(gt_AL)
gt_SH = normalize()(gt_SH)
mask = normalize(grayscale=True)(mask)
gt_BA = normalize(grayscale=True)(gt_BA)
gt_BP = normalize(grayscale=True)(gt_BP)
gt_BC = torch.Tensor(list(gt_BC))
srgb_img = torch.unsqueeze(srgb_img, 0) # [1, 3, 256, 256]
gt_AL = torch.unsqueeze(gt_AL, 0)
gt_SH = torch.unsqueeze(gt_SH, 0)
mask = torch.unsqueeze(mask, 0)
gt_BA = torch.unsqueeze(gt_BA, 0)
gt_BP = torch.unsqueeze(gt_BP, 0)
# radiantest = torch.unsqueeze(radiantest, 0)
return {
'A': srgb_img,
'gt_AL': gt_AL,
'gt_SH': gt_SH,
'mask': mask,
'gt_BA': gt_BA,
'gt_BP': gt_BP,
'gt_BC': gt_BC,
'A_paths': img_path
}
def __getitem__(self, index):
### input A (label maps)
A_path = self.A_paths[index]
A = Image.open(A_path).convert('RGB')
A = A.resize((512, 512), Image.BICUBIC)
a = float(np.random.random_integers(-1, 1)) / float(10)
#A = F.adjust_hue(A, a)
#A = F.adjust_saturation(A,2)
#w, h = COLOR.size
#w2 = int(w/3)
#A = COLOR.crop([0,0,w2,h])
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)
else:
transform_A = get_transform(self.opt,
params,
method=Image.NEAREST,
normalize=False)
A_tensor = transform_A(A) * 255.0
### input H (heat images)
H_path = self.H_paths[index]
H = Image.open(H_path).convert('RGB')
#H = COLOR.crop([w2,0,w2,h])
#H = F.adjust_hue(H, a)
#H = F.adjust_saturation(H,2)
#H = F.adjust_brightness(H, -0.2)
transform_H = get_transform(self.opt, params)
H_tensor = transform_H(H)
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')
#B = COLOR.crop([w2*2,0,w2,h])
B = F.adjust_hue(B, a)
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 = {
'A': A_tensor,
'inst': inst_tensor,
'image': B_tensor,
'H': H_tensor,
'feat': feat_tensor,
'path': A_path
} #
return input_dict
def __getitem__(self, index):
### MyTest for diffuse
if self.MyTest=='Diff':
## load images
A_path = self.A_paths[index]
AB = Image.open(A_path).convert('RGB')
w, h = AB.size
## crop to obtain imageA(input) and imageB(diff)
w5 = int(w / 5)
A = AB.crop((0, 0, w5, h))
Nor = AB.crop((w5, 0, 2*w5, h))
Dif = AB.crop((2*w5, 0, 3*w5, h))
Rou = AB.crop((3*w5, 0, 4*w5, h))
Spe = AB.crop((4*w5, 0, 5*w5, h))
## gamma correction for both A and B
gamma_A=255.0*(np.array(A)/255.0)**(1/2.2)
# gamma_B=255.0*(np.array(B)/255.0)**(1/2.2)
A=Image.fromarray(np.uint8(gamma_A))
if self.augment_color:
gamma = np.random.rand() + 0.5
gamma_Dif=255.0*(np.array(Dif)/255.0)**gamma
Dif=Image.fromarray(np.uint8(gamma_Dif))
gamma_Spe=255.0*(np.array(Spe)/255.0)**gamma
Spe=Image.fromarray(np.uint8(gamma_Spe))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params)
A_tensor = transform(A)
Nor_tensor = transform(Nor)
Dif_tensor = transform(Dif)
Rou_tensor = transform(Rou)
Spe_tensor = transform(Spe)
B_tensor=torch.cat((Nor_tensor,Dif_tensor,Rou_tensor,Spe_tensor), 0)
elif self.MyTest=='Normal':
A_path = self.A_paths[index]
AB = Image.open(A_path).convert('RGB')
w, h = AB.size
## crop to obtain imageA(input) and imageB(normal)
w5 = int(w / 5)
A = AB.crop((0, 0, w5, h))
B = AB.crop((w5, 0, 2*w5, h))
## gamma correction for only A
gamma_A=255.0*(np.array(A)/255.0)**(1/2.2)
A=Image.fromarray(np.uint8(gamma_A))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params)
A_tensor = transform(A)
B_tensor = transform(B)
elif self.MyTest=='Spec':
A_path = self.A_paths[index]
AB = Image.open(A_path).convert('RGB')
w, h = AB.size
## crop to obtain imageA(input) and imageB(normal)
w5 = int(w / 5)
A = AB.crop((0, 0, w5, h))
B = AB.crop((4*w5, 0, 5*w5, h))
## gamma correction for only A
gamma_A=255.0*(np.array(A)/255.0)**(1/2.2)
A=Image.fromarray(np.uint8(gamma_A))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params)
A_tensor = transform(A)
B_tensor = transform(B)
elif self.MyTest=='Rough':
A_path = self.A_paths[index]
AB = Image.open(A_path).convert('RGB')
w, h = AB.size
## crop to obtain imageA(input) and imageB(normal)
w5 = int(w / 5)
A = AB.crop((0, 0, w5, h))
B = AB.crop((3*w5, 0, 4*w5, h))
## gamma correction for only A
gamma_A=255.0*(np.array(A)/255.0)**(1/2.2)
A=Image.fromarray(np.uint8(gamma_A))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params)
A_tensor = transform(A)
B_tensor = transform(B)
elif self.MyTest=='NA':
### 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)
# for all_4D and all_5D cases
else:
if self.mode=='Syn':
A_path = self.A_paths[index]
# print('syn index', index)
AB = Image.open(A_path).convert('RGB')
w, h = AB.size
## crop to obtain imageA(input) and imageB(normal)
w5 = int(w / 5)
A = AB.crop((0, 0, w5, h))
Nor = AB.crop((w5, 0, 2*w5, h))
Dif = AB.crop((2*w5, 0, 3*w5, h))
Rou = AB.crop((3*w5, 0, 4*w5, h))
Spe = AB.crop((4*w5, 0, 5*w5, h))
## gamma correction for only A
## 2.2
gamma_A=255.0*(np.array(A)/255.0)**(1/2.2)
## log scale
# gamma_A=255.0*logTensor(np.array(A)/255.0)
A=Image.fromarray(np.uint8(gamma_A))
if self.augment_color:
gamma = np.random.rand() + 0.5
gamma_Dif=255.0*(np.array(Dif)/255.0)**gamma
Dif=Image.fromarray(np.uint8(gamma_Dif))
gamma_Spe=255.0*(np.array(Spe)/255.0)**gamma
Spe=Image.fromarray(np.uint8(gamma_Spe))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params)
A_tensor = transform(A)
Nor_tensor = transform(Nor)
Dif_tensor = transform(Dif)
Rou_tensor = transform(Rou)
Spe_tensor = transform(Spe)
B_tensor=torch.cat((Nor_tensor,Dif_tensor,Rou_tensor,Spe_tensor), 0)
# print('norm: ',B_tensor.shape)
## this is for real images testing
elif self.mode=='Real':
A_path = self.A_paths[index]
A = Image.open(A_path).convert('RGB')
## first gamma correction to linear
# gamma_A=(np.array(A)/255.0)**(2.2)*255
# ## then linear to log domain
# gamma_A=255.0*lognp(gamma_A)
# A=Image.fromarray(np.uint8(gamma_A))
## transform A and B in the same way
B_tensor = inst_tensor = feat_tensor = 0
params = get_params(self.opt, A.size)
transform = get_transform(self.opt, params,normalize=False)
A_tensor = transform(A)
### 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