def __getitem__(self, index):
if self.mode == 0:
img = None
while img is None:
with open(self.c_imgs[index], 'rb') as f:
img = Image.open(f).convert('RGB')
index += 1
index -= 1
elif self.mode == 1:
img = None
while img is None:
img = load_image(self.d_imgs[index])
index += 1
index -= 1
elif self.mode == 2:
c_img = None
d_img = None
while (c_img is None) or (d_img is None):
c_img = load_image(self.c_imgs[index])
d_img = load_image(self.d_imgs[index])
index += 1
img = [c_img, d_img]
index -= 1
else:
raise Exception('Wrong mode {:d}'.format(self.mode))
if self.transform is not None:
if self.mode == 2:
img = [self.transform(i) for i in img]
else:
img = self.transform(img)
return img
def __img_resize__(self, img_path, transform, resolution, semantic=False):
"""# Check if image needs to be resized (Nope too slow)
old_img = Image.open(img_path)
o_w, o_h = old_img.size
if o_w == resolution == o_h:
return img_path
"""
# Resize image
direct, name = os.path.split(img_path)
new_dir = os.path.join(direct, 'resized')
if not os.path.isdir(new_dir):
os.mkdir(new_dir)
if new_dir not in self.resize_directories:
self.resize_directories[new_dir] = set(os.listdir(new_dir))
new_name = 'resized_{}px_{:s}'.format(resolution, name)
new_path = os.path.join(new_dir, new_name)
if new_name not in self.resize_directories[new_dir]:
if semantic:
img = Image.open(img_path)
else:
img = load_image(img_path)
try:
img = transform(img)
except:
print('Problem with image {}'.format(img_path))
exit()
img.save(new_path)
return new_path
def __getitem__(self, index):
point = self.points[index]
inps = []
outs = []
for inp in self.input_types:
if inp == 'img':
img_path = os.path.join(self.data_path, self.scene,
point.img_path)
img = load_image(img_path)
img = None if img is None else self.transforms['img'](img)
inps.append(img)
elif inp == 'label':
img = single_channel_loader(point.sem_path)
img = None if img is None else self.transforms['label'](img)
inps.append(img)
else:
raise NotImplementedError('Not implemented yet (%s)' %
str(inp))
for out in self.output_types:
if out == 'pose':
p = point.pose
p = None if p is None else self.transforms['pose'](p)
outs.append(p)
elif out == 'label':
#print('GET SEMANTIC LAB')
img = single_channel_loader(point.sem_path)
#print(img.shape)
img = None if img is None else self.transforms['label'](img)
#print(img.shape)
outs.append(img)
else:
raise NotImplementedError('Not implemented yet')
return inps[0] if len(inps) <= 1 else inps, outs[0] if len(
outs) <= 1 else outs
def __getitem__(self, index):
"""
Augmentation index defines which type of images is returned:
0: standard daytime image
1: artificial nighttime images
>=2: stylized images
"""
augmentation_index = self.types[index]
inps = []
outs = []
img_sample = self.images[index % len(self.images)]
for inp in self.input_types:
if inp == 'img':
if augmentation_index == 0:
img_path = img_sample.path
elif augmentation_index == 1:
img_path = img_sample.nighttime
elif augmentation_index >= 2:
img_path = img_sample.stylized[augmentation_index - 2]
else:
raise NotImplementedError(
'Whats going on? Augmentation index: {:s}\t Index: {:d}'
.format(str(augmentation_index), index))
img = load_image(img_path)
img = None if img is None else self.transforms['img'](img)
inps.append(img)
elif inp == 'label':
img = single_channel_loader(img_sample.semantic)
img = None if img is None else self.transforms['label'](img)
inps.append(img)
elif inp == 'point_cloud':
pc = self.sift_points[img_sample.point_cloud]
#Normalize
#print('----------- NORMALIZE ---------')
#print(pc.shape)
#print(pc.mean(axis=1).shape)
pc = pc - pc.mean(axis=0)
pc = pc / pc.std(axis=0)
pc = pc.T
#print(pc.mean(axis=1))
#print(pc.std(axis=1))
pc = None if pc is None else self.transforms['point_cloud'](pc)
inps.append(pc)
else:
raise NotImplementedError('Not implemented yet (%s)' %
str(inp))
for out in self.output_types:
if out == 'pose':
p = img_sample.pose
p = None if p is None else self.transforms['pose'](p).squeeze()
outs.append(p)
elif out == 'label':
img = single_channel_loader(img_sample.semantic)
img = None if img is None else self.transforms['label'](img)
outs.append(img)
else:
raise NotImplementedError('Not implemented yet')
return inps[0] if len(inps) <= 1 else tuple(
inps), outs[0] if len(outs) <= 1 else outs
def __getitem__(self, index):
if self.skip_images:
img = None
pose = self.poses[index]
else:
if self.mode == 0:
img = None
while img is None:
img = load_image(self.c_imgs[index])
pose = self.poses[index]
index += 1
index -= 1
elif self.mode == 1:
img = None
while img is None:
img = load_image(self.d_imgs[index])
pose = self.poses[index]
index += 1
index -= 1
elif self.mode == 2:
c_img = None
d_img = None
while (c_img is None) or (d_img is None):
c_img = load_image(self.c_imgs[index])
d_img = load_image(self.d_imgs[index])
pose = self.poses[index]
index += 1
img = [c_img, d_img]
index -= 1
else:
raise Exception('Wrong mode {:d}'.format(self.mode))
if self.target_transform is not None:
pose = self.target_transform(pose)
if self.skip_images:
return img, pose
if self.transform is not None:
if self.mode == 2:
img = [self.transform(i) for i in img]
else:
img = self.transform(img)
return img, pose
def __getitem__(self, index):
point = self.points[index]
inps = []
outs = []
img_path = os.path.join(self.data_path, self.scene, point.img_path)
img = load_image(img_path)
img = self.transforms['img'](img)
p = point.pose
p = self.transforms['pose'](p)
return img, p
def __getitem__(self, index):
augmentation_index = 0
if self.night_augmentation:
augmentation_index = index // self.len
index = index % self.len
elif self.only_augmentation:
augmentation_index = 1
inps = []
outs = []
for inp in self.input_types:
if inp == 'img':
if augmentation_index == 0:
img_path = os.path.join(self.data_path,
self.img_paths[index])
else:
img_path = self.night_img_paths[index]
img = load_image(img_path)
img = None if img is None else self.transforms['img'](img)
inps.append(img)
elif inp == 'label':
img = single_channel_loader(self.sem_labels[index])
img = None if img is None else self.transforms['label'](img)
inps.append(img)
elif inp == 'point_cloud':
pc = self.sift_points[self.points_per_img[index]]
#Normalize
#print('----------- NORMALIZE ---------')
#print(pc.shape)
#print(pc.mean(axis=1).shape)
pc = pc - pc.mean(axis=0)
pc = pc / pc.std(axis=0)
pc = pc.T
#print(pc.mean(axis=1))
#print(pc.std(axis=1))
pc = None if pc is None else self.transforms['point_cloud'](pc)
inps.append(pc)
else:
raise NotImplementedError('Not implemented yet (%s)' %
str(inp))
for out in self.output_types:
if out == 'pose':
p = self.poses[index]
p = None if p is None else self.transforms['pose'](p).squeeze()
outs.append(p)
elif out == 'label':
img = single_channel_loader(self.sem_labels[index])
img = None if img is None else self.transforms['label'](img)
outs.append(img)
else:
raise NotImplementedError('Not implemented yet')
return inps[0] if len(inps) == 1 else tuple(inps), outs[0] if len(
outs) == 1 else outs
def __load_items__(self, index):
img = load_image(os.path.join(self.dir_path, self.imgs[index].name))
imfullsize = max(img.size)
if self.imsize is not None:
img = imresize(img, self.imsize)
if self.transform is not None:
img = self.transform(img)
pt_ids = self.imgs[index].point3D_ids
pts3d = np.vstack([self.pts[i].xyz for i in pt_ids])
mean, std = np.mean(pts3d, axis=0), np.std(pts3d, axis=0)
if self.demean:
pts3d -= mean
pts3d /= std
pts3d = torch.from_numpy(pts3d).float()
return img, pts3d
def _loader(self, name, index):
"""
Loads an image stored in the internal dataframe or gets an pose from the poses list
:param name : string (valid names: 'left', 'right', 'label_colorized', 'label', 'depth')
used to select the type of data to load
:param index: : int, the index of a certain image
:returns : the loaded data
if no path is given for the certain image, None is returned
"""
if name == 'pose':
return self.poses[index]
else:
path = self.df[name].iloc[index]
if pd.isna(path):
return None
else:
return load_image(path, self.LOADERS[name])
torch.manual_seed(seed)
if CUDA:
torch.cuda.manual_seed(seed)
model.cuda()
pred_poses = np.zeros((L, 7)) # store all predicted poses
targ_poses = np.zeros((L, 7)) # store all target poses
with open(args.import_file) as f:
features_file = json.load(f)
results = {}
for uid, path in tqdm(features_file.items()):
# import pdb; pdb.set_trace()
image_filename = osp.join(data_dir, path)
image = data_utils.load_image(image_filename)
image_transformed = data_set.transform(image)
features = model.feature_extractor(image_transformed.unsqueeze(0))
results[uid] = features.detach().numpy()
np.save(args.export_file, results)
exit(0)
# inference loop
for batch_idx, (data, target) in enumerate(loader):
if batch_idx % 200 == 0:
print 'Image {:d} / {:d}'.format(batch_idx, len(loader))
# indices into the global arrays storing poses
if (args.model.find('vid') >= 0) or args.pose_graph:
idx = data_set.get_indices(batch_idx)
# activate GPUs
CUDA = torch.cuda.is_available()
torch.manual_seed(seed)
if CUDA:
torch.cuda.manual_seed(seed)
model.cuda()
L = len(files)
pred_poses = np.zeros((L, 7)) # store all predicted poses
for i, file in tqdm.tqdm(enumerate(files), total=L):
#if i % 200 == 0:
# print('Image {:d} / {:d}'.format(i, len(files)))
#print('Load file %s'%file)
data = load_image(file[1])
data = data_transform(data).unsqueeze(0).unsqueeze(0)
_, output, _ = step_feedfwd(data, model, CUDA, train=False)
output = output[0]
s = output.size()
output = output.cpu().data.numpy().reshape((-1, s[-1]))
q = [qexp(p[3:]) for p in output]
output = np.hstack((output[:, :3], np.asarray(q)))
output[:, :3] = (output[:, :3] * pose_s) + pose_m
pred_poses[i, :] = output[len(output) // 2]
output_file = open('logs/'+args.output_file, 'w')
for i, file in enumerate(files):
else:
c.execute(
'''CREATE TABLE global_features (image_id INTEGER PRIMARY_KEY NOT NULL, cols INTEGER, data BLOB)'''
)
if args.augmented:
c.execute(
'''CREATE TABLE global_augmented_features (image_id INTEGER PRIMARY_KEY NOT NULL, cols INTEGER, data BLOB)'''
)
except sqlite3.Error as e:
print(e)
exit()
print('Loading image information')
images = get_images()
get_img = lambda i: load_image(args.data_path + images[i].name)
get_img_augmented = lambda i: load_image(
os.path.join(args.augmented_path,
os.path.split(images[i].name)[-1]).replace('.jpg', '.png'))
print('Found %d images' % len(images))
predictions = []
times = []
model.eval()
print('Start processing images')
for cnt, i in enumerate(images.keys()):
if cnt % (len(images) // 10) == 0:
c.commit()
print('%4d/%d' % (cnt, len(images)), end='\t')
if len(times) > 0:
