def optimize(self):
# init g2o solver
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
opt.set_algorithm(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
# add frames to graph
for frame in self.frames:
pose = frame.pose
sbacam = g2o.SBACam(
g2o.SE3Quat(frame.pose[0:3, 0:3], frame.pose[0:3, 3]))
# sbacam.set_cam(frame.K[0][0], frame.K[1][1], frame.K[2][0], frame.K[2][1], 1.0)
sbacam.set_cam(1.0, 1.0, 0.0, 0.0, 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(frame.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(frame.id == 0)
opt.add_vertex(v_se3)
# add points to frames
PT_ID_OFFSET = 0x10000
for point in self.points:
pt = g2o.VertexSBAPointXYZ()
pt.set_id(point.id + PT_ID_OFFSET)
pt.set_estimate(point.pt[0:3])
pt.set_marginalized(True)
pt.set_fixed(False)
opt.add_vertex(pt)
for frame in point.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, opt.vertex(frame.id))
uv = frame.kps[frame.pts.index(point)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
# opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(20)
# add pose back to frame
for frame in self.frames:
est = opt.vertex(frame.id).estimate()
R = est.rotation().matrix()
t = est.translation()
frame.pose = poseRt(R, t)
def optimize(self):
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
# add frames to graph
for f in self.frames:
pose = f.pose
#pose = np.linalg.inv(pose)
sbacam = g2o.SBACam(g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3]))
sbacam.set_cam(f.K[0][0], f.K[1][1], f.K[0][2], f.K[1][2], 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(f.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(f.id <= 1)
opt.add_vertex(v_se3)
# add points to frames
PT_ID_OFFSET = 0x10000
for p in self.points:
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id + PT_ID_OFFSET)
pt.set_estimate(p.pt[0:3])
pt.set_marginalized(True)
pt.set_fixed(False)
opt.add_vertex(pt)
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, opt.vertex(f.id))
uv = f.kpus[f.pts.index(p)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(50)
# put frames back
for f in self.frames:
est = opt.vertex(f.id).estimate()
R = est.rotation().matrix()
t = est.translation()
f.pose = poseRt(R, t)
# put points back
for p in self.points:
est = opt.vertex(p.id + PT_ID_OFFSET).estimate()
p.pt = np.array(est)
def add_edge(self, id, point_id, pose_id, meas):
if meas.is_stereo():
edge = self.stereo_edge(meas.xyx)
elif meas.is_left():
edge = self.mono_edge(meas.xy)
elif meas.is_right():
edge = self.mono_edge_right(meas.xy)
edge.set_id(id)
edge.set_vertex(0, self.vertex(point_id * 2 + 1))
edge.set_vertex(1, self.vertex(pose_id * 2))
kernel = g2o.RobustKernelHuber(self.delta)
edge.set_robust_kernel(kernel)
super().add_edge(edge)
def add_edge(self, point_id, pose_id, edge_id,
measurement,
information=np.identity(2),
robust_kernel=g2o.RobustKernelHuber(np.sqrt(5.991))): # 95% CI
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, self.vertex(point_id * 2 + 1))
edge.set_vertex(1, self.vertex(pose_id * 2))
edge.set_id(edge_id)
edge.set_measurement(measurement) # projection
edge.set_information(information)
if robust_kernel is not None:
edge.set_robust_kernel(robust_kernel)
super().add_edge(edge)
def add_edge(self, edge_id, point_id, pose_id,
measurement,
information=np.identity(2),
robust_kernel=g2o.RobustKernelHuber(np.sqrt(5.991))):
# edge = g2o.EdgeSE3ProjectXYZ()
edge = g2o.EdgeProjectXYZ2UV()
edge.set_id(edge_id)
edge.set_vertex(0, self.vertex(point_id) )
edge.set_vertex(1, self.vertex(pose_id) )
edge.set_measurement(measurement)
edge.set_information(information)
if robust_kernel is not None:
edge.set_robust_kernel(robust_kernel)
edge.set_parameter_id(0,0)
super().add_edge(edge)
return edge
def add_edge(
self,
point_id,
pose_id,
measurement,
information=np.identity(2),
robust_kernel=g2o.RobustKernelHuber(np.sqrt(5.991)),
):
edge = g2o.EdgeProjectXYZ2UV()
edge.set_parameter_id(0, 0)
edge.set_vertex(0, self._optimizer.vertex(point_id))
edge.set_vertex(1, self._optimizer.vertex(pose_id))
edge.set_measurement(measurement) # pixel point (u,v)
edge.set_information(information)
edge.set_robust_kernel(robust_kernel)
self._optimizer.add_edge(edge)
def prepare_optimiser(self, verbose):
# create g2o optimizer
self.opt = g2o.SparseOptimizer()
self.solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
self.solver = g2o.OptimizationAlgorithmLevenberg(self.solver)
self.opt.set_algorithm(self.solver)
# add normalized camera
cam = g2o.CameraParameters(1.0, (0.0, 0.0), 0)
cam.set_id(0)
self.opt.add_parameter(cam)
self.robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
self.graph_frames, self.graph_points = {}, {}
if verbose:
self.opt.set_verbose(True)
def add_edge(self, v0,v1, measurement=None,
information=np.identity(6),
robust_kernel = None): #95% CI
edge = g2o.EdgeSE3()
# edge = g2o.EdgeProjectXYZ2UV()
edge.set_vertex(0, v0)
edge.set_vertex(1, v1)
if measurement is None:
measurement = g2o.Isometry3d(g2o.Quaternion(0,0,0,1),np.array([0,1,0]))
edge.set_measurement(measurement) # relative pose
edge.set_information(information)
# edge.set_parameter_id(0, 0)
robust_kernel=g2o.RobustKernelHuber(np.sqrt(5.991))#5.991
if robust_kernel is not None:
edge.set_robust_kernel(robust_kernel)
super().add_edge(edge)
def optimize(self, max_iters):
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
# adding frames to graph
for f in self.frames:
sbacam = g2o.SBACam(g2o.SE3Quat(f.pose[0:3, 0:3], f.pose[0:3, 3]))
sbacam.set_cam(f.T[0][0], f.T[1][1], f.T[2][0], f.T[2][1], 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(f.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(f.id == 0)
opt.add_vertex(v_se3)
# add points to graph
for p in self.points:
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id + 0x10000)
pt.set_estimate(p.location[0:3])
pt.set_marginalized(True)
pt.set_fixed(False)
opt.add_vertex(pt)
# add connections between frames that contain a point in the graph
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, opt.vertex(f.id))
uv = f.kpts[f.pts.index(p)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(max_iters)
def optimize(self):
# optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
for f in self.frames:
sbacam = g2o.SBACam(g2o.SE3Quat(f.pose[:3, :3], f.pose[:3, 3]))
sbacam.set_cam(f.K[0][0], f.K[1][1], f.K[2][0], f.K[2][1], 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(f.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(f.id == 0)
opt.add_vertex(v_se3)
for p in self.points:
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id + 0x10000)
pt.set_estimate(p.pt[0:3])
pt.set_marginalized(True)
pt.set_fixed(False)
opt.add_vertex(pt)
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, opt.vertex(f.id))
uv = f.kps[f.pts.index(p)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(20)
def bundle_adjustment(keyframes, points, local_window, fixed_points=False, verbose=False, rounds=10, use_robust_kernel=False, abort_flag=g2o.Flag()):
if local_window is None:
local_frames = keyframes
else:
local_frames = keyframes[-local_window:]
# create g2o optimizer
opt = g2o.SparseOptimizer()
block_solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
#block_solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(block_solver)
opt.set_algorithm(solver)
opt.set_force_stop_flag(abort_flag)
thHuberMono = math.sqrt(5.991); # chi-square 2 DOFS
graph_keyframes, graph_points = {}, {}
# add frame vertices to graph
for kf in (local_frames if fixed_points else keyframes): # if points are fixed then consider just the local frames, otherwise we need all frames or at least two frames for each point
if kf.is_bad:
continue
#print('adding vertex frame ', f.id, ' to graph')
se3 = g2o.SE3Quat(kf.Rcw, kf.tcw)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(kf.kid * 2) # even ids (use f.kid here!)
v_se3.set_fixed(kf.kid==0 or kf not in local_frames) #(use f.kid here!)
opt.add_vertex(v_se3)
# confirm pose correctness
#est = v_se3.estimate()
#assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
#assert np.allclose(pose[0:3, 3], est.translation())
graph_keyframes[kf] = v_se3
num_edges = 0
# add point vertices to graph
for p in points:
assert(p is not None)
if p.is_bad: # do not consider bad points
continue
if __debug__:
if not any([f in keyframes for f in p.keyframes()]):
Printer.red('point without a viewing frame!!')
continue
#print('adding vertex point ', p.id,' to graph')
v_p = g2o.VertexSBAPointXYZ()
v_p.set_id(p.id * 2 + 1) # odd ids
v_p.set_estimate(p.pt[0:3])
v_p.set_marginalized(True)
v_p.set_fixed(fixed_points)
opt.add_vertex(v_p)
graph_points[p] = v_p
# add edges
for kf, idx in p.observations():
if kf.is_bad:
continue
if kf not in graph_keyframes:
continue
#print('adding edge between point ', p.id,' and frame ', f.id)
edge = g2o.EdgeSE3ProjectXYZ()
edge.set_vertex(0, v_p)
edge.set_vertex(1, graph_keyframes[kf])
edge.set_measurement(kf.kpsu[idx])
invSigma2 = Frame.feature_manager.inv_level_sigmas2[kf.octaves[idx]]
edge.set_information(np.eye(2)*invSigma2)
if use_robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = kf.camera.fx
edge.fy = kf.camera.fy
edge.cx = kf.camera.cx
edge.cy = kf.camera.cy
opt.add_edge(edge)
num_edges += 1
if verbose:
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(rounds)
# put frames back
for kf in graph_keyframes:
est = graph_keyframes[kf].estimate()
#R = est.rotation().matrix()
#t = est.translation()
#f.update_pose(poseRt(R, t))
kf.update_pose(g2o.Isometry3d(est.orientation(), est.position()))
# put points back
if not fixed_points:
for p in graph_points:
p.update_position(np.array(graph_points[p].estimate()))
p.update_normal_and_depth(force=True)
mean_squared_error = opt.active_chi2()/max(num_edges,1)
return mean_squared_error
def local_bundle_adjustment(keyframes, points, keyframes_ref=[], fixed_points=False, verbose=False, rounds=10, abort_flag=g2o.Flag(), map_lock=None):
# create g2o optimizer
opt = g2o.SparseOptimizer()
block_solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
#block_solver = g2o.BlockSolverSE3(g2o.LinearSolverEigenSE3())
#block_solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(block_solver)
opt.set_algorithm(solver)
opt.set_force_stop_flag(abort_flag)
#robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991)) # chi-square 2 DOFs
thHuberMono = math.sqrt(5.991); # chi-square 2 DOFS
graph_keyframes, graph_points = {}, {}
# add frame vertices to graph
for kf in keyframes:
if kf.is_bad:
continue
#print('adding vertex frame ', f.id, ' to graph')
se3 = g2o.SE3Quat(kf.Rcw, kf.tcw)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(kf.kid * 2) # even ids (use f.kid here!)
v_se3.set_fixed(kf.kid==0) # (use f.kid here!)
opt.add_vertex(v_se3)
graph_keyframes[kf] = v_se3
# confirm pose correctness
#est = v_se3.estimate()
#assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
#assert np.allclose(pose[0:3, 3], est.translation())
# add reference frame vertices to graph
for kf in keyframes_ref:
if kf.is_bad:
continue
#print('adding vertex frame ', f.id, ' to graph')
se3 = g2o.SE3Quat(kf.Rcw, kf.tcw)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(kf.kid * 2) # even ids (use f.kid here!)
v_se3.set_fixed(True)
opt.add_vertex(v_se3)
graph_keyframes[kf] = v_se3
graph_edges = {}
num_edges = 0
num_bad_edges = 0
# add point vertices to graph
for p in points:
assert(p is not None)
if p.is_bad: # do not consider bad points
continue
if not any([f in keyframes for f in p.keyframes()]):
Printer.orange('point %d without a viewing keyframe in input keyframes!!' %(p.id))
#Printer.orange(' keyframes: ',p.observations_string())
continue
#print('adding vertex point ', p.id,' to graph')
v_p = g2o.VertexSBAPointXYZ()
v_p.set_id(p.id * 2 + 1) # odd ids
v_p.set_estimate(p.pt[0:3])
v_p.set_marginalized(True)
v_p.set_fixed(fixed_points)
opt.add_vertex(v_p)
graph_points[p] = v_p
# add edges
for kf, p_idx in p.observations():
if kf.is_bad:
continue
if kf not in graph_keyframes:
continue
if __debug__:
p_f = kf.get_point_match(p_idx)
if p_f != p:
print('frame: ', kf.id, ' missing point ', p.id, ' at index p_idx: ', p_idx)
if p_f is not None:
print('p_f:', p_f)
print('p:',p)
assert(kf.get_point_match(p_idx) is p)
#print('adding edge between point ', p.id,' and frame ', f.id)
edge = g2o.EdgeSE3ProjectXYZ()
edge.set_vertex(0, v_p)
edge.set_vertex(1, graph_keyframes[kf])
edge.set_measurement(kf.kpsu[p_idx])
invSigma2 = Frame.feature_manager.inv_level_sigmas2[kf.octaves[p_idx]]
edge.set_information(np.eye(2)*invSigma2)
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = kf.camera.fx
edge.fy = kf.camera.fy
edge.cx = kf.camera.cx
edge.cy = kf.camera.cy
opt.add_edge(edge)
graph_edges[edge] = (p,kf,p_idx) # one has kf.points[p_idx] == p
num_edges += 1
if verbose:
opt.set_verbose(True)
if abort_flag.value:
return -1,0
# initial optimization
opt.initialize_optimization()
opt.optimize(5)
if not abort_flag.value:
chi2Mono = 5.991 # chi-square 2 DOFs
# check inliers observation
for edge, edge_data in graph_edges.items():
p = edge_data[0]
if p.is_bad:
continue
if edge.chi2() > chi2Mono or not edge.is_depth_positive():
edge.set_level(1)
num_bad_edges += 1
edge.set_robust_kernel(None)
# optimize again without outliers
opt.initialize_optimization()
opt.optimize(rounds)
# search for final outlier observations and clean map
num_bad_observations = 0 # final bad observations
outliers_data = []
for edge, edge_data in graph_edges.items():
p, kf, p_idx = edge_data
if p.is_bad:
continue
assert(kf.get_point_match(p_idx) is p)
if edge.chi2() > chi2Mono or not edge.is_depth_positive():
num_bad_observations += 1
outliers_data.append(edge_data)
if map_lock is None:
map_lock = RLock() # put a fake lock
with map_lock:
# remove outlier observations
for d in outliers_data:
p, kf, p_idx = d
p_f = kf.get_point_match(p_idx)
if p_f is not None:
assert(p_f is p)
p.remove_observation(kf,p_idx)
# the following instruction is now included in p.remove_observation()
#f.remove_point(p) # it removes multiple point instances (if these are present)
#f.remove_point_match(p_idx) # this does not remove multiple point instances, but now there cannot be multiple instances any more
# put frames back
for kf in graph_keyframes:
est = graph_keyframes[kf].estimate()
#R = est.rotation().matrix()
#t = est.translation()
#f.update_pose(poseRt(R, t))
kf.update_pose(g2o.Isometry3d(est.orientation(), est.position()))
# put points back
if not fixed_points:
for p in graph_points:
p.update_position(np.array(graph_points[p].estimate()))
p.update_normal_and_depth(force=True)
active_edges = num_edges-num_bad_edges
mean_squared_error = opt.active_chi2()/active_edges
return mean_squared_error, num_bad_observations/max(num_edges,1)
def pose_optimization(frame, verbose=False, rounds=10):
is_ok = True
# create g2o optimizer
opt = g2o.SparseOptimizer()
#block_solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
#block_solver = g2o.BlockSolverSE3(g2o.LinearSolverDenseSE3())
block_solver = g2o.BlockSolverSE3(g2o.LinearSolverEigenSE3())
solver = g2o.OptimizationAlgorithmLevenberg(block_solver)
opt.set_algorithm(solver)
#robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991)) # chi-square 2 DOFs
thHuberMono = math.sqrt(5.991); # chi-square 2 DOFS
point_edge_pairs = {}
num_point_edges = 0
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(g2o.SE3Quat(frame.Rcw, frame.tcw))
v_se3.set_id(0)
v_se3.set_fixed(False)
opt.add_vertex(v_se3)
with MapPoint.global_lock:
# add point vertices to graph
for idx, p in enumerate(frame.points):
if p is None:
continue
# reset outlier flag
frame.outliers[idx] = False
# add edge
#print('adding edge between point ', p.id,' and frame ', frame.id)
edge = g2o.EdgeSE3ProjectXYZOnlyPose()
edge.set_vertex(0, opt.vertex(0))
edge.set_measurement(frame.kpsu[idx])
invSigma2 = Frame.feature_manager.inv_level_sigmas2[frame.octaves[idx]]
edge.set_information(np.eye(2)*invSigma2)
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = frame.camera.fx
edge.fy = frame.camera.fy
edge.cx = frame.camera.cx
edge.cy = frame.camera.cy
edge.Xw = p.pt[0:3]
opt.add_edge(edge)
point_edge_pairs[p] = (edge, idx) # one edge per point
num_point_edges += 1
if num_point_edges < 3:
Printer.red('pose_optimization: not enough correspondences!')
is_ok = False
return 0, is_ok, 0
if verbose:
opt.set_verbose(True)
# perform 4 optimizations:
# after each optimization we classify observation as inlier/outlier;
# at the next optimization, outliers are not included, but at the end they can be classified as inliers again
chi2Mono = 5.991 # chi-square 2 DOFs
num_bad_point_edges = 0
for it in range(4):
v_se3.set_estimate(g2o.SE3Quat(frame.Rcw, frame.tcw))
opt.initialize_optimization()
opt.optimize(rounds)
num_bad_point_edges = 0
for p, edge_pair in point_edge_pairs.items():
edge, idx = edge_pair
if frame.outliers[idx]:
edge.compute_error()
chi2 = edge.chi2()
if chi2 > chi2Mono:
frame.outliers[idx] = True
edge.set_level(1)
num_bad_point_edges +=1
else:
frame.outliers[idx] = False
edge.set_level(0)
if it == 2:
edge.set_robust_kernel(None)
if len(opt.edges()) < 10:
Printer.red('pose_optimization: stopped - not enough edges!')
is_ok = False
break
print('pose optimization: available ', num_point_edges, ' points, found ', num_bad_point_edges, ' bad points')
if num_point_edges == num_bad_point_edges:
Printer.red('pose_optimization: all the available correspondences are bad!')
is_ok = False
# update pose estimation
if is_ok:
est = v_se3.estimate()
# R = est.rotation().matrix()
# t = est.translation()
# frame.update_pose(poseRt(R, t))
frame.update_pose(g2o.Isometry3d(est.orientation(), est.position()))
# since we have only one frame here, each edge corresponds to a single distinct point
num_valid_points = num_point_edges - num_bad_point_edges
mean_squared_error = opt.active_chi2()/max(num_valid_points,1)
return mean_squared_error, is_ok, num_valid_points
def optimize(frames,
points,
local_window,
fix_points,
verbose=False,
rounds=50):
if local_window is None:
local_frames = frames
else:
local_frames = frames[-local_window:]
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
# add normalized camera
cam = g2o.CameraParameters(1.0, (0.0, 0.0), 0)
cam.set_id(0)
opt.add_parameter(cam)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
graph_frames, graph_points = {}, {}
# add frames to graph
for f in (local_frames if fix_points else frames):
pose = f.pose
se3 = g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3])
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(f.id * 2)
v_se3.set_fixed(f.id <= 1 or f not in local_frames)
#v_se3.set_fixed(f.id != 0)
opt.add_vertex(v_se3)
# confirm pose correctness
est = v_se3.estimate()
assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
assert np.allclose(pose[0:3, 3], est.translation())
graph_frames[f] = v_se3
# add points to frames
for p in points:
if not any([f in local_frames for f in p.frames]):
continue
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id * 2 + 1)
pt.set_estimate(p.pt[0:3])
pt.set_marginalized(True)
pt.set_fixed(fix_points)
opt.add_vertex(pt)
graph_points[p] = pt
# add edges
for f, idx in zip(p.frames, p.idxs):
if f not in graph_frames:
continue
edge = g2o.EdgeProjectXYZ2UV()
edge.set_parameter_id(0, 0)
edge.set_vertex(0, pt)
edge.set_vertex(1, graph_frames[f])
edge.set_measurement(f.kps[idx])
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
if verbose:
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(rounds)
# put frames back
for f in graph_frames:
est = graph_frames[f].estimate()
R = est.rotation().matrix()
t = est.translation()
f.pose = poseRt(R, t)
# put points back
if not fix_points:
for p in graph_points:
p.pt = np.array(graph_points[p].estimate())
return opt.active_chi2()
def main():
optimizer = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverEigenSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
focal_length = (500, 500)
principal_point = (320, 240)
baseline = 0.075
true_points = np.hstack([
np.random.random((500, 1)) * 3 - 1.5,
np.random.random((500, 1)) - 0.5,
np.random.random((500, 1)) + 3])
num_pose = 15
for i in range(num_pose):
# pose here means transform points from camera coordinates to world coordinates
pose = g2o.SE3Quat(np.identity(3), [i*0.04-1, 0, 0])
sbacam = g2o.SBACam(pose)
sbacam.set_cam(*focal_length, *principal_point, baseline)
v_cam = g2o.VertexCam()
v_cam.set_id(i)
v_cam.set_estimate(sbacam)
if i < 2:
v_cam.set_fixed(True)
optimizer.add_vertex(v_cam)
point_id = num_pose
inliers = dict()
sse = defaultdict(float)
for i, point in enumerate(true_points):
visible = []
for j in range(num_pose):
proj = optimizer.vertex(j).estimate().w2i.dot(
np.hstack([point, [1]])) # project to left camera
z = proj[:2] / proj[2]
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
visible.append((j, z))
if len(visible) < 2:
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_id(point_id)
vp.set_marginalized(True)
vp.set_estimate(point + np.random.randn(3))
optimizer.add_vertex(vp)
inlier = True
for j, z in visible:
if np.random.random() < args.outlier_ratio:
inlier = False
z = np.random.random(2) * [640, 480]
z += np.random.randn(2) * args.pixel_noise
edge = g2o.EdgeProjectP2MC() # if stereo, use EdgeProjectP2SC
edge.set_vertex(0, vp)
edge.set_vertex(1, optimizer.vertex(j))
edge.set_measurement(z)
edge.set_information(np.identity(2))
if args.robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber())
#edge.set_parameter_id(0, 0)
optimizer.add_edge(edge)
if inlier:
inliers[point_id] = i
error = vp.estimate() - true_points[i]
sse[0] += np.sum(error**2)
point_id += 1
print('num vertices:', len(optimizer.vertices()))
print('num edges:', len(optimizer.edges()))
print('Performing full BA:')
optimizer.initialize_optimization()
optimizer.set_verbose(True)
optimizer.optimize(10)
for i in inliers:
vp = optimizer.vertex(i)
error = vp.estimate() - true_points[inliers[i]]
sse[1] += np.sum(error**2)
print('\nRMSE (inliers only):')
print('before optimization:', np.sqrt(sse[0] / len(inliers)))
print('after optimization:', np.sqrt(sse[1] / len(inliers)))
def localOptimization(frames,
points,
frames_ref=[],
fixed_points=False,
verbose=False,
rounds=10):
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
#robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991)) # chi-square 2 DOFs
thHuberMono = math.sqrt(5.991)
# chi-square 2 DOFS
graph_frames, graph_points = {}, {}
all_frames = frames + frames_ref
# add frame vertices to graph
for f in all_frames:
#print('adding vertex frame ', f.id, ' to graph')
pose = f.pose
se3 = g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3])
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(f.id * 2) # even ids
v_se3.set_fixed(f.id < 1 or f in frames_ref)
opt.add_vertex(v_se3)
graph_frames[f] = v_se3
# confirm pose correctness
#est = v_se3.estimate()
#assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
#assert np.allclose(pose[0:3, 3], est.translation())
graph_edges = {}
num_point_edges = 0
# add point vertices to graph
for p in points:
assert (p is not None)
if p.is_bad and not fixed_points: # do not consider bad points unless they are fixed
continue
if not any([f in frames for f in p.frames]): # this is redundant now
continue
#print('adding vertex point ', p.id,' to graph')
v_p = g2o.VertexSBAPointXYZ()
v_p.set_id(p.id * 2 + 1) # odd ids
v_p.set_estimate(p.pt[0:3])
v_p.set_marginalized(True)
v_p.set_fixed(fixed_points)
opt.add_vertex(v_p)
graph_points[p] = v_p
# add edges
for f, p_idx in zip(p.frames, p.idxs):
assert (f.points[p_idx] == p)
if f not in graph_frames:
continue
#print('adding edge between point ', p.id,' and frame ', f.id)
edge = g2o.EdgeSE3ProjectXYZ()
edge.set_vertex(0, v_p)
edge.set_vertex(1, graph_frames[f])
edge.set_measurement(f.kpsu[p_idx])
invSigma2 = Frame.detector.inv_level_sigmas2[f.octaves[p_idx]]
edge.set_information(np.eye(2) * invSigma2)
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = f.fx
edge.fy = f.fy
edge.cx = f.cx
edge.cy = f.cy
opt.add_edge(edge)
graph_edges[edge] = (p, f, p_idx) # f.points[p_idx] == p
num_point_edges += 1
if verbose:
opt.set_verbose(True)
# initial optimization
opt.initialize_optimization()
opt.optimize(5)
chi2Mono = 5.991 # chi-square 2 DOFs
# check inliers observation
for edge, edge_data in graph_edges.items():
p = edge_data[0]
if p.is_bad is True:
continue
if edge.chi2() > chi2Mono or not edge.is_depth_positive():
edge.set_level(1)
edge.set_robust_kernel(None)
# optimize again without outliers
opt.initialize_optimization()
opt.optimize(rounds)
# clean map observations
num_bad_observations = 0
outliers_data = []
for edge, edge_data in graph_edges.items():
p, f, p_idx = edge_data
if p.is_bad is True:
continue
assert (f.points[p_idx] == p)
if edge.chi2() > chi2Mono or not edge.is_depth_positive():
num_bad_observations += 1
outliers_data.append((p, f, p_idx))
for d in outliers_data:
(p, f, p_idx) = d
assert (f.points[p_idx] == p)
p.remove_observation(f, p_idx)
f.remove_point(p)
# put frames back
for f in graph_frames:
est = graph_frames[f].estimate()
R = est.rotation().matrix()
t = est.translation()
f.pose = poseRt(R, t)
# put points back
if not fixed_points:
for p in graph_points:
p.pt = np.array(graph_points[p].estimate())
return opt.active_chi2(), num_bad_observations / num_point_edges
def optimize(self):
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
if LOCAL_WINDOW is None:
local_frames = self.frames
else:
local_frames = self.frames[-LOCAL_WINDOW:]
# add frames to graph
for f in self.frames:
pose = f.pose
sbacam = g2o.SBACam(g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3]))
sbacam.set_cam(f.K[0][0], f.K[1][1], f.K[0][2], f.K[1][2], 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(f.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(f.id <= 1 or f not in local_frames)
opt.add_vertex(v_se3)
# add points to frames
PT_ID_OFFSET = 0x10000
for p in self.points:
if not any([f in local_frames for f in p.frames]):
continue
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id + PT_ID_OFFSET)
pt.set_estimate(p.pt[0:3])
pt.set_marginalized(True)
pt.set_fixed(False)
opt.add_vertex(pt)
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, opt.vertex(f.id))
uv = f.kpus[f.pts.index(p)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
#opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(50)
# put frames back
for f in self.frames:
est = opt.vertex(f.id).estimate()
R = est.rotation().matrix()
t = est.translation()
f.pose = poseRt(R, t)
# put points back (and cull)
new_points = []
for p in self.points:
vert = opt.vertex(p.id + PT_ID_OFFSET)
if vert is None:
new_points.append(p)
continue
est = vert.estimate()
# 2 match point that's old
old_point = len(p.frames) == 2 and p.frames[-1] not in local_frames
# compute reprojection error
errs = []
for f in p.frames:
uv = f.kpus[f.pts.index(p)]
proj = np.dot(np.dot(f.K, np.linalg.inv(f.pose)[:3]),
np.array([est[0], est[1], est[2], 1.0]))
proj = proj[0:2] / proj[2]
errs.append(np.linalg.norm(proj-uv))
# cull
if (old_point and np.mean(errs) > 30) or np.mean(errs) > 100:
p.delete()
continue
p.pt = np.array(est)
new_points.append(p)
self.points = new_points
return opt.chi2()
def optimize(self, K, frames, fix_points=False):
PT_OFFSET = 10000
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
rk = g2o.RobustKernelHuber(np.sqrt(5.991))
# only optimize these poses and their Points
local_frames = self.frames[-frames:]
# a vertex for each camera pose
for f in self.frames:
assert (f.id < PT_OFFSET)
quat = g2o.SE3Quat(f.pose[:3, :3], f.pose[:3, 3])
sbacam = g2o.SBACam(quat)
sbacam.set_cam(K[0, 0], K[1, 1], K[0, 2], K[1, 2],
1.0) # for pixel input
v = g2o.VertexCam()
v.set_id(f.id)
v.set_estimate(sbacam)
v.set_fixed(f.id < 2 or f not in local_frames)
opt.add_vertex(v)
# a vertex for each point in cloud
for p in self.points:
# if p.frames[-1] not in local_frames:
if not any([f in local_frames for f in p.frames]):
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_id(PT_OFFSET + p.id)
vp.set_estimate(p.pt3d)
vp.set_marginalized(True)
vp.set_fixed(fix_points)
opt.add_vertex(vp)
# edge connects every camera with every point
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
# edge = g2o.EdgeSE3ProjectXYZ()
edge.set_vertex(0, vp)
edge.set_vertex(1, opt.vertex(f.id))
idx = f.pts.index(p)
edge.set_measurement(f.kpus[idx])
edge.set_information(np.eye(2))
edge.set_robust_kernel(rk)
opt.add_edge(edge)
# opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(20)
# print("chi2", opt.active_chi2())
# get back optimized poses
self.opath = []
for f in self.frames:
f_est = opt.vertex(f.id).estimate()
R = f_est.rotation().matrix()
t = f_est.translation()
Rt = np.eye(4)
Rt[:3, :3] = R
Rt[:3, 3] = t.T
# print(Rt)
self.opath.append(t)
f.pose = Rt
if fix_points:
return
new_points = []
# add back or cull
for p in self.points:
vp = opt.vertex(PT_OFFSET + p.id)
if vp is None: # not updated
new_points.append(p)
continue
vp = opt.vertex(PT_OFFSET + p.id)
p_est = vp.estimate()
# if (len(p.frames) <= 5) and (p.frames[-1] not in local_frames):
# p.delete()
# continue
errors = []
for f in p.frames:
f_est = opt.vertex(f.id).estimate()
measured = f.kpus[f.pts.index(p)]
projected = f_est.w2i.dot(np.hstack(
[p_est, [1]])) # only works because is VertexCam
projected = projected[:2] / projected[
2] # don't forget to h**o
errors.append(np.linalg.norm(measured - projected))
error = np.mean(errors) # mean of squares - over all frames
if error > 1.0: # px
# print(f"error {error}, dropping")
p.delete()
else:
p.pt3d = np.array(p_est)
new_points.append(p)
print("Dropping:",
len(self.points) - len(new_points), ", Remaining:",
len(new_points))
self.points = new_points
def main():
optimizer = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
true_points = np.hstack([
np.random.random((500, 1)) * 3 - 1.5,
np.random.random((500, 1)) - 0.5,
np.random.random((500, 1)) + 3
])
focal_length = [500, 500]
principal_point = [320, 240]
baseline = 0.075
camera = g2o.CameraParameters(500, [320, 240], 0.075)
camera.set_id(10000)
optimizer.add_parameter(camera)
true_poses = []
num_pose = 5
for i in range(num_pose):
# pose here transform points from world coordinates to camera coordinates
pose = g2o.SE3Quat(np.identity(3), [i * 0.04 - 1, 0, 0])
true_poses.append(pose)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_id(i)
v_se3.set_estimate(pose)
if i < 2:
v_se3.set_fixed(True)
optimizer.add_vertex(v_se3)
point_id = num_pose
inliers = dict()
sse = defaultdict(float)
for i, point in enumerate(true_points):
visible = []
for j, pose in enumerate(true_poses):
z = camera.cam_map(pose * point)
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
visible.append((j, z))
if len(visible) < 2:
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_id(point_id)
vp.set_marginalized(True)
vp.set_estimate(point + np.random.randn(3))
optimizer.add_vertex(vp)
inlier = True
for j, z in visible:
if np.random.random() < args.outlier_ratio:
inlier = False
z = np.array([
np.random.uniform(64, 640),
np.random.uniform(0, 480),
np.random.uniform(0, 64)
]) # disparity
z[2] = z[0] - z[2]
z += np.random.randn(2) * args.pixel_noise
edge = g2o.Edge_XYZ_VSC()
edge.set_vertex(0, vp)
edge.set_vertex(1, optimizer.vertex(j))
edge.set_measurement(z)
edge.set_information(np.identity(2))
if args.robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber())
edge.set_parameter_id(0, 0)
optimizer.add_edge(edge)
if inlier:
inliers[point_id] = i
error = vp.estimate() - true_points[i]
sse[0] += np.sum(error**2)
point_id += 1
print('Performing full BA:')
optimizer.initialize_optimization()
optimizer.set_verbose(True)
optimizer.optimize(10)
for i in inliers:
vp = optimizer.vertex(i)
error = vp.estimate() - true_points[inliers[i]]
sse[1] += np.sum(error**2)
print('\nCamera focal: \n{}\n'.format(camera.focal_length))
print('\nCamera principal point: \n{}\n'.format(camera.principal_point))
print('\nRMSE (inliers only):')
print('before optimization:', np.sqrt(sse[0] / len(inliers)))
print('after optimization:', np.sqrt(sse[1] / len(inliers)))
def add_edge(self,
vertex0_id,
vertex1_id,
measure,
measure_information=None,
robust_kernel_value=None):
'''
Helper function to add an edge
vertex 0 and 1 are valid IDs of vertex inside optimizer.
measure is a Isometry3d that map the transform from vertex0 to vertex1
'''
## TODO
# robust kernels? They are made to reduce the impact of outliers.
# They have to be specified separatly for each edge, with a value
# example : robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
# edge.set_robust_kernel(robust_kernel)
##
# print("add_edge")
# print(optimizer.vertices())
if vertex0_id in self.optimizer.vertices():
with self.lock:
if vertex1_id not in self.optimizer.vertices():
vc1 = g2o.VertexSE3()
vc1.set_id(vertex1_id)
vc1.set_estimate(
self.optimizer.vertex(vertex0_id).estimate() * measure)
vc1.set_fixed(False)
self.optimizer.add_vertex(vc1)
self.set_of_new_vertex.add(vc1)
edge = g2o.EdgeSE3()
edge.set_vertex(0, self.optimizer.vertex(vertex0_id))
edge.set_vertex(1, self.optimizer.vertex(vertex1_id))
edge.set_measurement(measure)
if measure_information is not None:
edge.set_information(measure_information)
if robust_kernel_value is not None:
robust_kernel = g2o.RobustKernelHuber(robust_kernel_value)
edge.set_robust_kernel(robust_kernel)
self.optimizer.add_edge(edge)
# Adding edge to set of new edge to update initialization
self.set_of_new_edges.add(edge)
else:
if vertex1_id in self.optimizer.vertices():
with self.lock:
vc0 = g2o.VertexSE3()
vc0.set_id(vertex0_id)
vc0.set_estimate(
self.optimizer.vertex(vertex1_id).estimate() *
measure.inverse())
vc0.set_fixed(False)
self.optimizer.add_vertex(vc0)
self.set_of_new_vertex.add(vc0)
edge = g2o.EdgeSE3()
edge.set_vertex(0, self.optimizer.vertex(vertex0_id))
edge.set_vertex(1, self.optimizer.vertex(vertex1_id))
edge.set_measurement(measure)
if (measure_information):
edge.set_information(measure_information)
# edge.set_information(np.eye(6) * 2)
finished = self.optimizer.add_edge(edge)
self.set_of_new_edges.add(edge)
else:
with self.lock:
vc0 = g2o.VertexSE3()
vc0.set_id(vertex0_id)
vc0.set_fixed(False)
self.optimizer.add_vertex(vc0)
self.set_of_new_vertex.add(vc0)
self.add_edge(vertex0_id,
vertex1_id,
measure,
robust_kernel_value=robust_kernel_value)
def main():
optimizer = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
true_points = np.hstack([
np.random.random((500, 1)) * 3 - 1.5,
np.random.random((500, 1)) - 0.5,
np.random.random((500, 1)) + 3
])
focal_length = (500, 500)
principal_point = (320, 240)
baseline = 0.075
for frame_id in range(args.n_sensors):
g2o.VertexCamRig.set_cam(frame_id, *focal_length, *principal_point)
sensor_pose = g2o.Isometry3d(np.identity(3),
[frame_id * baseline, 0, 0])
g2o.VertexCamRig.set_calibration(frame_id, sensor_pose)
true_poses = []
num_pose = 5
for i in range(num_pose):
# pose here transform points from world coordinates to camera coordinates
pose = g2o.Isometry3d(np.identity(3), [i * 0.04 - 1, 0, 0])
true_poses.append(pose)
v_se3 = g2o.VertexCamRig()
v_se3.set_id(i)
v_se3.set_estimate(pose)
if i < 2:
v_se3.set_fixed(True)
optimizer.add_vertex(v_se3)
point_id = num_pose
inliers = dict()
sse = defaultdict(float)
for i, point in enumerate(true_points):
visible = []
for j in range(num_pose):
sens_vis = 0
projections = []
for frame_id in range(args.n_sensors):
z = optimizer.vertex(j).map_point(frame_id, point)
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
projections.append((frame_id, z))
if len(projections) > 1:
visible.append((j, projections))
if len(visible) < 2:
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_id(point_id)
vp.set_marginalized(True)
vp.set_estimate(point + np.random.randn(3))
optimizer.add_vertex(vp)
inlier = True
if np.random.random() < args.outlier_ratio:
inlier = False
if inlier:
inliers[point_id] = i
error = vp.estimate() - true_points[i]
sse[0] += np.sum(error**2)
for j, projections in visible:
for frame_id, z in projections:
if not inliers:
z = np.array([
np.random.uniform(64, 640),
np.random.uniform(0, 480)
])
z += np.random.randn(2) * args.pixel_noise * [1, 1]
edge = g2o.Edge_XYZ_VRIG()
edge.set_vertex(0, vp)
edge.set_vertex(1, optimizer.vertex(j))
edge.set_measurement(np.hstack((z, [frame_id])))
edge.set_information(np.identity(3))
if args.robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber())
edge.set_parameter_id(0, 0)
optimizer.add_edge(edge)
point_id += 1
print('num points', len(inliers))
print('Performing full BA:')
optimizer.initialize_optimization()
optimizer.set_verbose(True)
optimizer.optimize(10)
for i in inliers:
vp = optimizer.vertex(i)
error = vp.estimate() - true_points[inliers[i]]
sse[1] += np.sum(error**2)
print('\nRMSE (inliers only):')
print('before optimization:', np.sqrt(sse[0] / len(inliers)))
print('after optimization:', np.sqrt(sse[1] / len(inliers)))
sse = defaultdict(float)
for i, gt_pose in enumerate(true_poses):
vp = optimizer.vertex(i)
error = vp.estimate().translation() - pose.translation()
sse[1] += np.sum(error**2)
print('\nRMSE (inliers only):')
print('pose error before optimization:', np.sqrt(sse[0] / len(inliers)))
print('pose error after optimization:', np.sqrt(sse[1] / len(inliers)))
def optimization(frames,
points,
local_window,
fixed_points=False,
verbose=False,
rounds=40,
use_robust_kernel=False):
if local_window is None:
local_frames = frames
else:
local_frames = frames[-local_window:]
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
thHuberMono = math.sqrt(5.991)
# chi-square 2 DOFS
graph_frames, graph_points = {}, {}
# add frame vertices to graph
for f in (
local_frames if fixed_points else frames
): # if points are fixed then consider just the local frames, otherwise we need all frames or at least two frames for each point
#print('adding vertex frame ', f.id, ' to graph')
pose = f.pose
se3 = g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3])
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(f.id * 2) # even ids
v_se3.set_fixed(f.id < 1 or f not in local_frames)
opt.add_vertex(v_se3)
# confirm pose correctness
#est = v_se3.estimate()
#assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
#assert np.allclose(pose[0:3, 3], est.translation())
graph_frames[f] = v_se3
# add point vertices to graph
for p in points:
if p.is_bad and not fixed_points:
continue
if not any([f in local_frames for f in p.frames]):
continue
#print('adding vertex point ', p.id,' to graph')
v_p = g2o.VertexSBAPointXYZ()
v_p.set_id(p.id * 2 + 1) # odd ids
v_p.set_estimate(p.pt[0:3])
v_p.set_marginalized(True)
v_p.set_fixed(fixed_points)
opt.add_vertex(v_p)
graph_points[p] = v_p
# add edges
for f, idx in zip(p.frames, p.idxs):
if f not in graph_frames:
continue
#print('adding edge between point ', p.id,' and frame ', f.id)
edge = g2o.EdgeSE3ProjectXYZ()
edge.set_vertex(0, v_p)
edge.set_vertex(1, graph_frames[f])
edge.set_measurement(f.kpsu[idx])
invSigma2 = Frame.detector.inv_level_sigmas2[f.octaves[idx]]
edge.set_information(np.eye(2) * invSigma2)
if use_robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = f.fx
edge.fy = f.fy
edge.cx = f.cx
edge.cy = f.cy
opt.add_edge(edge)
if verbose:
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(rounds)
# put frames back
for f in graph_frames:
est = graph_frames[f].estimate()
R = est.rotation().matrix()
t = est.translation()
f.pose = poseRt(R, t)
# put points back
if not fixed_points:
for p in graph_points:
p.pt = np.array(graph_points[p].estimate())
return opt.active_chi2()
def main():
optimizer = g2o.SparseOptimizer()
solver = g2o.BlockSolverX(g2o.LinearSolverCSparseX())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
true_points = np.hstack([
np.random.random((1000, 1)) * 3 - 1.5,
np.random.random((1000, 1)) - 0.5,
np.random.random((1000, 1)) + 10
])
focal_length = (500, 500)
principal_point = (320, 240)
baseline = 0.075
g2o.VertexSCam.set_cam(*focal_length, *principal_point, baseline)
for i in range(2):
t = np.array([0, 0, i])
cam = g2o.Isometry3d(np.identity(3), t)
vc = g2o.VertexSCam()
vc.set_id(i)
vc.set_estimate(cam)
if i == 0:
vc.set_fixed(True)
vc.set_all()
optimizer.add_vertex(vc)
trans0 = optimizer.vertex(0).estimate().inverse()
trans1 = optimizer.vertex(1).estimate().inverse()
for i in range(len(true_points)):
pt0 = trans0 * true_points[i]
pt1 = trans1 * true_points[i]
# add noise
pt0 += np.random.randn(3) * args.pos_noise
pt1 += np.random.randn(3) * args.pos_noise
# form edge, with normals in varioius positions
nm0 = np.array([0, i, 1])
nm0 = nm0 / np.linalg.norm(nm0)
nm1 = np.array([0, i, 1])
nm1 = nm1 / np.linalg.norm(nm1)
meas = g2o.EdgeGICP()
meas.pos0 = pt0
meas.pos1 = pt1
meas.normal0 = nm0
meas.normal1 = nm1
edge = g2o.Edge_V_V_GICP()
edge.set_vertex(0, optimizer.vertex(0))
edge.set_vertex(1, optimizer.vertex(1))
edge.set_measurement(meas)
edge.set_information(meas.prec0(0.01))
optimizer.add_edge(edge)
# set up SBA projections
if args.num_points > 0:
true_points = np.hstack([
np.random.random((args.num_points, 1)) * 3 - 1.5,
np.random.random((args.num_points, 1)) - 0.5,
np.random.random((args.num_points, 1)) + 10
])
cam_num = 2
for i, point in enumerate(true_points):
vp = g2o.VertexSBAPointXYZ()
vp.set_id(cam_num + i)
vp.set_marginalized(True)
vp.set_estimate(point + np.random.randn(3))
optimizer.add_vertex(vp)
for j in range(cam_num):
z = optimizer.vertex(j).map_point(point)
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
z += np.random.randn(3) * args.pixel_noise * [
1, 1, 1 / 16.
]
edge = g2o.Edge_XYZ_VSC()
edge.set_vertex(0, vp)
edge.set_vertex(1, optimizer.vertex(j))
edge.set_measurement(z)
edge.set_information(np.identity(3))
edge.set_robust_kernel(g2o.RobustKernelHuber())
optimizer.add_edge(edge)
# move second cam off of its true position
vc = optimizer.vertex(1)
cam = g2o.Isometry3d(vc.estimate().R, np.array([-0.1, -0.1, 0.2]))
vc.set_estimate(cam)
optimizer.initialize_optimization()
optimizer.compute_active_errors()
print('Initial chi2 =', optimizer.chi2())
optimizer.set_verbose(True)
optimizer.optimize(20)
print('\nSecond vertex should be near [0, 0, 1]')
print('before optimization:', cam.t)
print('after optimization:', optimizer.vertex(1).estimate().t)
print('error:', optimizer.vertex(1).estimate().t - [0, 0, 1])
'''
def poseOptimization(frame, verbose=False, rounds=10):
is_ok = True
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
#robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991)) # chi-square 2 DOFs
thHuberMono = math.sqrt(5.991)
# chi-square 2 DOFS
point_edge_pairs = {}
num_point_edges = 0
se3 = g2o.SE3Quat(frame.pose[0:3, 0:3], frame.pose[0:3, 3])
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(0)
v_se3.set_fixed(False)
opt.add_vertex(v_se3)
# add point vertices to graph
for idx, p in enumerate(frame.points):
if p is None: # do not use p.is_bad here since a single point observation is ok for pose optimization
continue
frame.outliers[idx] = False
# add edge
#print('adding edge between point ', p.id,' and frame ', frame.id)
edge = g2o.EdgeSE3ProjectXYZOnlyPose()
edge.set_vertex(0, opt.vertex(0))
edge.set_measurement(frame.kpsu[idx])
invSigma2 = Frame.detector.inv_level_sigmas2[frame.octaves[idx]]
edge.set_information(np.eye(2) * invSigma2)
edge.set_robust_kernel(g2o.RobustKernelHuber(thHuberMono))
edge.fx = frame.fx
edge.fy = frame.fy
edge.cx = frame.cx
edge.cy = frame.cy
edge.Xw = p.pt[0:3]
opt.add_edge(edge)
point_edge_pairs[p] = (edge, idx) # one edge per point
num_point_edges += 1
if num_point_edges < 3:
Printer.red('poseOptimization: not enough correspondences!')
is_ok = False
return 0, is_ok, 0
if verbose:
opt.set_verbose(True)
# We perform 4 optimizations, after each optimization we classify observation as inlier/outlier
# At the next optimization, outliers are not included, but at the end they can be classified as inliers again.
chi2Mono = 5.991 # chi-square 2 DOFs
num_bad_points = 0
for it in range(4):
opt.initialize_optimization()
opt.optimize(rounds)
num_bad_points = 0
for p, edge_pair in point_edge_pairs.items():
if frame.outliers[edge_pair[1]] is True:
edge_pair[0].compute_error()
chi2 = edge_pair[0].chi2()
if chi2 > chi2Mono:
frame.outliers[edge_pair[1]] = True
edge_pair[0].set_level(1)
num_bad_points += 1
else:
frame.outliers[edge_pair[1]] = False
edge_pair[0].set_level(0)
if it == 2:
edge_pair[0].set_robust_kernel(None)
if len(opt.edges()) < 10:
Printer.red('poseOptimization: stopped - not enough edges!')
is_ok = False
break
print('pose optimization: initial ', num_point_edges, ' points, found ',
num_bad_points, ' bad points')
if num_point_edges == num_bad_points:
Printer.red(
'poseOptimization: all the initial correspondences are bad!')
is_ok = False
# update pose estimation
if is_ok is True:
est = v_se3.estimate()
R = est.rotation().matrix()
t = est.translation()
frame.pose = poseRt(R, t)
num_valid_points = num_point_edges - num_bad_points
return opt.active_chi2(), is_ok, num_valid_points
def optimize(self, local_window=20, fix_points=False, verbose=False):
# create g2o optimizer
opt = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
opt.set_algorithm(solver)
if self.alt:
principal_point = (self.frames[0].K[0][2], self.frames[0].K[1][2])
cam = g2o.CameraParameters(self.frames[0].K[0][0], principal_point,
0)
cam.set_id(0)
opt.add_parameter(cam)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
if local_window is None:
local_frames = self.frames
else:
local_frames = self.frames[-local_window:]
graph_frames, graph_points = {}, {}
# add frames to graph
for f in (local_frames if fix_points else self.frames):
if not self.alt:
pose = np.linalg.inv(f.pose)
se3 = g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3])
sbacam = g2o.SBACam(se3)
sbacam.set_cam(f.K[0][0], f.K[1][1], f.K[0][2], f.K[1][2], 0.0)
v_se3 = g2o.VertexCam()
v_se3.set_estimate(sbacam)
else:
pose = f.pose
se3 = g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3])
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_estimate(se3)
v_se3.set_id(f.id * 2)
v_se3.set_fixed(f.id <= 1 or f not in local_frames)
# v_se3.set_fixed(f.id != 0)
opt.add_vertex(v_se3)
# confirm pose correctness
est = v_se3.estimate()
assert np.allclose(pose[0:3, 0:3], est.rotation().matrix())
assert np.allclose(pose[0:3, 3], est.translation())
graph_frames[f] = v_se3
# add points to frames
for p in self.points:
if not any([f in local_frames for f in p.frames]):
continue
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id * 2 + 1)
pt.set_estimate(p.loc[0:3])
pt.set_marginalized(True)
pt.set_fixed(fix_points)
opt.add_vertex(pt)
graph_points[p] = pt
# add edges
for f, idx in zip(p.frames, p.idxs):
if f not in graph_frames:
continue
if not self.alt:
edge = g2o.EdgeProjectP2MC()
else:
edge = g2o.EdgeProjectXYZ2UV()
edge.set_parameter_id(0, 0)
edge.set_vertex(0, pt)
edge.set_vertex(1, graph_frames[f])
uv = f.raw_pts[idx]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
opt.add_edge(edge)
if verbose:
opt.set_verbose(True)
opt.initialize_optimization()
opt.optimize(50)
# put frames back
for f in graph_frames:
est = graph_frames[f].estimate()
R = est.rotation().matrix()
t = est.translation()
if not self.alt:
f.pose = np.linalg.inv(pose_homogeneous(R, t))
else:
f.pose = pose_homogeneous(R, t)
# put points back (and cull)
if not fix_points:
culled_pt_count = 0
for p in graph_points:
est = graph_points[p].estimate()
p.pt = np.array(est)
# remove points if the number of observations <= (n-1)
old_point = len(
p.frames) <= 9 and p.frames[-1].id + 17 < self.max_frame
# compute reprojection error
errs = []
for f, idx in zip(p.frames, p.idxs):
uv = f.raw_pts[idx]
proj = np.dot(np.dot(f.K, f.pose[:3]),
np.array([est[0], est[1], est[2], 1.0]))
proj = proj[0:2] / proj[2]
errs.append(np.linalg.norm(proj - uv))
# cull
if old_point or np.mean(errs) > 2:
culled_pt_count += 1
self.points.remove(p)
p.delete()
print("Culled: %d points" % culled_pt_count)
return opt.active_chi2()
def optimize(self, local_window = LOCAL_WINDOW, fix_points = False, verbose = False):
# create the g2o optimizer
optimizer = g2o.SparseOptimizer()
graph_solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
graph_solver = g2o.OptimizationAlgorithmLevenberg(graph_solver)
optimizer.set_algorithm(graph_solver)
robust_kernel = g2o.RobustKernelHuber(np.sqrt(5.991))
if local_window is None:
local_frames = self.frames
else:
local_frames = self.frames[-local_window:]
# add frames to the graph
for f in self.frames:
pose = np.linalg.inv(f.pose)
sbacam = g2o.SBACam(g2o.SE3Quat(pose[0:3, 0:3], pose[0:3, 3]))
sbacam.set_cam(f.k[0][0], f.k[1][1], f.k[0][2], f.k[1][2], 1.0)
v_se3 = g2o.VertexCam()
v_se3.set_id(f.id)
v_se3.set_estimate(sbacam)
v_se3.set_fixed(f.id <= 1 or f not in local_frames)
optimizer.add_vertex(v_se3)
# add points to the frames
point_id_offset = 0x10000
for p in self.points:
if not any([f in local_frames for f in p.frames]):
continue
pt = g2o.VertexSBAPointXYZ()
pt.set_id(p.id + point_id_offset)
pt.set_estimate(p.point[0:3])
pt.set_marginalized(True)
pt.set_fixed(fix_points)
optimizer.add_vertex(pt)
for f in p.frames:
edge = g2o.EdgeProjectP2MC()
edge.set_vertex(0, pt)
edge.set_vertex(1, optimizer.vertex(f.id))
uv = f._kps[f.pts.index(p)]
edge.set_measurement(uv)
edge.set_information(np.eye(2))
edge.set_robust_kernel(robust_kernel)
optimizer.add_edge(edge)
if verbose:
optimizer.set_verbose(True)
optimizer.initialize_optimization()
optimizer.optimize(20)
# put the frames back
for f in self.frames:
estimate = optimizer.vertex(f.id).estimate()
r = estimate.rotation().matrix()
t = estimate.translation()
f.pose = np.linalg.inv(pose_rt(r, t))
# put points back
if not fix_points:
new_points = []
for p in self.points:
vert = optimizer.vertex(p.id + point_id_offset)
if vert is None:
new_points.append(p)
continue
estimate = vert.estimate()
old_point = len(p.frames) <= 2 and p.frames[-1] not in local_frames
# try and computer the reprojection error of the point
errors = []
for f in p.frames:g
uv = f._kps[f.pts.index(p)]
proj = np.dot(np.dot(f.k, f.pose[:3]),
np.array([estimate[0], estimate[1], estimate[2], 1.0]))
proj = proj[0:2]/proj[2]
errors.append(np.linalg.norm(proj-uv))
# culling
if old_point or np.mean(errors) > 5:
p.delete_point()
continue
p.point = np.array(estimate)
new_points.append(p)
print("Culled points: %d" %(len(self.points) - len(new_points)))
self.points = new_points
return optimizer.active_chi2()
def main():
optimizer = g2o.SparseOptimizer()
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
focal_length = 1000
principal_point = (320, 240)
cam = g2o.CameraParameters(focal_length, principal_point, 0)
cam.set_id(0)
optimizer.add_parameter(cam)
true_points = np.hstack([
np.random.random((500, 1)) * 3 - 1.5,
np.random.random((500, 1)) - 0.5,
np.random.random((500, 1)) + 3
])
true_poses = []
num_pose = 15
for i in range(num_pose):
# pose here means transform points from world coordinates to camera coordinates
pose = g2o.SE3Quat(np.identity(3), [i * 0.04 - 1, 0, 0])
true_poses.append(pose)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_id(i)
v_se3.set_estimate(pose)
if i < 2:
v_se3.set_fixed(True)
optimizer.add_vertex(v_se3)
point_id = num_pose
inliers = dict()
sse = defaultdict(float)
for i, point in enumerate(true_points):
visible = []
for j, pose in enumerate(true_poses):
z = cam.cam_map(pose * point)
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
visible.append((j, z))
if len(visible) < 2:
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_id(point_id)
vp.set_marginalized(True)
vp.set_estimate(point + np.random.randn(3))
optimizer.add_vertex(vp)
inlier = True
for j, z in visible:
if np.random.random() < args.outlier_ratio:
inlier = False
z = np.random.random(2) * [640, 480]
z += np.random.randn(2) * args.pixel_noise
edge = g2o.EdgeProjectXYZ2UV()
edge.set_vertex(0, vp)
edge.set_vertex(1, optimizer.vertex(j))
edge.set_measurement(z)
edge.set_information(np.identity(2))
if args.robust_kernel:
edge.set_robust_kernel(g2o.RobustKernelHuber())
edge.set_parameter_id(0, 0)
optimizer.add_edge(edge)
if inlier:
inliers[point_id] = i
error = vp.estimate() - true_points[i]
sse[0] += np.sum(error**2)
point_id += 1
print('num vertices:', len(optimizer.vertices()))
print('num edges:', len(optimizer.edges()))
print('Performing full BA:')
optimizer.initialize_optimization()
optimizer.set_verbose(True)
optimizer.optimize(10)
for i in inliers:
print(i)
vp = optimizer.vertex(i)
error = vp.estimate() - true_points[inliers[i]]
sse[1] += np.sum(error**2)
print('\nRMSE (inliers only):')
print('before optimization:', np.sqrt(sse[0] / len(inliers)))
print('after optimization:', np.sqrt(sse[1] / len(inliers)))
def graph_to_optimizer(self):
"""Convert a :class: graph to a :class: g2o.SparseOptimizer. Only the edges and vertices fields need to be
filled out.
Returns:
A :class: g2o.SparseOptimizer that can be optimized via its optimize class method.
"""
optimizer = g2o.SparseOptimizer()
optimizer.set_algorithm(g2o.OptimizationAlgorithmLevenberg(
g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())))
if self.is_sparse_bundle_adjustment:
for i in self.vertices:
if self.vertices[i].mode == VertexType.TAGPOINT:
vertex = g2o.VertexSBAPointXYZ()
vertex.set_estimate(self.vertices[i].estimate[:3])
else:
vertex = g2o.VertexSE3Expmap()
vertex.set_estimate(pose_to_se3quat(self.vertices[i].estimate))
vertex.set_id(i)
vertex.set_fixed(self.vertices[i].fixed)
optimizer.add_vertex(vertex)
cam_idx = 0
for i in self.edges:
if self.edges[i].corner_ids is None:
edge = g2o.EdgeSE3Expmap()
for j, k in enumerate([self.edges[i].startuid,
self.edges[i].enduid]):
edge.set_vertex(j, optimizer.vertex(k))
edge.set_measurement(pose_to_se3quat(self.edges[i].measurement))
edge.set_information(self.edges[i].information)
optimizer.add_edge(edge)
else:
# Note: we only use the focal length in the x direction since: (a) that's all that g2o supports and
# (b) it is always the same in ARKit (at least currently)
cam = g2o.CameraParameters(self.edges[i].camera_intrinsics[0],
self.edges[i].camera_intrinsics[2:], 0)
cam.set_id(cam_idx)
optimizer.add_parameter(cam)
for corner_idx, corner_id in enumerate(self.edges[i].corner_ids):
edge = g2o.EdgeProjectPSI2UV()
edge.resize(3)
edge.set_vertex(0, optimizer.vertex(corner_id))
edge.set_vertex(1, optimizer.vertex(self.edges[i].startuid))
edge.set_vertex(2, optimizer.vertex(self.edges[i].enduid))
edge.set_information(self.edges[i].information)
edge.set_measurement(self.edges[i].measurement[corner_idx * 2:corner_idx * 2 + 2])
edge.set_parameter_id(0, cam_idx)
if self.use_huber:
edge.set_robust_kernel(g2o.RobustKernelHuber(self.huber_delta))
optimizer.add_edge(edge)
cam_idx += 1
else:
for i in self.vertices:
vertex = g2o.VertexSE3()
vertex.set_id(i)
vertex.set_estimate(pose_to_isometry(self.vertices[i].estimate))
vertex.set_fixed(self.vertices[i].fixed)
optimizer.add_vertex(vertex)
for i in self.edges:
edge = g2o.EdgeSE3()
for j, k in enumerate([self.edges[i].startuid,
self.edges[i].enduid]):
edge.set_vertex(j, optimizer.vertex(k))
edge.set_measurement(pose_to_isometry(self.edges[i].measurement))
edge.set_information(self.edges[i].information)
edge.set_id(i)
optimizer.add_edge(edge)
return optimizer
def main():
optimizer = g2o.SparseOptimizer()
# solver = g2o.BlockSolverSE3(g2o.LinearSolverEigenSE3())
solver = g2o.BlockSolverSE3(g2o.LinearSolverCholmodSE3())
# solver = g2o.BlockSolverSE3(g2o.LinearSolverCSparseSE3())
solver = g2o.OptimizationAlgorithmLevenberg(solver)
optimizer.set_algorithm(solver)
# Convergence Criterion
terminate = g2o.SparseOptimizerTerminateAction()
terminate.set_gain_threshold(1e-6)
optimizer.add_post_iteration_action(terminate)
# Robust cost Function (Huber function) delta
delta = np.sqrt(5.991)
true_points = np.hstack([
np.random.random((25, 1)) * 3 - 1.5,
np.random.random((25, 1)) - 0.5,
np.random.random((25, 1)) + 3])
fx = 600.
fy = 600.
cx = 320.
cy = 240.
principal_point = (cx, cy)
cam = g2o.CameraParameters(fx, principal_point, 0)
true_poses = []
num_pose = 10
for i in range(num_pose):
# pose here means transform points from world coordinates to camera coordinates
pose = g2o.SE3Quat(np.identity(3), [i*0.04-1, 0, 0])
true_poses.append(pose)
v_se3 = g2o.VertexSE3Expmap()
v_se3.set_id(i)
v_se3.set_estimate(pose)
if i < 2:
v_se3.set_fixed(True)
optimizer.add_vertex(v_se3)
print(optimizer.vertices())
point_id = num_pose
inliers = dict()
sse = defaultdict(float)
vp_edge = []
for i, point in enumerate(true_points):
visible = []
for j, pose in enumerate(true_poses):
z = cam.cam_map(pose * point)
if 0 <= z[0] < 640 and 0 <= z[1] < 480:
visible.append((j, z))
if len(visible) < 2:
continue
vp = g2o.VertexSBAPointXYZ()
vp.set_estimate(point + np.random.randn(3))
vp.set_id(point_id)
vp.set_marginalized(True)
optimizer.add_vertex(vp)
inlier = True
for j, z in visible:
if np.random.random() < args.outlier_ratio:
inlier = False
z = np.random.random(2) * [640, 480]
z += np.random.randn(2) * args.pixel_noise
e = g2o.EdgeSE3ProjectXYZ()
e.set_vertex(0,vp)
e.set_vertex(1,optimizer.vertex(j))
e.set_measurement(z)
e.set_information(np.identity(2))
rk = g2o.RobustKernelHuber()
e.set_robust_kernel(rk)
rk.set_delta(delta)
e.fx = fx
e.fy = fy
e.cx = cx
e.cy = cy
optimizer.add_edge(e)
vp_edge.append(e)
if inlier:
inliers[point_id] = i
error = vp.estimate() - true_points[i]
sse[0] += np.sum(error**2)
point_id += 1
print('num vertices:', len(optimizer.vertices()))
print('num edges:', len(optimizer.edges()))
print(optimizer.vertices())
print()
print('Performing full BA:')
optimizer.initialize_optimization()
optimizer.set_verbose(True)
optimizer.optimize(5)
for i in inliers:
vp = optimizer.vertex(i)
error = vp.estimate() - true_points[inliers[i]]
sse[1] += np.sum(error**2)
print('\nRMSE (inliers only):')
print('before optimization:', np.sqrt(sse[0] / len(inliers)))
print('after optimization:', np.sqrt(sse[1] / len(inliers)))
# print(optimizer.vertices())
print()
for i in xrange(num_pose):
print(optimizer.vertex(i).estimate().inverse().matrix())
j = num_pose
for i in xrange(len(inliers)):
print(optimizer.vertex(j).estimate().shape)
j += 1
i = 0
"""
parm.set_id(id)
poseOptimizer.add_parameter(parm)
# Add 3d points and 2 edge from 2d points
index = 5
index_points = []
index_points.append(index)
index_edge = 5
for triangulationPairsPoint in triangulationPairsPoints_LF:
point = g2o.VertexSBAPointXYZ()
point.set_id(index)
point.set_estimate(triangulationPairsPoint.Point3d.flatten())
poseOptimizer.add_vertex(point)
# Add edge to front camera pose
kernel = g2o.RobustKernelHuber()
kernel.set_delta(1)
poseOptimizer.add_edge(index_edge, [point, vertexes[0]],
triangulationPairsPoint.Point2d1.flatten(),
0,
robust_kernel=kernel)
index_edge += 1
# Add edge to front camera2 pose
kernel = g2o.RobustKernelHuber()
kernel.set_delta(1)
poseOptimizer.add_edge(index_edge, [point, vertexes[4]],
triangulationPairsPoint.Point2d1.flatten(),
0,
robust_kernel=kernel)
index_edge += 1
