h2d::detail::Matrix_< FPT > Class Template Reference

A simple wrapper over a 3x3 matrix, provides root functionalities. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::detail::Matrix_< FPT >:

Collaboration diagram for h2d::detail::Matrix_< FPT >:

Public Member Functions
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

Protected Member Functions
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
bool	_isNormalized = false
matrix_t< FPT >	_mdata

Friends
template<typename T >
class	Matrix_
template<typename T1 , typename T2 >
Matrix_< T1 >	operator* (const Matrix_< T1 > &, const Matrix_< T2 > &)
std::ostream &	operator<< (std::ostream &f, const Matrix_ &h)
template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >
void	product (base::LPBase< T1, FPT1 > &, const detail::Matrix_< FPT2 > &, const base::LPBase< T2, FPT1 > &)
	Implementation of product 3x3 by 3x1. More...
template<typename FPT1 , typename FPT2 , typename FPT3 >
void	product (Matrix_< FPT1 > &, const Matrix_< FPT2 > &, const Matrix_< FPT3 > &)
	Implementation of product 3x3 by 3x3. More...

Detailed Description

template<typename FPT>
class h2d::detail::Matrix_< FPT >

A simple wrapper over a 3x3 matrix, provides root functionalities.

Homogeneous (thus the 'mutable' attribute).

Todo:

20240326: we might need to add another level of inheritance. This class inherits Common, which is designed to be inherited geometric primitives and as such holds member function that cannot be used on a matrix ! (example: isInside() )
So either we remove the latter function and find a way to put it somewhere else, either we create another intermediate class.

Constructor & Destructor Documentation

Matrix_() [1/2]

template<typename FPT>

h2d::detail::Matrix_< FPT >::Matrix_ ( )

inline

Constructor.

    {
        p_fillZero();
    }

Matrix_() [2/2]

template<typename FPT>

template<typename FPT2 >

h2d::detail::Matrix_< FPT >::Matrix_ ( const Matrix_< FPT2 > &  other )

inline

Copy-Constructor.

    {
        for( int i=0; i<3; i++ )
            for( int j=0; j<3; j++ )
                _mdata[i][j] = other._mdata[i][j];
        _isNormalized = other._isNormalized;
    }

Member Function Documentation

determ()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::detail::Matrix_< FPT >::determ ( ) const

inline

Return determinant of matrix.

See https://en.wikipedia.org/wiki/Determinant

    {
        auto det = _mdata[0][0] * p_det2x2( {1,1, 1,2, 2,1, 2,2} );
        det     -= _mdata[0][1] * p_det2x2( {1,0, 1,2, 2,0, 2,2} );
        det     += _mdata[0][2] * p_det2x2( {1,0, 1,1, 2,0, 2,1} );
        return det;
    }

getRaw() [1/2]

template<typename FPT>

matrix_t<FPT>& h2d::detail::Matrix_< FPT >::getRaw ( )

inline

{ return _mdata; }

Here is the caller graph for this function:

getRaw() [2/2]

template<typename FPT>

const matrix_t<FPT>& h2d::detail::Matrix_< FPT >::getRaw ( ) const

inline

{ return _mdata; }

inverse()

template<typename FPT>

Matrix_& h2d::detail::Matrix_< FPT >::inverse ( )

inline

Inverse matrix.

    {
        auto det = determ();
        if( homog2d_abs(det) < thr::nullDeter() )
            HOMOG2D_THROW_ERROR_1( "matrix is not invertible, det=" << std::scientific << homog2d_abs(det) );

        auto adjugate = p_adjugate();
        p_divideAll(adjugate, det);
        _mdata = adjugate._mdata;
        _isNormalized = false;
        return *this;
    }

Here is the caller graph for this function:

isNormalized()

template<typename FPT>

bool h2d::detail::Matrix_< FPT >::isNormalized ( ) const

inline

{ return _isNormalized; }

Here is the caller graph for this function:

p_divideAll()

template<typename FPT>

template<typename FPT2 >

void h2d::detail::Matrix_< FPT >::p_divideAll ( detail::Matrix_< FPT > &  mat, FPT2  value  ) const

inlineprotected

Divide all elements of mat by value.

    {
        for( int i=0; i<3; i++ )
            for( int j=0; j<3; j++ )
                mat._mdata[i][j] /= value;
        _isNormalized = false;
    }

p_divideBy()

template<typename FPT>

void h2d::detail::Matrix_< FPT >::p_divideBy ( size_t  r, size_t  c  ) const

inlineprotected

Divide all elements by the value at (r,c), used for normalization.

No need to check value, done by caller

    {
//      assert( std::fabs( _mdata[r][c] ) > 1000*std::numeric_limits<FPT>::epsilon() );
        for( auto& li: _mdata )
            for( auto& e: li )
                e /= _mdata[r][c];
    }

p_fillEye()

template<typename FPT>

void h2d::detail::Matrix_< FPT >::p_fillEye ( )

inlineprotected

    {
        p_fillZero();
        _mdata[0][0] = 1.;
        _mdata[1][1] = 1.;  // "eye" matrix => unit transformation
        _mdata[2][2] = 1.;
    }

Here is the caller graph for this function:

p_fillWith()

template<typename FPT>

template<typename T >

void h2d::detail::Matrix_< FPT >::p_fillWith ( const T &  in )

inlineprotected

    {
        for( auto i=0; i<3; i++ )
            for( auto j=0; j<3; j++ )
                _mdata[i][j] = in[i][j];
        _isNormalized = false;
    }

Here is the caller graph for this function:

p_fillZero()

template<typename FPT>

void h2d::detail::Matrix_< FPT >::p_fillZero ( )

inlineprotected

    {
        for( auto& li: _mdata )
            for( auto& e: li )
                e = 0.;
    }

p_normalizeMat()

template<typename FPT>

void h2d::detail::Matrix_< FPT >::p_normalizeMat ( int  r, int  c  ) const

inlineprotected

    {
#ifndef HOMOG2D_NOCHECKS
        if( std::fabs(_mdata[r][c]) < thr::nullDenom() )
            HOMOG2D_THROW_ERROR_1(
                "Unable to normalize matrix, value at ("
                    << r << ',' << c << ") less than " << thr::nullDenom()
            );
#endif
        p_divideBy( r, c );
        if( std::signbit( _mdata[r][c] ) )
            for( auto& li: _mdata )
                for( auto& e: li )
                    e = -e;
        _isNormalized = true;
    }

Here is the caller graph for this function:

set()

template<typename FPT>

template<typename T >

void h2d::detail::Matrix_< FPT >::set ( size_t  r, size_t  c, T  v  )

inline

    {
        #ifndef HOMOG2D_NOCHECKS
            HOMOG2D_CHECK_ROW_COL;
        #endif
        _mdata[r][c] = v;
    }

Here is the caller graph for this function:

transpose()

template<typename FPT>

Matrix_& h2d::detail::Matrix_< FPT >::transpose ( )

inline

Transpose and return matrix.

    {
        matrix_t<FPT> out;
        for( int i=0; i<3; i++ )
            for( int j=0; j<3; j++ )
                out[i][j] = _mdata[j][i];
        _mdata = out;
        _isNormalized = false;
        return *this;
    }

Here is the caller graph for this function:

value() [1/2]

template<typename FPT>

const FPT& h2d::detail::Matrix_< FPT >::value ( size_t  r, size_t  c  ) const

inline

    {
        #ifndef HOMOG2D_NOCHECKS
            HOMOG2D_CHECK_ROW_COL;
        #endif
        return _mdata[r][c];
    }

Here is the caller graph for this function:

value() [2/2]

template<typename FPT>

FPT& h2d::detail::Matrix_< FPT >::value ( size_t  r, size_t  c  )

inline

    {
        #ifndef HOMOG2D_NOCHECKS
            HOMOG2D_CHECK_ROW_COL;
        #endif
        return _mdata[r][c];
    }

Friends And Related Function Documentation

Matrix_

template<typename FPT>

template<typename T >

friend class Matrix_

friend

operator*

template<typename FPT>

template<typename T1 , typename T2 >

Matrix_<T1> operator* ( const Matrix_< T1 > &  h1, const Matrix_< T2 > &  h2  )

friend

{
//  HOMOG2D_START;
    Matrix_<T1> out;
    product( out, h1, h2 );
    return out;
}

operator<<

template<typename FPT>

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

friend

    {
        for( const auto& li: h._mdata )
        {
            f << "| ";
            for( const auto& e: li )
                f << std::setw(6) << e << ' ';
            f << " |\n";
        }
        return f;
    }

product [1/2]

template<typename FPT>

template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >

void product ( base::LPBase< T1, FPT1 > &  out, const detail::Matrix_< FPT2 > &  h, const base::LPBase< T2, FPT1 > &  in  )

friend

Implementation of product 3x3 by 3x1.

• T1 and T2: typ::IsLine or typ::IsPoint (same but also different)

{
    for( int i=0; i<3; i++ )
    {
        auto sum  = static_cast<HOMOG2D_INUMTYPE>(h._mdata[i][0]) * in._v[0];
        sum      += h._mdata[i][1] * in._v[1];
        sum      += h._mdata[i][2] * in._v[2];
        out._v[i] = sum;
    }
}

product [2/2]

template<typename FPT>

template<typename FPT1 , typename FPT2 , typename FPT3 >

void product ( Matrix_< FPT1 > &  out, const Matrix_< FPT2 > &  h1, const Matrix_< FPT3 > &  h2  )

friend

Implementation of product 3x3 by 3x3.

{
    out.p_fillZero();
    for( int i=0; i<3; i++ )
        for( int j=0; j<3; j++ )
            for( int k=0; k<3; k++ )
                out.value(i,j) +=
                    static_cast<HOMOG2D_INUMTYPE>( h1.value(i,k) ) * h2.value(k,j);
}

Member Data Documentation

_isNormalized

template<typename FPT>

bool h2d::detail::Matrix_< FPT >::_isNormalized = false

mutableprotected

_mdata

template<typename FPT>

matrix_t<FPT> h2d::detail::Matrix_< FPT >::_mdata

mutableprotected

---

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

• homog2d.hpp