PARP Research Group University of Murcia


Projective Geometry
[Math extensions]

Functions related to Projective Geometry. More...

Functions

QVMatrix ComputeProjectiveHomography (const QList< QPointFMatching > &matchings)
 Obtains a planar homography from a list of point correspondences.
QVMatrix ComputeAffineHomography (const QList< QPointFMatching > &matchings)
 Obtains an affine homography from a list of point correspondences.
QVMatrix ComputeEuclideanHomography (const QList< QPointFMatching > &matchings)
 Obtain an euclidean mapping for a set of inter-image point matchings.
QVMatrix cvFindFundamentalMat (const QList< QPointFMatching > &matchings)
 Obtains the fundamental matrix between two images, using the 8 point algorithm.
QPointF ApplyHomography (const QVMatrix &homography, const QPointF &point)
 Maps a point using an homography.
QList< QPointF > ApplyHomography (const QVMatrix &homography, const QList< QPointF > &sourcePoints)
 Maps a set of points using an homography.
QVImage< uChar, 1 > ApplyHomography (const QVMatrix &homography, const QVImage< uChar, 1 > &image, const int interpolation=IPPI_INTER_CUBIC)
 Performs an homography distortion on an image.
QVImage< uChar, 3 > ApplyHomography (const QVMatrix &homography, const QVImage< uChar, 3 > &image, const int interpolation=IPPI_INTER_CUBIC)
 Performs an homography distortion on an image.
double HomographyTestError (const QVMatrix &homography)
 Function to test if a 3x3 matrix corresponds to an homography.
void GetExtrinsicCameraMatrixFromHomography (const QVMatrix &K, const QVMatrix &H, QVMatrix &M4x4)
void GetDirectIntrinsicCameraMatrixFromHomography (const QVMatrix &H, QVMatrix &K)
 Diagonal intrinsic camera matrix calibration.
void CalibrateCameraFromPlanarHomography (const QVMatrix &H, QVMatrix &K, QVMatrix &Rt)
 Diagonal intrinsic camera matrix calibration.
void GetPinholeCameraIntrinsicsFromPlanarHomography (const QVMatrix &H, QVMatrix &K, const int iterations=100, const double maxGradientNorm=1e-3, const double step=0.01, const double tol=1e-4)
 Obtains the intrinsic camera matrix from a planar homography.
QList< QVMatrixgetCanonicalCameraMatricesFromEssentialMatrix (const QVMatrix &E)
 Obtains the canonical matrices corresponding to an essential matrix.
QVMatrix getEssentialMatrixFromCanonicalCameraMatrix (const QVMatrix &P)
 Obtains the essential matrix corresponding to a canonical camera matrix.
QVMatrix getCameraMatrixFrom2D3DPointCorrespondences (const QList< QPointF > &points2d, const QList< QV3DPointF > &points3d)
 Obtains the canonical camera matrix corresponding to a set of 3D point to image point matchings.
QVMatrix refineExtrinsicCameraMatrixWithQRDecomposition (const QVMatrix &P)
 Eliminates errors in the rotation component of a canonical camera matrix using a QR decomposition.
QVMatrix refineExtrinsicCameraMatrixWithPolarDecomposition (const QVMatrix &P)
 Eliminates errors in the rotation component of a canonical camera matrix using a Polar decomposition.
QV3DPointF triangulate3DPointFromNViews (const QList< QPointF > &points, const QList< QVMatrix > &Plist)
 Recovers the location of a 3D point from its projection on several images and their corresponding canonical camera matrices.
QV3DPointF triangulate3DPointFrom2Views (const QPointF &point1, const QVMatrix &P1, const QPointF &point2, const QVMatrix &P2)
 Recovers the location of a 3D point from its projection on two images and their corresponding canonical camera matrices.

Detailed Description

Functions related to Projective Geometry.

Projective Geometry is based on the principles of perspective. It models the relationships between image points $ \mathbf{x} $ and their corresponding points $ \mathbf{X} $ in the 3D world. It is the most fundamental theoretical tool for 3D reconstruction, and augmented reality applications.

This module uses the concept of projection camera matrices. A projection camera matrix $ \mathbf{P}_{3 \times 4} $ models the linear relationship between the location 3D points and their corresponding pixels in a certain image. The projection camera matrix contains thus information about the intrinsic camera parameters, and the location and orientation of the camera, in the 3D space.

Using homogeneous notation (where $ \mathbf{X}_{4 \times 1} = (x,y,z,1) $ is a 3D point, and $ \mathbf{x}_{3 \times 1} = (column, row, 1) $ is its corresponding projection location in the image) the following equation holds:

$ \mathbf{x} \propto \mathbf{P} \mathbf{X} $

Matrix $ \mathbf{P} $ is decomposed in the intrinsic ($ \mathbf{K}_{3 \times 3} $) and the extrinsic ($ \left[ \begin{array}{c|c} \mathbf{R}_{3 \times 3} & \mathbf{t}_{3 \times 1} \end{array} \right] $) camera matrices, with the following expression:

$ \mathbf{P} = \mathbf{K} \left[ \begin{array}{c|c} \mathbf{R} & \mathbf{t} \end{array} \right] $

Another convention used in this module is the canonical camera matrix. It is equivalent to the extrinsic matrix of a camera matrix:

$ \mathbf{C}_N = \left[ \begin{array}{c|c} \mathbf{R} & \mathbf{t} \end{array} \right] $

3D reconstruction from 2 views

From fundamental and essential matrices. The fundamental matrix relates the locations of corresponding points at two different images:

$ \mathbf{x} F \mathbf{x}' = 0 $

The essential matrix relates the normalized locations of corresponding points at two different images:

$ \mathbf{\hat{x}} E \mathbf{\hat{x}}' = 0 $

These normalized locations are obtained eliminating the deformations induced by the intrinsic camera parameters in the coordinates of the pixels.

Camera location from a set of correspondences between 3D points and image pixels

The planar homography matrix

An homography matrix corresponds to a planar homography mapping between corresponding planar points appearing in two images.

Function Documentation

QVImage<uChar, 3> ApplyHomography ( const QVMatrix homography,
const QVImage< uChar, 3 > &  image,
const int  interpolation = IPPI_INTER_CUBIC 
)

Performs an homography distortion on an image.

The homography is represented as a $ H_{3 \times 3} $ matrix. These matrices can be obtained using methods like ComputeEuclideanHomography, ComputeProjectiveHomography, or ComputeAffineHomography.

This function takes a three channel image, and an homography matrix as inputs. Each point $ (x, y) $ in the input image is mapped to its location in the resulting image $ (x', y') $ using the homography $ H $ as follows:

$ \left(\begin{array}{c} x' \\ y' \\ 1 \end{array}\right) \propto H \left(\begin{array}{c} x \\ y \\ 1 \end{array}\right) $

See also:
ComputeEuclideanHomography

ComputeAffineHomography

ComputeProjectiveHomography

Parameters:
homography The homography transformation matrix
image The input image to distort
interpolation Type of interpolation. Possible values for this parameter are:
  • IPPI_INTER_NN. Nearest neighbor interpolation
  • IPPI_INTER_LINEAR. Linear interpolation
  • IPPI_INTER_CUBIC. Cubic interpolation
Note:
This function is based on functionallity from the Intel IPP library. Thus compatibility with that library must be enabled to be available.

Definition at line 397 of file qvprojective.cpp.

QVImage<uChar, 1> ApplyHomography ( const QVMatrix homography,
const QVImage< uChar, 1 > &  image,
const int  interpolation = IPPI_INTER_CUBIC 
)

Performs an homography distortion on an image.

The homography is represented as a $ H_{3 \times 3} $ matrix. These matrices can be obtained using methods like ComputeEuclideanHomography, ComputeProjectiveHomography, or ComputeAffineHomography.

This function takes a single channel image, and an homography matrix as inputs. Each point $ (x, y) $ in the input image is mapped to its location in the resulting image $ (x', y') $ using the homography $ H $ as follows:

$ \left(\begin{array}{c} x' \\ y' \\ 1 \end{array}\right) \propto H \left(\begin{array}{c} x \\ y \\ 1 \end{array}\right) $

See also:
ComputeEuclideanHomography

ComputeAffineHomography

ComputeProjectiveHomography

Parameters:
homography The homography transformation matrix
image The input image to distort
interpolation Type of interpolation. Possible values for this parameter are:
  • IPPI_INTER_NN. Nearest neighbor interpolation
  • IPPI_INTER_LINEAR. Linear interpolation
  • IPPI_INTER_CUBIC. Cubic interpolation
Note:
This function is based on functionallity from the Intel IPP library. Thus compatibility with that library must be enabled to be available.

Definition at line 390 of file qvprojective.cpp.

QList<QPointF> ApplyHomography ( const QVMatrix homography,
const QList< QPointF > &  sourcePoints 
)

Maps a set of points using an homography.

This is an overloaded version of the ApplyHomography(const QVMatrix &, const QPointF &) function provided by convenience. This funcion takes a list of points from the 2D plane, and an homography matrix as inputs. The output will be a list of points obtained by mapping the points from the input list, using the homography.

See also:
ApplyHomography(const QVMatrix &, const QPointF &)

ComputeEuclideanHomography

ComputeAffineHomography

ComputeProjectiveHomography

Parameters:
homography The homography transformation matrix
sourcePoints Points to apply the homography transformation

Definition at line 382 of file qvprojective.cpp.

QPointF ApplyHomography ( const QVMatrix homography,
const QPointF &  point 
)

Maps a point using an homography.

This function maps a point $ (x, y) $ in the 2D plane, using a planar homography. The homography is represented as a $ H_{3 \times 3} $ matrix. These matrices can be obtained using methods like ComputeEuclideanHomography, ComputeProjectiveHomography, or ComputeAffineHomography from a set of point correspondences between the original 2D plane, and the mapped plane.

The output of the function is a point $ (x', y') $ which holds the following equation:

$ \left(\begin{array}{c} x' \\ y' \\ 1 \end{array}\right) \propto H \left(\begin{array}{c} x \\ y \\ 1 \end{array}\right) $

See also:
ComputeEuclideanHomography

ComputeAffineHomography

ComputeProjectiveHomography

Parameters:
homography The homography transformation matrix
point Point to apply the homography transformation

Definition at line 371 of file qvprojective.cpp.

Referenced by ApplyHomography().

void CalibrateCameraFromPlanarHomography ( const QVMatrix H,
QVMatrix K,
QVMatrix Rt 
)

Diagonal intrinsic camera matrix calibration.

This function obtains a diagonal intrinsic camera matrix, consisting on the focal distance only. This matrix is such that

$ H = K \left[ R | t\right] $

Where $ R $ is a rotation matrix. This matrix is obtained with a minimization process, so its result is more precise than that obtained with GetDirectIntrinsicCameraMatrixFromHomography function.

See also:
GetDirectIntrinsicCameraMatrixFromHomography
Todo:
write documentation for this function

Definition at line 443 of file qvprojective.cpp.

QVMatrix ComputeAffineHomography ( const QList< QPointFMatching > &  matchings  ) 

Obtains an affine homography from a list of point correspondences.

This function obtains the homography matrix $ M $ which most closely maps the source points to their destination, in the input point matching list. This homography matrix will represent an affine transformation.

The function returns the matrix corresponding to the planar homography, from a list of three or more point correspondences between the location of those points at the source plane and their location in the destination plane.

Usage:

QList< QPair<QPointF, QPointF> > matchings;
matchings.append(QPair<QPointF, QPointF>(QPointF(-171,109),     QPointF(-100,+100)));
matchings.append(QPair<QPointF, QPointF>(QPointF(-120,31),      QPointF(-100,-100)));
matchings.append(QPair<QPointF, QPointF>(QPointF(117,53),       QPointF(+100,-100)));

const QVMatrix M = ComputeAffineHomography(matchings);

Any point $ p $ from the 2D plane can be mapped to another point in the plane $ q $ with an affine matrix $ M $ using the following C++ code:

Or by using the ApplyHomography functions.

See also:
ApplyHomography(const QVMatrix &, const QPointF &)

ApplyHomography(const QVMatrix &, const QList<QPointF> &)

Parameters:
matchings list of point matchings from the original location, to the destination location.

Definition at line 153 of file qvprojective.cpp.

QVMatrix ComputeEuclideanHomography ( const QList< QPointFMatching > &  matchings  ) 

Obtain an euclidean mapping for a set of inter-image point matchings.

This function obtains an euclidean mapping between the source an destination locations of a set of point matchings. The mapping is returned as a $ 3 \times 3 $ matrix which can be multiplied to the source location of each mapping point in homogeneous coordinates, obtaining a location close to the destination location from the matching.

Todo:
write documentation for this function

Definition at line 201 of file qvprojective.cpp.

QVMatrix ComputeProjectiveHomography ( const QList< QPointFMatching > &  matchings  ) 

Obtains a planar homography from a list of point correspondences.

This function obtains the homography matrix $ A $ which most closely maps the source points to their corresponding destination, in the input point matching list. This homography matrix will represent a projective transformation.

The function returns the matrix corresponding to the planar homography, from a list of four or more point correspondences between the location of those points at the source plane and their location in the destination plane.

Projective homography matrices can be used to obtain a frontal view of any planar figure appearing in an image. The following code and images shows this effect:

rectification_homography.png

Image on the left is the original picture obtained with a pin-hole camera. Image on the right was obtained aplying a rectification homography to the pixels in the original image. This rectification homography is obtained using the function ComputeProjectiveHomography with the four point correspondences between the points in the images featured with yellow dots:

QList< QPair<QPointF, QPointF> > matchings;
matchings.append(QPair<QPointF, QPointF>(QPointF(-171,109),     QPointF(-100,+100)));
matchings.append(QPair<QPointF, QPointF>(QPointF(-120,31),      QPointF(-100,-100)));
matchings.append(QPair<QPointF, QPointF>(QPointF(117,53),       QPointF(+100,-100)));
matchings.append(QPair<QPointF, QPointF>(QPointF(11,115),       QPointF(+100,+100)));

const QVMatrix H = ComputeProjectiveHomography(matchings);

The obtained matrix $ H $ holds the following equation:

$ H \propto \left( \begin{array}{ccc} 0.63868 & 0.77290 & -39.73059 \\ -0.11082 & 1.94177 & -165.90578 \\ -0.00034 & -0.00378 & 1 \\ \end{array} \right)$

Also for each point matching $ p \mapsto p' $ contained in the matchings list, the following equation holds.

$ p' \propto H p $

or

$ p' \times H p = 0 $

In C++ source code:

QPair<QPointF, QPointF> matching;
foreach(matching, matchings)
        {
        const QVVector  p_0 = QVVector::homogeneousCoordinates(matching.first),
                        p_1 = QVVector::homogeneousCoordinates(matching.second);
        std::cout << "p1 x H p0 =" << (p_1 ^ H*p_0) << std::endl;
        }

The printed values are close to 0.

Any point $ p $ from the 2D plane can be mapped to another point in the plane $ q $ with an homography matrix $ H $ using the following C++ code:

Or by using the ApplyHomography functions.

See also:
ApplyHomography(const QVMatrix &, const QPointF &)

ApplyHomography(const QVMatrix &, const QList<QPointF> &)

Parameters:
matchings list of point matchings from the original location, to the destination location.

Definition at line 93 of file qvprojective.cpp.

QVMatrix cvFindFundamentalMat ( const QList< QPointFMatching > &  matchings  ) 

Obtains the fundamental matrix between two images, using the 8 point algorithm.

This function performs point normalization to robustly obtain the F matrix.

Note:
This function is based on functionallity from the OpenCV library. Thus compatibility with that library must be enabled to be available.
Parameters:
matchings list of 8 point matchings

Definition at line 264 of file qvprojective.cpp.

Referenced by cvFindFundamentalMat().

QVMatrix getCameraMatrixFrom2D3DPointCorrespondences ( const QList< QPointF > &  points2d,
const QList< QV3DPointF > &  points3d 
)

Obtains the canonical camera matrix corresponding to a set of 3D point to image point matchings.

The following formula models the relation between a set of points from the 3D world $ \{ X_i \}_{i=1..n} $ and their projections $ \{ x_i \}_{i=1..n} $ at an image:

$ x_i \propto P X_i $

This function uses a DLT to obtain the camera matrix $ P $ from a given set of 3D points and their corresponding image points.

Parameters:
points2d List containing the points from the image.
points3d List containing the 3D points.
Returns:
The canonical camera matrix.

Definition at line 557 of file qvprojective.cpp.

QList<QVMatrix> getCanonicalCameraMatricesFromEssentialMatrix ( const QVMatrix E  ) 

Obtains the canonical matrices corresponding to an essential matrix.

See section 9.6.2 from Multiple View Geometry in Computer Vision.

Parameters:
E The input essential matrix.
Returns:
A list containing the two possible canonocal camera matrices

Definition at line 534 of file qvprojective.cpp.

void GetDirectIntrinsicCameraMatrixFromHomography ( const QVMatrix H,
QVMatrix K 
)

Diagonal intrinsic camera matrix calibration.

This function obtains a diagonal intrinsic camera matrix, consisting on the focal distance only. This matrix is such that

$ H = K \left[ R | t\right] $

Where $ R $ is a rotation matrix. This function returns a direct approximation for the $ K $ matrix.

Todo:
rename to GetDirectCameraIntrinsicsFromPlanarHomography
See also:
GetIntrinsicCameraMatrixFromHomography

Definition at line 427 of file qvprojective.cpp.

Referenced by CalibrateCameraFromPlanarHomography().

QVMatrix getEssentialMatrixFromCanonicalCameraMatrix ( const QVMatrix P  ) 

Obtains the essential matrix corresponding to a canonical camera matrix.

This method estimates the essential matrix of a two view scenario, provided the second camera matrix $ P_2 $, considering the first camera matrix as the identity: $ P_1 = \left[ I | 0 \right] $ See section 9.6.1 from Multiple View Geometry in Computer Vision.

Parameters:
P The input canonical matrix.
Returns:
The essential matrix corresponding to P.

Definition at line 552 of file qvprojective.cpp.

void GetExtrinsicCameraMatrixFromHomography ( const QVMatrix K,
const QVMatrix H,
QVMatrix M4x4 
)

Todo:
write documentation for this function

Definition at line 480 of file qvprojective.cpp.

void GetPinholeCameraIntrinsicsFromPlanarHomography ( const QVMatrix H,
QVMatrix K,
const int  iterations = 100,
const double  maxGradientNorm = 1e-3,
const double  step = 0.01,
const double  tol = 1e-4 
)

Obtains the intrinsic camera matrix from a planar homography.

This functions obtains the intrinsic calibration matrix $ K $ corresponding to a simple pinhole camera model. The intrinsic camera matrix has only one free parameter, related to the focal distance of the camera:

$ K = \left(\begin{array}{ccc} f & 0 & 0 \\ 0 & f & 0 \\ 0 & 0 & 1 \\ \end{array}\right) $

This function should receive a planar homography corresponding to the mapping of a set of know template points, to an image frame captured with the camera containing a view of that template.

The following is an example of a full intrinsic camera calibration, knowing a set of point matchings between the template image and the input image read from the camera:

[...]
QList< QPointFMatching > matchings;
matchings.append(QPointFMatching(QPointF(-171,109),     QPointF(-100,+100)));
matchings.append(QPointFMatching(QPointF(-120,31),      QPointF(-100,-100)));
matchings.append(QPointFMatching(QPointF(117,53),       QPointF(+100,-100)));
matchings.append(QPointFMatching(QPointF(11,115),       QPointF(+100,+100)));

QVMatrix H, K;
H = ComputeProjectiveHomography(matchings);
GetPinholeCameraIntrinsicsFromPlanarHomography(H, K);
[...]

For further understanding of the planar homography calibration process, see ComputeProjectiveHomography function documentation.

Parameters:
H Input planar homography.
K Matrix to store the intrinsic camera matrix
iterations Cumber of iterations to perform camera calibration
maxGradientNorm Minimal value of the gradient size (norm 2) to stop the minimization when reached.
step Corresponds to parameter step for the gsl_multimin_fdfminimizer_set function.
tol Corresponds to parameter tol for the gsl_multimin_fdfminimizer_set function.
Returns:
a value close to 1 when the matrix doesn't corresponds to an homography, and close to 0 when it is close to be an homography.
See also:
ComputeProjectiveHomography

Definition at line 500 of file qvprojective.cpp.

double HomographyTestError ( const QVMatrix homography  ) 

Function to test if a 3x3 matrix corresponds to an homography.

Every matrix which holds a perspective deformation from one plane to another should validate some constrains. The most important is that its two first columns should be perpendicular, and with a similar size, because for the matrix to correspond to an homography, they should be contained in a base of a rotated coordinate system. Given the following homography matrix:

$ H = \left[ R_1 R_2 -CR^t \right] $

The error value returned by this function for it will be:

$ error = \left| \frac{ \|R_1\| - \|R_2\| }{ \|R_1\| + \|R_2\| } \right| + \left| \frac{ R_1 \cdot R_2}{ \|R_1\| \|R_2\| } \right| $

That error is a measure of the difference of sizes between the norm of the two column vectors of the homography, corresponding to the two first columns of the rotation matrix, and their dot product. When both values are close to zero, the matrix corresponds to an homography, and it won't otherwise.

A good method to prove that a matrix corresponds to an homography using this function, can be done testing the return value with a threshold of aproximately 0.3. If the return value of this function for a matrix is lower than this threshold, that matrix is likely to correspond to an homography, and is not likely to correspond otherwise.

Parameters:
homography a possible homography matrix.
Returns:
a value close to 1 when the matrix doesn't corresponds to an homography, and close to 0 when it is close to be an homography.

Definition at line 405 of file qvprojective.cpp.

QVMatrix refineExtrinsicCameraMatrixWithPolarDecomposition ( const QVMatrix P  ) 

Eliminates errors in the rotation component of a canonical camera matrix using a Polar decomposition.

Given a matrix P* = [R*|t*] which approximates a canonical camera matrix, this function obtains the closest valid canonical matrix $ P = [R|t]$. The rotation matrix of this valid canonical matrix must be an orthogonal matrix. Thus it must fullfill:

$ R^T R = I $

This function uses a correcting square 3x3 matrix E-1 that satisfies the following equation:

$ E^-1 P* = P (1) $

This matrix E-1 also satisfies that the matrix R is the rotation matrix closest to R* in a certain sense. Using the polar decomposition of R*, the function obtains the E which corrects it to the closest valid rotation matrix R regarding the Frobenius norm $ ||R-R*||_F $.

The polar decomposition of the transpose of matrix R* is the following:

$ R* = D^T U^T $

Where U is a rotation matrix and D is a positive-semidefinite Hermitian matrix. The matrix DT is used as the matrix E.

See also:
QVMatrix refineExtrinsicCameraMatrixWithQRDecomposition(const QVMatrix &)

Definition at line 637 of file qvprojective.cpp.

Referenced by QVEuclideanMapping3::QVEuclideanMapping3().

QVMatrix refineExtrinsicCameraMatrixWithQRDecomposition ( const QVMatrix P  ) 

Eliminates errors in the rotation component of a canonical camera matrix using a QR decomposition.

Function refineExtrinsicCameraMatrixWithPolarDecomposition(const QVMatrix &) obtains a valid canonical camera matrix P = [R|t] from a given initial approximation P* = [R*|t*], using the Polar decomposition.

This function obtains a computationally more efficient approximation of the P matrix using a QR decomposition. The rotation matrix R of the resulting P is not the closest rotation matrix to the initial R* regarding the Frobenius norm $ ||R-R*||_F $.

Despite of that, this function can be used when a faster and slightly less accurate version of the best P is wanted.

Definition at line 621 of file qvprojective.cpp.

QV3DPointF triangulate3DPointFrom2Views ( const QPointF &  point1,
const QVMatrix P1,
const QPointF &  point2,
const QVMatrix P2 
)

Recovers the location of a 3D point from its projection on two images and their corresponding canonical camera matrices.

Given the projection formula:

$ x \propto P X $

The location of the 3D point $ X $ can be triangulated with its projection on two images.

This function triangulates the location of a 3D point $ X $ from the locations of two image projections $ x_1 $, $ x_2 $ and the corresponding canonical camera matrices for these images $ P_1 $, $ P_2 $.

The method used is described at section 12.2 from Multiple View Geometry in Computer Vision.

Parameters:
point1 The projected location of the 3D point in the first image.
P1 The camera matrix for the first image.
point2 The projected location of the 3D point in the second image.
P2 The camera matrix for the second image.
Returns:
The triangulated location for the point.

Definition at line 664 of file qvprojective.cpp.

QV3DPointF triangulate3DPointFromNViews ( const QList< QPointF > &  points,
const QList< QVMatrix > &  Plist 
)

Recovers the location of a 3D point from its projection on several images and their corresponding canonical camera matrices.

Given the projection formula:

$ x \propto P X $

The location of the 3D point $ X $ can be triangulated with its projection on two or more images.

This function triangulates the location of a 3D point $ X $ from the locations of two or more image projections $ \{ x_i \}_{i=1..n} $ and the corresponding canonical camera matrices for these images $ \{ P_i \}_{i=1..n} $.

The method used is described at section 12.2 from Multiple View Geometry in Computer Vision.

Parameters:
points List containing the points from the image.
Plist List containing the canonical camera matrices.
Returns:
The triangulated location for the point.

Definition at line 685 of file qvprojective.cpp.




QVision framework. PARP research group. Copyright © 2007, 2008, 2009, 2010.