def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load_images()
images = sorted(scene_manager.images.itervalues(),
key=lambda image: image.name)
save_camera_ply(args.output_file, images, args.scale)
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load()
image_ids = map(scene_manager.get_image_from_name,
iter(lambda: sys.stdin.readline().strip(), ""))
scene_manager.delete_images(image_ids)
scene_manager.save(args.output_folder)
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load_cameras()
scene_manager.load_images()
if args.sort:
images = sorted(scene_manager.images.itervalues(),
key=lambda im: im.name)
else:
images = scene_manager.images.values()
fid = open(args.output_file, "w")
fid_filenames = open(args.output_file + ".list.txt", "w")
print >> fid, "# Bundle file v0.3"
print >> fid, len(images), 0
for image in images:
print >> fid_filenames, image.name
camera = scene_manager.cameras[image.camera_id]
print >> fid, 0.5 * (camera.fx + camera.fy), 0, 0
R, t = image.R(), image.t
print >> fid, R[0, 0], R[0, 1], R[0, 2]
print >> fid, -R[1, 0], -R[1, 1], -R[1, 2]
print >> fid, -R[2, 0], -R[2, 1], -R[2, 2]
print >> fid, t[0], -t[1], -t[2]
fid.close()
fid_filenames.close()
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load()
with open(args.output_file, "w") as fid:
fid.write("NVM_V3\n \n{:d}\n".format(len(scene_manager.images)))
image_fmt_str = " {:.3f} " + 7 * "{:.7f} "
for image_id, image in scene_manager.images.iteritems():
camera = scene_manager.cameras[image.camera_id]
f = 0.5 * (camera.fx + camera.fy)
fid.write(args.image_name_prefix + image.name)
fid.write(
image_fmt_str.format(*((f, ) + tuple(image.q.q) +
tuple(image.C()))))
if camera.distortion_func is None:
fid.write("0 0\n")
else:
fid.write("{:.7f} 0\n".format(-camera.k1))
image_id_to_idx = dict(
(image_id, i) for i, image_id in enumerate(scene_manager.images))
fid.write("{:d}\n".format(len(scene_manager.points3D)))
for i, point3D_id in enumerate(scene_manager.point3D_ids):
fid.write(
"{:.7f} {:.7f} {:.7f} ".format(*scene_manager.points3D[i]))
fid.write(
"{:d} {:d} {:d} ".format(*scene_manager.point3D_colors[i]))
keypoints = [(image_id_to_idx[image_id], kp_idx) +
tuple(scene_manager.images[image_id].points2D[kp_idx])
for image_id, kp_idx in
scene_manager.point3D_id_to_images[point3D_id]]
fid.write("{:d}".format(len(keypoints)))
fid.write((len(keypoints) * " {:d} {:d} {:.3f} {:.3f}" +
"\n").format(*itertools.chain(*keypoints)))
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load()
images = sorted(scene_manager.images.itervalues(), key=image_to_idx)
if args.method.lower() == "linear":
new_images = interpolate_linear(images, args.camera_id, args.format)
else:
new_images = interpolate_hermite(images, args.camera_id, args.format)
map(scene_manager.add_image, new_images)
scene_manager.save(args.output_folder)
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load()
# expect each line of input corresponds to one row
P = np.array(
[map(float,
sys.stdin.readline().strip().split()) for _ in xrange(3)])
scene_manager.points3D[:] = scene_manager.points3D.dot(P[:, :3].T) + P[:,
3]
# get rotation without any global scaling (assuming isotropic scaling)
scale = np.cbrt(np.linalg.det(P[:, :3]))
q_old_from_new = ~Quaternion.FromR(P[:, :3] / scale)
for image in scene_manager.images.itervalues():
image.q *= q_old_from_new
image.tvec = scale * image.tvec - image.R().dot(P[:, 3])
scene_manager.save(args.output_folder)
def main(args):
scene_manager = SceneManager(args.input_folder)
scene_manager.load()
assert (len(scene_manager.cameras) == 4)
zed_l = "frame_chess_zed_left_"
zed_r = "frame_chess_zed_right_"
zed_count = 0
for image in scene_manager.images.itervalues():
if zed_l in image.name:
zed_count = zed_count + 1
zed_gt_scale_in_meters = 0.120
zed_diff_vec = np.zeros((zed_count, 3))
for image in scene_manager.images.itervalues():
if zed_l in image.name:
row_id = int(image.name.split(zed_l, 1)[1][:-4])
if row_id < zed_count:
zed_diff_vec[row_id] = zed_diff_vec[row_id] + image.C()
if zed_r in image.name:
row_id = int(image.name.split(zed_r, 1)[1][:-4])
if row_id < zed_count:
zed_diff_vec[row_id] = zed_diff_vec[row_id] - image.C()
print(np.linalg.norm(zed_diff_vec, axis=1))
scale = zed_gt_scale_in_meters / np.median(
np.linalg.norm(zed_diff_vec, axis=1))
print("Scaling the model by {}".format(scale))
scene_manager.points3D[:] = scene_manager.points3D[:] * scale
for image in scene_manager.images.itervalues():
image.tvec = image.tvec * scale
# Print the relative transform from camera 1 to camera 2. [R|t]
ricoh_image_l_name = "frame_chess_left_{}.png".format(str(0).zfill(4))
ricoh_image_r_name = "frame_chess_right_{}.png".format(str(0).zfill(4))
#ricoh_image_l_name = "cubemap_left_cam_001_{}.png".format(str(0).zfill(4))
#ricoh_image_r_name = "cubemap_right_cam_001_{}.png".format(str(0).zfill(4))
for image in scene_manager.images.itervalues():
if ricoh_image_l_name == image.name:
ricoh_image_l = image
if ricoh_image_r_name == image.name:
ricoh_image_r = image
print("Relative transformation is:")
rel_pose = np.matmul(ricoh_image_r.Pose(), ricoh_image_l.InvPose())
np.set_printoptions(suppress=True)
print(rel_pose)
print("\nRelative transformation inverse is:")
print(np.linalg.inv(rel_pose))
scene_manager.save(args.output_folder)
# Save rel_pose in the ini settings format.
pose_save_str = "\n[RicohRelativePose]"
pose_save_str = pose_save_str + "\nextrinsics = [ " + np.array2string(
rel_pose, precision=10, separator=';', suppress_small=False).replace(
"]", "").replace("[", "").replace("\n", "") + " ]"
pose_save_str = pose_save_str + "\ninput_path = " + args.input_folder
pose_save_str = pose_save_str + "\noutput_path = " + args.output_folder
pose_save_str = pose_save_str + "\n"
with open(os.path.join(args.output_folder, "extrinsics.ini"),
"w") as text_file:
text_file.write(pose_save_str)
def main(args):
suffix = ".photometric.bin" if args.photometric else ".geometric.bin"
image_file = os.path.join(args.dense_folder, "images", args.image_filename)
depth_file = os.path.join(args.dense_folder, args.stereo_folder,
"depth_maps", args.image_filename + suffix)
if args.save_normals:
normals_file = os.path.join(args.dense_folder, args.stereo_folder,
"normal_maps",
args.image_filename + suffix)
# load camera intrinsics from the COLMAP reconstruction
scene_manager = SceneManager(os.path.join(args.dense_folder, "sparse"))
scene_manager.load_cameras()
scene_manager.load_images()
image_id, image = scene_manager.get_image_from_name(args.image_filename)
camera = scene_manager.cameras[image.camera_id]
rotation_camera_from_world = image.R()
camera_center = image.C()
# load image, depth map, and normal map
image = imageio.imread(image_file)
with open(depth_file, "rb") as fid:
w = int("".join(iter(lambda: fid.read(1), "&")))
h = int("".join(iter(lambda: fid.read(1), "&")))
c = int("".join(iter(lambda: fid.read(1), "&")))
depth_map = np.fromfile(fid, np.float32).reshape(h, w)
if (h, w) != image.shape[:2]:
depth_map = zoom(
depth_map,
(float(image.shape[0]) / h, float(image.shape[1]) / w),
order=0)
if args.save_normals:
with open(normals_file, "rb") as fid:
w = int("".join(iter(lambda: fid.read(1), "&")))
h = int("".join(iter(lambda: fid.read(1), "&")))
c = int("".join(iter(lambda: fid.read(1), "&")))
normals = np.fromfile(fid,
np.float32).reshape(c, h,
w).transpose([1, 2, 0])
if (h, w) != image.shape[:2]:
normals = zoom(
normals,
(float(image.shape[0]) / h, float(image.shape[1]) / w, 1.),
order=0)
if args.min_depth is not None:
depth_map[depth_map < args.min_depth] = 0.
if args.max_depth is not None:
depth_map[depth_map > args.max_depth] = 0.
# create 3D points
#depth_map = np.minimum(depth_map, 100.)
points3D = np.dstack(camera.get_image_grid() + [depth_map])
points3D[:, :, :2] *= depth_map[:, :, np.newaxis]
# save
points3D = points3D.astype(np.float32).reshape(-1, 3)
if args.save_normals:
normals = normals.astype(np.float32).reshape(-1, 3)
image = image.reshape(-1, 3)
if image.dtype != np.uint8:
if image.max() <= 1:
image = (image * 255.).astype(np.uint8)
else:
image = image.astype(np.uint8)
if args.world_space:
points3D = points3D.dot(rotation_camera_from_world) + camera_center
if args.save_normals:
normals = normals.dot(rotation_camera_from_world)
if args.save_normals:
vertices = np.rec.fromarrays(tuple(points3D.T) + tuple(normals.T) +
tuple(image.T),
names="x,y,z,nx,ny,nz,red,green,blue")
else:
vertices = np.rec.fromarrays(tuple(points3D.T) + tuple(image.T),
names="x,y,z,red,green,blue")
vertices = PlyElement.describe(vertices, "vertex")
PlyData([vertices]).write(args.output_filename)