h2d::Ellipse_< FPT > Class Template Reference

Ellipse as a conic in matrix form. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::Ellipse_< FPT >:

Collaboration diagram for h2d::Ellipse_< FPT >:

Public Types
using	FType = FPT
using	SType = typ::T_Ellipse

Public Member Functions
HOMOG2D_INUMTYPE	area () const
	Area of ellipse. More...
void	draw (img::Image< cv::Mat > &, img::DrawParams dp=img::DrawParams()) const
	Draw Ellipse (Opencv implementation) More...
void	draw (img::Image< img::SvgImage > &, img::DrawParams dp=img::DrawParams()) const
	Draw Ellipse (SVG implementation) More...
std::pair< Line2d_< FPT >, Line2d_< FPT > >	getAxisLines () const
	Returns pair of axis lines of ellipse. More...
HOMOG2D_INUMTYPE	length () const
	Returns (approximate) perimeter of ellipse using the Ramanujan second formulae. More...
template<typename TX , typename TY >
void	moveTo (TX x, TY y)
	Move Ellipse to new location. More...
template<typename T1 >
void	moveTo (const Point2d_< T1 > &new_org)
	Move Ellipse to new location, given by new_org. More...
bool	operator!= (const Ellipse_ &e) const
	Comparison operator. Does normalization if required. More...
bool	operator== (const Ellipse_ &h) const
	Comparison operator. Does normalization if required. More...
template<typename FPT2 >
bool	pointIsInside (const Point2d_< FPT2 > &) const
	Returns true if point is inside ellipse. More...
template<typename TX , typename TY >
void	translate (TX dx, TY dy)
	Translate Ellipse. More...
template<typename T1 , typename T2 >
void	translate (const std::pair< T1, T2 > &ppt)
	Translate Ellipse. More...
Type	type () const
Constructors
	Ellipse_ ()
	Default constructor: centered at (0,0), major=2, minor=1. More...
template<typename T1 , typename T2 = double, typename T3 = double>
	Ellipse_ (const Point2d_< T1 > &pt, T2 major=2., T2 minor=1., T3 angle=0.)
	Constructor 1. More...
template<typename T1 , typename T2 = double, typename T3 = double>
	Ellipse_ (T1 x, T1 y, T2 major=2., T2 minor=1., T3 angle=0.)
	Constructor 2. More...
	Ellipse_ (const Circle_< FPT > &cir)
	Constructor 3, import from circle. More...
template<typename FPT2 >
	Ellipse_ (const Ellipse_< FPT2 > &other)
	Copy-Constructor. More...
attributes of ellipse
constexpr size_t	size () const
	Returns 1. More...
bool	isCircle (HOMOG2D_INUMTYPE thres=1.E-10) const
	Returns true if ellipse is a circle. More...
Point2d_< FPT >	getCenter () const
	Returns center of ellipse. More...
CPolyline_< FPT >	getOBB () const
	Returns oriented bounding box of ellipse as a closed Polyline. More...
auto	getBB () const
	Returns axis-aligned bounding box of ellipse. More...
HOMOG2D_INUMTYPE	angle () const
	Returns angle of ellipse. More...
std::pair< HOMOG2D_INUMTYPE, HOMOG2D_INUMTYPE >	getMajMin () const
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
Public Member Functions inherited from h2d::rtp::Root
virtual	~Root ()

Friends
template<typename T >
class	Ellipse_
template<typename FPT1 , typename FPT2 >
Ellipse_< FPT1 >	operator* (const Homogr_< FPT2 > &, const Circle_< FPT1 > &)
	Apply homography to a Circle, produces an Ellipse. More...
template<typename FPT1 , typename FPT2 >
Ellipse_< FPT1 >	operator* (const Homogr_< FPT2 > &, const Ellipse_< FPT1 > &)
	Apply homography to a Ellipse, produces an Ellipse. More...
template<typename T >
std::ostream &	operator<< (std::ostream &f, const Ellipse_< T > &ell)

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 FPT>
class h2d::Ellipse_< FPT >

Ellipse as a conic in matrix form.

This enables its projection using homography

See:

• https://en.wikipedia.org/wiki/Ellipse#General_ellipse
• https://en.wikipedia.org/wiki/Matrix_representation_of_conic_sections

General equation of an ellipse:

\[ A x^2 + B x y + C y^2 + D x + E y + F = 0 \]

It can be written as a 3 x 3 matrix:

\[ \begin{bmatrix} A & B/2 & D/2 \\ B/2 & C & E/2 \\ D/2 & E/2 & F \end{bmatrix} \]

Matrix coefficients computed from center x0,y0, major and minor distances (a,b) and angle theta:

\[ \begin{aligned} A &= a^2 \sin^2\theta + b^2 \cos^2\theta \\ B &= 2\left(b^2 - a^2\right) \sin\theta \cos\theta \\ C &= a^2 \cos^2\theta + b^2 \sin^2\theta \\ D &= -2A x_\circ - B y_\circ \\ E &= - B x_\circ - 2C y_\circ \\ F &= A x_\circ^2 + B x_\circ y_\circ + C y_\circ^2 - a^2 b^2 \end{aligned} \]

Homography projection: https://math.stackexchange.com/a/2320082/133647

\[ Q' = H^{-T} \cdot Q \cdot H^{-1} \]

Member Typedef Documentation

FType

template<typename FPT>

using h2d::Ellipse_< FPT >::FType = FPT

SType

template<typename FPT>

using h2d::Ellipse_< FPT >::SType = typ::T_Ellipse

Constructor & Destructor Documentation

Ellipse_() [1/5]

template<typename FPT>

h2d::Ellipse_< FPT >::Ellipse_ ( )

inline

Default constructor: centered at (0,0), major=2, minor=1.

              : Ellipse_( 0., 0., 2., 1., 0. )
    {}

Ellipse_() [2/5]

template<typename FPT>

template<typename T1 , typename T2 = double, typename T3 = double>

h2d::Ellipse_< FPT >::Ellipse_ ( const Point2d_< T1 > &  pt, T2  major = 2., T2  minor = 1., T3  angle = 0.  )

inline

Constructor 1.

        : Ellipse_( pt.getX(), pt.getY(), major, minor, angle )
    {}

Ellipse_() [3/5]

template<typename FPT>

template<typename T1 , typename T2 = double, typename T3 = double>

h2d::Ellipse_< FPT >::Ellipse_ ( T1  x, T1  y, T2  major = 2., T2  minor = 1., T3  angle = 0.  )

inlineexplicit

Constructor 2.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        HOMOG2D_CHECK_IS_NUMBER(T3);
        if( major<minor )
            std::swap( major, minor );
        p_init( x, y, major, minor, angle );
    }

Ellipse_() [4/5]

template<typename FPT>

h2d::Ellipse_< FPT >::Ellipse_ ( const Circle_< FPT > &  cir )

inlineexplicit

Constructor 3, import from circle.

    {
        p_init( cir.center().getX(), cir.center().getY(), cir.radius(), cir.radius(), 0. );
    }

Ellipse_() [5/5]

template<typename FPT>

template<typename FPT2 >

h2d::Ellipse_< FPT >::Ellipse_ ( const Ellipse_< FPT2 > &  other )

inline

Copy-Constructor.

        : detail::Matrix_<FPT>( other )
    {}

Member Function Documentation

angle()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::Ellipse_< FPT >::angle

(

)

const

Returns angle of ellipse.

See also

angle( const Ellipse_& )

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    return par.theta;
}

Here is the caller graph for this function:

area()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::Ellipse_< FPT >::area ( ) const

inlinevirtual

Area of ellipse.

Implements h2d::rtp::Root.

    {
        auto par = p_getParams<HOMOG2D_INUMTYPE>();
        return M_PI * par.a * par.b;
    }

draw() [1/2]

template<typename FPT >

void h2d::Ellipse_< FPT >::draw ( img::Image< cv::Mat > &  im, img::DrawParams  dp = img::DrawParams()  ) const

virtual

Draw Ellipse (Opencv implementation)

• see https://docs.opencv.org/3.4/d6/d6e/group__imgproc__draw.html#ga28b2267d35786f5f890ca167236cbc69

Implements h2d::rtp::Root.

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    cv::ellipse(
        im.getReal(),
        cv::Point( par.x0,par.y0 ),
        cv::Size( par.a, par.b ),
        par.theta*180./M_PI,
        0., 360.,
        dp.cvColor(),
        dp._dpValues._lineThickness,
        dp._dpValues._lineType==1?cv::LINE_AA:cv::LINE_8
    );
}

Here is the caller graph for this function:

draw() [2/2]

template<typename FPT >

void h2d::Ellipse_< FPT >::draw ( img::Image< img::SvgImage > &  im, img::DrawParams  dp = img::DrawParams()  ) const

virtual

Draw Ellipse (SVG implementation)

Implements h2d::rtp::Root.

{
    im.getReal()._svgString << "<ellipse cx=\""
        << getCenter().getX()
        << "\" cy=\""
        << getCenter().getY()
        << "\" rx=\""
        << getMajMin().first
        << "\" ry=\""
        << getMajMin().second
        << "\" stroke=\""
        << dp.getSvgRgbColor()
        << "\" stroke-width=\"" << dp._dpValues._lineThickness << "\" ";
    if( !dp.holdsFill() )
        im.getReal()._svgString << "fill=\"none\" ";
    im.getReal()._svgString << dp.getAttrString()
        << "transform=\"rotate(" << angle()*180./M_PI << ',' << getCenter().getX() << ',' << getCenter().getY()
        << ")\" />\n";
}

getAxisLines()

template<typename FPT >

std::pair< Line2d_< FPT >, Line2d_< FPT > > h2d::Ellipse_< FPT >::getAxisLines

(

)

const

Returns pair of axis lines of ellipse.

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    auto dy = static_cast<HOMOG2D_INUMTYPE>(par.sint) * par.a;
    auto dx = static_cast<HOMOG2D_INUMTYPE>(par.cost) * par.a;
    Point2d_<HOMOG2D_INUMTYPE> ptA(
        par.x0 + dx,
        par.y0 + dy
    );
    auto pt0 = Point2d_<HOMOG2D_INUMTYPE>( par.x0, par.y0 );
    auto li_H = ptA * pt0;
    HOMOG2D_LOG( std::scientific << "ptA=" << ptA << " pt0=" << pt0 << " li_H=" << li_H );

    auto li_V = li_H.getOrthogLine( pt0 );
    return std::make_pair( li_H, li_V );
}

Here is the caller graph for this function:

getBB()

template<typename FPT >

auto h2d::Ellipse_< FPT >::getBB

(

)

const

Returns axis-aligned bounding box of ellipse.

• see https://math.stackexchange.com/questions/91132/how-to-get-the-limits-of-rotated-ellipse

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    auto vx = par.a2 * par.cost * par.cost  + par.b2 * par.sint * par.sint;
    auto vy = par.a2 * par.sint * par.sint  + par.b2 * par.cost * par.cost;
    auto vx_sq = homog2d_sqrt( vx );
    auto vy_sq = homog2d_sqrt( vy );
    return FRect_<HOMOG2D_INUMTYPE>(
        Point2d_<HOMOG2D_INUMTYPE>( par.x0 - vx_sq, par.y0 - vy_sq ),
        Point2d_<HOMOG2D_INUMTYPE>( par.x0 + vx_sq, par.y0 + vy_sq )
    );
}

Here is the caller graph for this function:

getCenter()

template<typename FPT >

Point2d_< FPT > h2d::Ellipse_< FPT >::getCenter

(

)

const

Returns center of ellipse.

See also

center( const T& )

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    return Point2d_<FPT>( par.x0, par.y0 );
}

Here is the caller graph for this function:

getMajMin()

template<typename FPT >

std::pair< HOMOG2D_INUMTYPE, HOMOG2D_INUMTYPE > h2d::Ellipse_< FPT >::getMajMin

(

)

const

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    return std::make_pair( par.a, par.b );
}

Here is the caller graph for this function:

getOBB()

template<typename FPT >

CPolyline_< FPT > h2d::Ellipse_< FPT >::getOBB

(

)

const

Returns oriented bounding box of ellipse as a closed Polyline.

Algorithm:

• build line liH going through major axis, by using center point and point on semi-major axis, intersecting ellipse
• get opposite point ptB, lying on line and at distance a
• get the two parallel lines to liH, at a distance b
• get the two orthogonal lines at ptA and ptB

Todo:

20240330: unclear, the text above does not match what is done below (or does it?). Clarify that, and build a gif showing how this is done.

{
// step 1: build ptA using angle
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    auto dy = par.sint * par.a;
    auto dx = par.cost * par.a;
    Point2d_<FPT> ptA(
        par.x0 + dx,
        par.y0 + dy
    );
    auto pt0 = Point2d_<HOMOG2D_INUMTYPE>( par.x0, par.y0 );

// step 2: build main-axis line, going through center and ptA
    auto li_H = ptA * pt0;

// step 3: get ptB, using line and distance
    auto ppts = li_H.getPoints( pt0, par.a );
    auto ptB = ppts.first;
    if( ptB == ptA )
        ptB = ppts.second;

    auto para = getParallelLines( li_H, par.b );
    auto li_V1 = li_H.getOrthogLine( ptA );
    auto li_V2 = li_H.getOrthogLine( ptB );

    CPolyline_<FPT> out;
#ifndef HOMOG2D_DEBUGMODE
    out.p_addPoint( para.first  * li_V1 );
    out.p_addPoint( para.second * li_V1 );
    out.p_addPoint( para.second * li_V2 );
    out.p_addPoint( para.first  * li_V2 );
#else
    auto p1 = para.first  * li_V1;
    auto p2 = para.second * li_V1;
    auto p3 = para.second * li_V2;
    auto p4 = para.first  * li_V2;
    HOMOG2D_DEBUG_ASSERT(
        ( p2!=p1 && p3!=p2 && p4!=p3 ),
        "p1=" << p1 << " p2=" << p2 << " p3=" << p3 << " p4=" << p4
        << "\n para.1=" << para.first
        << "\n li_V1=" << li_V1
        << "\n ptA=" << ptA
        << "\n ptB=" << ptB
        << "\n " << ppts
    );
    out.p_addPoint( p1 );
    out.p_addPoint( p2 );
    out.p_addPoint( p3 );
    out.p_addPoint( p4 );
#endif
    return out;
}

Here is the caller graph for this function:

isCircle()

template<typename FPT >

bool h2d::Ellipse_< FPT >::isCircle

(

HOMOG2D_INUMTYPE

thres = 1.E-10

)

const

Returns true if ellipse is a circle.

Using the matrix representation, if A = C and B = 0, then the ellipse is a circle

You can provide the 0 threshold as and argument

{
    const auto& m = detail::Matrix_<FPT>::_mdata;
    HOMOG2D_INUMTYPE A  = m[0][0];
    HOMOG2D_INUMTYPE C  = m[1][1];
    HOMOG2D_INUMTYPE B2 = m[0][1];
    if( homog2d_abs(A-C) < thres )
        if( homog2d_abs(B2)*2. < thres )
            return true;
    return false;
}

Here is the caller graph for this function:

length()

template<typename FPT >

HOMOG2D_INUMTYPE h2d::Ellipse_< FPT >::length ( ) const

virtual

Returns (approximate) perimeter of ellipse using the Ramanujan second formulae.

See https://en.wikipedia.org/wiki/Ellipse#Circumference

Implements h2d::rtp::Root.

{
    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    auto ab_sum  = par.a + par.b;
    auto ab_diff = par.a - par.b;
    auto h = ab_diff * ab_diff / (ab_sum * ab_sum);
    auto denom = (HOMOG2D_INUMTYPE)10. + homog2d_sqrt(4. - 3. * h);
    return (par.a + par.b) * M_PI * ( 1. + 3. * h / denom );
}

moveTo() [1/2]

template<typename FPT>

template<typename TX , typename TY >

void h2d::Ellipse_< FPT >::moveTo ( TX  x, TY  y  )

inline

Move Ellipse to new location.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        auto par = p_getParams<HOMOG2D_INUMTYPE>();
        p_init( x, y, par.a, par.b, par.theta );
    }

moveTo() [2/2]

template<typename FPT>

template<typename T1 >

void h2d::Ellipse_< FPT >::moveTo ( const Point2d_< T1 > &  new_org )

inline

Move Ellipse to new location, given by new_org.

    {
        this->moveTo( new_org.getX(), new_org.getY() );
    }

operator!=()

template<typename FPT>

bool h2d::Ellipse_< FPT >::operator!= ( const Ellipse_< FPT > &  e ) const

inline

Comparison operator. Does normalization if required.

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

operator==()

template<typename FPT>

bool h2d::Ellipse_< FPT >::operator== ( const Ellipse_< FPT > &  h ) const

inline

Comparison operator. Does normalization if required.

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

        if( !detail::Matrix_<FPT>::isNormalized() )
            detail::Matrix_<FPT>::p_normalizeMat(2,2);
        if( !h.isNormalized() )
            h.p_normalizeMat(2,2);

        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;
    }

pointIsInside()

template<typename FPT >

template<typename FPT2 >

bool h2d::Ellipse_< FPT >::pointIsInside

(

const Point2d_< FPT2 > &

pt

)

const

Returns true if point is inside ellipse.

taken from https://stackoverflow.com/a/16814494/193789

{
    HOMOG2D_INUMTYPE x = pt.getX();
    HOMOG2D_INUMTYPE y = pt.getY();

    auto par = p_getParams<HOMOG2D_INUMTYPE>();
    const auto& x0 = par.x0;
    const auto& y0 = par.y0;

    auto v1 = par.cost * (x-x0) + par.sint * (y-y0);
    HOMOG2D_INUMTYPE sum = v1*v1 / par.a2;

    auto v2 = par.sint * (x-x0) - par.cost * (y-y0);
    sum += v2*v2 / par.b2;
    if( sum < 1. )
        return true;
    return false;
}

Here is the caller graph for this function:

size()

template<typename FPT>

constexpr size_t h2d::Ellipse_< FPT >::size ( ) const

inlinevirtual

Returns 1.

Implements h2d::rtp::Root.

    {
        return 1;
    }

translate() [1/2]

template<typename FPT>

template<typename TX , typename TY >

void h2d::Ellipse_< FPT >::translate ( TX  dx, TY  dy  )

inline

Translate Ellipse.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        auto par = p_getParams<HOMOG2D_INUMTYPE>();
        p_init( par.x0+dx, par.y0+dy, par.a, par.b, par.theta );
    }

translate() [2/2]

template<typename FPT>

template<typename T1 , typename T2 >

void h2d::Ellipse_< FPT >::translate ( const std::pair< T1, T2 > &  ppt )

inline

Translate Ellipse.

    {
        this->translate( ppt.first, ppt.second );
    }

type()

template<typename FPT>

Type h2d::Ellipse_< FPT >::type ( ) const

inlinevirtual

Implements h2d::rtp::Root.

    {
        return Type::Ellipse;
    }

Friends And Related Function Documentation

Ellipse_

template<typename FPT>

template<typename T >

friend class Ellipse_

friend

operator* [1/2]

template<typename FPT>

template<typename FPT1 , typename FPT2 >

Ellipse_<FPT1> operator* ( const Homogr_< FPT2 > &  h, const Circle_< FPT1 > &  cir  )

friend

Apply homography to a Circle, produces an Ellipse.

Converts the circle to an ellipse, then calls the corresponding code

{
    Ellipse_<FPT1> ell_in( cir );
    return h * ell_in;
}

operator* [2/2]

template<typename FPT>

template<typename FPT1 , typename FPT2 >

Ellipse_<FPT1> operator* ( const Homogr_< FPT2 > &  h, const Ellipse_< FPT1 > &  ell_in  )

friend

Apply homography to a Ellipse, produces an Ellipse.

\[ Q' = H^{-T} \cdot Q \cdot H^{-1} \]

{
    auto hm = static_cast<detail::Matrix_<HOMOG2D_INUMTYPE>>(h);
    hm.inverse();
    auto hmt = hm;
    hmt.transpose();

    const auto& ell_in2 = static_cast<detail::Matrix_<FPT1>>(ell_in);
    auto prod = hmt * ell_in2 * hm;

    Ellipse_<FPT1> out( prod );
    return out;
}

operator<<

template<typename FPT>

template<typename T >

std::ostream& operator<< ( std::ostream &  f, const Ellipse_< T > &  ell  )

friend

{
    auto par = ell.template p_getParams<HOMOG2D_INUMTYPE>();
    f << par;
    return f;
}

---

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

• homog2d.hpp