def pointing_correction(tile, i):
"""
Compute the translation that corrects the pointing error on a pair of tiles.
Args:
tile: dictionary containing the information needed to process the tile
i: index of the processed pair
"""
x, y, w, h = tile['coordinates']
out_dir = os.path.join(tile['dir'], 'pair_{}'.format(i))
img1 = cfg['images'][0]['img']
rpc1 = cfg['images'][0]['rpc']
img2 = cfg['images'][i]['img']
rpc2 = cfg['images'][i]['rpc']
if cfg['skip_existing'] and os.path.isfile(
os.path.join(out_dir, 'pointing.txt')):
print('pointing correction done on tile {} {} pair {}'.format(x, y, i))
return
# correct pointing error
print('correcting pointing on tile {} {} pair {}...'.format(x, y, i))
try:
if (('pointing_error_correction_method' in cfg)
and ('pointing_error_correction_degree' in cfg)):
pec_degree = cfg['pointing_error_correction_degree']
pec_method = cfg['pointing_error_correction_method']
apply_rectification = cfg['apply_rectification']
else:
pec_degree = 'analytic'
pec_method = 1
apply_rectification = True
A, m, F = pointing_accuracy.compute_correction(img1, rpc1, img2, rpc2,
x, y, w, h, pec_method,
pec_degree,
apply_rectification)
except common.RunFailure as e:
stderr = os.path.join(out_dir, 'stderr.log')
with open(stderr, 'w') as f:
f.write('ERROR during pointing correction with cmd: %s\n' %
e[0]['command'])
f.write('Stop processing this pair\n')
return
if A is not None: # A is the correction matrix
np.savetxt(os.path.join(out_dir, 'pointing.txt'), A, fmt='%6.12f')
if m is not None: # m is the list of sift matches
np.savetxt(os.path.join(out_dir, 'sift_matches.txt'), m, fmt='%9.3f')
np.savetxt(os.path.join(out_dir, 'center_keypts_sec.txt'),
np.mean(m[:, 2:], 0),
fmt='%9.3f')
if cfg['debug']:
visualisation.plot_matches(
img1, img2, rpc1, rpc2, m, x, y, w, h,
os.path.join(out_dir, 'sift_matches_pointing.png'))
if F is not None: # A is the correction matrix
np.savetxt(os.path.join(out_dir, 'affine_fundamental_matrix.txt'),
F,
fmt='%6.12f')
def pointing_correction(tile, i):
"""
Compute the translation that corrects the pointing error on a pair of tiles.
Args:
tile: dictionary containing the information needed to process the tile
i: index of the processed pair
"""
x, y, w, h = tile['coordinates']
out_dir = os.path.join(tile['dir'], 'pair_{}'.format(i))
img1 = cfg['images'][0]['img']
rpc1 = cfg['images'][0]['rpc']
img2 = cfg['images'][i]['img']
rpc2 = cfg['images'][i]['rpc']
if cfg['skip_existing'] and os.path.isfile(os.path.join(out_dir,
'pointing.txt')):
print('pointing correction done on tile {} {} pair {}'.format(x, y, i))
return
# correct pointing error
print('correcting pointing on tile {} {} pair {}...'.format(x, y, i))
try:
A, m = pointing_accuracy.compute_correction(img1, rpc1, img2, rpc2, x, y, w, h)
except common.RunFailure as e:
stderr = os.path.join(out_dir, 'stderr.log')
with open(stderr, 'w') as f:
f.write('ERROR during pointing correction with cmd: %s\n' % e[0]['command'])
f.write('Stop processing this pair\n')
return
if A is not None: # A is the correction matrix
np.savetxt(os.path.join(out_dir, 'pointing.txt'), A, fmt='%6.3f')
if m is not None: # m is the list of sift matches
np.savetxt(os.path.join(out_dir, 'sift_matches.txt'), m, fmt='%9.3f')
np.savetxt(os.path.join(out_dir, 'center_keypts_sec.txt'),
np.mean(m[:, 2:], 0), fmt='%9.3f')
if cfg['debug']:
visualisation.plot_matches(img1, img2, rpc1, rpc2, m, x, y, w, h,
os.path.join(out_dir,
'sift_matches_pointing.png'))
def pointing_correction(tile, i):
"""
Compute the translation that corrects the pointing error on a pair of tiles.
Args:
tile: dictionary containing the information needed to process the tile
i: index of the processed pair
"""
x, y, w, h = tile['coordinates']
out_dir = os.path.join(tile['dir'], 'pair_{}'.format(i))
img1 = cfg['images'][0]['img']
rpc1 = cfg['images'][0]['rpc']
img2 = cfg['images'][i]['img']
rpc2 = cfg['images'][i]['rpc']
# correct pointing error
print('correcting pointing on tile {} {} pair {}...'.format(x, y, i))
try:
A, m = pointing_accuracy.compute_correction(img1, rpc1, img2, rpc2, x,
y, w, h)
except common.RunFailure as e:
stderr = os.path.join(out_dir, 'stderr.log')
with open(stderr, 'w') as f:
f.write('ERROR during pointing correction with cmd: %s\n' %
e[0]['command'])
f.write('Stop processing this pair\n')
return
if A is not None: # A is the correction matrix
np.savetxt(os.path.join(out_dir, 'pointing.txt'), A, fmt='%6.3f')
if m is not None: # m is the list of sift matches
np.savetxt(os.path.join(out_dir, 'sift_matches.txt'), m, fmt='%9.3f')
np.savetxt(os.path.join(out_dir, 'center_keypts_sec.txt'),
np.mean(m[:, 2:], 0),
fmt='%9.3f')
if cfg['debug']:
visualisation.plot_matches(
img1, img2, rpc1, rpc2, m, x, y, w, h,
os.path.join(out_dir, 'sift_matches_pointing.png'))
def pointing_correction(tile, i):
"""
Compute the translation that corrects the pointing error on a pair of tiles.
Args:
tile: dictionary containing the information needed to process the tile
i: index of the processed pair
"""
x, y, w, h = tile['coordinates']
out_dir = os.path.join(tile['dir'], 'pair_{}'.format(i))
img1 = cfg['images'][0]['img']
rpc1 = cfg['images'][0]['rpc']
img2 = cfg['images'][i]['img']
rpc2 = cfg['images'][i]['rpc']
if cfg['skip_existing'] and os.path.isfile(
os.path.join(out_dir, 'pointing.txt')):
print('pointing correction done on tile {} {} pair {}'.format(x, y, i))
return
# correct pointing error
print('correcting pointing on tile {} {} pair {}...'.format(x, y, i))
A, m = pointing_accuracy.compute_correction(img1, rpc1, img2, rpc2, x, y,
w, h)
if A is not None: # A is the correction matrix
np.savetxt(os.path.join(out_dir, 'pointing.txt'), A, fmt='%6.3f')
if m is not None: # m is the list of sift matches
np.savetxt(os.path.join(out_dir, 'sift_matches.txt'), m, fmt='%9.3f')
np.savetxt(os.path.join(out_dir, 'center_keypts_sec.txt'),
np.mean(m[:, 2:], 0),
fmt='%9.3f')
if cfg['debug']:
visualisation.plot_matches(
img1, img2, rpc1, rpc2, m, x, y, w, h,
os.path.join(out_dir, 'sift_matches_pointing.png'))
def rectify_pair(im1,
im2,
rpc1,
rpc2,
x,
y,
w,
h,
out1,
out2,
A=None,
sift_matches=None,
method='rpc',
hmargin=0,
vmargin=0):
"""
Rectify a ROI in a pair of images.
Args:
im1, im2: paths to two image files
rpc1, rpc2: paths to the two xml files containing RPC data
x, y, w, h: four integers defining the rectangular ROI in the first
image. (x, y) is the top-left corner, and (w, h) are the dimensions
of the rectangle.
out1, out2: paths to the output rectified crops
A (optional): 3x3 numpy array containing the pointing error correction
for im2. This matrix is usually estimated with the pointing_accuracy
module.
sift_matches (optional): Nx4 numpy array containing a list of sift
matches, in the full image coordinates frame
method (default: 'rpc'): option to decide wether to use rpc of sift
matches for the fundamental matrix estimation.
{h,v}margin (optional): horizontal and vertical margins added on the
sides of the rectified images
Returns:
H1, H2: Two 3x3 matrices representing the rectifying homographies that
have been applied to the two original (large) images.
disp_min, disp_max: horizontal disparity range
"""
# read RPC data
rpc1 = rpc_model.RPCModel(rpc1)
rpc2 = rpc_model.RPCModel(rpc2)
# compute real or virtual matches
if method == 'rpc':
# find virtual matches from RPC camera models
matches = rpc_utils.matches_from_rpc(rpc1, rpc2, x, y, w, h,
cfg['n_gcp_per_axis'])
# correct second image coordinates with the pointing correction matrix
if A is not None:
matches[:, 2:] = common.points_apply_homography(
np.linalg.inv(A), matches[:, 2:])
else:
matches = sift_matches
# compute rectifying homographies
H1, H2, F = rectification_homographies(matches, x, y, w, h, hmargin,
vmargin)
if cfg['register_with_shear']:
# compose H2 with a horizontal shear to reduce the disparity range
a = np.mean(rpc_utils.altitude_range(rpc1, x, y, w, h))
lon, lat, alt = rpc_utils.ground_control_points(
rpc1, x, y, w, h, a, a, 4)
x1, y1 = rpc1.inverse_estimate(lon, lat, alt)[:2]
x2, y2 = rpc2.inverse_estimate(lon, lat, alt)[:2]
m = np.vstack([x1, y1, x2, y2]).T
m = np.vstack({tuple(row)
for row in m}) # remove duplicates due to no alt range
H2 = register_horizontally_shear(m, H1, H2)
# compose H2 with a horizontal translation to center disp range around 0
if sift_matches is not None:
sift_matches = filter_matches_epipolar_constraint(
F, sift_matches, cfg['epipolar_thresh'])
if len(sift_matches) < 10:
print('WARNING: no registration with less than 10 matches')
else:
H2 = register_horizontally_translation(sift_matches, H1, H2)
# compute disparity range
if cfg['debug']:
out_dir = os.path.dirname(out1)
np.savetxt(os.path.join(out_dir, 'sift_matches_disp.txt'),
sift_matches,
fmt='%9.3f')
visualisation.plot_matches(
im1, im2, rpc1, rpc2, sift_matches, x, y, w, h,
os.path.join(out_dir, 'sift_matches_disp.png'))
disp_m, disp_M = disparity_range(rpc1, rpc2, x, y, w, h, H1, H2,
sift_matches, A)
# compute rectifying homographies for non-epipolar mode (rectify the secondary tile only)
if block_matching.rectify_secondary_tile_only(cfg['matching_algorithm']):
H1_inv = np.linalg.inv(H1)
H1 = np.eye(
3
) # H1 is replaced by 2-D array with ones on the diagonal and zeros elsewhere
H2 = np.dot(H1_inv, H2)
T = common.matrix_translation(-x + hmargin, -y + vmargin)
H1 = np.dot(T, H1)
H2 = np.dot(T, H2)
# compute output images size
roi = [[x, y], [x + w, y], [x + w, y + h], [x, y + h]]
pts1 = common.points_apply_homography(H1, roi)
x0, y0, w0, h0 = common.bounding_box2D(pts1)
# check that the first homography maps the ROI in the positive quadrant
np.testing.assert_allclose(np.round([x0, y0]), [hmargin, vmargin],
atol=.01)
# apply homographies and do the crops
common.image_apply_homography(out1, im1, H1, w0 + 2 * hmargin,
h0 + 2 * vmargin)
common.image_apply_homography(out2, im2, H2, w0 + 2 * hmargin,
h0 + 2 * vmargin)
if block_matching.rectify_secondary_tile_only(cfg['matching_algorithm']):
pts_in = [[0, 0], [disp_m, 0], [disp_M, 0]]
pts_out = common.points_apply_homography(H1_inv, pts_in)
disp_m = pts_out[1, :] - pts_out[0, :]
disp_M = pts_out[2, :] - pts_out[0, :]
return H1, H2, disp_m, disp_M
def rectify_pair(im1, im2, rpc1, rpc2, x, y, w, h, out1, out2, A=None,
sift_matches=None, method='rpc', hmargin=0, vmargin=0):
"""
Rectify a ROI in a pair of images.
Args:
im1, im2: paths to two image files
rpc1, rpc2: paths to the two xml files containing RPC data
x, y, w, h: four integers defining the rectangular ROI in the first
image. (x, y) is the top-left corner, and (w, h) are the dimensions
of the rectangle.
out1, out2: paths to the output rectified crops
A (optional): 3x3 numpy array containing the pointing error correction
for im2. This matrix is usually estimated with the pointing_accuracy
module.
sift_matches (optional): Nx4 numpy array containing a list of sift
matches, in the full image coordinates frame
method (default: 'rpc'): option to decide wether to use rpc of sift
matches for the fundamental matrix estimation.
{h,v}margin (optional): horizontal and vertical margins added on the
sides of the rectified images
This function uses the parameter subsampling_factor from the
config module. If the factor z > 1 then the output images will
be subsampled by a factor z. The output matrices H1, H2, and the
ranges are also updated accordingly:
Hi = Z * Hi with Z = diag(1/z, 1/z, 1) and
disp_min = disp_min / z (resp _max)
Returns:
H1, H2: Two 3x3 matrices representing the rectifying homographies that
have been applied to the two original (large) images.
disp_min, disp_max: horizontal disparity range
"""
# read RPC data
rpc1 = rpc_model.RPCModel(rpc1)
rpc2 = rpc_model.RPCModel(rpc2)
# compute real or virtual matches
if method == 'rpc':
# find virtual matches from RPC camera models
matches = rpc_utils.matches_from_rpc(rpc1, rpc2, x, y, w, h,
cfg['n_gcp_per_axis'])
# correct second image coordinates with the pointing correction matrix
if A is not None:
matches[:, 2:] = common.points_apply_homography(np.linalg.inv(A),
matches[:, 2:])
else:
matches = sift_matches
# compute rectifying homographies
H1, H2, F = rectification_homographies(matches, x, y, w, h, hmargin, vmargin)
if cfg['register_with_shear']:
# compose H2 with a horizontal shear to reduce the disparity range
a = np.mean(rpc_utils.altitude_range(rpc1, x, y, w, h))
lon, lat, alt = rpc_utils.ground_control_points(rpc1, x, y, w, h, a, a, 4)
x1, y1 = rpc1.inverse_estimate(lon, lat, alt)[:2]
x2, y2 = rpc2.inverse_estimate(lon, lat, alt)[:2]
m = np.vstack([x1, y1, x2, y2]).T
m = np.vstack({tuple(row) for row in m}) # remove duplicates due to no alt range
H2 = register_horizontally_shear(m, H1, H2)
# compose H2 with a horizontal translation to center disp range around 0
if sift_matches is not None:
sift_matches = filter_matches_epipolar_constraint(F, sift_matches,
cfg['epipolar_thresh'])
if len(sift_matches) < 10:
print('WARNING: no registration with less than 10 matches')
else:
H2 = register_horizontally_translation(sift_matches, H1, H2)
# compute disparity range
if cfg['debug']:
out_dir = os.path.dirname(out1)
np.savetxt(os.path.join(out_dir, 'sift_matches_disp.txt'),
sift_matches, fmt='%9.3f')
visualisation.plot_matches(im1, im2, rpc1, rpc2, sift_matches, x, y, w, h,
os.path.join(out_dir, 'sift_matches_disp.png'))
disp_m, disp_M = disparity_range(rpc1, rpc2, x, y, w, h, H1, H2,
sift_matches, A)
# impose a minimal disparity range (TODO this is valid only with the
# 'center' flag for register_horizontally_translation)
disp_m = min(-3, disp_m)
disp_M = max(3, disp_M)
# compute rectifying homographies for non-epipolar mode (rectify the secondary tile only)
if block_matching.rectify_secondary_tile_only(cfg['matching_algorithm']):
H1_inv = np.linalg.inv(H1)
H1 = np.eye(3) # H1 is replaced by 2-D array with ones on the diagonal and zeros elsewhere
H2 = np.dot(H1_inv,H2)
T = common.matrix_translation(-x + hmargin, -y + vmargin)
H1 = np.dot(T, H1)
H2 = np.dot(T, H2)
# if subsampling_factor'] the homographies are altered to reflect the zoom
z = cfg['subsampling_factor']
if z != 1:
Z = np.diag((1/z, 1/z, 1))
H1 = np.dot(Z, H1)
H2 = np.dot(Z, H2)
disp_m = np.floor(disp_m / z)
disp_M = np.ceil(disp_M / z)
hmargin = int(np.floor(hmargin / z))
vmargin = int(np.floor(vmargin / z))
# compute output images size
roi = [[x, y], [x+w, y], [x+w, y+h], [x, y+h]]
pts1 = common.points_apply_homography(H1, roi)
x0, y0, w0, h0 = common.bounding_box2D(pts1)
# check that the first homography maps the ROI in the positive quadrant
np.testing.assert_allclose(np.round([x0, y0]), [hmargin, vmargin], atol=.01)
# apply homographies and do the crops
common.image_apply_homography(out1, im1, H1, w0 + 2*hmargin, h0 + 2*vmargin)
common.image_apply_homography(out2, im2, H2, w0 + 2*hmargin, h0 + 2*vmargin)
if cfg['disp_min'] is not None: disp_m = cfg['disp_min']
if cfg['disp_max'] is not None: disp_M = cfg['disp_max']
if block_matching.rectify_secondary_tile_only(cfg['matching_algorithm']):
pts_in = [[0, 0], [disp_m, 0], [disp_M, 0]]
pts_out = common.points_apply_homography(H1_inv,
pts_in)
disp_m = pts_out[1,:] - pts_out[0,:]
disp_M = pts_out[2,:] - pts_out[0,:]
return H1, H2, disp_m, disp_M
def rectify_pair(im1,
im2,
rpc1,
rpc2,
x,
y,
w,
h,
out1,
out2,
A=None,
sift_matches=None,
method='rpc',
hmargin=0,
vmargin=0):
"""
Rectify a ROI in a pair of images.
Args:
im1, im2: paths to two image files
rpc1, rpc2: paths to the two xml files containing RPC data
x, y, w, h: four integers defining the rectangular ROI in the first
image. (x, y) is the top-left corner, and (w, h) are the dimensions
of the rectangle.
out1, out2: paths to the output rectified crops
A (optional): 3x3 numpy array containing the pointing error correction
for im2. This matrix is usually estimated with the pointing_accuracy
module.
sift_matches (optional): Nx4 numpy array containing a list of sift
matches, in the full image coordinates frame
method (default: 'rpc'): option to decide wether to use rpc of sift
matches for the fundamental matrix estimation.
{h,v}margin (optional): horizontal and vertical margins added on the
sides of the rectified images
This function uses the parameter subsampling_factor from the
config module. If the factor z > 1 then the output images will
be subsampled by a factor z. The output matrices H1, H2, and the
ranges are also updated accordingly:
Hi = Z * Hi with Z = diag(1/z, 1/z, 1) and
disp_min = disp_min / z (resp _max)
Returns:
H1, H2: Two 3x3 matrices representing the rectifying homographies that
have been applied to the two original (large) images.
disp_min, disp_max: horizontal disparity range
"""
# read RPC data
rpc1 = rpc_model.RPCModel(rpc1)
rpc2 = rpc_model.RPCModel(rpc2)
# compute real or virtual matches
if method == 'rpc':
# find virtual matches from RPC camera models
matches = rpc_utils.matches_from_rpc(rpc1, rpc2, x, y, w, h,
cfg['n_gcp_per_axis'])
# correct second image coordinates with the pointing correction matrix
if A is not None:
matches[:, 2:] = common.points_apply_homography(
np.linalg.inv(A), matches[:, 2:])
else:
matches = sift_matches
# compute rectifying homographies
H1, H2, F = rectification_homographies(matches, x, y, w, h, hmargin,
vmargin)
if cfg['register_with_shear']:
# compose H2 with a horizontal shear to reduce the disparity range
a = np.mean(rpc_utils.altitude_range(rpc1, x, y, w, h))
lon, lat, alt = rpc_utils.ground_control_points(
rpc1, x, y, w, h, a, a, 4)
x1, y1 = rpc1.inverse_estimate(lon, lat, alt)[:2]
x2, y2 = rpc2.inverse_estimate(lon, lat, alt)[:2]
m = np.vstack([x1, y1, x2, y2]).T
m = np.vstack({tuple(row)
for row in m}) # remove duplicates due to no alt range
H2 = register_horizontally_shear(m, H1, H2)
# compose H2 with a horizontal translation to center disp range around 0
if sift_matches is not None:
sift_matches = filter_matches_epipolar_constraint(
F, sift_matches, cfg['epipolar_thresh'])
if len(sift_matches) < 10:
print('WARNING: no registration with less than 10 matches')
else:
H2 = register_horizontally_translation(sift_matches, H1, H2)
# compute disparity range
if cfg['debug']:
out_dir = os.path.dirname(out1)
np.savetxt(os.path.join(out_dir, 'sift_matches_disp.txt'),
sift_matches,
fmt='%9.3f')
visualisation.plot_matches(
im1, im2, rpc1, rpc2, sift_matches, x, y, w, h,
os.path.join(out_dir, 'sift_matches_disp.png'))
disp_m, disp_M = disparity_range(rpc1, rpc2, x, y, w, h, H1, H2,
sift_matches, A)
# impose a minimal disparity range (TODO this is valid only with the
# 'center' flag for register_horizontally_translation)
disp_m = min(-3, disp_m)
disp_M = max(3, disp_M)
# if subsampling_factor'] the homographies are altered to reflect the zoom
z = cfg['subsampling_factor']
if z != 1:
Z = np.diag((1 / z, 1 / z, 1))
H1 = np.dot(Z, H1)
H2 = np.dot(Z, H2)
disp_m = np.floor(disp_m / z)
disp_M = np.ceil(disp_M / z)
hmargin = int(np.floor(hmargin / z))
vmargin = int(np.floor(vmargin / z))
# compute output images size
roi = [[x, y], [x + w, y], [x + w, y + h], [x, y + h]]
pts1 = common.points_apply_homography(H1, roi)
x0, y0, w0, h0 = common.bounding_box2D(pts1)
# check that the first homography maps the ROI in the positive quadrant
np.testing.assert_allclose(np.round([x0, y0]), [hmargin, vmargin],
atol=.01)
# apply homographies and do the crops
common.image_apply_homography(out1, im1, H1, w0 + 2 * hmargin,
h0 + 2 * vmargin)
common.image_apply_homography(out2, im2, H2, w0 + 2 * hmargin,
h0 + 2 * vmargin)
return H1, H2, disp_m, disp_M
