1 Basic concepts of the homography explained with code {#tutorial_homography}
2 ====================================================
4 @prev_tutorial{tutorial_akaze_tracking}
8 Introduction {#tutorial_homography_Introduction}
11 This tutorial will demonstrate the basic concepts of the homography with some codes.
12 For detailed explanations about the theory, please refer to a computer vision course or a computer vision book, e.g.:
13 * Multiple View Geometry in Computer Vision, @cite HartleyZ00.
14 * An Invitation to 3-D Vision: From Images to Geometric Models, @cite Ma:2003:IVI
15 * Computer Vision: Algorithms and Applications, @cite RS10
17 The tutorial code can be found here [C++](https://github.com/opencv/opencv/tree/3.4/samples/cpp/tutorial_code/features2D/Homography),
18 [Python](https://github.com/opencv/opencv/tree/3.4/samples/python/tutorial_code/features2D/Homography),
19 [Java](https://github.com/opencv/opencv/tree/3.4/samples/java/tutorial_code/features2D/Homography).
20 The images used in this tutorial can be found [here](https://github.com/opencv/opencv/tree/3.4/samples/data) (`left*.jpg`).
22 Basic theory {#tutorial_homography_Basic_theory}
25 ### What is the homography matrix? {#tutorial_homography_What_is_the_homography_matrix}
27 Briefly, the planar homography relates the transformation between two planes (up to a scale factor):
42 h_{11} & h_{12} & h_{13} \\
43 h_{21} & h_{22} & h_{23} \\
44 h_{31} & h_{32} & h_{33}
53 The homography matrix is a `3x3` matrix but with 8 DoF (degrees of freedom) as it is estimated up to a scale. It is generally normalized (see also \ref lecture_16 "1")
54 with \f$ h_{33} = 1 \f$ or \f$ h_{11}^2 + h_{12}^2 + h_{13}^2 + h_{21}^2 + h_{22}^2 + h_{23}^2 + h_{31}^2 + h_{32}^2 + h_{33}^2 = 1 \f$.
56 The following examples show different kinds of transformation but all relate a transformation between two planes.
58 * a planar surface and the image plane (image taken from \ref projective_transformations "2")
60 ![](images/homography_transformation_example1.jpg)
62 * a planar surface viewed by two camera positions (images taken from \ref szeliski "3" and \ref projective_transformations "2")
64 ![](images/homography_transformation_example2.jpg)
66 * a rotating camera around its axis of projection, equivalent to consider that the points are on a plane at infinity (image taken from \ref projective_transformations "2")
68 ![](images/homography_transformation_example3.jpg)
70 ### How the homography transformation can be useful? {#tutorial_homography_How_the_homography_transformation_can_be_useful}
72 * Camera pose estimation from coplanar points for augmented reality with marker for instance (see the previous first example)
74 ![](images/homography_pose_estimation.jpg)
76 * Perspective removal / correction (see the previous second example)
78 ![](images/homography_perspective_correction.jpg)
80 * Panorama stitching (see the previous second and third example)
82 ![](images/homography_panorama_stitching.jpg)
84 Demonstration codes {#tutorial_homography_Demonstration_codes}
87 ### Demo 1: Pose estimation from coplanar points {#tutorial_homography_Demo1}
89 \note Please note that the code to estimate the camera pose from the homography is an example and you should use instead @ref cv::solvePnP if you want to estimate the camera pose for a planar or an arbitrary object.
91 The homography can be estimated using for instance the Direct Linear Transform (DLT) algorithm (see \ref lecture_16 "1" for more information).
92 As the object is planar, the transformation between points expressed in the object frame and projected points into the image plane expressed in the normalized camera frame is a homography. Only because the object is planar,
93 the camera pose can be retrieved from the homography, assuming the camera intrinsic parameters are known (see \ref projective_transformations "2" or \ref answer_dsp "4").
94 This can be tested easily using a chessboard object and `findChessboardCorners()` to get the corner locations in the image.
96 The first thing consists to detect the chessboard corners, the chessboard size (`patternSize`), here `9x6`, is required:
98 @snippet pose_from_homography.cpp find-chessboard-corners
100 ![](images/homography_pose_chessboard_corners.jpg)
102 The object points expressed in the object frame can be computed easily knowing the size of a chessboard square:
104 @snippet pose_from_homography.cpp compute-chessboard-object-points
106 The coordinate `Z=0` must be removed for the homography estimation part:
108 @snippet pose_from_homography.cpp compute-object-points
110 The image points expressed in the normalized camera can be computed from the corner points and by applying a reverse perspective transformation using the camera intrinsics and the distortion coefficients:
112 @snippet pose_from_homography.cpp load-intrinsics
114 @snippet pose_from_homography.cpp compute-image-points
116 The homography can then be estimated with:
118 @snippet pose_from_homography.cpp estimate-homography
120 A quick solution to retrieve the pose from the homography matrix is (see \ref pose_ar "5"):
122 @snippet pose_from_homography.cpp pose-from-homography
126 \boldsymbol{X} &= \left( X, Y, 0, 1 \right ) \\
127 \boldsymbol{x} &= \boldsymbol{P}\boldsymbol{X} \\
128 &= \boldsymbol{K} \left[ \boldsymbol{r_1} \hspace{0.5em} \boldsymbol{r_2} \hspace{0.5em} \boldsymbol{r_3} \hspace{0.5em} \boldsymbol{t} \right ]
135 &= \boldsymbol{K} \left[ \boldsymbol{r_1} \hspace{0.5em} \boldsymbol{r_2} \hspace{0.5em} \boldsymbol{t} \right ]
152 \boldsymbol{H} &= \lambda \boldsymbol{K} \left[ \boldsymbol{r_1} \hspace{0.5em} \boldsymbol{r_2} \hspace{0.5em} \boldsymbol{t} \right ] \\
153 \boldsymbol{K}^{-1} \boldsymbol{H} &= \lambda \left[ \boldsymbol{r_1} \hspace{0.5em} \boldsymbol{r_2} \hspace{0.5em} \boldsymbol{t} \right ] \\
154 \boldsymbol{P} &= \boldsymbol{K} \left[ \boldsymbol{r_1} \hspace{0.5em} \boldsymbol{r_2} \hspace{0.5em} \left( \boldsymbol{r_1} \times \boldsymbol{r_2} \right ) \hspace{0.5em} \boldsymbol{t} \right ]
158 This is a quick solution (see also \ref projective_transformations "2") as this does not ensure that the resulting rotation matrix will be orthogonal and the scale is estimated roughly by normalize the first column to 1.
160 A solution to have a proper rotation matrix (with the properties of a rotation matrix) consists to apply a polar decomposition
161 (see \ref polar_decomposition "6" or \ref polar_decomposition_svd "7" for some information):
163 @snippet pose_from_homography.cpp polar-decomposition-of-the-rotation-matrix
165 To check the result, the object frame projected into the image with the estimated camera pose is displayed:
167 ![](images/homography_pose.jpg)
169 ### Demo 2: Perspective correction {#tutorial_homography_Demo2}
171 In this example, a source image will be transformed into a desired perspective view by computing the homography that maps the source points into the desired points.
172 The following image shows the source image (left) and the chessboard view that we want to transform into the desired chessboard view (right).
174 ![Source and desired views](images/homography_source_desired_images.jpg)
176 The first step consists to detect the chessboard corners in the source and desired images:
179 @snippet perspective_correction.cpp find-corners
183 @snippet samples/python/tutorial_code/features2D/Homography/perspective_correction.py find-corners
187 @snippet samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java find-corners
190 The homography is estimated easily with:
193 @snippet perspective_correction.cpp estimate-homography
197 @snippet samples/python/tutorial_code/features2D/Homography/perspective_correction.py estimate-homography
201 @snippet samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java estimate-homography
204 To warp the source chessboard view into the desired chessboard view, we use @ref cv::warpPerspective
207 @snippet perspective_correction.cpp warp-chessboard
211 @snippet samples/python/tutorial_code/features2D/Homography/perspective_correction.py warp-chessboard
215 @snippet samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java warp-chessboard
220 ![](images/homography_perspective_correction_chessboard_warp.jpg)
222 To compute the coordinates of the source corners transformed by the homography:
225 @snippet perspective_correction.cpp compute-transformed-corners
229 @snippet samples/python/tutorial_code/features2D/Homography/perspective_correction.py compute-transformed-corners
233 @snippet samples/java/tutorial_code/features2D/Homography/PerspectiveCorrection.java compute-transformed-corners
236 To check the correctness of the calculation, the matching lines are displayed:
238 ![](images/homography_perspective_correction_chessboard_matches.jpg)
240 ### Demo 3: Homography from the camera displacement {#tutorial_homography_Demo3}
242 The homography relates the transformation between two planes and it is possible to retrieve the corresponding camera displacement that allows to go from the first to the second plane view (see @cite Malis for more information).
243 Before going into the details that allow to compute the homography from the camera displacement, some recalls about camera pose and homogeneous transformation.
245 The function @ref cv::solvePnP allows to compute the camera pose from the correspondences 3D object points (points expressed in the object frame) and the projected 2D image points (object points viewed in the image).
246 The intrinsic parameters and the distortion coefficients are required (see the camera calibration process).
262 r_{11} & r_{12} & r_{13} & t_x \\
263 r_{21} & r_{22} & r_{23} & t_y \\
264 r_{31} & r_{32} & r_{33} & t_z
272 &= \boldsymbol{K} \hspace{0.2em} ^{c}\textrm{M}_o
282 \f$ \boldsymbol{K} \f$ is the intrinsic matrix and \f$ ^{c}\textrm{M}_o \f$ is the camera pose. The output of @ref cv::solvePnP is exactly this: `rvec` is the Rodrigues rotation vector and `tvec` the translation vector.
284 \f$ ^{c}\textrm{M}_o \f$ can be represented in a homogeneous form and allows to transform a point expressed in the object frame into the camera frame:
294 \hspace{0.2em} ^{c}\textrm{M}_o
303 ^{c}\textrm{R}_o & ^{c}\textrm{t}_o \\
314 r_{11} & r_{12} & r_{13} & t_x \\
315 r_{21} & r_{22} & r_{23} & t_y \\
316 r_{31} & r_{32} & r_{33} & t_z \\
328 Transform a point expressed in one frame to another frame can be easily done with matrix multiplication:
330 * \f$ ^{c_1}\textrm{M}_o \f$ is the camera pose for the camera 1
331 * \f$ ^{c_2}\textrm{M}_o \f$ is the camera pose for the camera 2
333 To transform a 3D point expressed in the camera 1 frame to the camera 2 frame:
336 ^{c_2}\textrm{M}_{c_1} = \hspace{0.2em} ^{c_2}\textrm{M}_{o} \cdot \hspace{0.1em} ^{o}\textrm{M}_{c_1} = \hspace{0.2em} ^{c_2}\textrm{M}_{o} \cdot \hspace{0.1em} \left( ^{c_1}\textrm{M}_{o} \right )^{-1} =
338 ^{c_2}\textrm{R}_{o} & ^{c_2}\textrm{t}_{o} \\
342 ^{c_1}\textrm{R}_{o}^T & - \hspace{0.2em} ^{c_1}\textrm{R}_{o}^T \cdot \hspace{0.2em} ^{c_1}\textrm{t}_{o} \\
347 In this example, we will compute the camera displacement between two camera poses with respect to the chessboard object. The first step consists to compute the camera poses for the two images:
349 @snippet homography_from_camera_displacement.cpp compute-poses
351 ![](images/homography_camera_displacement_poses.jpg)
353 The camera displacement can be computed from the camera poses using the formulas above:
355 @snippet homography_from_camera_displacement.cpp compute-c2Mc1
357 The homography related to a specific plane computed from the camera displacement is:
359 ![By Homography-transl.svg: Per Rosengren derivative work: Appoose (Homography-transl.svg) [CC BY 3.0 (http://creativecommons.org/licenses/by/3.0)], via Wikimedia Commons](images/homography_camera_displacement.png)
361 On this figure, `n` is the normal vector of the plane and `d` the distance between the camera frame and the plane along the plane normal.
362 The [equation](https://en.wikipedia.org/wiki/Homography_(computer_vision)#3D_plane_to_plane_equation) to compute the homography from the camera displacement is:
365 ^{2}\textrm{H}_{1} = \hspace{0.2em} ^{2}\textrm{R}_{1} - \hspace{0.1em} \frac{^{2}\textrm{t}_{1} \cdot n^T}{d}
368 Where \f$ ^{2}\textrm{H}_{1} \f$ is the homography matrix that maps the points in the first camera frame to the corresponding points in the second camera frame, \f$ ^{2}\textrm{R}_{1} = \hspace{0.2em} ^{c_2}\textrm{R}_{o} \cdot \hspace{0.1em} ^{c_1}\textrm{R}_{o}^{T} \f$
369 is the rotation matrix that represents the rotation between the two camera frames and \f$ ^{2}\textrm{t}_{1} = \hspace{0.2em} ^{c_2}\textrm{R}_{o} \cdot \left( - \hspace{0.1em} ^{c_1}\textrm{R}_{o}^{T} \cdot \hspace{0.1em} ^{c_1}\textrm{t}_{o} \right ) + \hspace{0.1em} ^{c_2}\textrm{t}_{o} \f$
370 the translation vector between the two camera frames.
372 Here the normal vector `n` is the plane normal expressed in the camera frame 1 and can be computed as the cross product of 2 vectors (using 3 non collinear points that lie on the plane) or in our case directly with:
374 @snippet homography_from_camera_displacement.cpp compute-plane-normal-at-camera-pose-1
376 The distance `d` can be computed as the dot product between the plane normal and a point on the plane or by computing the [plane equation](http://mathworld.wolfram.com/Plane.html) and using the D coefficient:
378 @snippet homography_from_camera_displacement.cpp compute-plane-distance-to-the-camera-frame-1
380 The projective homography matrix \f$ \textbf{G} \f$ can be computed from the Euclidean homography \f$ \textbf{H} \f$ using the intrinsic matrix \f$ \textbf{K} \f$ (see @cite Malis), here assuming the same camera between the two plane views:
383 \textbf{G} = \gamma \textbf{K} \textbf{H} \textbf{K}^{-1}
386 @snippet homography_from_camera_displacement.cpp compute-homography
388 In our case, the Z-axis of the chessboard goes inside the object whereas in the homography figure it goes outside. This is just a matter of sign:
391 ^{2}\textrm{H}_{1} = \hspace{0.2em} ^{2}\textrm{R}_{1} + \hspace{0.1em} \frac{^{2}\textrm{t}_{1} \cdot n^T}{d}
394 @snippet homography_from_camera_displacement.cpp compute-homography-from-camera-displacement
396 We will now compare the projective homography computed from the camera displacement with the one estimated with @ref cv::findHomography
400 [0.32903393332201, -1.244138808862929, 536.4769088231476;
401 0.6969763913334046, -0.08935909072571542, -80.34068504082403;
402 0.00040511729592961, -0.001079740100565013, 0.9999999999999999]
404 homography from camera displacement:
405 [0.4160569997384721, -1.306889006892538, 553.7055461075881;
406 0.7917584252773352, -0.06341244158456338, -108.2770029401219;
407 0.0005926357240956578, -0.001020651672127799, 1]
411 The homography matrices are similar. If we compare the image 1 warped using both homography matrices:
413 ![Left: image warped using the homography estimated. Right: using the homography computed from the camera displacement](images/homography_camera_displacement_compare.jpg)
415 Visually, it is hard to distinguish a difference between the result image from the homography computed from the camera displacement and the one estimated with @ref cv::findHomography function.
417 ### Demo 4: Decompose the homography matrix {#tutorial_homography_Demo4}
419 OpenCV 3 contains the function @ref cv::decomposeHomographyMat which allows to decompose the homography matrix to a set of rotations, translations and plane normals.
420 First we will decompose the homography matrix computed from the camera displacement:
422 @snippet decompose_homography.cpp compute-homography-from-camera-displacement
424 The results of @ref cv::decomposeHomographyMat are:
426 @snippet decompose_homography.cpp decompose-homography-from-camera-displacement
430 rvec from homography decomposition: [-0.0919829920641369, -0.5372581036567992, 1.310868863540717]
431 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
432 tvec from homography decomposition: [-0.7747961019053186, -0.02751124463434032, -0.6791980037590677] and scaled by d: [-0.1578091561210742, -0.005603443652993778, -0.1383378976078466]
433 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
434 plane normal from homography decomposition: [-0.1973513139420648, 0.6283451996579074, -0.7524857267431757]
435 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
438 rvec from homography decomposition: [-0.0919829920641369, -0.5372581036567992, 1.310868863540717]
439 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
440 tvec from homography decomposition: [0.7747961019053186, 0.02751124463434032, 0.6791980037590677] and scaled by d: [0.1578091561210742, 0.005603443652993778, 0.1383378976078466]
441 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
442 plane normal from homography decomposition: [0.1973513139420648, -0.6283451996579074, 0.7524857267431757]
443 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
446 rvec from homography decomposition: [0.1053487907109967, -0.1561929144786397, 1.401356552358475]
447 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
448 tvec from homography decomposition: [-0.4666552552894618, 0.1050032934770042, -0.913007654671646] and scaled by d: [-0.0950475510338766, 0.02138689274867372, -0.1859598508065552]
449 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
450 plane normal from homography decomposition: [-0.3131715472900788, 0.8421206145721947, -0.4390403768225507]
451 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
454 rvec from homography decomposition: [0.1053487907109967, -0.1561929144786397, 1.401356552358475]
455 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
456 tvec from homography decomposition: [0.4666552552894618, -0.1050032934770042, 0.913007654671646] and scaled by d: [0.0950475510338766, -0.02138689274867372, 0.1859598508065552]
457 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
458 plane normal from homography decomposition: [0.3131715472900788, -0.8421206145721947, 0.4390403768225507]
459 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
462 The result of the decomposition of the homography matrix can only be recovered up to a scale factor that corresponds in fact to the distance `d` as the normal is unit length.
463 As you can see, there is one solution that matches almost perfectly with the computed camera displacement. As stated in the documentation:
466 At least two of the solutions may further be invalidated if point correspondences are available by applying positive depth constraint (all points must be in front of the camera).
469 As the result of the decomposition is a camera displacement, if we have the initial camera pose \f$ ^{c_1}\textrm{M}_{o} \f$, we can compute the current camera pose
470 \f$ ^{c_2}\textrm{M}_{o} = \hspace{0.2em} ^{c_2}\textrm{M}_{c_1} \cdot \hspace{0.1em} ^{c_1}\textrm{M}_{o} \f$ and test if the 3D object points that belong to the plane are projected in front of the camera or not.
471 Another solution could be to retain the solution with the closest normal if we know the plane normal expressed at the camera 1 pose.
473 The same thing but with the homography matrix estimated with @ref cv::findHomography
477 rvec from homography decomposition: [0.1552207729599141, -0.152132696119647, 1.323678695078694]
478 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
479 tvec from homography decomposition: [-0.4482361704818117, 0.02485247635491922, -1.034409687207331] and scaled by d: [-0.09129598307571339, 0.005061910238634657, -0.2106868109173855]
480 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
481 plane normal from homography decomposition: [-0.1384902722707529, 0.9063331452766947, -0.3992250922214516]
482 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
485 rvec from homography decomposition: [0.1552207729599141, -0.152132696119647, 1.323678695078694]
486 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
487 tvec from homography decomposition: [0.4482361704818117, -0.02485247635491922, 1.034409687207331] and scaled by d: [0.09129598307571339, -0.005061910238634657, 0.2106868109173855]
488 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
489 plane normal from homography decomposition: [0.1384902722707529, -0.9063331452766947, 0.3992250922214516]
490 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
493 rvec from homography decomposition: [-0.2886605671759886, -0.521049903923871, 1.381242030882511]
494 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
495 tvec from homography decomposition: [-0.8705961357284295, 0.1353018038908477, -0.7037702049789747] and scaled by d: [-0.177321544550518, 0.02755804196893467, -0.1433427218822783]
496 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
497 plane normal from homography decomposition: [-0.2284582117722427, 0.6009247303964522, -0.7659610393954643]
498 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
501 rvec from homography decomposition: [-0.2886605671759886, -0.521049903923871, 1.381242030882511]
502 rvec from camera displacement: [-0.09198299206413783, -0.5372581036567995, 1.310868863540717]
503 tvec from homography decomposition: [0.8705961357284295, -0.1353018038908477, 0.7037702049789747] and scaled by d: [0.177321544550518, -0.02755804196893467, 0.1433427218822783]
504 tvec from camera displacement: [0.1578091561210745, 0.005603443652993617, 0.1383378976078466]
505 plane normal from homography decomposition: [0.2284582117722427, -0.6009247303964522, 0.7659610393954643]
506 plane normal at camera 1 pose: [0.1973513139420654, -0.6283451996579068, 0.752485726743176]
509 Again, there is also a solution that matches with the computed camera displacement.
511 ### Demo 5: Basic panorama stitching from a rotating camera {#tutorial_homography_Demo5}
513 \note This example is made to illustrate the concept of image stitching based on a pure rotational motion of the camera and should not be used to stitch panorama images.
514 The [stitching module](@ref stitching) provides a complete pipeline to stitch images.
516 The homography transformation applies only for planar structure. But in the case of a rotating camera (pure rotation around the camera axis of projection, no translation), an arbitrary world can be considered
517 ([see previously](@ref tutorial_homography_What_is_the_homography_matrix)).
519 The homography can then be computed using the rotation transformation and the camera intrinsic parameters as (see for instance \ref homography_course "8"):
528 \bf{K} \hspace{0.1em} \bf{R} \hspace{0.1em} \bf{K}^{-1}
536 To illustrate, we used Blender, a free and open-source 3D computer graphics software, to generate two camera views with only a rotation transformation between each other.
537 More information about how to retrieve the camera intrinsic parameters and the `3x4` extrinsic matrix with respect to the world can be found in \ref answer_blender "9" (an additional transformation
538 is needed to get the transformation between the camera and the object frames) with Blender.
540 The figure below shows the two generated views of the Suzanne model, with only a rotation transformation:
542 ![](images/homography_stitch_compare.jpg)
544 With the known associated camera poses and the intrinsic parameters, the relative rotation between the two views can be computed:
547 @snippet panorama_stitching_rotating_camera.cpp extract-rotation
551 @snippet samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py extract-rotation
555 @snippet samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java extract-rotation
559 @snippet panorama_stitching_rotating_camera.cpp compute-rotation-displacement
563 @snippet samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py compute-rotation-displacement
567 @snippet samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java compute-rotation-displacement
570 Here, the second image will be stitched with respect to the first image. The homography can be calculated using the formula above:
573 @snippet panorama_stitching_rotating_camera.cpp compute-homography
577 @snippet samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py compute-homography
581 @snippet samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java compute-homography
584 The stitching is made simply with:
587 @snippet panorama_stitching_rotating_camera.cpp stitch
591 @snippet samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py stitch
595 @snippet samples/java/tutorial_code/features2D/Homography/PanoramaStitchingRotatingCamera.java stitch
598 The resulting image is:
600 ![](images/homography_stitch_Suzanne.jpg)
602 Additional references {#tutorial_homography_Additional_references}
603 ---------------------
605 * \anchor lecture_16 1. [Lecture 16: Planar Homographies](http://www.cse.psu.edu/~rtc12/CSE486/lecture16.pdf), Robert Collins
606 * \anchor projective_transformations 2. [2D projective transformations (homographies)](https://ags.cs.uni-kl.de/fileadmin/inf_ags/3dcv-ws11-12/3DCV_WS11-12_lec04.pdf), Christiano Gava, Gabriele Bleser
607 * \anchor szeliski 3. [Computer Vision: Algorithms and Applications](http://szeliski.org/Book/drafts/SzeliskiBook_20100903_draft.pdf), Richard Szeliski
608 * \anchor answer_dsp 4. [Step by Step Camera Pose Estimation for Visual Tracking and Planar Markers](https://dsp.stackexchange.com/a/2737)
609 * \anchor pose_ar 5. [Pose from homography estimation](https://team.inria.fr/lagadic/camera_localization/tutorial-pose-dlt-planar-opencv.html)
610 * \anchor polar_decomposition 6. [Polar Decomposition (in Continuum Mechanics)](http://www.continuummechanics.org/polardecomposition.html)
611 * \anchor polar_decomposition_svd 7. [A Personal Interview with the Singular Value Decomposition](https://web.stanford.edu/~gavish/documents/SVD_ans_you.pdf), Matan Gavish
612 * \anchor homography_course 8. [Homography](http://people.scs.carleton.ca/~c_shu/Courses/comp4900d/notes/homography.pdf), Dr. Gerhard Roth
613 * \anchor answer_blender 9. [3x4 camera matrix from blender camera](https://blender.stackexchange.com/a/38210)