def prep_dataset(config):
"""
Expand dataset configuration to match split length
Parameters
----------
config : CfgNode
Dataset configuration
Returns
-------
config : CfgNode
Updated dataset configuration
"""
# If there is no dataset, do nothing
if len(config.path) == 0:
return config
# Get split length and expand other arguments to the same length
n = len(config.split)
config.dataset = make_list(config.dataset, n)
config.path = make_list(config.path, n)
config.depth_type = make_list(config.depth_type, n)
if 'repeat' in config:
config.repeat = make_list(config.repeat, n)
# Return updated configuration
return config
def load_class(filename, paths, concat=True):
"""
Look for a file in different locations and return its method with the same name
Optionally, you can use concat to search in path.filename instead
Parameters
----------
filename : str
Name of the file we are searching for
paths : str or list of str
Folders in which the file will be searched
concat : bool
Flag to concatenate filename to each path during the search
Returns
-------
method : Function
Loaded method
"""
# for each path in paths
for path in make_list(paths):
# Create full path
full_path = '{}.{}'.format(path, filename) if concat else path
if importlib.util.find_spec(full_path):
# Return method with same name as the file
return getattr(importlib.import_module(full_path), filename)
raise ValueError('Unknown class {}'.format(filename))
def prep_dataset(config):
"""
Expand dataset configuration to match split length
Parameters
----------
config : CfgNode
Dataset configuration
Returns
-------
config : CfgNode
Updated dataset configuration
"""
# If there is no dataset, do nothing
if len(config.path) == 0:
return config
# If cameras is not a double list, make it so
if not config.cameras or not is_list(config.cameras[0]):
config.cameras = [config.cameras]
# Get maximum length and expand other arguments to the same length
n = max(len(config.split), len(config.cameras), len(config.depth_type))
config.dataset = make_list(config.dataset, n)
config.path = make_list(config.path, n)
config.split = make_list(config.split, n)
config.input_depth_type = make_list(config.input_depth_type, n)
config.depth_type = make_list(config.depth_type, n)
config.cameras = make_list(config.cameras, n)
if 'repeat' in config:
config.repeat = make_list(config.repeat, n)
# Return updated configuration
return config
def compute_inv_depths(self, image):
"""Computes inverse depth maps from single images"""
# Randomly flip and estimate inverse depth maps
flip_lr = random.random() < self.flip_lr_prob if self.training else False
inv_depths = make_list(flip_model(self.depth_net, image, flip_lr))
# If upsampling depth maps
if self.upsample_depth_maps:
inv_depths = interpolate_scales(
inv_depths, mode='nearest', align_corners=None)
# Return inverse depth maps
return inv_depths
def compute_depth_net(self, image):
"""Computes inverse depth maps from single images"""
# Randomly flip and estimate inverse depth maps
inv_depths, raysurf = self.flip_model(self.depth_net, image, False)
inv_depths = make_list(inv_depths)
# If upsampling depth maps
if self.upsample_depth_maps:
inv_depths = self.interpolate_scales(inv_depths,
mode='nearest',
align_corners=None)
# Return inverse depth maps
return inv_depths, raysurf
def load_network(network, path, prefixes=''):
"""
Loads a pretrained network
Parameters
----------
network : nn.Module
Network that will receive the pretrained weights
path : str
File containing a 'state_dict' key with pretrained network weights
prefixes : str or list of str
Layer name prefixes to consider when loading the network
Returns
-------
network : nn.Module
Updated network with pretrained weights
"""
prefixes = make_list(prefixes)
# If path is a string
if is_str(path):
saved_state_dict = torch.load(path, map_location='cpu')['state_dict']
if path.endswith('.pth.tar'):
saved_state_dict = backwards_state_dict(saved_state_dict)
# If state dict is already provided
else:
saved_state_dict = path
# Get network state dict
network_state_dict = network.state_dict()
updated_state_dict = OrderedDict()
n, n_total = 0, len(network_state_dict.keys())
for key, val in saved_state_dict.items():
for prefix in prefixes:
prefix = prefix + '.'
if prefix in key:
idx = key.find(prefix) + len(prefix)
key = key[idx:]
if key in network_state_dict.keys() and \
same_shape(val.shape, network_state_dict[key].shape):
updated_state_dict[key] = val
n += 1
network.load_state_dict(updated_state_dict, strict=False)
base_color, attrs = 'cyan', ['bold', 'dark']
color = 'green' if n == n_total else 'yellow' if n > 0 else 'red'
print0(
pcolor('###### Pretrained {} loaded:'.format(prefixes[0]),
base_color,
attrs=attrs) +
pcolor(' {}/{} '.format(n, n_total), color, attrs=attrs) +
pcolor('tensors', base_color, attrs=attrs))
return network
def __getitem__(self, idx):
"""Get a dataset sample"""
# Get DGP sample (if single sensor, make it a list)
self.sample_dgp = self.dataset[idx]
self.sample_dgp = [make_list(sample) for sample in self.sample_dgp]
# Loop over all cameras
sample = []
for i in range(self.num_cameras):
data = {
'idx': idx,
'dataset_idx': self.dataset_idx,
'sensor_name': self.get_current('datum_name', i),
'filename': '%s_%010d' % (self.split, idx),
#
'rgb': self.get_current('rgb', i),
'intrinsics': self.get_current('intrinsics', i),
}
if self.with_depth:
data.update({
'depth': self.get_current('depth', i),
})
if self.with_pose:
data.update({
'extrinsics': [
pose.matrix
for pose in self.get_current('extrinsics', i)
],
'pose':
[pose.matrix for pose in self.get_current('pose', i)],
})
if self.has_context:
data.update({
'rgb_context': self.get_context('rgb', i),
})
sample.append(data)
# Apply same data transformations for all sensors
if self.data_transform:
sample = [self.data_transform(smp) for smp in sample]
# Return sample (stacked if necessary)
return stack_sample(sample)
def __getitem__(self, idx):
"""Get a dataset sample"""
# Get DGP sample (if single sensor, make it a list)
self.sample_dgp = self.dataset[idx]
self.sample_dgp = [make_list(sample) for sample in self.sample_dgp]
# Loop over all cameras
sample = []
for i in range(self.num_cameras):
data = {
'idx': idx,
'dataset_idx': self.dataset_idx,
'sensor_name': self.get_current('datum_name', i),
#
'filename': self.get_filename(idx, i),
'splitname': '%s_%010d' % (self.split, idx),
#
'rgb': self.get_current('rgb', i),
'intrinsics': self.get_current('intrinsics', i),
}
# If depth is returned
if self.with_depth:
data.update({
'depth': self.generate_depth_map(idx, i, data['filename'])
})
# If pose is returned
if self.with_pose:
data.update({
'extrinsics': self.get_current('extrinsics', i).matrix,
'pose': self.get_current('pose', i).matrix,
})
# If context is returned
if self.has_context:
data.update({
'rgb_context': self.get_context('rgb', i),
})
# If context pose is returned
if self.with_pose:
# Get original values to calculate relative motion
orig_extrinsics = Pose.from_matrix(data['extrinsics'])
orig_pose = Pose.from_matrix(data['pose'])
data.update({
'extrinsics_context':
[(orig_extrinsics.inverse() * extrinsics).matrix
for extrinsics in self.get_context('extrinsics', i)],
'pose_context':
[(orig_pose.inverse() * pose).matrix
for pose in self.get_context('pose', i)],
})
sample.append(data)
# Apply same data transformations for all sensors
if self.data_transform:
sample = [self.data_transform(smp) for smp in sample]
# Return sample (stacked if necessary)
return stack_sample(sample)
def __getitem__(self, idx):
"""Get a dataset sample"""
# Get DGP sample (if single sensor, make it a list)
self.sample_dgp = self.dataset[idx]
self.sample_dgp = [make_list(sample) for sample in self.sample_dgp]
if self.with_geometric_context:
self.sample_dgp_left = self.dataset_left[idx]
self.sample_dgp_left = [
make_list(sample) for sample in self.sample_dgp_left
]
self.sample_dgp_right = self.dataset_right[idx]
self.sample_dgp_right = [
make_list(sample) for sample in self.sample_dgp_right
]
# print('self.sample_dgp :')
# print(self.sample_dgp)
# print('self.sample_dgp_left :')
# print(self.sample_dgp_left)
# print('self.sample_dgp_right :')
# print(self.sample_dgp_right)
# Loop over all cameras
sample = []
for i in range(self.num_cameras):
i_left = self.get_camera_idx_left(i)
i_right = self.get_camera_idx_right(i)
# print(self.get_current('datum_name', i))
# print(self.get_filename(idx, i))
# print(self.get_current('intrinsics', i))
# print(self.with_depth)
data = {
'idx':
idx,
'dataset_idx':
self.dataset_idx,
'sensor_name':
self.get_current('datum_name', i),
#
'filename':
self.get_filename(idx, i),
'splitname':
'%s_%010d' % (self.split, idx),
#
'rgb':
self.get_current('rgb', i),
'intrinsics':
self.get_current('intrinsics', i),
'extrinsics':
self.get_current('extrinsics', i).matrix,
'path_to_ego_mask':
os.path.join(
os.path.dirname(self.path),
self._get_path_to_ego_mask(self.get_filename(idx, i))),
}
# If depth is returned
if self.with_depth:
data.update({
'depth':
self.generate_depth_map(idx, i, data['filename'])
})
# If pose is returned
if self.with_pose:
data.update({
'pose': self.get_current('pose', i).matrix,
})
if self.has_context:
orig_extrinsics = Pose.from_matrix(data['extrinsics'])
data.update({
'rgb_context':
self.get_context('rgb', i),
'intrinsics_context':
self.get_context('intrinsics', i),
'extrinsics_context':
[(extrinsics.inverse() * orig_extrinsics).matrix
for extrinsics in self.get_context('extrinsics', i)],
})
data.update({
'path_to_ego_mask_context': [
os.path.join(
os.path.dirname(self.path),
self._get_path_to_ego_mask(
self.get_filename(idx, i)))
for _ in range(len(data['rgb_context']))
],
})
data.update({
'context_type': [],
})
for _ in range(self.bwd):
data['context_type'].append('backward')
for _ in range(self.fwd):
data['context_type'].append('forward')
# If context pose is returned
if self.with_pose:
# Get original values to calculate relative motion
orig_pose = Pose.from_matrix(data['pose'])
data.update({
'pose_context':
[(orig_pose.inverse() * pose).matrix
for pose in self.get_context('pose', i)],
})
if self.with_geometric_context:
orig_extrinsics = data['extrinsics']
#orig_extrinsics[:3,3] = -np.dot(orig_extrinsics[:3,:3].transpose(), orig_extrinsics[:3,3])
orig_extrinsics_left = self.get_current_left(
'extrinsics', i_left).matrix
orig_extrinsics_right = self.get_current_right(
'extrinsics', i_right).matrix
#orig_extrinsics_left[:3,3] = -np.dot(orig_extrinsics_left[:3,:3].transpose(), orig_extrinsics_left[:3,3])
#orig_extrinsics_right[:3,3] = -np.dot(orig_extrinsics_right[:3,:3].transpose(), orig_extrinsics_right[:3,3])
orig_extrinsics = Pose.from_matrix(orig_extrinsics)
orig_extrinsics_left = Pose.from_matrix(orig_extrinsics_left)
orig_extrinsics_right = Pose.from_matrix(orig_extrinsics_right)
data['rgb_context'].append(self.get_current_left(
'rgb', i_left))
data['rgb_context'].append(
self.get_current_right('rgb', i_right))
data['intrinsics_context'].append(
self.get_current_left('intrinsics', i_left))
data['intrinsics_context'].append(
self.get_current_right('intrinsics', i_right))
data['extrinsics_context'].append(
(orig_extrinsics_left.inverse() * orig_extrinsics).matrix)
data['extrinsics_context'].append(
(orig_extrinsics_right.inverse() * orig_extrinsics).matrix)
#data['extrinsics_context'].append((orig_extrinsics.inverse() * orig_extrinsics_left).matrix)
#data['extrinsics_context'].append((orig_extrinsics.inverse() * orig_extrinsics_right).matrix)
data['path_to_ego_mask_context'].append(
os.path.join(
os.path.dirname(self.path),
self._get_path_to_ego_mask(
self.get_filename_left(idx, i_left))))
data['path_to_ego_mask_context'].append(
os.path.join(
os.path.dirname(self.path),
self._get_path_to_ego_mask(
self.get_filename_right(idx, i_right))))
data['context_type'].append('left')
data['context_type'].append('right')
data.update({
'sensor_name_left':
self.get_current_left('datum_name', i_left),
'sensor_name_right':
self.get_current_right('datum_name', i_right),
#
'filename_left':
self.get_filename_left(idx, i_left),
'filename_right':
self.get_filename_right(idx, i_right),
#
#'rgb_left': self.get_current_left('rgb', i),
#'rgb_right': self.get_current_right('rgb', i),
#'intrinsics_left': self.get_current_left('intrinsics', i),
#'intrinsics_right': self.get_current_right('intrinsics', i),
#'extrinsics_left': self.get_current_left('extrinsics', i).matrix,
#'extrinsics_right': self.get_current_right('extrinsics', i).matrix,
#'path_to_ego_mask_left': self._get_path_to_ego_mask(self.get_filename_left(idx, i)),
#'path_to_ego_mask_right': self._get_path_to_ego_mask(self.get_filename_right(idx, i)),
})
# data.update({
# 'extrinsics_context_left':
# [(orig_extrinsics_left.inverse() * extrinsics_left).matrix
# for extrinsics_left in self.get_context_left('extrinsics', i)],
# 'extrinsics_context_right':
# [(orig_extrinsics_right.inverse() * extrinsics_right).matrix
# for extrinsics_right in self.get_context_right('extrinsics', i)],
# 'intrinsics_context_left': self.get_context_left('intrinsics', i),
# 'intrinsics_context_right': self.get_context_right('intrinsics', i),
# })
sample.append(data)
# Apply same data transformations for all sensors
if self.data_transform:
sample = [self.data_transform(smp) for smp in sample]
# Return sample (stacked if necessary)
return stack_sample(sample)
