def cost_function(v, *args):
"""
Objective function to minimize in order to correct the pointing error.
Arguments:
v: vector of size 3 or 4, containing the parameters of the euclidean
transformation we are looking for.
rpc1, rpc2: two instances of the rpc_model.RPCModel class
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 the one of the big images.
alpha: relative weight of the error terms: e + alpha*(h-h0)^2. See
paper for more explanations.
Returns:
The sum of pointing errors and altitude differences, as written in the
paper formula (1).
"""
rpc1, rpc2, matches = args[0], args[1], args[2]
if len(args) == 4:
alpha = args[3]
else:
alpha = 0.01
# verify that parameters are in the bounding box
if (np.abs(v[0]) > 200*np.pi or
np.abs(v[1]) > 10000 or
np.abs(v[2]) > 10000):
print 'warning: cost_function is going too far'
print v
if (len(v) > 3):
if (np.abs(v[3]) > 20000):
print 'warning: cost_function is going too far'
print v
# compute the altitudes from the matches without correction
x1 = matches[:, 0]
y1 = matches[:, 1]
x2 = matches[:, 2]
y2 = matches[:, 3]
h0 = rpc_utils.compute_height(rpc1, rpc2, x1, y1, x2, y2)[0]
# transform the coordinates of points in the second image according to
# matrix A, built from vector v
A = euclidean_transform_matrix(v)
p2 = common.points_apply_homography(A, matches[:, 2:4])
x2 = p2[:, 0]
y2 = p2[:, 1]
# compute the cost
h, e = rpc_utils.compute_height(rpc1, rpc2, x1, y1, x2, y2)
cost = np.sum((h - h0)**2)
cost *= alpha
cost += np.sum(e)
#print cost
return cost
def evaluation_iterative(im1,
im2,
rpc1,
rpc2,
x,
y,
w,
h,
A=None,
matches=None):
"""
Measures the maximal pointing error on a Pleiades' pair of images.
Args:
im1, im2: paths to the two Pleiades images (usually jp2 or tif)
rpc1, rpc2: two instances of the rpc_model.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.
A (optional): 3x3 numpy array containing the pointing error correction
for im2.
matches (optional): Nx4 numpy array containing a list of matches to use
to compute the pointing error
Returns:
the mean pointing error, in the direction orthogonal to the epipolar
lines. This error is measured in pixels.
"""
if not matches:
matches = sift.matches_on_rpc_roi(im1, im2, rpc1, rpc2, x, y, w, h)
p1 = matches[:, 0:2]
p2 = matches[:, 2:4]
print '%d sift matches' % len(matches)
# apply pointing correction matrix, if available
if A is not None:
p2 = common.points_apply_homography(A, p2)
# compute the pointing error for each match
x1 = p1[:, 0]
y1 = p1[:, 1]
x2 = p2[:, 0]
y2 = p2[:, 1]
e = rpc_utils.compute_height(rpc1, rpc2, x1, y1, x2, y2)[1]
# matches = matches[e < 0.1, :]
# visualisation.plot_matches_pleiades(im1, im2, matches)
print "max, mean, min pointing error, from %d points:" % (len(matches))
print np.max(e), np.mean(e), np.min(e)
# return the mean error
return np.mean(np.abs(e))
def evaluation_iterative(im1, im2, rpc1, rpc2, x, y, w, h, A=None,
matches=None):
"""
Measures the maximal pointing error on a Pleiades' pair of images.
Args:
im1, im2: paths to the two Pleiades images (usually jp2 or tif)
rpc1, rpc2: two instances of the rpc_model.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.
A (optional): 3x3 numpy array containing the pointing error correction
for im2.
matches (optional): Nx4 numpy array containing a list of matches to use
to compute the pointing error
Returns:
the mean pointing error, in the direction orthogonal to the epipolar
lines. This error is measured in pixels.
"""
if matches is None:
matches = filtered_sift_matches_roi(im1, im2, rpc1, rpc2, x, y, w, h)
p1 = matches[:, 0:2]
p2 = matches[:, 2:4]
print '%d sift matches' % len(matches)
# apply pointing correction matrix, if available
if A is not None:
p2 = common.points_apply_homography(A, p2)
# compute the pointing error for each match
x1 = p1[:, 0]
y1 = p1[:, 1]
x2 = p2[:, 0]
y2 = p2[:, 1]
e = rpc_utils.compute_height(rpc1, rpc2, x1, y1, x2, y2)[1]
# matches = matches[e < 0.1, :]
# visualisation.plot_matches_pleiades(im1, im2, matches)
print "max, mean, min pointing error, from %d points:" % (len(matches))
print np.max(e), np.mean(e), np.min(e)
# return the mean error
return np.mean(np.abs(e))