Perform a bundle adjustment of an image mosaic.

bundle_adjust_mosaic performs a bundle adjustment of an image mosaic. This can be used to determine the geometry of a mosaic as robustly as possible, and hence to determine the transformations of the images in the mosaic more accurately than with single image pairs.

To achieve this, the projective transformation for each overlapping image pair in the mosaic should be determined with proj_match_points_ransac. For example, for a 2x2 block of images in the following layout

+---+---+
| 1 | 2 |
+---+---+
| 3 | 4 |
+---+---+

The 3x3 projective transformation matrices that correspond to the image pairs are passed in HomMatrices2D. Additionally, the coordinates of the matched point pairs in the image pairs must be passed in Rows1, Cols1, Rows2, and Cols2. They can be determined from the output of proj_match_points_ransac with tuple_select or with the HDevelop function subset. To enable bundle_adjust_mosaic to determine which point pair belongs to which image pair, NumCorrespondences must contain the number of found point matches for each image pair.

The parameter Transformation determines the class of transformations that is used in the bundle adjustment to transform the image points. This can be used to restrict the allowable transformations. For Transformation = 'projective', projective transformations are used (see vector_to_proj_hom_mat2d). For Transformation = 'affine', affine transformations are used (see vector_to_hom_mat2d), for Transformation = 'similarity', similarity transformations (see vector_to_similarity), and for Transformation = 'rigid' rigid transformations (see vector_to_rigid).

The resulting bundle-adjusted transformations are retuned as an array of 3x3 projective transformation matrices in MosaicMatrices2D. In addition, the points reconstructed by the bundle adjustment are returned in (Rows, Cols). The average projection error of the reconstructed points is returned in Error. This can be used to check whether the optimization has converged to useful values.

* Assume that Images contains the four images of the mosaic in the
* layout given in the above description.  Then the following example
* computes the bundle-adjusted transformation matrices.
From := [1,1,1,2,2,3]
To := [2,3,4,3,4,4]
HomMatrices2D := []
Rows1 := []
Cols1 := []
Rows2 := []
Cols2 := []
NumMatches := []
for J := 0 to |From|-1 by 1
    select_obj (Images, From[J], ImageF)
    select_obj (Images, To[J], ImageT)
    points_foerstner (ImageF, 1, 2, 3, 100, 0.1, 'gauss', 'true',
                      RowsF, ColsF, _, _, _, _, _, _, _, _)
    points_foerstner (ImageT, 1, 2, 3, 100, 0.1, 'gauss', 'true',
                      RowsT, ColsT, _, _, _, _, _, _, _, _)
    proj_match_points_ransac (ImageF, ImageT, RowsF, ColsF, RowsT, ColsT,
                              'ncc', 10, 0, 0, 480, 640, 0, 0.5,
                              'gold_standard', 2, 42, HomMat2D,
                              Points1, Points2)
    HomMatrices2D := [HomMatrices2D,HomMat2D]
    Rows1 := [Rows1,subset(RowsF,Points1)]
    Cols1 := [Cols1,subset(ColsF,Points1)]
    Rows2 := [Rows2,subset(RowsT,Points2)]
    Cols2 := [Cols2,subset(ColsT,Points2)]
    NumMatches := [NumMatches,|Points1|]
endfor
bundle_adjust_mosaic (4, 1, From, To, HomMatrices2D, Rows1, Cols1,
                      Rows2, Cols2, NumMatches, 'rigid', MosaicMatrices)
gen_bundle_adjusted_mosaic (Images, MosaicImage, HomMatrices2D,
                            'default', 'false', TransMat2D)

If the parameters are valid, the operator bundle_adjust_mosaic returns the value 2 (H_MSG_TRUE). If necessary an exception handling is raised.

bundle_adjust_mosaic is reentrant and processed without parallelization.

proj_match_points_ransac

gen_bundle_adjusted_mosaic

gen_projective_mosaic

Matching