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))