h2d::Hmatrix_< M, FPT > Class Template Reference

A 2D homography, defining a planar transformation. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::Hmatrix_< M, FPT >:

Collaboration diagram for h2d::Hmatrix_< M, FPT >:

Public Member Functions
template<typename T >
void	applyTo (T &) const
	Apply homography to a vector/array/list (type T) of points or lines. More...
void	buildFrom4Points (const std::vector< Point2d_< FPT >> &, const std::vector< Point2d_< FPT >> &, int method=1)
	Build Homography from 2 sets of 4 points. More...
void	copyTo (cv::Mat &, int type=CV_64F) const
	Copy matrix to Opencv cv::Mat. More...
void	init ()
Hmatrix_ &	inverse ()
	Inverse matrix. More...
void	normalize () const
	Homography normalisation (const because flag _hasChanged declared as mutable) More...
bool	operator!= (const Hmatrix_ &h) const
	Comparison operator. Does normalization if required. More...
Hmatrix_ &	operator= (const Hmatrix_< M, FPT > &other)
	Assignment operator. More...
Hmatrix_ &	operator= (const cv::Mat &)
	Get homography from Opencv cv::Mat. More...
bool	operator== (const Hmatrix_ &h) const
	Comparison operator. Does normalization if required. More...
Constructors
	Hmatrix_ ()
	Default constructor, initialize to unit transformation. More...
template<typename T >
	Hmatrix_ (T val)
	Constructor, set homography to a rotation matrix of angle val. More...
template<typename T1 , typename T2 >
	Hmatrix_ (T1 tx, T2 ty)
	Constructor, set homography to a translation matrix ( see Hmatrix_( T ) ) More...
template<typename T >
	Hmatrix_ (const std::vector< std::vector< T >> &in)
	Constructor, used to fill with a vector of vector matrix. More...
template<typename T >
	Hmatrix_ (const std::array< std::array< T, 3 >, 3 > &in)
	Constructor, used to fill with a std::array. More...
	Hmatrix_ (const Hmatrix_< M, FPT > &other)
	Copy-constructor. More...
	Hmatrix_ (const cv::Mat &mat)
	Constructor used to initialise with a cv::Mat, call the assignment operator. More...
Adding/assigning a transformation
template<typename T >
Hmatrix_ &	addTranslation (T tx, T ty)
	Adds a translation tx,ty to the matrix. More...
template<typename T1 , typename T2 >
Hmatrix_ &	setTranslation (T1 tx, T2 ty)
	Sets the matrix as a translation tx,ty. More...
template<typename T >
Hmatrix_ &	addRotation (T theta)
	Adds a rotation with an angle theta (radians) to the matrix. More...
template<typename T >
Hmatrix_ &	setRotation (T theta)
	Sets the matrix as a rotation with an angle theta (radians) More...
template<typename T >
Hmatrix_ &	addScale (T k)
	Adds the same scale factor to the matrix. More...
template<typename T1 , typename T2 >
Hmatrix_ &	addScale (T1 kx, T2 ky)
	Adds a scale factor to the matrix. More...
template<typename T >
Hmatrix_ &	setScale (T k)
	Sets the matrix as a scaling transformation (same on two axis) More...
template<typename T1 , typename T2 >
Hmatrix_ &	setScale (T1 kx, T2 ky)
	Sets the matrix as a scaling transformation. More...
Public Member Functions inherited from h2d::detail::Matrix_< FPT >
HOMOG2D_INUMTYPE	determ () const
	Return determinant of matrix. More...
matrix_t< FPT > &	getRaw ()
const matrix_t< FPT > &	getRaw () const
Matrix_ &	inverse ()
	Inverse matrix. More...
bool	isNormalized () const
	Matrix_ ()
	Constructor. More...
template<typename FPT2 >
	Matrix_ (const Matrix_< FPT2 > &other)
	Copy-Constructor. More...
template<typename T >
void	set (size_t r, size_t c, T v)
Matrix_ &	transpose ()
	Transpose and return matrix. More...
const FPT &	value (size_t r, size_t c) const
FPT &	value (size_t r, size_t c)
Public Member Functions inherited from h2d::detail::Common< FPT >
std::pair< int, int >	dsize () const
	Get data size expressed as number of bits for, respectively, mantissa and exponent. More...
Dtype	dtype () const
	Get numerical data type as a Dtype value, can be stringified with h2d::getString(Dtype) More...
template<typename T >
constexpr bool	isInside (const Common< T > &) const
	This function is a fallback for all sub-classes that do not provide such a method. More...
size_t	size () const

Friends
template<typename T1 , typename T2 >
class	LPBase
template<typename T , typename U >
Line2d_< T >	operator* (const Homogr_< U > &, const Line2d_< T > &)
template<typename T , typename U >
Point2d_< T >	operator* (const Homogr_< U > &, const Point2d_< T > &)
template<typename T , typename U , typename V >
base::LPBase< typename detail::HelperPL< T >::OtherType, V >	operator* (const Hmatrix_< typ::IsEpipmat, U > &h, const base::LPBase< T, V > &in)
Hmatrix_	operator* (const Hmatrix_ &h1, const Hmatrix_ &h2)
	Matrix multiplication, call the base class product. More...
std::ostream &	operator<< (std::ostream &f, const Hmatrix_ &h)

Additional Inherited Members
Protected Member Functions inherited from h2d::detail::Matrix_< FPT >
template<typename FPT2 >
void	p_divideAll (detail::Matrix_< FPT > &mat, FPT2 value) const
	Divide all elements of mat by value. More...
void	p_divideBy (size_t r, size_t c) const
	Divide all elements by the value at (r,c), used for normalization. More...
void	p_fillEye ()
template<typename T >
void	p_fillWith (const T &in)
void	p_fillZero ()
void	p_normalizeMat (int r, int c) const
Protected Attributes inherited from h2d::detail::Matrix_< FPT >
bool	_isNormalized = false
matrix_t< FPT >	_mdata

Detailed Description

template<typename M, typename FPT>
class h2d::Hmatrix_< M, FPT >

A 2D homography, defining a planar transformation.

To define an affine or rigid transformation, you can use:

• setRotation()
• setTranslation()
• setScale()

To add an affine or rigid transformation to the current one, you can use:

• addRotation()
• addTranslation()
• addScale()

To return to unit transformation, use init()

Implemented as a 3x3 matrix

Templated by Floating-Point Type (FPT) and by type M (typ::IsEpipmat or typ::IsHomogr)

Constructor & Destructor Documentation

Hmatrix_() [1/7]

template<typename M, typename FPT>

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( )

inline

Default constructor, initialize to unit transformation.

    {
        init();
    }

Hmatrix_() [2/7]

template<typename M, typename FPT>

template<typename T >

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( T  val )

inlineexplicit

Constructor, set homography to a rotation matrix of angle val.

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        init();
        setRotation( val );
    }

Hmatrix_() [3/7]

template<typename M, typename FPT>

template<typename T1 , typename T2 >

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( T1  tx, T2  ty  )

inlineexplicit

Constructor, set homography to a translation matrix ( see Hmatrix_( T ) )

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        init();
        setTranslation( tx, ty );
    }

Hmatrix_() [4/7]

template<typename M, typename FPT>

template<typename T >

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( const std::vector< std::vector< T >> &  in )

inline

Constructor, used to fill with a vector of vector matrix.

Warning

• Input matrix must be 3 x 3, but type can be anything that can be copied to double
• no checking is done on validity of matrix as an homography. Thus some assert can get triggered elsewhere.

    {
#ifndef HOMOG2D_NOCHECKS
        HOMOG2D_CHECK_IS_NUMBER(T);
        if( in.size() != 3 )
            HOMOG2D_THROW_ERROR_1( "Invalid line size for input: " << in.size() );
        for( auto li: in )
            if( li.size() != 3 )
                HOMOG2D_THROW_ERROR_1( "Invalid column size for input: " << li.size() );
#endif
        detail::Matrix_<FPT>::p_fillWith( in );
        normalize();
    }

Hmatrix_() [5/7]

template<typename M, typename FPT>

template<typename T >

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( const std::array< std::array< T, 3 >, 3 > &  in )

inline

Constructor, used to fill with a std::array.

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        detail::Matrix_<FPT>::p_fillWith( in );
        normalize();
    }

Hmatrix_() [6/7]

template<typename M, typename FPT>

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( const Hmatrix_< M, FPT > &  other )

inline

Copy-constructor.

        : detail::Matrix_<FPT>( other)
        , _hasChanged   ( true )
        , _hmt          (  nullptr )
    {
        detail::Matrix_<FPT>::getRaw() = other.getRaw();
    }

Hmatrix_() [7/7]

template<typename M, typename FPT>

h2d::Hmatrix_< M, FPT >::Hmatrix_ ( const cv::Mat &  mat )

inline

Constructor used to initialise with a cv::Mat, call the assignment operator.

    {
        *this = mat;
    }

Member Function Documentation

addRotation()

template<typename M, typename FPT>

template<typename T >

Hmatrix_& h2d::Hmatrix_< M, FPT >::addRotation ( T  theta )

inline

Adds a rotation with an angle theta (radians) to the matrix.

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        Hmatrix_ out;
        out.setRotation( theta );
        *this = out * *this;
        return *this;
    }

Here is the caller graph for this function:

addScale() [1/2]

template<typename M, typename FPT>

template<typename T >

Hmatrix_& h2d::Hmatrix_< M, FPT >::addScale ( T  k )

inline

Adds the same scale factor to the matrix.

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        return this->addScale( k, k );
    }

Here is the caller graph for this function:

addScale() [2/2]

template<typename M, typename FPT>

template<typename T1 , typename T2 >

Hmatrix_& h2d::Hmatrix_< M, FPT >::addScale ( T1  kx, T2  ky  )

inline

Adds a scale factor to the matrix.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        Hmatrix_ out;
        out.setScale( kx, ky );
        *this = out * *this;
        _hasChanged = true;
        return *this;
    }

addTranslation()

template<typename M, typename FPT>

template<typename T >

Hmatrix_& h2d::Hmatrix_< M, FPT >::addTranslation ( T  tx, T  ty  )

inline

Adds a translation tx,ty to the matrix.

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        Hmatrix_ out;
        out.setTranslation( tx, ty );
        *this = out * *this;
        return *this;
    }

Here is the caller graph for this function:

applyTo()

template<typename W , typename FPT >

template<typename T >

void h2d::Hmatrix_< W, FPT >::applyTo

(

T &

vin

)

const

Apply homography to a vector/array/list (type T) of points or lines.

{
#if 0
    std::transform(
        std::begin( vin ),
        std::end( vin ),
        std::begin( vin ),
        [](){}
    );
#else
    for( auto& elem: vin )
        elem = *this * elem;
#endif
}

Here is the caller graph for this function:

buildFrom4Points()

template<typename M , typename FPT>

void h2d::Hmatrix_< M, FPT >::buildFrom4Points	(	const std::vector< Point2d_< FPT >> &	vpt1,
		const std::vector< Point2d_< FPT >> &	vpt2,
		int	method = 1
	)

Build Homography from 2 sets of 4 points.

• Requires either Eigen or Opencv
• we build a 8x8 matrix A and a 8x1 vector B, and get the solution from X = A^-1 B
• see this for details: https://skramm.lautre.net/files/misc/Kramm_compute_H_from_4pts.pdf

See also

free function: h2d::buildFrom4Points()

Todo:

fix this so that user can provide a std::array of points

Parameters

vpt1	source points
vpt2	destination points
method	0: Eigen, 1: Opencv (default)

{
    if( vpt1.size() != 4 )
        HOMOG2D_THROW_ERROR_1( "invalid vector size for source points, should be 4, value=" << vpt1.size() );
    if( vpt2.size() != 4 )
        HOMOG2D_THROW_ERROR_1( "invalid vector size for dest points, should be 4, value=" << vpt2.size() );
    assert( method == 0 || method == 1 );

    if( method == 0 )
    {
#ifdef HOMOG2D_USE_EIGEN
        *this = detail::buildFrom4Points_Eigen( vpt1, vpt2 );
#else
        throw std::runtime_error( "Unable, build without Eigen support" );
#endif
    }
    else
    {
#ifdef HOMOG2D_USE_OPENCV
        *this = detail::buildFrom4Points_Opencv( vpt1, vpt2 );
#else
        throw std::runtime_error( "Unable, build without Opencv support" );
#endif
    }
}

Here is the caller graph for this function:

copyTo()

template<typename W , typename FPT >

void h2d::Hmatrix_< W, FPT >::copyTo	(	cv::Mat &	mat,
		int	type = CV_64F
	)		const

Copy matrix to Opencv cv::Mat.

The output matrix is passed by reference to avoid issues with Opencv copy operator, and is allocated here.

User can pass a type as second argument: CV_32F for float, CV_64F for double (default)

{
    auto& data = detail::Matrix_<FPT>::_mdata;
#ifndef HOMOG2D_NOCHECKS
    if( type != CV_64F && type != CV_32F )
        throw std::runtime_error( "invalid OpenCv matrix type" );
#endif
    mat.create( 3, 3, type ); // default:CV_64F
    size_t i=0;
    switch( type )
    {
        case CV_64F:
            for( auto it = mat.begin<double>(); it != mat.end<double>(); it++, i++ )
                *it = data[i/3][i%3];
            break;
        case CV_32F:
            for( auto it = mat.begin<float>(); it != mat.end<float>(); it++, i++ )
                *it = data[i/3][i%3];
            break;
        default: assert(0);
    }
}

Here is the caller graph for this function:

init()

template<typename M, typename FPT>

void h2d::Hmatrix_< M, FPT >::init ( )

inline

    {
        impl_mat_init0( detail::BaseHelper<M>() );
    }

inverse()

template<typename M, typename FPT>

Hmatrix_& h2d::Hmatrix_< M, FPT >::inverse ( )

inline

Inverse matrix.

    {
        detail::Matrix_<FPT>::inverse();
        normalize();
        return *this;
    }

Here is the caller graph for this function:

normalize()

template<typename M, typename FPT>

void h2d::Hmatrix_< M, FPT >::normalize ( ) const

inline

Homography normalisation (const because flag _hasChanged declared as mutable)

    {
        detail::Matrix_<FPT>::p_normalizeMat(2,2);
        _hasChanged = true;
    }

Here is the caller graph for this function:

operator!=()

template<typename M, typename FPT>

bool h2d::Hmatrix_< M, FPT >::operator!= ( const Hmatrix_< M, FPT > &  h ) const

inline

Comparison operator. Does normalization if required.

    {
        return !(*this == h);
    }

operator=() [1/2]

template<typename M, typename FPT>

Hmatrix_& h2d::Hmatrix_< M, FPT >::operator= ( const Hmatrix_< M, FPT > &  other )

inline

Assignment operator.

    {
        if( this != &other )
            detail::Matrix_<FPT>::getRaw() = other.getRaw();
        _hasChanged = true;
        return *this;
    }

operator=() [2/2]

template<typename W, typename FPT>

Hmatrix_< W, FPT > & h2d::Hmatrix_< W, FPT >::operator=

(

const cv::Mat &

mat

)

Get homography from Opencv cv::Mat.

{
    auto type = mat.type();
#ifndef HOMOG2D_NOCHECKS
    if( mat.rows != 3 || mat.cols != 3 )
        throw std::runtime_error( "invalid matrix size, rows=" + std::to_string(mat.rows) + " cols=" + std::to_string(mat.cols) );
    if( mat.channels() != 1 )
        throw std::runtime_error( "invalid matrix nb channels: " + std::to_string(mat.channels() ) );
    if( type != CV_64F && type != CV_32F )
        throw std::runtime_error( "invalid matrix type" );
#endif
    size_t i=0;

    auto& data = detail::Matrix_<FPT>::_mdata;
    switch( type )
    {
        case CV_64F:
            for( auto it = mat.begin<double>(); it != mat.end<double>(); it++, i++ )
                data[i/3][i%3] = *it;
            break;
        case CV_32F:
            for( auto it = mat.begin<float>(); it != mat.end<float>(); it++, i++ )
                data[i/3][i%3] = *it;
            break;
        default: assert(0);
    }
    return *this;
}

operator==()

template<typename M, typename FPT>

bool h2d::Hmatrix_< M, FPT >::operator== ( const Hmatrix_< M, FPT > &  h ) const

inline

Comparison operator. Does normalization if required.

This does an absolute comparison of all matrix elements, one by one, and if one differs more than the threshold, it will return false

    {
        auto& data = detail::Matrix_<FPT>::_mdata;

        if( !detail::Matrix_<FPT>::isNormalized() )
            normalize();
        if( !h.isNormalized() )
            h.normalize();

        for( int i=0; i<3; i++ )
            for( int j=0; j<3; j++ )
                if( std::fabs(
                    static_cast<HOMOG2D_INUMTYPE>( data[i][j] ) - h.value(i,j) )
                    >= thr::nullDeter()
                )
                    return false;
        return true;
    }

setRotation()

template<typename M, typename FPT>

template<typename T >

Hmatrix_& h2d::Hmatrix_< M, FPT >::setRotation ( T  theta )

inline

Sets the matrix as a rotation with an angle theta (radians)

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        auto& mat = detail::Matrix_<FPT>::_mdata;
        init();
        mat[0][0] = mat[1][1] = std::cos(theta);
        mat[1][0] = std::sin(theta);
        mat[0][1] = -mat[1][0];
        detail::Matrix_<FPT>::_isNormalized = true;
        _hasChanged = true;
        return *this;
    }

Here is the caller graph for this function:

setScale() [1/2]

template<typename M, typename FPT>

template<typename T >

Hmatrix_& h2d::Hmatrix_< M, FPT >::setScale ( T  k )

inline

Sets the matrix as a scaling transformation (same on two axis)

    {
        HOMOG2D_CHECK_IS_NUMBER(T);
        return setScale( k, k );
    }

Here is the caller graph for this function:

setScale() [2/2]

template<typename M, typename FPT>

template<typename T1 , typename T2 >

Hmatrix_& h2d::Hmatrix_< M, FPT >::setScale ( T1  kx, T2  ky  )

inline

Sets the matrix as a scaling transformation.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        init();
        auto& mat = detail::Matrix_<FPT>::_mdata;
        mat[0][0] = kx;
        mat[1][1] = ky;
        detail::Matrix_<FPT>::_isNormalized = true;
        _hasChanged = true;
        return *this;
    }

setTranslation()

template<typename M, typename FPT>

template<typename T1 , typename T2 >

Hmatrix_& h2d::Hmatrix_< M, FPT >::setTranslation ( T1  tx, T2  ty  )

inline

Sets the matrix as a translation tx,ty.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        init();
        auto& mat = detail::Matrix_<FPT>::_mdata;
        mat[0][2] = tx;
        mat[1][2] = ty;
        detail::Matrix_<FPT>::_isNormalized = true;
        _hasChanged = true;
        return *this;
    }

Here is the caller graph for this function:

Friends And Related Function Documentation

LPBase

template<typename M, typename FPT>

template<typename T1 , typename T2 >

friend class LPBase

friend

operator* [1/4]

template<typename M, typename FPT>

template<typename T , typename U >

Line2d_<T> operator* ( const Homogr_< U > &  , const Line2d_< T > &    )

friend

operator* [2/4]

template<typename M, typename FPT>

template<typename T , typename U >

Point2d_<T> operator* ( const Homogr_< U > &  , const Point2d_< T > &    )

friend

operator* [3/4]

template<typename M, typename FPT>

template<typename T , typename U , typename V >

base::LPBase<typename detail::HelperPL<T>::OtherType,V> operator* ( const Hmatrix_< typ::IsEpipmat, U > &  h, const base::LPBase< T, V > &  in  )

friend

operator* [4/4]

template<typename M, typename FPT>

Hmatrix_ operator* ( const Hmatrix_< M, FPT > &  h1, const Hmatrix_< M, FPT > &  h2  )

friend

Matrix multiplication, call the base class product.

    {
        Hmatrix_ out;
        detail::product( out, static_cast<detail::Matrix_<FPT>>(h1), static_cast<detail::Matrix_<FPT>>(h2) ) ;
        out.normalize();
        out._hasChanged = true;
        return out;
    }

operator<<

template<typename M, typename FPT>

std::ostream& operator<< ( std::ostream &  f, const Hmatrix_< M, FPT > &  h  )

friend

    {
        f << "Hmatrix:\n"
            << static_cast<const detail::Matrix_<FPT>&>(h);
        return f;
    }

---

The documentation for this class was generated from the following file:

• homog2d.hpp