h2d::img::Image< T > Class Template Reference

Opaque data structure, will hold the image type, depending on back-end library. This type is the one used in all the drawing functions. More...

#include <homog2d.hpp>

Public Member Functions
void	clear (Color c=Color(255, 255, 255))
void	clear (uint8_t, uint8_t, uint8_t)
void	clear (uint8_t)
template<>
void	clear (uint8_t, uint8_t, uint8_t)
template<>
void	clear (uint8_t r, uint8_t g, uint8_t b)
template<>
void	clear (uint8_t col)
int	cols () const
template<typename U >
void	draw (const U &object, img::DrawParams dp=img::DrawParams())
template<typename U , typename V >
void	draw (const std::pair< U, V > &p_objects, img::DrawParams dp=img::DrawParams())
void	drawText (std::string, Point2d_< float >, img::DrawParams dp=img::DrawParams())
template<>
void	drawText (std::string str, Point2d_< float > pt, img::DrawParams dp)
	Draw text on Svg image. More...
template<>
void	drawText (std::string str, Point2d_< float > pt, img::DrawParams dp)
	Draw text on Opencv image. More...
T &	getReal ()
	Returns a reference on the underlying image. More...
const T &	getReal () const
	Returns a const reference on the underlying image. More...
	Image ()=default
	Image (T &m)
	Image (size_t, size_t)
	That constructor is the default, shouln't be instanciated, see specializations. More...
template<>
	Image (size_t width, size_t height)
template<>
	Image (size_t width, size_t height)
int	rows () const
void	setSize (size_t width, size_t height)
template<typename F >
void	setSize (const std::pair< F, F > &)
template<>
void	setSize (size_t width, size_t height)
template<typename T >
void	setSize (const std::pair< T, T > &pa)
void	show (std::string wname)
	Show image on window wname (not available for SVG !) More...
std::pair< size_t, size_t >	size () const
void	write (std::string) const
template<>
void	write (std::string fname) const
template<>
void	write (std::string fname) const

Friends
std::ostream &	operator<< (std::ostream &, const Image< SvgImage > &)
	Streaming operator (only defined for SVG) More...

Detailed Description

template<typename T>
class h2d::img::Image< T >

Opaque data structure, will hold the image type, depending on back-end library. This type is the one used in all the drawing functions.

At present the two allowed types are cv::Mat (external Opencv library, requires the symbol HOMOG2D_USE_OPENCV to be defined) or SvgImage (no dependency)

Constructor & Destructor Documentation

Image() [1/5]

template<typename T>

h2d::img::Image< T >::Image ( )

default

Image() [2/5]

template<typename T>

h2d::img::Image< T >::Image ( T &  m )

inline

                 : _realImg(m)
    {}

Image() [3/5]

template<typename T>

h2d::img::Image< T >::Image ( size_t  , size_t    )

inline

That constructor is the default, shouln't be instanciated, see specializations.

    {
        assert(0);
//      static_assert( detail::AlwaysFalse<std::false_type>::value, "no concrete implementation available" );
//      static_assert( std::false_type, "no concrete implementation available" );
    }

Image() [4/5]

template<>

h2d::img::Image< cv::Mat >::Image ( size_t  width, size_t  height  )

inline

{
    p_setSize( width, height );
}

Image() [5/5]

template<>

h2d::img::Image< SvgImage >::Image ( size_t  width, size_t  height  )

inline

{
    setSize( width, height );
}

Member Function Documentation

clear() [1/6]

template<typename T>

void h2d::img::Image< T >::clear ( Color  c = Color(255,255,255) )

inline

{ clear(c.r,c.g,c.b); }

Here is the caller graph for this function:

clear() [2/6]

template<typename T>

void h2d::img::Image< T >::clear ( uint8_t  , uint8_t  , uint8_t    )

inline

    {
        assert(0);
    }

clear() [3/6]

template<typename T>

void h2d::img::Image< T >::clear ( uint8_t  )

inline

    {
        assert(0);
    }

clear() [4/6]

template<>

void h2d::img::Image< SvgImage >::clear ( uint8_t  , uint8_t  , uint8_t    )

inline

{
    _realImg._svgString.str("");
    _realImg._svgString.clear();
}

clear() [5/6]

template<>

void h2d::img::Image< cv::Mat >::clear ( uint8_t  r, uint8_t  g, uint8_t  b  )

inline

{
    _realImg = cv::Scalar(b,g,r);
}

clear() [6/6]

template<>

void h2d::img::Image< cv::Mat >::clear ( uint8_t  col )

inline

{
    _realImg = cv::Scalar(col,col,col);
}

cols()

template<typename T>

int h2d::img::Image< T >::cols ( ) const

inline

{ return _width; }

Here is the caller graph for this function:

draw() [1/2]

template<typename IMG >

template<typename U >

void h2d::img::Image< IMG >::draw	(	const U &	object,
		img::DrawParams	dp = img::DrawParams()
	)

{
    object.draw( *this, dp );
}

Here is the caller graph for this function:

draw() [2/2]

template<typename IMG >

template<typename U , typename V >

void h2d::img::Image< IMG >::draw	(	const std::pair< U, V > &	p_objects,
		img::DrawParams	dp = img::DrawParams()
	)

{
    pairp.first.draw( *this, dp );
    pairp.second.draw( *this, dp );
}

drawText() [1/3]

template<typename T>

void h2d::img::Image< T >::drawText	(	std::string	,
		Point2d_< float >	,
		img::DrawParams	dp = img::DrawParams()
	)

Here is the caller graph for this function:

drawText() [2/3]

template<>

void h2d::img::Image< img::SvgImage >::drawText ( std::string  str, Point2d_< float >  pt, img::DrawParams  dp  )

inline

Draw text on Svg image.

Todo:

20230118: find a way to add a default parameter for dp (not allowed on explicit instanciation)

{
    getReal()._svgString << "<text x=\"" << pt.getX()
        << "\" y=\"" << pt.getY()
        << "\" font-size=\"" << dp._dpValues._fontSize << "px"
        << "\" fill=\"#" << std::hex << std::setfill('0')
            << std::setw(2) << (int)dp.color().r
            << std::setw(2) << (int)dp.color().g
            << std::setw(2) << (int)dp.color().b
        << std::dec << "\">" << str << "</text>\n";
}

drawText() [3/3]

template<>

void h2d::img::Image< cv::Mat >::drawText ( std::string  str, Point2d_< float >  pt, img::DrawParams  dp  )

inline

Draw text on Opencv image.

{
    auto col = dp.color();
    cv::putText(
        getReal(), str, pt.getCvPtd(),
        cv::FONT_HERSHEY_SIMPLEX,   // font id, see https://docs.opencv.org/4.7.0/
        0.03 * dp._dpValues._fontSize, // scale factor (approximate...)
        cv::Scalar( col.b, col.g, col.r )
    );
}

getReal() [1/2]

template<typename T>

T& h2d::img::Image< T >::getReal ( )

inline

Returns a reference on the underlying image.

    {
        return _realImg;
    }

Here is the caller graph for this function:

getReal() [2/2]

template<typename T>

const T& h2d::img::Image< T >::getReal ( ) const

inline

Returns a const reference on the underlying image.

    {
        return _realImg;
    }

rows()

template<typename T>

int h2d::img::Image< T >::rows ( ) const

inline

{ return _height; }

Here is the caller graph for this function:

setSize() [1/4]

template<typename IMG >

void h2d::img::Image< IMG >::setSize	(	size_t	width,
		size_t	height
	)

{
    _width = width;
    _height = height;
}

Here is the caller graph for this function:

setSize() [2/4]

template<typename T>

template<typename F >

void h2d::img::Image< T >::setSize

(

const std::pair< F, F > &

)

setSize() [3/4]

template<>

void h2d::img::Image< cv::Mat >::setSize ( size_t  width, size_t  height  )

inline

{
    p_setSize( width, height );
}

setSize() [4/4]

template<typename T>

template<typename T >

void h2d::img::Image< T >::setSize

(

const std::pair< T, T > &

pa

)

{
    setSize( pa.first, pa.second );
}

show()

template<typename T>

void h2d::img::Image< T >::show ( std::string  wname )

inline

Show image on window wname (not available for SVG !)

    {
        cv::imshow( wname, _realImg );
    }

Here is the caller graph for this function:

size()

template<typename T>

std::pair<size_t,size_t> h2d::img::Image< T >::size ( ) const

inline

    {
        return std::make_pair( _width, _height );
    }

write() [1/3]

template<typename T>

void h2d::img::Image< T >::write ( std::string  ) const

inline

    {
        assert(0);
    }

Here is the caller graph for this function:

write() [2/3]

template<>

void h2d::img::Image< SvgImage >::write ( std::string  fname ) const

inline

{
    std::ofstream file( fname );
    if( !file.is_open() )
    {
        HOMOG2D_THROW_ERROR_1( "unable to open output file '" + fname + "'" );
    }
    file << "<svg version=\"1.1\" width=\"" << _width
        << "\" height=\"" << _height
        << "\" style=\"background-color:white;\" xmlns=\"http://www.w3.org/2000/svg\">\n"
        << "<style>\n"
        << ".txt1 { font: bold 12px sans-serif; };\n"   // text style, you can change or add classes as required
        << "</style>\n";

    file << _realImg._svgString.str();
    file << "</svg>\n";
}

write() [3/3]

template<>

void h2d::img::Image< cv::Mat >::write ( std::string  fname ) const

inline

{
    cv::imwrite( fname, _realImg );
}

Friends And Related Function Documentation

operator<<

template<typename T>

std::ostream& operator<< ( std::ostream &  f, const Image< SvgImage< T > > &  im  )

friend

Streaming operator (only defined for SVG)

{
    f << "<svg version=\"1.1\" width=\"" << im._width
        << "\" height=\"" << im._height
        << "\" style=\"background-color:white;\" xmlns=\"http://www.w3.org/2000/svg\">\n"
        << "<style>\n"
        << ".txt1 { font: bold 12px sans-serif; };\n"   // text style, you can change or add classes as required
        << "</style>\n";

    f << im._realImg._svgString.str();
    f << "</svg>\n";

    return f;
}

---

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

• homog2d.hpp