#include <vpHomography.h>

Inheritance diagram for vpHomography:

Public Member Functions
	vpHomography ()

	vpHomography (const vpHomography &H)

	vpHomography (const vpHomogeneousMatrix &aMb, const vpPlane &bP)

	vpHomography (const vpRotationMatrix &aRb, const vpTranslationVector &atb, const vpPlane &bP)

	vpHomography (const vpThetaUVector &tu, const vpTranslationVector &atb, const vpPlane &bP)

	vpHomography (const vpPoseVector &arb, const vpPlane &bP)

virtual	~vpHomography ()

void	buildFrom (const vpRotationMatrix &aRb, const vpTranslationVector &atb, const vpPlane &bP)

void	buildFrom (const vpThetaUVector &tu, const vpTranslationVector &atb, const vpPlane &bP)

void	buildFrom (const vpPoseVector &arb, const vpPlane &bP)

void	buildFrom (const vpHomogeneousMatrix &aMb, const vpPlane &bP)

vpHomography	collineation2homography (const vpCameraParameters &cam) const

vpMatrix	convert () const

void	computeDisplacement (vpRotationMatrix &aRb, vpTranslationVector &atb, vpColVector &n)

void	computeDisplacement (const vpColVector &nd, vpRotationMatrix &aRb, vpTranslationVector &atb, vpColVector &n)

double	det () const

void	eye ()

vpHomography	homography2collineation (const vpCameraParameters &cam) const

vpHomography	inverse (double sv_threshold=1e-16, unsigned int *rank=NULL) const

void	inverse (vpHomography &Hi) const

void	load (std::ifstream &f)

vpHomography	operator* (const vpHomography &H) const

vpHomography	operator* (const double &v) const

vpColVector	operator* (const vpColVector &b) const

vpPoint	operator* (const vpPoint &H) const

vpHomography	operator/ (const double &v) const

vpHomography &	operator/= (double v)

vpHomography &	operator= (const vpHomography &H)

vpHomography &	operator= (const vpMatrix &H)

vpImagePoint	projection (const vpImagePoint &p)

void	resize (unsigned int nrows, unsigned int ncols, bool flagNullify=true)

void	save (std::ofstream &f) const


void	setIdentity ()

Inherited functionalities from vpArray2D
unsigned int	getCols () const

double	getMaxValue () const

double	getMinValue () const

unsigned int	getRows () const

unsigned int	size () const

void	resize (unsigned int nrows, unsigned int ncols, bool flagNullify=true, bool recopy_=true)

void	reshape (unsigned int nrows, unsigned int ncols)

bool	operator== (const vpArray2D< double > &A) const

bool	operator!= (const vpArray2D< double > &A) const

double *	operator[] (unsigned int i)

double *	operator[] (unsigned int i) const

vpArray2D< double >	hadamard (const vpArray2D< double > &m) const

Static Public Member Functions
static void	DLT (const std::vector< double > &xb, const std::vector< double > &yb, const std::vector< double > &xa, const std::vector< double > &ya, vpHomography &aHb, bool normalization=true)

static void	HLM (const std::vector< double > &xb, const std::vector< double > &yb, const std::vector< double > &xa, const std::vector< double > &ya, bool isplanar, vpHomography &aHb)

static bool	ransac (const std::vector< double > &xb, const std::vector< double > &yb, const std::vector< double > &xa, const std::vector< double > &ya, vpHomography &aHb, std::vector< bool > &inliers, double &residual, unsigned int nbInliersConsensus, double threshold, bool normalization=true)

static vpImagePoint	project (const vpCameraParameters &cam, const vpHomography &bHa, const vpImagePoint &iPa)

static vpPoint	project (const vpHomography &bHa, const vpPoint &Pa)

static void	robust (const std::vector< double > &xb, const std::vector< double > &yb, const std::vector< double > &xa, const std::vector< double > &ya, vpHomography &aHb, std::vector< bool > &inlier, double &residual, double weights_threshold=0.4, unsigned int niter=4, bool normalization=true)

Inherited I/O from vpArray2D with Static Public Member Functions
static bool	load (const std::string &filename, vpArray2D< double > &A, bool binary=false, char *header=NULL)

static bool	loadYAML (const std::string &filename, vpArray2D< double > &A, char *header=NULL)

static bool	save (const std::string &filename, const vpArray2D< double > &A, bool binary=false, const char *header="")

static bool	saveYAML (const std::string &filename, const vpArray2D< double > &A, const char *header="")

Public Attributes
double *	data

Protected Attributes
unsigned int	rowNum

unsigned int	colNum

double **	rowPtrs

unsigned int	dsize

Related Functions
(Note that these are not member functions.)
enum	vpGEMMmethod

Detailed Description

Implementation of an homography and operations on homographies.

This class aims to compute the homography wrt. two images [31].

The vpHomography class is derived from vpArray2D<double>.

These two images are both described by a set of points. The 2 sets (one per image) are sets of corresponding points : for a point in a image, there is the corresponding point (image of the same 3D point) in the other image points set. These 2 sets are the only data needed to compute the homography. One method used is the one introduced by Ezio Malis during his PhD [26]. A normalization is carried out on this points in order to improve the conditioning of the problem, what leads to improve the stability of the result.

Store and compute the homography such that

$^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$

with

$^a{\bf H}_b = ^a{\bf R}_b + \frac{^a{\bf t}_b}{^bd} { ^b{\bf n}^T}$

The Tutorial: Homography estimation from points explains how to use this class.

The example below shows also how to manipulate this class to first compute a ground truth homography from camera poses, project pixel coordinates points using an homography and lastly estimate an homography from a subset of 4 matched points in frame a and frame b respectively.

#include <visp3/core/vpHomogeneousMatrix.h>
#include <visp3/core/vpMath.h>
#include <visp3/core/vpMeterPixelConversion.h>
#include <visp3/vision/vpHomography.h>
int main()
{
  // Initialize in the object frame the coordinates in meters of 4 points that
  // belong to a planar object
  vpPoint Po[4];
  Po[0].setWorldCoordinates(-0.1, -0.1, 0);
  Po[1].setWorldCoordinates( 0.2, -0.1, 0);
  Po[2].setWorldCoordinates( 0.1,  0.1, 0);
  Po[3].setWorldCoordinates(-0.1,  0.3, 0);
  // Initialize the pose between camera frame a and object frame o
  vpHomogeneousMatrix aMo(0, 0, 1, 0, 0, 0); // Camera is 1 meter far
  // Initialize the pose between camera frame a and camera frame
  // b. These two frames correspond for example to two successive
  // camera positions
  vpHomogeneousMatrix aMb(0.2, 0.1, 0, 0, 0, vpMath::rad(2));
  // Compute the pose between camera frame b and object frame
  vpHomogeneousMatrix bMo = aMb.inverse() * aMo;
  // Initialize camera intrinsic parameters
  vpCameraParameters cam;
  // Compute the coordinates in pixels of the 4 object points in the
  // camera frame a
  vpPoint Pa[4];
  std::vector<double> xa(4), ya(4); // Coordinates in pixels of the points in frame a
  for(int i=0 ; i < 4 ; i++) {
    Pa[i] = Po[i]; Pa[i].project(aMo); // Project the points from object frame to camera frame a
    vpMeterPixelConversion::convertPoint(cam,
                                         Pa[i].get_x(), Pa[i].get_y(),
                                         xa[i], ya[i]);
  }
  // Compute the coordinates in pixels of the 4 object points in the
  // camera frame b
  vpPoint Pb[4];
  std::vector<double> xb(4), yb(4); // Coordinates in pixels of the points in frame b
  for(int i=0 ; i < 4 ; i++) {
    Pb[i] = Po[i]; Pb[i].project(bMo); // Project the points from object frame to camera frame a
  }
  // Compute equation of the 3D plane containing the points in camera frame b
  vpPlane bP(Pb[0], Pb[1], Pb[2]);
  // Compute the corresponding ground truth homography
  vpHomography aHb(aMb, bP);
  std::cout << "Ground truth homography aHb: \n" << aHb<< std::endl;
  // Compute the coordinates of the points in frame b using the ground
  // truth homography and the coordinates of the points in frame a
  vpHomography bHa = aHb.inverse();
  for(int i = 0; i < 4 ; i++){
    double inv_z = 1. / (bHa[2][0] * xa[i] + bHa[2][1] * ya[i] + bHa[2][2]);
    xb[i] = (bHa[0][0] * xa[i] + bHa[0][1] * ya[i] + bHa[0][2]) * inv_z;
    yb[i] = (bHa[1][0] * xa[i] + bHa[1][1] * ya[i] + bHa[1][2]) * inv_z;
  }
  // Estimate the homography from 4 points coordinates expressed in pixels
  vpHomography::DLT(xb, yb, xa, ya, aHb, true);
  aHb /= aHb[2][2]; // Apply a scale factor to have aHb[2][2] = 1
  std::cout << "Estimated homography aHb: \n" << aHb<< std::endl;
}

Examples:: homographyHartleyDLT2DObject.cpp, homographyHLM2DObject.cpp, homographyHLM3DObject.cpp, homographyRansac2DObject.cpp, planarObjectDetector.cpp, testDisplacement.cpp, tutorial-homography-from-points.cpp, tutorial-matching-keypoint-homography.cpp, tutorial-matching-surf-homography-deprecated.cpp, and tutorial-template-tracker.cpp.

Definition at line 174 of file vpHomography.h.

Constructor & Destructor Documentation

vpHomography::vpHomography ( )

initialize an homography as Identity

Definition at line 60 of file vpHomography.cpp.

References eye().

vpHomography::vpHomography ( const vpHomography & H )

initialize an homography from another homography

Definition at line 66 of file vpHomography.cpp.

vpHomography::vpHomography	(	const vpHomogeneousMatrix &	aMb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

initialize an homography from another homography

Definition at line 71 of file vpHomography.cpp.

References buildFrom().

vpHomography::vpHomography	(	const vpRotationMatrix &	aRb,
		const vpTranslationVector &	atb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Definition at line 82 of file vpHomography.cpp.

References buildFrom().

vpHomography::vpHomography	(	const vpThetaUVector &	tu,
		const vpTranslationVector &	atb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Definition at line 76 of file vpHomography.cpp.

References buildFrom().

vpHomography::vpHomography	(	const vpPoseVector &	arb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Definition at line 88 of file vpHomography.cpp.

References buildFrom().

virtual vpHomography::~vpHomography ( )

inlinevirtual

Definition at line 213 of file vpHomography.h.

References vpArray2D< Type >::load(), operator*(), and vpArray2D< Type >::operator=().

Member Function Documentation

void vpHomography::buildFrom	(	const vpRotationMatrix &	aRb,
		const vpTranslationVector &	atb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Examples:: testDisplacement.cpp.

Definition at line 108 of file vpHomography.cpp.

Referenced by vpHomography().

void vpHomography::buildFrom	(	const vpThetaUVector &	tu,
		const vpTranslationVector &	atb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Definition at line 100 of file vpHomography.cpp.

void vpHomography::buildFrom	(	const vpPoseVector &	arb,
		const vpPlane &	bP
	)

Construction from Translation and rotation and a plane.

Definition at line 116 of file vpHomography.cpp.

References vpHomogeneousMatrix::buildFrom(), and vpHomogeneousMatrix::insert().

void vpHomography::buildFrom	(	const vpHomogeneousMatrix &	aMb,
		const vpPlane &	bP
	)

Construction from homogeneous matrix and a plane.

Definition at line 93 of file vpHomography.cpp.

vpHomography vpHomography::collineation2homography ( const vpCameraParameters & cam ) const

Transform an homography from pixel space to calibrated domain.

Given homography $\bf G$ corresponding to the collineation matrix in the pixel space, compute the homography matrix $\bf H$ in the Euclidian space or calibrated domain using:

${\bf H} = {\bf K}^{-1} {\bf G} {\bf K}$

Parameters

[in]

cam

: Camera parameters used to fill ${\bf K}$ matrix such as

${\bf K} = \left[ \begin{array}{ccc} p_x & 0 & u_0 \\ 0 & p_y & v_0 \\ 0 & 0 & 1 \end{array}\right]$

Returns: The corresponding homography matrix $\bf H$ in the Euclidian space or calibrated domain.

See also: homography2collineation()

Definition at line 786 of file vpHomography.cpp.

References vpCameraParameters::get_px(), vpCameraParameters::get_px_inverse(), vpCameraParameters::get_py(), vpCameraParameters::get_py_inverse(), vpCameraParameters::get_u0(), and vpCameraParameters::get_v0().

void vpHomography::computeDisplacement	(	vpRotationMatrix &	aRb,
		vpTranslationVector &	atb,
		vpColVector &	n
	)

Compute the camera displacement between two images from the homography ${^a}{\bf H}_b$ which is here an implicit parameter (*this).

Parameters

aRb	: Rotation matrix as an output ${^a}{\bf R}_b$ .
atb	: Translation vector as an output $^a{\bf t}_b$ .
n	: Normal vector to the plane as an output.

Examples:: homographyHartleyDLT2DObject.cpp, homographyHLM2DObject.cpp, homographyHLM3DObject.cpp, testDisplacement.cpp, and tutorial-homography-from-points.cpp.

Definition at line 61 of file vpHomographyExtract.cpp.

Referenced by computeDisplacement().

void vpHomography::computeDisplacement	(	const vpColVector &	nd,
		vpRotationMatrix &	aRb,
		vpTranslationVector &	atb,
		vpColVector &	n
	)

Compute the camera displacement between two images from the homography ${^a}{\bf H}_b$ which is here an implicit parameter (*this).

Camera displacement between ${^a}{\bf p}$ and ${^a}{\bf p}$ is represented as a rotation matrix ${^a}{\bf R}_b$ and a translation vector $^a{\bf t}_b$ from which an homogeneous matrix can be build (vpHomogeneousMatrix).

Parameters

nd	: Input normal vector to the plane used to compar with the normal vector n extracted from the homography.
aRb	: Rotation matrix as an output ${^a}{\bf R}_b$ .
atb	: Translation vector as an output $^a{\bf t}_b$ .
n	: Normal vector to the plane as an output.

Definition at line 92 of file vpHomographyExtract.cpp.

References computeDisplacement(), convert(), vpMatrix::det(), vpRotationMatrix::eye(), vpRotationMatrix::isARotationMatrix(), vpColVector::resize(), vpMath::sqr(), vpMatrix::svd(), vpTranslationVector::t(), vpRotationMatrix::t(), and vpColVector::t().

vpMatrix vpHomography::convert ( ) const

Converts an homography to a matrix.

Returns: The 3x3 matrix corresponding to the homography.

Definition at line 758 of file vpHomography.cpp.

Referenced by computeDisplacement(), and vpMbtDistanceKltPoints::computeHomography().

double vpHomography::det ( ) const

Return homography determinant.

Definition at line 476 of file vpHomography.cpp.

void vpHomography::DLT	(	const std::vector< double > &	xb,
		const std::vector< double > &	yb,
		const std::vector< double > &	xa,
		const std::vector< double > &	ya,
		vpHomography &	aHb,
		bool	normalization = `true`
	)

static

From couples of matched points $^a{\bf p}=(x_a,y_a,1)$ in image a and $^b{\bf p}=(x_b,y_b,1)$ in image b with homogeneous coordinates, computes the homography matrix by resolving $^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$ using the DLT (Direct Linear Transform) algorithm.

At least 4 couples of points are needed.

To do so, we use the DLT algorithm on the data, ie we resolve the linear system by SDV : $\bf{Ah} =0$ where $\bf{h}$ is the vector with the terms of $^a{\bf H}_b$ and $\mathbf{A}$ depends on the points coordinates.

For each point, in homogeneous coordinates we have:

$^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$

which is equivalent to:

$^a{\bf p} \times {^a{\bf H}_b \; ^b{\bf p}} =0$

If we note $\mathbf{h}_j^T$ the $j^{\textrm{th}}$ line of $^a{\bf H}_b$ , we can write:

$^a{\bf H}_b \; ^b{\bf p} = \left( \begin{array}{c}\mathbf{h}_1^T \;^b{\bf p} \\\mathbf{h}_2^T \; ^b{\bf p} \\\mathbf{h}_3^T \;^b{\bf p} \end{array}\right)$

Setting $^a{\bf p}=(x_{a},y_{a},w_{a})$ , the cross product can be rewritten by:

$^a{\bf p} \times ^a{\bf H}_b \; ^b{\bf p} =\left( \begin{array}{c}y_{a}\mathbf{h}_3^T \; ^b{\bf p}-w_{a}\mathbf{h}_2^T \; ^b{\bf p} \\w_{a}\mathbf{h}_1^T \; ^b{\bf p} -x_{a}\mathbf{h}_3^T \; ^b{\bf p} \\x_{a}\mathbf{h}_2^T \; ^b{\bf p}- y_{a}\mathbf{h}_1^T \; ^b{\bf p}\end{array}\right)$

$\underbrace{\left( \begin{array}{ccc}\mathbf{0}^T & -w_{a} \; ^b{\bf p}^T & y_{a} \; ^b{\bf p}^T \\ w_{a} \; ^b{\bf p}^T&\mathbf{0}^T & -x_{a} \; ^b{\bf p}^T \\ -y_{a} \; ^b{\bf p}^T & x_{a} \; ^b{\bf p}^T & \mathbf{0}^T\end{array}\right)}_{\mathbf{A}_i (3\times 9)} \underbrace{\left( \begin{array}{c}\mathbf{h}_{1}^{T} \\ \mathbf{h}_{2}^{T}\\\mathbf{h}_{3}^{T}\end{array}\right)}_{\mathbf{h} (9\times 1)}=0$

leading to an homogeneous system to be solved: $\mathbf{A}\mathbf{h}=0$ with $\mathbf{A}=\left(\mathbf{A}_1^T, ..., \mathbf{A}_i^T, ..., \mathbf{A}_n^T \right)^T$ .

It can be solved using an SVD decomposition:

$\bf A = UDV^T$

h is the column of V associated with the smalest singular value of A

Parameters

xb,yb	: Coordinates vector of matched points in image b. These coordinates are expressed in meters.
xa,ya	: Coordinates vector of matched points in image a. These coordinates are expressed in meters.
aHb	: Estimated homography that relies the transformation from image a to image b.
normalization	: When set to true, the coordinates of the points are normalized. The normalization carried out is the one preconized by Hartley.

Exceptions

vpMatrixException::rankDeficient : When the rank of the matrix that should be 8 is deficient.

Examples:: homographyHartleyDLT2DObject.cpp, and tutorial-homography-from-points.cpp.

Definition at line 250 of file vpHomographyDLT.cpp.

References vpException::dimensionError, vpException::fatalError, vpMatrix::getCol(), vpMatrixException::rankDeficient, vpArray2D< Type >::resize(), vpMatrix::svd(), vpERROR_TRACE, and vpTRACE.

Referenced by ransac().

void vpHomography::eye ( )

Set the homography as identity transformation by setting the diagonal to 1 and all other values to 0.

Examples:: testDisplacement.cpp.

Definition at line 487 of file vpHomography.cpp.

Referenced by setIdentity(), and vpHomography().

unsigned int vpArray2D< double >::getCols ( ) const

inlineinherited

Return the number of columns of the 2D array.

See also: getRows(), size()

Examples:: servoViper850Point2DArtVelocity-jointAvoidance-basic.cpp, testAprilTag.cpp, testColVector.cpp, testDisplacement.cpp, testImageFilter.cpp, testMatrix.cpp, testMatrixConditionNumber.cpp, testMatrixConvolution.cpp, testMatrixDeterminant.cpp, testMatrixInitialization.cpp, testMatrixInverse.cpp, testMatrixPseudoInverse.cpp, testPoseVector.cpp, testRowVector.cpp, testSvd.cpp, testTranslationVector.cpp, and tutorial-matlab.cpp.

Definition at line 279 of file vpArray2D.h.

References vpArray2D< Type >::colNum, vpArray2D< Type >::getMaxValue(), and vpArray2D< Type >::getMinValue().

Referenced by vpMatrix::cond(), vpRowVector::cppPrint(), vpMatrix::cppPrint(), vpRowVector::csvPrint(), vpMatrix::csvPrint(), vpMatrix::detByLUEigen3(), vpMatrix::extract(), vpRotationMatrix::getCol(), vpHomogeneousMatrix::getCol(), vpMatrix::getCol(), vpMatrix::inducedL2Norm(), vpMatrix::inverseByLUEigen3(), vpMatrix::inverseByQRLapack(), vpRotationMatrix::isARotationMatrix(), vpMatrix::kernel(), vpRowVector::maplePrint(), vpMatrix::maplePrint(), vpRowVector::matlabPrint(), vpMatrix::matlabPrint(), vpMatrix::nullSpace(), vpRowVector::operator*(), vpRowVector::operator+(), vpRowVector::operator+=(), vpRowVector::operator-(), vpRowVector::operator-=(), vpForceTwistMatrix::print(), vpVelocityTwistMatrix::print(), vpRowVector::print(), vpMatrix::print(), vpMatrix::pseudoInverse(), vpMatrix::row(), vpMatrix::svdEigen3(), vpMatrix::svdLapack(), and vpMatrix::svdOpenCV().

double vpArray2D< double >::getMaxValue ( ) const

inherited

Return the array max value.

Examples:: servoMomentImage.cpp, and testArray2D.cpp.

double vpArray2D< double >::getMinValue ( ) const

inherited

Return the array min value.

Examples:: servoMomentImage.cpp, and testArray2D.cpp.

unsigned int vpArray2D< double >::getRows ( ) const

inlineinherited

Return the number of rows of the 2D array.

See also: getCols(), size()

Examples:: mbtGenericTrackingDepth.cpp, mbtGenericTrackingDepthOnly.cpp, testAprilTag.cpp, testColVector.cpp, testDisplacement.cpp, testGenericTracker.cpp, testGenericTrackerDepth.cpp, testImageFilter.cpp, testMatrix.cpp, testMatrixConditionNumber.cpp, testMatrixConvolution.cpp, testMatrixDeterminant.cpp, testMatrixInitialization.cpp, testMatrixInverse.cpp, testMatrixPseudoInverse.cpp, testPoseVector.cpp, testRowVector.cpp, testSvd.cpp, testTranslationVector.cpp, and tutorial-matlab.cpp.

Definition at line 289 of file vpArray2D.h.

References vpArray2D< Type >::rowNum.

Referenced by vpMatrix::column(), vpMatrix::cond(), vpColVector::cppPrint(), vpMatrix::cppPrint(), vpColVector::csvPrint(), vpMatrix::csvPrint(), vpMatrix::detByLUEigen3(), vpMatrix::extract(), vpRotationMatrix::getCol(), vpHomogeneousMatrix::getCol(), vpMatrix::getCol(), vpMatrix::inducedL2Norm(), vpMatrix::inverseByCholeskyLapack(), vpMatrix::inverseByLUEigen3(), vpMatrix::inverseByQRLapack(), vpRotationMatrix::isARotationMatrix(), vpMatrix::kernel(), vpColVector::maplePrint(), vpMatrix::maplePrint(), vpColVector::matlabPrint(), vpMatrix::matlabPrint(), vpMatrix::nullSpace(), vpColVector::operator+(), vpColVector::operator+=(), vpColVector::operator-(), vpColVector::operator-=(), vpForceTwistMatrix::print(), vpVelocityTwistMatrix::print(), vpPoseVector::print(), vpColVector::print(), vpMatrix::print(), vpMatrix::pseudoInverse(), vpMatrix::svdEigen3(), vpMatrix::svdLapack(), and vpMatrix::svdOpenCV().

vpArray2D<double > vpArray2D< double >::hadamard ( const vpArray2D< double > & m ) const

inherited

Compute the Hadamard product (element wise matrix multiplication).

Parameters

m	: Second matrix;

Returns: m1.hadamard(m2) The Hadamard product : $m1 \circ m2 = (m1 \circ m2)_{i,j} = (m1)_{i,j} (m2)_{i,j}$

Examples:: testArray2D.cpp.

void vpHomography::HLM	(	const std::vector< double > &	xb,
		const std::vector< double > &	yb,
		const std::vector< double > &	xa,
		const std::vector< double > &	ya,
		bool	isplanar,
		vpHomography &	aHb
	)

static

From couples of matched points $^a{\bf p}=(x_a,y_a,1)$ in image a and $^b{\bf p}=(x_b,y_b,1)$ in image b with homogeneous coordinates, computes the homography matrix by resolving $^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$ using Ezio Malis linear method (HLM) [25].

This method can consider points that are planar or non planar. The algorithm for planar scene implemented in this file is described in Ezio Malis PhD thesis [26].

Parameters

xb,yb	: Coordinates vector of matched points in image b. These coordinates are expressed in meters.
xa,ya	: Coordinates vector of matched points in image a. These coordinates are expressed in meters.
isplanar	: If true the points are assumed to be in a plane, otherwise there are assumed to be non planar.
aHb	: Estimated homography that relies the transformation from image a to image b.

If the boolean isplanar is true the points are assumed to be in a plane otherwise there are assumed to be non planar.

See also: DLT() when the scene is planar.

Examples:: homographyHLM2DObject.cpp, homographyHLM3DObject.cpp, and tutorial-homography-from-points.cpp.

Definition at line 622 of file vpHomographyMalis.cpp.

References vpException::dimensionError, and vpException::fatalError.

Referenced by vpPose::poseFromRectangle().

vpHomography vpHomography::homography2collineation ( const vpCameraParameters & cam ) const

Transform an homography from calibrated domain to pixel space.

Given homography $\bf H$ in the Euclidian space or in the calibrated domain, compute the homography $\bf G$ corresponding to the collineation matrix in the pixel space using:

${\bf G} = {\bf K} {\bf H} {\bf K}^{-1}$

Parameters

[in]

cam

: Camera parameters used to fill ${\bf K}$ matrix such as

${\bf K} = \left[ \begin{array}{ccc} p_x & 0 & u_0 \\ 0 & p_y & v_0 \\ 0 & 0 & 1 \end{array}\right]$

Returns: The corresponding collineation matrix $\bf G$ in the pixel space.

See also: collineation2homography()

Definition at line 842 of file vpHomography.cpp.

References vpCameraParameters::get_px(), vpCameraParameters::get_px_inverse(), vpCameraParameters::get_py(), vpCameraParameters::get_py_inverse(), vpCameraParameters::get_u0(), and vpCameraParameters::get_v0().

Referenced by project().

vpHomography vpHomography::inverse	(	double	sv_threshold = `1e-16`,
		unsigned int *	rank = `NULL`
	)		const

invert the homography

Return inverted homography.

Parameters

[in]	sv_threshold	: Threshold used to test the singular values. If a singular value is lower than this threshold we consider that the homography is not full rank.
[out]	rank	: Rank of the homography that should be 3.

Returns: $\bf H^{-1}$

Definition at line 171 of file vpHomography.cpp.

References vpHomogeneousMatrix::convert(), and vpMatrix::pseudoInverse().

Referenced by inverse().

void vpHomography::inverse ( vpHomography & bHa ) const

invert the homography

Invert the homography.

Parameters

bHa	: $\bf H^{-1}$ with H = *this.

Definition at line 194 of file vpHomography.cpp.

References inverse().

void vpHomography::load ( std::ifstream & f )

Load an homography from a file.

Read an homography in a file, verify if it is really an homogeneous matrix.

Parameters

f	: the file. This file has to be written using save().

See also: save()

Definition at line 400 of file vpHomography.cpp.

References vpPlane::getD(), vpPlane::getNormal(), vpException::ioError, and vpColVector::t().

static bool vpArray2D< double >::load	(	const std::string &	filename,
		vpArray2D< double > &	A,
		bool	binary = `false`,
		char *	header = `NULL`
	)

inlinestaticinherited

Load a matrix from a file.

Parameters

filename	: Absolute file name.
A	: Array to be loaded
binary	: If true the matrix is loaded from a binary file, else from a text file.
header	: Header of the file is loaded in this parameter.

Returns: Returns true if success.

See also: save()

Definition at line 540 of file vpArray2D.h.

References vpException::badValue, and vpArray2D< Type >::resize().

static bool vpArray2D< double >::loadYAML	(	const std::string &	filename,
		vpArray2D< double > &	A,
		char *	header = `NULL`
	)

inlinestaticinherited

Load an array from a YAML-formatted file.

Parameters

filename	: absolute file name.
A	: array to be loaded from the file.
header	: header of the file is loaded in this parameter.

Returns: Returns true on success.

See also: saveYAML()

Examples:: servoFlirPtuIBVS.cpp, servoFrankaIBVS.cpp, servoFrankaPBVS.cpp, tutorial-flir-ptu-ibvs.cpp, and tutorial-hand-eye-calibration.cpp.

Definition at line 652 of file vpArray2D.h.

References vpArray2D< Type >::resize().

bool vpArray2D< double >::operator!= ( const vpArray2D< double > & A ) const

inherited

Not equal to comparison operator of a 2D array.

vpHomography vpHomography::operator* ( const vpHomography & H ) const

Multiplication by an homography.

Parameters

H	: Homography to multiply with.

vpHomography aHb, bHc;
// Initialize aHb and bHc homographies
vpHomography aHc = aHb * bHc;

Definition at line 225 of file vpHomography.cpp.

vpHomography vpHomography::operator* ( const double & v ) const

Multiply an homography by a scalar.

Parameters

v	: Value of the scalar.

double v = 1.1;
vpHomography aHb;
// Initialize aHb
vpHomography H = aHb * v;

Definition at line 275 of file vpHomography.cpp.

References vpArray2D< Type >::data, and vpArray2D< double >::data.

vpColVector vpHomography::operator* ( const vpColVector & b ) const

Operation a = aHb * b.

Parameters

b	: 3 dimension vector.

Definition at line 245 of file vpHomography.cpp.

References vpException::dimensionError, and vpArray2D< Type >::size().

vpPoint vpHomography::operator* ( const vpPoint & b_P ) const

From the coordinates of the point in image plane b and the homography between image a and b computes the coordinates of the point in image plane a.

Parameters

b_P	: 2D coordinates of the point in the image plane b.

Returns: A point with 2D coordinates in the image plane a.

Definition at line 295 of file vpHomography.cpp.

References vpPoint::get_w(), vpPoint::get_x(), vpPoint::get_y(), vpPoint::set_w(), vpPoint::set_x(), and vpPoint::set_y().

vpHomography vpHomography::operator/ ( const double & v ) const

Divide an homography by a scalar.

Parameters

v	: Value of the scalar.

vpHomography aHb;
// Initialize aHb
vpHomography H = aHb / aHb[2][2];

Definition at line 328 of file vpHomography.cpp.

References vpArray2D< Type >::data, vpArray2D< double >::data, and vpException::divideByZeroError.

vpHomography & vpHomography::operator/= ( double v )

Divide all the element of the homography matrix by v : Hij = Hij / v.

Definition at line 344 of file vpHomography.cpp.

References vpArray2D< double >::data, and vpException::divideByZeroError.

vpHomography & vpHomography::operator= ( const vpHomography & H )

Copy operator. Allow operation such as aHb = H

Parameters

H	: Homography matrix to be copied.

Definition at line 364 of file vpHomography.cpp.

vpHomography & vpHomography::operator= ( const vpMatrix & H )

Copy operator. Allow operation such as aHb = H

Parameters

H	: Matrix to be copied.

Definition at line 380 of file vpHomography.cpp.

References vpException::dimensionError, vpArray2D< Type >::getCols(), and vpArray2D< Type >::getRows().

bool vpArray2D< double >::operator== ( const vpArray2D< double > & A ) const

inherited

Equal to comparison operator of a 2D array.

double * vpArray2D< double >::operator[] ( unsigned int i )

inlineinherited

Set element $A_{ij} = x$ using A[i][j] = x.

Definition at line 484 of file vpArray2D.h.

double * vpArray2D< double >::operator[] ( unsigned int i ) const

inlineinherited

Get element $x = A_{ij}$ using x = A[i][j].

Definition at line 486 of file vpArray2D.h.

vpImagePoint vpHomography::project	(	const vpCameraParameters &	cam,
		const vpHomography &	bHa,
		const vpImagePoint &	iPa
	)

static

Given iPa a pixel with coordinates $(u_a,v_a)$ in image a, and the homography bHa in the Euclidian space or calibrated domain that links image a and b, computes the coordinates of the pixel $(u_b,v_b)$ in the image b using the camera parameters matrix $\bf K$ .

Compute $^b{\bf p} = {\bf K} \; {^b}{\bf H}_a \; {\bf K}^{-1} {^a}{\bf p}$ with $^a{\bf p}=(u_a,v_a,1)$ and $^b{\bf p}=(u_b,v_b,1)$

Returns: The coordinates in pixel of the point with coordinates .

Examples:: tutorial-homography-from-points.cpp, tutorial-matching-keypoint-homography.cpp, and tutorial-matching-surf-homography-deprecated.cpp.

Definition at line 519 of file vpHomography.cpp.

References vpImagePoint::get_u(), vpImagePoint::get_v(), and homography2collineation().

vpPoint vpHomography::project	(	const vpHomography &	bHa,
		const vpPoint &	Pa
	)

static

Given Pa a point with normalized coordinates $(x_a,y_a,1)$ in the image plane a, and the homography bHa in the Euclidian space that links image a and b, computes the normalized coordinates of the point $(x_b,y_b,1)$ in the image plane b.

Compute $^b{\bf p} = {^b}{\bf H}_a \; {^a}{\bf p}$ with $^a{\bf p}=(x_a,y_a,1)$ and $^b{\bf p}=(x_b,y_b,1)$

Returns: The coordinates in meter of the point with coordinates .

Definition at line 545 of file vpHomography.cpp.

References vpPoint::get_x(), vpPoint::get_y(), vpPoint::set_x(), and vpPoint::set_y().

vpImagePoint vpHomography::projection ( const vpImagePoint & ipb )

Project the current image point (in frame b) into the frame a using the homography aHb.

Parameters

ipb	: Homography defining the relation between frame a and frame b.

Returns: The projected image point in the frame a.

Definition at line 736 of file vpHomography.cpp.

References vpImagePoint::get_u(), vpImagePoint::get_v(), vpImagePoint::set_u(), and vpImagePoint::set_v().

bool vpHomography::ransac	(	const std::vector< double > &	xb,
		const std::vector< double > &	yb,
		const std::vector< double > &	xa,
		const std::vector< double > &	ya,
		vpHomography &	aHb,
		std::vector< bool > &	inliers,
		double &	residual,
		unsigned int	nbInliersConsensus,
		double	threshold,
		bool	normalization = `true`
	)

static

From couples of matched points $^a{\bf p}=(x_a,y_a,1)$ in image a and $^b{\bf p}=(x_b,y_b,1)$ in image b with homogeneous coordinates, computes the homography matrix by resolving $^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$ using Ransac algorithm.

Parameters

xb,yb	: Coordinates vector of matched points in image b. These coordinates are expressed in meters.
xa,ya	: Coordinates vector of matched points in image a. These coordinates are expressed in meters.
aHb	: Estimated homography that relies the transformation from image a to image b.
inliers	: Vector that indicates if a matched point is an inlier (true) or an outlier (false).
residual	: Global residual computed as $r = \sqrt{1/n \sum_{inliers} {\\| {^a{\bf p} - {\hat{^a{\bf H}_b}} {^b{\bf p}}} \\|}^{2}}$ with the number of inliers.
nbInliersConsensus	: Minimal number of points requested to fit the estimated homography.
threshold	: Threshold for outlier removing. A point is considered as an outlier if the reprojection error $\\| {^a{\bf p} - {\hat{^a{\bf H}_b}} {^b{\bf p}}} \\|$ is greater than this threshold.
normalization	: When set to true, the coordinates of the points are normalized. The normalization carried out is the one preconized by Hartley.

Returns: true if the homography could be computed, false otherwise.

Examples:: homographyRansac2DObject.cpp, tutorial-matching-keypoint-homography.cpp, and tutorial-matching-surf-homography-deprecated.cpp.

Definition at line 318 of file vpHomographyRansac.cpp.

References vpException::dimensionError, DLT(), vpException::fatalError, and vpERROR_TRACE.

void vpArray2D< double >::reshape	(	unsigned int	nrows,
		unsigned int	ncols
	)

inlineinherited

Examples:: testMatrixInitialization.cpp.

Definition at line 379 of file vpArray2D.h.

References vpException::dimensionError, vpArray2D< Type >::dsize, vpArray2D< Type >::operator!=(), vpArray2D< Type >::operator==(), vpArray2D< Type >::resize(), and vpArray2D< Type >::rowPtrs.

void vpHomography::resize	(	unsigned int	nrows,
		unsigned int	ncols,
		bool	flagNullify = `true`
	)

inline

This function is not applicable to an homography that is always a 3-by-3 matrix.

Exceptions

vpException::fatalError When this function is called.

Definition at line 266 of file vpHomography.h.

References vpException::fatalError, and vpArray2D< Type >::save().

Referenced by robust().

void vpArray2D< double >::resize	(	unsigned int	nrows,
		unsigned int	ncols,
		bool	flagNullify = `true`,
		bool	recopy_ = `true`
	)

inlineinherited

Set the size of the array and initialize all the values to zero.

Parameters

nrows	: number of rows.
ncols	: number of column.
flagNullify	: if true, then the array is re-initialized to 0 after resize. If false, the initial values from the common part of the array (common part between old and new version of the array) are kept. Default value is true.
recopy_	: if true, will perform an explicit recopy of the old data.

Examples:: testArray2D.cpp, testMatrix.cpp, testMatrixConditionNumber.cpp, testMatrixDeterminant.cpp, testMatrixInitialization.cpp, testMatrixInverse.cpp, testMatrixPseudoInverse.cpp, and testSvd.cpp.

Definition at line 304 of file vpArray2D.h.

References vpArray2D< Type >::colNum, vpArray2D< Type >::dsize, vpException::memoryAllocationError, vpArray2D< Type >::rowNum, and vpArray2D< Type >::rowPtrs.

Referenced by vpMatrix::diag(), vpMatrix::eye(), vpMatrix::init(), vpMatrix::operator,(), vpMatrix::operator<<(), vpMatrix::operator=(), vpMatrix::stack(), and vpMatrix::svdOpenCV().

void vpHomography::robust	(	const std::vector< double > &	xb,
		const std::vector< double > &	yb,
		const std::vector< double > &	xa,
		const std::vector< double > &	ya,
		vpHomography &	aHb,
		std::vector< bool > &	inliers,
		double &	residual,
		double	weights_threshold = `0.4`,
		unsigned int	niter = `4`,
		bool	normalization = `true`
	)

static

From couples of matched points $^a{\bf p}=(x_a,y_a,1)$ in image a and $^b{\bf p}=(x_b,y_b,1)$ in image b with homogeneous coordinates, computes the homography matrix by resolving $^a{\bf p} = ^a{\bf H}_b\; ^b{\bf p}$ using a robust estimation scheme.

This method is to compare to DLT() except that here a robust estimator is used to reject couples of points that are considered as outliers.

At least 4 couples of points are needed.

Parameters

xb,yb	: Coordinates vector of matched points in image b. These coordinates are expressed in meters.
xa,ya	: Coordinates vector of matched points in image a. These coordinates are expressed in meters.
aHb	: Estimated homography that relies the transformation from image a to image b.
inliers	: Vector that indicates if a matched point is an inlier (true) or an outlier (false).
residual	: Global residual computed as $r = \sqrt{1/n \sum_{inliers} {\\| {^a{\bf p} - {\hat{^a{\bf H}_b}} {^b{\bf p}}} \\|}^{2}}$ with the number of inliers.
weights_threshold	: Threshold applied on the weights updated during the robust estimation and used to consider if a point is an outlier or an inlier. Values should be in [0:1]. A couple of matched points that have a weight lower than this threshold is considered as an outlier. A value equal to zero indicates that all the points are inliers.
niter	: Number of iterations of the estimation process.
normalization	: When set to true, the coordinates of the points are normalized. The normalization carried out is the one preconized by Hartley.

See also: DLT(), ransac()

Examples:: tutorial-matching-keypoint-homography.cpp, and tutorial-matching-surf-homography-deprecated.cpp.

Definition at line 593 of file vpHomography.cpp.

References vpArray2D< Type >::data, vpException::dimensionError, vpException::fatalError, vpRobust::MEstimator(), vpMatrix::pseudoInverse(), resize(), and vpRobust::TUKEY.

void vpHomography::save ( std::ofstream & f ) const

Save an homography in a file. The laod() function allows then to read and set the homography from this file.

See also: load()

Definition at line 203 of file vpHomography.cpp.

References vpException::ioError.

static bool vpArray2D< double >::save	(	const std::string &	filename,
		const vpArray2D< double > &	A,
		bool	binary = `false`,
		const char *	header = `""`
	)

inlinestaticinherited

Save a matrix to a file.

Parameters

filename	: Absolute file name.
A	: Array to be saved.
binary	: If true the matrix is saved in a binary file, else a text file.
header	: Optional line that will be saved at the beginning of the file.

Returns: Returns true if success.

Warning : If you save the matrix as in a text file the precision is less than if you save it in a binary file.

See also: load()

Definition at line 737 of file vpArray2D.h.

References vpArray2D< Type >::getCols(), and vpArray2D< Type >::getRows().

static bool vpArray2D< double >::saveYAML	(	const std::string &	filename,
		const vpArray2D< double > &	A,
		const char *	header = `""`
	)

inlinestaticinherited

Save an array in a YAML-formatted file.

Parameters

filename	: absolute file name.
A	: array to be saved in the file.
header	: optional lines that will be saved at the beginning of the file. Should be YAML-formatted and will adapt to the indentation if any.

Returns: Returns true if success.

Here is an example of outputs.

vpArray2D<double> M(3,4);
vpArray2D::saveYAML("matrix.yml", M, "example: a YAML-formatted header");
vpArray2D::saveYAML("matrixIndent.yml", M, "example:\n    - a YAML-formatted
header\n    - with inner indentation"); 

Content of matrix.yml:

example: a YAML-formatted header
rows: 3
cols: 4
data:
  - [0, 0, 0, 0]
  - [0, 0, 0, 0]
  - [0, 0, 0, 0]

Content of matrixIndent.yml:

example:
    - a YAML-formatted header
    - with inner indentation
rows: 3
cols: 4
data:
    - [0, 0, 0, 0]
    - [0, 0, 0, 0]
    - [0, 0, 0, 0]

See also: loadYAML()

Examples:: tutorial-chessboard-pose.cpp, tutorial-franka-acquire-calib-data.cpp, and tutorial-hand-eye-calibration.cpp.

Definition at line 830 of file vpArray2D.h.

References vpArray2D< Type >::getCols(), and vpArray2D< Type >::getRows().

void vpHomography::setIdentity ( )

Deprecated:: You should rather use eye().

Deprecated:: You should rather use eye().

Set the homography as identity transformation.

See also: eye()

Definition at line 504 of file vpHomography.cpp.

References eye().

unsigned int vpArray2D< double >::size ( ) const

inlineinherited

Return the number of elements of the 2D array.

Examples:: testColVector.cpp, testDisplacement.cpp, testEigenConversion.cpp, testMatrix.cpp, testMatrixInitialization.cpp, testPoseVector.cpp, testRobotViper650-frames.cpp, testRobotViper850-frames.cpp, testRowVector.cpp, testThread2.cpp, testTranslationVector.cpp, testTukeyEstimator.cpp, tutorial-ibvs-4pts-wireframe-robot-afma6.cpp, tutorial-ibvs-4pts-wireframe-robot-viper.cpp, tutorial-mb-generic-tracker-rgbd-blender.cpp, tutorial-mb-generic-tracker-rgbd-realsense.cpp, and tutorial-mb-generic-tracker-rgbd.cpp.

Definition at line 291 of file vpArray2D.h.

References vpArray2D< Type >::rowNum.

Referenced by vpRowVector::insert(), vpColVector::insert(), vpColVector::operator*(), vpRotationVector::operator,(), vpTranslationVector::operator,(), vpRotationMatrix::operator,(), vpHomogeneousMatrix::operator,(), vpQuaternionVector::operator=(), vpTranslationVector::operator=(), vpRzyzVector::operator=(), vpRxyzVector::operator=(), vpRzyxVector::operator=(), vpThetaUVector::operator=(), vpMatrix::stack(), vpRotationVector::toStdVector(), vpRowVector::toStdVector(), and vpColVector::toStdVector().

Friends And Related Function Documentation

enum vpGEMMmethod

Operations are :

VP_GEMM_A_T to use the transpose matrix of A instead of the matrix A
VP_GEMM_B_T to use the transpose matrix of B instead of the matrix B
VP_GEMM_C_T to use the transpose matrix of C instead of the matrix C

Definition at line 57 of file vpGEMM.h.

Member Data Documentation

unsigned int vpArray2D< double >::colNum

protectedinherited

Number of columns in the array.

Definition at line 137 of file vpArray2D.h.

double * vpArray2D< double >::data

inherited

Address of the first element of the data array.

Examples:: testArray2D.cpp, testDisplacement.cpp, testEigenConversion.cpp, testImageFilter.cpp, testMatrix.cpp, testTranslationVector.cpp, and tutorial-matlab.cpp.

Definition at line 145 of file vpArray2D.h.

Referenced by vpMatrix::AAt(), vpMatrix::AtA(), vpQuaternionVector::buildFrom(), vpHomogeneousMatrix::buildFrom(), vpThetaUVector::buildFrom(), vpRzyzVector::buildFrom(), vpRxyzVector::buildFrom(), vpRzyxVector::buildFrom(), vpSubColVector::checkParentStatus(), vpSubRowVector::checkParentStatus(), vpSubMatrix::checkParentStatus(), vpColVector::clear(), vpHomogeneousMatrix::convert(), vpMatrix::detByLUEigen3(), vpMatrix::detByLUOpenCV(), vpMatrix::expm(), vpThetaUVector::extract(), vpMatrix::frobeniusNorm(), vpMatrix::getRow(), vpThetaUVector::getTheta(), vpThetaUVector::getU(), vpColVector::hadamard(), vpMatrix::hadamard(), vpSubColVector::init(), vpSubRowVector::init(), vpSubMatrix::init(), vpColVector::insert(), vpMatrix::insert(), vpMatrix::inverseByCholeskyOpenCV(), vpMatrix::inverseByLUEigen3(), vpMatrix::inverseByLUOpenCV(), vpTranslationVector::operator*(), vpRowVector::operator*(), operator*(), vpColVector::operator*(), vpMatrix::operator*(), vpRotationVector::operator,(), vpTranslationVector::operator,(), vpRotationMatrix::operator,(), vpHomogeneousMatrix::operator,(), vpRowVector::operator,(), vpColVector::operator,(), vpTranslationVector::operator-(), vpRowVector::operator-(), vpColVector::operator-(), vpTranslationVector::operator/(), vpRowVector::operator/(), operator/(), vpColVector::operator/(), operator/=(), vpRotationVector::operator<<(), vpTranslationVector::operator<<(), vpRotationMatrix::operator<<(), vpHomogeneousMatrix::operator<<(), vpRowVector::operator<<(), vpColVector::operator<<(), vpSubColVector::operator=(), vpSubRowVector::operator=(), vpQuaternionVector::operator=(), vpTranslationVector::operator=(), vpRotationMatrix::operator=(), vpRzyzVector::operator=(), vpRxyzVector::operator=(), vpRzyxVector::operator=(), vpRowVector::operator=(), vpThetaUVector::operator=(), vpColVector::operator=(), vpMatrix::operator=(), vpRowVector::operator==(), vpColVector::operator==(), vpColVector::operator[](), vpMatrix::qr(), vpMatrix::qrPivot(), vpRowVector::reshape(), vpColVector::reshape(), vpQuaternionVector::set(), vpMatrix::stack(), vpMatrix::stackRows(), vpColVector::sum(), vpColVector::sumSquare(), vpMatrix::svdEigen3(), vpMatrix::svdLapack(), vpMatrix::svdOpenCV(), vpRotationVector::t(), vpTranslationVector::t(), vpPoseVector::t(), vpRowVector::t(), vpColVector::t(), vpRotationVector::toStdVector(), vpRowVector::toStdVector(), vpColVector::toStdVector(), vpMatrix::transpose(), vpColVector::vpColVector(), vpHomogeneousMatrix::vpHomogeneousMatrix(), vpMatrix::vpMatrix(), vpRowVector::vpRowVector(), vpQuaternionVector::w(), vpQuaternionVector::x(), vpQuaternionVector::y(), vpQuaternionVector::z(), vpSubColVector::~vpSubColVector(), vpSubMatrix::~vpSubMatrix(), and vpSubRowVector::~vpSubRowVector().

unsigned int vpArray2D< double >::dsize

protectedinherited

unsigned int vpArray2D< double >::rowNum

protectedinherited

Number of rows in the array.

Definition at line 135 of file vpArray2D.h.

double ** vpArray2D< double >::rowPtrs

protectedinherited

Address of the first element of each rows.

Definition at line 139 of file vpArray2D.h.

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Related Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation