def __init__(self, directory, is_2015=False, scale=1.0):
"""
Ground truth dataset iterator
"""
if is_2015:
left_dir, right_dir = 'image_2', 'image_3'
noc_dir, occ_dir = 'disp_noc_0', 'disp_occ_0'
calib_left, calib_right = 'P2', 'P3'
else:
left_dir, right_dir = 'image_0', 'image_1'
noc_dir, occ_dir = 'disp_noc', 'disp_occ'
calib_left, calib_right = 'P0', 'P1'
self.scale = scale
# Stereo is only evaluated on the _10.png images
self.stereo = StereoDatasetReader(os.path.expanduser(directory),
left_template=''.join([left_dir, '/%06i_10.png']),
right_template=''.join([right_dir, '/%06i_10.png']), scale=scale, grayscale=True)
self.noc = ImageDatasetReader(template=os.path.join(os.path.expanduser(directory), noc_dir, '%06i_10.png'))
self.occ = ImageDatasetReader(template=os.path.join(os.path.expanduser(directory), occ_dir, '%06i_10.png'))
def calib_read(fn, scale):
db = AttrDict.load_yaml(fn)
P0 = np.float32(db[calib_left].split(' '))
P1 = np.float32(db[calib_right].split(' '))
fx, cx, cy = P0[0], P0[2], P0[6]
baseline_px = np.fabs(P1[3])
return StereoCamera.from_calib_params(fx, fx, cx, cy, baseline_px=baseline_px)
self.calib = DatasetReader(template=os.path.join(os.path.expanduser(directory), 'calib/%06i.txt'),
process_cb=lambda fn: calib_read(fn, scale))
self.poses = repeat(None)
def __init__(self, directory='', scene=''):
# Read images
# nfiles = number_of_files(os.path.expanduser(directory))
# files = [os.path.join(directory, 'scene_%02i_%04i.png' % (idx/1000, idx%1000)) for idx in np.arange(nfiles)]
path = os.path.join(directory, '%s_images_archieve' % scene)
img_files = read_dir(os.path.expanduser(path), pattern='*.png', recursive=False, verbose=False, flatten=True)
gt_files = map(lambda fn: fn.replace('%s_images' % scene, '%s_GT' % scene).replace('.png', '.txt'), img_files)
def process_gt_cb(fn):
data = AttrDict()
with open(fn) as f:
for l in f:
key = l[0:l.find('=')].replace(' ', '')
if l.find('[') < 0:
val = float(l[l.find('=')+1:l.find(';')].replace(' ', ''))
else:
val = l[l.find('[')+1:l.find(']')]
val = np.array(map(lambda v: float(v), val.split(',')))
data[key] = val
return data
self.rgb = ImageDatasetReader.from_filenames(img_files)
self.gt = DatasetReader.from_filenames(files=gt_files, process_cb=process_gt_cb)
def __init__(self, target, instance, files):
self.target = target
self.instance = instance
mask_files = natural_sort(
filter(lambda fn: '_mask.png' in fn, files))
depth_files = natural_sort(
filter(lambda fn: '_depth.png' in fn, files))
rgb_files = natural_sort(
list(set(files) - set(mask_files) - set(depth_files)))
loc_files = natural_sort(
map(lambda fn: fn.replace('.png', '_loc.txt'), rgb_files))
assert (len(mask_files) == len(depth_files) == len(rgb_files) ==
len(loc_files))
self.rgb = ImageDatasetReader.from_filenames(rgb_files)
self.depth = ImageDatasetReader.from_filenames(depth_files)
self.mask = ImageDatasetReader.from_filenames(mask_files)
def __init__(self,
directory='',
template='data/img/img%04i_0.png',
velodyne_template=None,
start_idx=1,
max_files=100000,
scale=1.0):
# Set args
self.scale = scale
# Calibration
try:
calib_fn = os.path.join(os.path.expanduser(directory), 'info',
'intrinsics.txt')
s = open(calib_fn, 'r').readlines()
s = ''.join(s[1:])
for item in ['\n', '[', ']', ' ']:
s = s.replace(item, '')
K = np.fromstring(s, sep=',').reshape(3, 3)
self.calib_ = Camera.from_intrinsics(
CameraIntrinsic(K, shape=RPGUrban.shape[:2])).scaled(scale)
except Exception as e:
print('Failed to read calibration data: {}'.format(e))
self.calib_ = None
# Read stereo images
try:
self.rgb_ = ImageDatasetReader(template=os.path.join(
os.path.expanduser(directory), template),
start_idx=start_idx,
max_files=max_files,
scale=scale)
except Exception as e:
print('Failed to read rgb data: {}'.format(e))
self.rgb_ = NoneReader()
# Read poses
def load_poses(fn):
"""
poses: image_id tx ty tz qx qy qz qw
"""
X = (np.fromfile(fn, dtype=np.float64, sep=' ')).reshape(-1, 8)
abs_poses = map(lambda p: RigidTransform(xyzw=p[4:], tvec=p[1:4]),
X)
rel_poses = [abs_poses[0].inverse() * p for p in abs_poses]
return rel_poses
try:
pose_fn = os.path.join(os.path.expanduser(directory), 'info',
'groundtruth.txt')
self.poses_ = FileReader(pose_fn, process_cb=load_poses)
except Exception as e:
self.poses_ = NoneReader()
def __init__(self, target, instance, files):
self.target = target
self.instance = instance
mask_files = natural_sort(
filter(lambda fn: '_maskcrop.png' in fn, files))
depth_files = natural_sort(
filter(lambda fn: '_depthcrop.png' in fn, files))
rgb_files = natural_sort(
list(set(files) - set(mask_files) - set(depth_files)))
loc_files = natural_sort(
map(lambda fn: fn.replace('_crop.png', '_loc.txt'), rgb_files))
# Ensure all have equal number of files (Hack! doesn't ensure filename consistency)
nfiles = np.min([
len(loc_files),
len(mask_files),
len(depth_files),
len(rgb_files)
])
mask_files, depth_files, rgb_files, loc_files = mask_files[:nfiles], depth_files[:nfiles], \
rgb_files[:nfiles], loc_files[:nfiles]
# print target, instance, len(loc_files), len(mask_files), len(depth_files), len(rgb_files)
assert (len(mask_files) == len(depth_files) == len(rgb_files) ==
len(loc_files))
# Read images
self.rgb = ImageDatasetReader.from_filenames(rgb_files)
self.depth = ImageDatasetReader.from_filenames(depth_files)
self.mask = ImageDatasetReader.from_filenames(mask_files)
# Read top-left locations of bounding box
self.locations = np.vstack([
np.loadtxt(loc, delimiter=',', dtype=np.int32)
for loc in loc_files
])
class KITTIStereoGroundTruthDatasetReader(object):
def __init__(self, directory, is_2015=False, scale=1.0):
"""
Ground truth dataset iterator
"""
if is_2015:
left_dir, right_dir = 'image_2', 'image_3'
noc_dir, occ_dir = 'disp_noc_0', 'disp_occ_0'
calib_left, calib_right = 'P2', 'P3'
else:
left_dir, right_dir = 'image_0', 'image_1'
noc_dir, occ_dir = 'disp_noc', 'disp_occ'
calib_left, calib_right = 'P0', 'P1'
self.scale = scale
# Stereo is only evaluated on the _10.png images
self.stereo = StereoDatasetReader(
os.path.expanduser(directory),
left_template=''.join([left_dir, '/%06i_10.png']),
right_template=''.join([right_dir, '/%06i_10.png']),
scale=scale, grayscale=True)
self.noc = ImageDatasetReader(
template=os.path.join(os.path.expanduser(directory),
noc_dir, '%06i_10.png'))
self.occ = ImageDatasetReader(
template=os.path.join(os.path.expanduser(directory),
occ_dir, '%06i_10.png'))
def calib_read(fn, scale):
db = AttrDict.load_yaml(fn)
P0 = np.float32(db[calib_left].split(' '))
P1 = np.float32(db[calib_right].split(' '))
fx, cx, cy = P0[0], P0[2], P0[6]
baseline_px = np.fabs(P1[3])
return StereoCamera.from_calib_params(fx, fx, cx, cy,
baseline_px=baseline_px)
self.calib = DatasetReader(
template=os.path.join(os.path.expanduser(directory),
'calib/%06i.txt'),
process_cb=lambda fn: calib_read(fn, scale))
self.poses_ = NoneReader()
def iter_gt_frames(self, *args, **kwargs):
"""
Iterate over all the ground-truth data
- For noc, occ disparity conversion, see
devkit_stereo_flow/matlab/disp_read.m
"""
for (left, right), noc, occ, calib in izip(
self.iter_stereo_frames(*args, **kwargs),
self.noc.iteritems(*args, **kwargs),
self.occ.iteritems(*args, **kwargs),
self.calib.iteritems(*args, **kwargs)):
yield AttrDict(left=left, right=right,
depth=(occ/256).astype(np.float32),
noc=(noc/256).astype(np.float32),
occ=(occ/256).astype(np.float32),
calib=calib, pose=None)
def iteritems(self, *args, **kwargs):
return self.stereo.left.iteritems(*args, **kwargs)
def iter_stereo_frames(self, *args, **kwargs):
return self.stereo.iteritems(*args, **kwargs)
def iterframes(self, *args, **kwargs):
for (left, right), pose in izip(
self.iter_stereo_frames(*args, **kwargs),
self.poses.iteritems(*args, **kwargs)):
yield AttrDict(left=left, right=right,
velodyne=None, pose=pose)
@property
def stereo_frames(self):
return self.iter_stereo_frames()
@property
def poses(self):
return self.poses_
def __init__(self, files, meta_file, aligned_file, version, name=''):
self.name = name
self.version = version
self.rgb_files, self.depth_files = UWRGBDSceneDataset._reader.scene_files(
files, version)
assert (len(self.depth_files) == len(self.rgb_files))
# RGB, Depth
# TODO: Check depth seems scaled by 256 not 16
self.rgb = ImageDatasetReader.from_filenames(self.rgb_files)
self.depth = ImageDatasetReader.from_filenames(self.depth_files)
# BBOX
self.bboxes = UWRGBDSceneDataset._reader.load_bboxes(meta_file, version) \
if meta_file is not None else [None] * len(self.rgb_files)
assert (len(self.bboxes) == len(self.rgb_files))
# POSE
# Version 2 only supported! Version 1 support for rgbd scene (unclear)
self.poses = UWRGBDSceneDataset._reader.load_poses(aligned_file.pose, version) \
if aligned_file is not None and version == 'v2' else [None] * len(self.rgb_files)
assert (len(self.poses) == len(self.rgb_files))
# Aligned point cloud
if aligned_file is not None:
if version != 'v2':
raise RuntimeError('Version v2 is only supported')
ply_xyz, ply_rgb = UWRGBDSceneDataset._reader.load_ply(
aligned_file.ply, version)
ply_label = UWRGBDSceneDataset._reader.load_plylabel(
aligned_file.label, version)
# Remapping to v1 index
ply_label = np.array(
[UWRGBDSceneDataset.v2_to_v1[l] for l in ply_label],
dtype=np.int32)
# Get object info
object_info = UWRGBDSceneDataset._reader.cluster_ply_labels(
ply_xyz[::30], ply_rgb[::30], ply_label[::30])
# Add camera info
intrinsic = CameraIntrinsic(
K=UWRGBDSceneDataset.camera_params.K_rgb,
shape=UWRGBDDataset.default_rgb_shape)
camera = Camera.from_intrinsics_extrinsics(
intrinsic, CameraExtrinsic.identity())
self.map_info = AttrDict(camera=camera, objects=object_info)
# # 1c. Determine centroid of each cluster
# unique_centers = np.vstack([np.mean(ply_xyz[ply_label == l], axis=0) for l in unique_labels])
# self.map_info = AttrDict(
# points=ply_xyz, color=ply_rgb, labels=ply_label,
# unique_labels=unique_labels, unique_centers=unique_centers, camera=camera
# )
assert (len(ply_xyz) == len(ply_rgb))
print('*********************************')
print('Scene {}, Images: {}, Poses: {}\nAligned: {}'.format(
self.scene_name, len(self.rgb_files), len(self.poses),
aligned_file))