def local_translation(r1, r2, x, y, w, h, m):
"""
Estimates the optimal translation to minimise the relative pointing error
on a given tile.
Args:
r1, r2: two instances of the rpc_model.RPCModel class
x, y, w, h: region of interest in the reference image (r1)
m: Nx4 numpy array containing a list of matches, one per line. Each
match is given by (p1, p2, q1, q2) where (p1, p2) is a point of the
reference view and (q1, q2) is the corresponding point in the
secondary view.
Returns:
3x3 numpy array containing the homogeneous representation of the
optimal planar translation, to be applied to the secondary image in
order to correct the pointing error.
"""
# estimate the affine fundamental matrix between the two views
n = cfg['n_gcp_per_axis']
rpc_matches = rpc_utils.matches_from_rpc(r1, r2, x, y, w, h, n)
F = estimation.affine_fundamental_matrix(rpc_matches)
# compute the error vectors
e = error_vectors(m, F, 'sec')
# compute the median: as the vectors are collinear (because F is affine)
# computing the median of each component independently is correct
N = len(e)
out_x = np.sort(e[:, 0])[int(N / 2)]
out_y = np.sort(e[:, 1])[int(N / 2)]
# the correction to be applied to the second view is the opposite
A = np.array([[1, 0, -out_x], [0, 1, -out_y], [0, 0, 1]])
return A
def matches_on_rpc_roi(im1, im2, rpc1, rpc2, x, y, w, h):
"""
Compute a list of SIFT matches between two images on a given roi.
The corresponding roi in the second image is determined using the rpc
functions.
Args:
im1, im2: paths to two large tif images
rpc1, rpc2: two instances of the rpcm.RPCModel class
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.
Returns:
matches: 2D numpy array containing a list of matches. Each line
contains one pair of points, ordered as x1 y1 x2 y2.
The coordinate system is that of the full images.
"""
x2, y2, w2, h2 = rpc_utils.corresponding_roi(rpc1, rpc2, x, y, w, h)
# estimate an approximate affine fundamental matrix from the rpcs
rpc_matches = rpc_utils.matches_from_rpc(rpc1, rpc2, x, y, w, h, 5)
F = estimation.affine_fundamental_matrix(rpc_matches)
# sift matching method:
method = 'relative' if cfg[
'relative_sift_match_thresh'] is True else 'absolute'
# if less than 10 matches, lower thresh_dog. An alternative would be ASIFT
thresh_dog = 0.0133
for i in range(2):
p1 = image_keypoints(im1, x, y, w, h, thresh_dog=thresh_dog)
p2 = image_keypoints(im2, x2, y2, w2, h2, thresh_dog=thresh_dog)
matches = keypoints_match(p1,
p2,
method,
cfg['sift_match_thresh'],
F,
epipolar_threshold=cfg['max_pointing_error'],
model='fundamental')
if matches is not None and matches.ndim == 2 and matches.shape[0] > 10:
break
thresh_dog /= 2.0
else:
print("WARNING: sift.matches_on_rpc_roi: found no matches.")
return None
return matches
def test_matches_from_rpc():
"""
Test for rpc_utils.matches_from_rpc().
"""
r1 = rpcm.rpc_from_geotiff(
data_path(os.path.join('input_pair', 'img_01.tif')))
r2 = rpcm.rpc_from_geotiff(
data_path(os.path.join('input_pair', 'img_02.tif')))
test_matches = rpc_utils.matches_from_rpc(r1, r2, 100, 100, 200, 200, 5)
expected_matches = np.loadtxt(
data_path(
os.path.join('expected_output', 'units',
'unit_matches_from_rpc.txt')))
np.testing.assert_equal(test_matches.shape[0], 125, verbose=True)
np.testing.assert_allclose(test_matches,
expected_matches,
rtol=0.01,
atol=0.1,
verbose=True)
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 GeoTIFF image files
rpc1, rpc2: two instances of the rpcm.RPCModel class
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
"""
# 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:])
elif method == 'sift':
matches = sift_matches
else:
raise Exception(
"Unknown value {} for argument 'method'".format(method))
if matches is None or len(matches) < 4:
raise NoRectificationMatchesError(
"No or not enough matches found to rectify image pair")
# compute rectifying homographies
H1, H2, F = rectification_homographies(matches, x, y, w, h)
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.projection(lon, lat, alt)[:2]
x2, y2 = rpc2.projection(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) < 1:
warnings.warn(
"Need at least one sift match for the horizontal registration",
category=NoHorizontalRegistrationWarning,
)
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)
# recompute hmargin and homographies
hmargin = int(np.ceil(max([hmargin, np.fabs(disp_m), np.fabs(disp_M)])))
T = common.matrix_translation(hmargin, vmargin)
H1, H2 = np.dot(T, H1), 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)
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
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)
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)
# recompute hmargin and homographies
hmargin = int(np.ceil(max([hmargin, np.fabs(disp_m), np.fabs(disp_M)])))
T = common.matrix_translation(hmargin, vmargin)
H1, H2 = np.dot(T, H1), np.dot(T, H2)
# 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