Halcon 部分算子汇总一（calibration-adjust_mosaic_images.hdev）

adjust_mosaic_images.hdev


* This example program shows how 128 images of the interior of a church can be
* combined into a mosaic that covers a 360x130 degree view.  The images were acquired
* with a camera in which the exposure and white balance were set to automatic.
* Therefore, there are very large brightness and color differences between the images.
* Hence, adjust_mosaic_images is used to align the images radiometrically.
* Furthermore, blending is used to hide the transitions between the individual
* images that make up the mosaic.
dev_update_off ()
dev_close_window ()
dev_open_window (0, 0, 978, 324, 'black', WindowHandle)
dev_set_part (0, 0, 647, 1955)
set_display_font (WindowHandle, 16, 'mono', 'true', 'false')
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Reading images...')
* Read the 128 images that make up the mosaic.
gen_empty_obj (Images)
for J := 1 to 128 by 1
    read_image (Image, 'panorama/sankt_martin_automatic_' + J$'03d')
    concat_obj (Images, Image, Images)
endfor
get_image_size (Image, Width, Height)
* Construct the tuples that determine which images should be matched.  The
* mosaic images were acquired as 16 vertical strips of 8 images each.
* For each image, we match the image below the current image in the same
* strip and the image to the left of the current image in the adjacent strip.
FF := [1,1,2,2,3,3,4,4,5,5,6,6,7,7,8]
TT := [2,9,3,10,4,11,5,12,6,13,7,14,8,15,16]
From := []
To := []
for J := 0 to 15 by 1
    From := [From,(FF - 1 + 8 * J) % 128 + 1]
    To := [To,(TT - 1 + 8 * J) % 128 + 1]
endfor
* Initialize the data that is required for the self-calibration.
HomMatrices2D := []
Rows1 := []
Cols1 := []
Rows2 := []
Cols2 := []
NumMatches := []
for J := 0 to |From| - 1 by 1
    * Select the images to match.
    select_obj (Images, ImageF, From[J])
    select_obj (Images, ImageT, To[J])
    * Perform the point extraction of the images.
    points_foerstner (ImageF, 1, 2, 3, 50, 0.1, 'gauss', 'true', RowsF, ColsF, CoRRJunctions, CoRCJunctions, CoCCJunctions, RowArea, ColumnArea, CoRRArea, CoRCArea, CoCCArea)
    points_foerstner (ImageT, 1, 2, 3, 50, 0.1, 'gauss', 'true', RowsT, ColsT, CoRRJunctions1, CoRCJunctions1, CoCCJunctions1, RowArea1, ColumnArea1, CoRRArea1, CoRCArea1, CoCCArea1)
    concat_obj (ImageT, ImageF, ImageTF)
    tile_images_offset (ImageTF, TiledImage, [0,0], [0,Width + 20], [-1,-1], [-1,-1], [-1,-1], [-1,-1], 2 * Width + 20, Height)
    gen_cross_contour_xld (PointsF, RowsF, ColsF + Width + 20, 6, rad(45))
    gen_cross_contour_xld (PointsT, RowsT, ColsT, 6, rad(0))
    * Convert the images to gray value images.
    rgb1_to_gray (ImageF, ImageFG)
    rgb1_to_gray (ImageT, ImageTG)
    * Determine the projective transformation between the images.
    proj_match_points_ransac (ImageFG, ImageTG, RowsF, ColsF, RowsT, ColsT, 'ncc', 10, 0, 0, 648, 968, [rad(-10),rad(40)], 0.5, 'gold_standard', 10, 42, HomMat2D, Points1, Points2)
    * After this, we accumulate the required data.
    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|]
    * The rest of the code within the loop visualizes the point matches.
    RF := subset(RowsF,Points1)
    CF := subset(ColsF,Points1) + Width + 20
    RT := subset(RowsT,Points2)
    CT := subset(ColsT,Points2)
    gen_empty_obj (Matches)
    for K := 0 to |RF| - 1 by 1
        gen_contour_polygon_xld (Match, [RF[K],RT[K]], [CF[K],CT[K]])
        concat_obj (Matches, Match, Matches)
    endfor
    dev_clear_window ()
    dev_display (TiledImage)
    dev_set_color ('blue')
    dev_display (Matches)
    dev_set_color ('green')
    dev_display (PointsF)
    dev_display (PointsT)
    dev_set_color ('yellow')
    set_tposition (WindowHandle, 20, 20)
    write_string (WindowHandle, 'Matches between images ' + From[J]$'d' + ' and ' + To[J]$'d')
endfor
dev_clear_window ()
dev_set_window_extents (-1, -1, 856, 428)
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Performing self-calibration...')
* Perform the self-calibration.
stationary_camera_self_calibration (128, 968, 648, 6, From, To, HomMatrices2D, Rows1, Cols1, Rows2, Cols2, NumMatches, 'gold_standard', ['focus','principal_point','kappa'], 'true', CameraMatrix, Kappa, RotationMatrices, X, Y, Z, Error)
dev_clear_window ()
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Removing radial distortions...')
* Remove the radial distortions from the images./移除相机径向畸变
cam_mat_to_cam_par (CameraMatrix, Kappa, 968, 648, CamParam)
change_radial_distortion_cam_par ('fixed', CamParam, 0, CamParOut)
gen_radial_distortion_map (Map, CamParam, CamParOut, 'bilinear')
map_image (Images, Map, Images)
dev_clear_window ()
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Adjusting the images radiometrically...')
* Before we adjust the images radiometrically, we compute the perspective
* transformations between the images from the camera matrix and the rotation
* matrices that are returned by the self-calibration.  They are more accurate
* than the perspective transformations that are returned by the matching
* since they have been optimized over all images.  For details on how the
* perspective transformation matrices are computed by the code below, see the
* documentation of stationary_camera_self_calibration.
hom_mat2d_invert (CameraMatrix, CameraMatrixInv)
PermMat := [0.0,1.0,0.5,1.0,0.0,0.5,0.0,0.0,1.0]
hom_mat2d_invert (PermMat, PermMatInv)
hom_mat2d_compose (CameraMatrixInv, PermMatInv, CamMatPermInv)
hom_mat2d_compose (PermMat, CameraMatrix, CamMatPerm)
HomMats2D := []
for J := 0 to |From| - 1 by 1
    RotMatFrom := RotationMatrices[9 * (From[J] - 1):9 * (From[J] - 1) + 8]
    RotMatTo := RotationMatrices[9 * (To[J] - 1):9 * (To[J] - 1) + 8]
    hom_mat2d_transpose (RotMatFrom, RotMatFromInv)
    hom_mat2d_compose (RotMatTo, RotMatFromInv, RotMat)
    hom_mat2d_compose (RotMat, CamMatPermInv, RotCamMatInv)
    hom_mat2d_compose (CamMatPerm, RotCamMatInv, HomMat2D)
    HomMats2D := [HomMats2D,HomMat2D]
endfor
* Now adjust the images radiometrically.  Since the exposure and white balance
* were set to automatic, we calculate 'mult_gray'.  Since the camera is a consumer
* camera and therefore has a highly nonlinear response, we compute 'response'.
* To compensate the vignetting in the images, we compute 'vignetting'. Finally,
* to speed up the optimization, we use a subsampling by a factor of 4.
adjust_mosaic_images (Images, CorrectedImages, From, To, 118, HomMats2D, 'gold_standard', ['mult_gray','response','vignetting','subsampling_4'], 'laguerre')
* Since the reference image was not aligned perfectly horizontally, we modify the
* calibrated rotation matrices by rotating them by -5.5 degrees around the x axis.
hom_mat3d_identity (HomMat3D)
hom_mat3d_rotate (HomMat3D, rad(-5.5), 'x', 0, 0, 0, HomMat3D)
RotMat := [HomMat3D[0:2],HomMat3D[4:6],HomMat3D[8:10]]
RotMats := []
for J := 0 to 127 by 1
    RotMatCalib := RotationMatrices[J * 9:J * 9 + 8]
    hom_mat2d_compose (RotMatCalib, RotMat, RotMatRot)
    RotMats := [RotMats,RotMatRot]
endfor
dev_clear_window ()
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Creating spherical mosaic of the original images...')
* Create the spherical mosaic of the original images.
gen_spherical_mosaic (Images, SphericalMosaicOrig, CameraMatrix, RotMats, -90, 90, -180, 180, 0, 'voronoi', 'bilinear')
get_image_size (SphericalMosaicOrig, Width, Height)
dev_set_part (0, 0, Height - 1, Width - 1)
dev_clear_window ()
dev_display (SphericalMosaicOrig)
dev_set_color ('yellow')
set_tposition (WindowHandle, Height - 300, 20)
write_string (WindowHandle, 'Spherical mosaic of the original images')
set_tposition (WindowHandle, Height - 150, 20)
write_string (WindowHandle, 'Press \'Run\' to continue')
stop ()
dev_clear_window ()
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Creating spherical mosaic of the radiometrically adjusted images...')
* Create the spherical mosaic of the radiometrically adjusted images.
gen_spherical_mosaic (CorrectedImages, SphericalMosaicAdjust, CameraMatrix, RotMats, -90, 90, -180, 180, 0, 'voronoi', 'bilinear')
get_image_size (SphericalMosaicAdjust, Width, Height)
dev_set_part (0, 0, Height - 1, Width - 1)
dev_clear_window ()
dev_display (SphericalMosaicAdjust)
dev_set_color ('yellow')
set_tposition (WindowHandle, Height - 300, 20)
write_string (WindowHandle, 'Spherical mosaic of the radiometrically adjusted images')
set_tposition (WindowHandle, Height - 150, 20)
write_string (WindowHandle, 'Press \'Run\' to continue')
stop ()
dev_clear_window ()
dev_set_color ('yellow')
set_tposition (WindowHandle, 20, 20)
write_string (WindowHandle, 'Creating blended spherical mosaic of the radiometrically adjusted images...')
* Create the blended spherical mosaic of the radiometrically adjusted images.
gen_spherical_mosaic (CorrectedImages, SphericalMosaicAdjustBlend, CameraMatrix, RotMats, -90, 90, -180, 180, 0, 'blend', 'bilinear')
get_image_size (SphericalMosaicAdjustBlend, Width, Height)
dev_set_part (0, 0, Height - 1, Width - 1)
dev_clear_window ()
dev_display (SphericalMosaicAdjustBlend)
dev_set_color ('yellow')
set_tposition (WindowHandle, Height - 300, 20)
write_string (WindowHandle, 'Blended spherical mosaic of the radiometrically adjusted images')