h2d::FRect_< FPT > Class Template Reference

A Flat Rectangle, modeled by its two opposite points. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::FRect_< FPT >:

Collaboration diagram for h2d::FRect_< FPT >:

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

Public Member Functions
void	draw (img::Image< cv::Mat > &, img::DrawParams dp=img::DrawParams()) const
	Draw FRect (Opencv implementation) More...
void	draw (img::Image< img::SvgImage > &, img::DrawParams dp=img::DrawParams()) const
	Draw FRect (SVG implementation) More...
std::array< Point2d_< FPT >, 4 >	get4Pts () const
	Returns the 4 points of the rectangle, starting from "smallest" one, and in clockwise order. More...
std::pair< Segment_< FPT >, Segment_< FPT > >	getDiagonals () const
FRect_< FPT >	getExtended () const
std::array< Segment_< FPT >, 4 >	getSegs () const
	Returns the 4 segments of the rectangle, starting with the first vertical one. More...
template<typename FPT1 , typename FPT2 >
void	set (const Point2d_< FPT1 > &pa, const Point2d_< FPT2 > &pb)
	Assigns points pa and pb to rectangle. More...
template<typename T >
void	set (T x1, T y1, T x2, T y2)
	Assigns points (x1,y1) and (x2,y2) to rectangle. More...
Type	type () const
Constructors
	FRect_ ()
	Default constructor, initialize rectangle to (0,0)-(1,1) More...
template<typename FPT2 >
	FRect_ (const Point2d_< FPT2 > &pa, const Point2d_< FPT2 > &pb)
	Constructor from 2 points. More...
template<typename FPT2 >
	FRect_ (const PointPair_< FPT2 > &ppts)
	Constructor from pair of points. More...
template<typename FPT2 , typename T1 , typename T2 >
	FRect_ (const Point2d_< FPT2 > &p0, T1 w, T2 h)
	Constructor from center point, width and height. More...
template<typename T1 , typename T2 , typename T3 , typename T4 >
	FRect_ (T1 x1, T2 y1, T3 x2, T4 y2)
	Constructor from x1, y1, x2, y2. More...
template<typename FPT2 >
	FRect_ (const FRect_< FPT2 > &other)
	Copy-Constructor. More...
Attributes access
HOMOG2D_INUMTYPE	height () const
HOMOG2D_INUMTYPE	width () const
HOMOG2D_INUMTYPE	area () const
HOMOG2D_INUMTYPE	length () const
constexpr size_t	size () const
FRect_< FPT >	getBB () const
	get BB of rectangle. Needed for getBB( pair of objects ) More...
PointPair_< FPT >	getPts () const
	Returns the 2 major points of the rectangle. More...
Point2d_< FPT >	getCenter () const
	Returns center of rectangle. More...
Circle_< FPT >	getBoundingCircle () const
	Return circle passing through 4 points of flat rectangle. More...
Circle_< FPT >	getInscribedCircle () const
	Return circle inscribed in rectangle. More...
Modifying functions
template<typename TX , typename TY >
void	translate (TX dx, TY dy)
	Translate FRect. More...
template<typename T1 , typename T2 >
void	translate (const std::pair< T1, T2 > &pa)
	Translate FRect. More...
template<typename TX , typename TY >
void	moveTo (TX x, TY y)
	Move FRect to other location. More...
template<typename T1 >
void	moveTo (const Point2d_< T1 > &pt)
	Move FRect to other location, given by pt. More...
template<typename FPT2 >
void	rotate (Rotate, const Point2d_< FPT2 > &)
	Rotates the rectangle by either 90°, 180°, 270° (-90°) at point refpt. More...
void	rotate (Rotate)
	Rotates the rectangle by either 90°, 180°, 270° (-90°) at point (0,0) More...
Union/intersection area
template<typename FPT2 >
CPolyline_< FPT >	unionArea (const FRect_< FPT2 > &other) const
	Computes the CPolyline of the union of two rectangles. More...
template<typename FPT2 >
detail::RectArea< FPT >	intersectArea (const FRect_< FPT2 > &other) const
	Returns Rectangle of the intersection area of two rectangles. More...
template<typename FPT2 >
CPolyline_< FPT >	operator| (const FRect_< FPT2 > &other) const
template<typename FPT2 >
detail::RectArea< FPT >	operator& (const FRect_< FPT2 > &other) const
Enclosing functions
template<typename T >
bool	isInside (const T &shape) const
	Returns true if rectangle is inside shape (Circle_ or FRect_ or base::Polyline) More...
template<typename FPT2 >
constexpr bool	isInside (const OPolyline_< FPT2 > &) const
	A FRect is never inside an open polyline. More...
template<typename FPT2 >
bool	isInside (const CPolyline_< FPT2 > &poly) const
	For a rectangle to be inside a closed Polyline, two conditions are necessary: More...
Intersection functions
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Line2d_< FPT2 > &line) const
	FRect/Line intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Segment_< FPT2 > &seg) const
	FRect/Segment intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Circle_< FPT2 > &circle) const
	FRect/Circle intersection. More...
template<typename PLT2 , typename FPT2 >
detail::IntersectM< FPT >	intersects (const base::PolylineBase< PLT2, FPT2 > &pl) const
	FRect/Polyline intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const FRect_< FPT2 > &rect) const
	FRect/FRect intersection. More...
Operators
template<typename FPT2 >
bool	operator== (const FRect_< FPT2 > &other) const
template<typename FPT2 >
bool	operator!= (const FRect_< FPT2 > &other) const
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	FRect_
template<typename T >
std::ostream &	operator<< (std::ostream &f, const FRect_< T > &r)

Detailed Description

template<typename FPT>
class h2d::FRect_< FPT >

A Flat Rectangle, modeled by its two opposite points.

Member Typedef Documentation

FType

template<typename FPT>

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

SType

template<typename FPT>

using h2d::FRect_< FPT >::SType = typ::T_FRect

Constructor & Destructor Documentation

FRect_() [1/6]

template<typename FPT>

h2d::FRect_< FPT >::FRect_ ( )

inline

Default constructor, initialize rectangle to (0,0)-(1,1)

    {
        _ptR2.set( 1., 1. );
    }

FRect_() [2/6]

template<typename FPT>

template<typename FPT2 >

h2d::FRect_< FPT >::FRect_ ( const Point2d_< FPT2 > &  pa, const Point2d_< FPT2 > &  pb  )

inline

Constructor from 2 points.

    {
        set( pa, pb );
    }

FRect_() [3/6]

template<typename FPT>

template<typename FPT2 >

h2d::FRect_< FPT >::FRect_ ( const PointPair_< FPT2 > &  ppts )

inline

Constructor from pair of points.

    {
        set( ppts.first, ppts.second );
    }

FRect_() [4/6]

template<typename FPT>

template<typename FPT2 , typename T1 , typename T2 >

h2d::FRect_< FPT >::FRect_ ( const Point2d_< FPT2 > &  p0, T1  w, T2  h  )

inline

Constructor from center point, width and height.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        set(
            Point2d_<FPT>( p0.getX()-0.5L*w, p0.getY()-0.5L*h ),
            Point2d_<FPT>( p0.getX()+0.5L*w, p0.getY()+0.5L*h )
        );
    }

Here is the call graph for this function:

FRect_() [5/6]

template<typename FPT>

template<typename T1 , typename T2 , typename T3 , typename T4 >

h2d::FRect_< FPT >::FRect_ ( T1  x1, T2  y1, T3  x2, T4  y2  )

inline

Constructor from x1, y1, x2, y2.

    {
        HOMOG2D_CHECK_IS_NUMBER(T1);
        HOMOG2D_CHECK_IS_NUMBER(T2);
        HOMOG2D_CHECK_IS_NUMBER(T3);
        HOMOG2D_CHECK_IS_NUMBER(T4);
        set( Point2d_<FPT>(x1,y1), Point2d_<FPT>(x2,y2) );
    }

FRect_() [6/6]

template<typename FPT>

template<typename FPT2 >

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

inline

Copy-Constructor.

        : _ptR1(other._ptR1),_ptR2(other._ptR2)
    {}

Here is the call graph for this function:

Member Function Documentation

area()

template<typename FPT>

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

inlinevirtual

Implements h2d::rtp::Root.

{ return height() * width(); }

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [1/2]

template<typename FPT >

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

virtual

Draw FRect (Opencv implementation)

Implements h2d::rtp::Root.

{
    cv::rectangle(
        im.getReal(),
        _ptR1.getCvPti(),
        _ptR2.getCvPti(),
        dp.cvColor(),
        dp._dpValues._lineThickness,
        dp._dpValues._lineType==1?cv::LINE_AA:cv::LINE_8
    );
    if( dp._dpValues._showPoints )
    {
        _ptR1.draw( im, dp );
        _ptR2.draw( im, dp );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [2/2]

template<typename FPT >

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

virtual

Draw FRect (SVG implementation)

Implements h2d::rtp::Root.

{
    im.getReal()._svgString << "<rect x=\""
        << getPts().first.getX()
        << "\" y=\""
        << getPts().first.getY()
        << "\" width=\""
        << width()
        << "\" height=\""
        << height()
        << "\" stroke=\""
        << dp.getSvgRgbColor()
        << "\" stroke-width=\"" << dp._dpValues._lineThickness << "\" ";
    if( !dp.holdsFill() )
        im.getReal()._svgString << "fill=\"none\" ";
    im.getReal()._svgString << dp.getAttrString() << "/>\n";
}

Here is the call graph for this function:

get4Pts()

template<typename FPT>

std::array<Point2d_<FPT>,4> h2d::FRect_< FPT >::get4Pts ( ) const

inline

Returns the 4 points of the rectangle, starting from "smallest" one, and in clockwise order.

 p1 +------+ p2
    |      |
    |      |
    |      |
 p0 +------+ p3

See also

get4Pts( const FRect_<FPT>& )

    {
        std::array<Point2d_<FPT>,4> arr;
        arr[0] = _ptR1;
        arr[1] = Point2d_<FPT>( _ptR1.getX(), _ptR2.getY() );
        arr[2] = _ptR2;
        arr[3] = Point2d_<FPT>( _ptR2.getX(), _ptR1.getY() );
        return arr;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getBB()

template<typename FPT>

FRect_<FPT> h2d::FRect_< FPT >::getBB ( ) const

inline

get BB of rectangle. Needed for getBB( pair of objects )

Todo:

20250205: fix this so that it return a "full res" rectangle

    { //FRect_<HOMOG2D_INUMTYPE> out;
//      out = *this;
        return *this;
//      return out;
    }

Here is the caller graph for this function:

getBoundingCircle()

template<typename FPT>

Circle_<FPT> h2d::FRect_< FPT >::getBoundingCircle ( ) const

inline

Return circle passing through 4 points of flat rectangle.

See also

h2d::getBoundingCircle()

    {
        auto middle_pt = getCenter();
        return Circle_<FPT>( middle_pt, middle_pt.distTo( _ptR1 ) );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getCenter()

template<typename FPT>

Point2d_<FPT> h2d::FRect_< FPT >::getCenter ( ) const

inline

Returns center of rectangle.

    {
        return Point2d_<FPT>(
            (static_cast<HOMOG2D_INUMTYPE>(_ptR1.getX() ) + _ptR2.getX() ) * 0.5,
            (static_cast<HOMOG2D_INUMTYPE>(_ptR1.getY() ) + _ptR2.getY() ) * 0.5
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getDiagonals()

template<typename FPT>

std::pair<Segment_<FPT>,Segment_<FPT> > h2d::FRect_< FPT >::getDiagonals ( ) const

inline

    {
        auto x1 = _ptR1.getX();
        auto y1 = _ptR1.getY();
        auto x2 = _ptR2.getX();
        auto y2 = _ptR2.getY();

        return std::make_pair(
            Segment_<FPT>(x1,y1,x2,y2),
            Segment_<FPT>(x1,y2,x2,y1)
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getExtended()

template<typename FPT>

FRect_<FPT> h2d::FRect_< FPT >::getExtended ( ) const

inline

    {
        auto x1 = _ptR1.getX() * 2. - _ptR2.getX();
        auto y1 = _ptR1.getY() * 2. - _ptR2.getY();

        auto x2 = _ptR2.getX() * 2. - _ptR1.getX();
        auto y2 = _ptR2.getY() * 2. - _ptR1.getY();

        return FRect_<FPT>( x1, y1, x2, y2 );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getInscribedCircle()

template<typename FPT>

Circle_<FPT> h2d::FRect_< FPT >::getInscribedCircle ( ) const

inline

Return circle inscribed in rectangle.

See also

h2d::getInscribedCircle()

    {
        auto segs = getSegs();
        auto center = getCenter();
        Circle_<FPT> cir( center );
        cir.radius() = std::min(
            center.distTo( segs[0] ),
            center.distTo( segs[1] )
        );
        return cir;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getPts()

template<typename FPT>

PointPair_<FPT> h2d::FRect_< FPT >::getPts ( ) const

inline

Returns the 2 major points of the rectangle.

See also

getPts( const FRect_<FPT>& )

    {
        return std::make_pair( _ptR1, _ptR2 );
    }

Here is the caller graph for this function:

getSegs()

template<typename FPT>

std::array<Segment_<FPT>,4> h2d::FRect_< FPT >::getSegs ( ) const

inline

Returns the 4 segments of the rectangle, starting with the first vertical one.

      s1
   +------+p2
   |      |
s0 |      | s2
   |      |
 p1+------+
      s3

See also

h2d::getSegs( const FRect_& )

    {
        auto pts = get4Pts();
        std::array<Segment_<FPT>,4> out;
        out[0] = Segment_<FPT>( pts[0], pts[1] );
        out[1] = Segment_<FPT>( pts[1], pts[2] );
        out[2] = Segment_<FPT>( pts[2], pts[3] );
        out[3] = Segment_<FPT>( pts[3], pts[0] );
        return out;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

height()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::FRect_< FPT >::height ( ) const

inline

{ return  _ptR2.getY() - _ptR1.getY(); }

Here is the call graph for this function:

Here is the caller graph for this function:

intersectArea()

template<typename FPT >

template<typename FPT2 >

detail::RectArea< FPT > h2d::FRect_< FPT >::intersectArea

(

const FRect_< FPT2 > &

other

)

const

Returns Rectangle of the intersection area of two rectangles.

Returns

An object of type detail::RectArea, that can be checked for success using the () operator, and if success, will hold the resulting FRect_

Algorithm:

4 situations need to be considered, depending on the number of intersection points:

• A: 2 intersection points on same segment => we have 2 points inside.

    +------+                   +------+
    |      |                   |      |
    |   +--+-----+          +--+----+ |
    |   |  |     |          |  |    | |
    |   |  |     |    or    |  |    | |  or ...
    |   +--+-----+          +--+----+ |
    |      |                   |      |
    +------+                   +------+
  

• B: 2 intersection points on different segments => for each rectangle, 1 point is inside the other.

    +------+
    |      |
    |      |
    |   +--+-----+
    |   |  |     |   or ...
    +---+--+     |
        |        |
        +--------+
  

• C: 3 points

    +------+-----+
    |      |     |
    |      |     |
    +------+-----+
    |      |
    +------+
  

• D: 4 intersection points: the intersection rectangle is made of these 4 points

       +------+
       |      |
    +--+------+-----+
    |  |      |     |
    |  |      |     |
    +--+------+-----+
       |      |
       +------+
  

{
    if( *this == other )                      // if same rectangles, then
        return detail::RectArea<FPT>(other);  // the intersection area is the rectangle

    auto inter = this->intersects( other );

    if( !inter() )                        // rectangles do not intersect
    {
        if( this->isInside( other ) )
            return detail::RectArea<FPT>(*this);
        if( other.isInside( *this ) )
            return detail::RectArea<FPT>(other);
        return detail::RectArea<FPT>();
    }

    if( inter.size() < 2 )                // only one intersection point
        return detail::RectArea<FPT>();   // => no intersection area!

    if( inter.size() == 4 )  // 4 intersection points => case "D"
        return detail::RectArea<FPT>(FRect_<FPT>( inter.get().at(0), inter.get().at(3) ) );

    if( inter.size() == 3 )  // 3 intersection points => case "C"
    {
        auto v = inter.get();

        auto xmin = std::min( v[0].getX(), std::min( v[1].getX(),v[2].getX() ) );
        auto ymin = std::min( v[0].getY(), std::min( v[1].getY(),v[2].getY() ) );
        auto xmax = std::max( v[0].getX(), std::max( v[1].getX(),v[2].getX() ) );
        auto ymax = std::max( v[0].getY(), std::max( v[1].getY(),v[2].getY() ) );
#ifndef HOMOG2D_DEBUGMODE
        assert( xmax-xmin > thr::nullOrthogDistance() );
        assert( ymax-ymin > thr::nullOrthogDistance() );
#else
        HOMOG2D_DEBUG_ASSERT(
            ( ( xmax-xmin > thr::nullOrthogDistance() )
            &&
            ( ymax-ymin > thr::nullOrthogDistance() )) ,
            std::scientific
            << "this=" << *this << " other=" << other
            << "\nxmax=" << xmax << " xmin=" << xmin
            << "\nymax=" << ymax << " ymin=" << ymin
            << "\nnod=" << thr::nullOrthogDistance()
        );
#endif
        return detail::RectArea<FPT>( FRect_<FPT>( xmin, ymin, xmax,ymax ) );
    }
/*------------------------
 If we get to this point, we have 2 intersection points
------------------------*/
#ifndef HOMOG2D_DEBUGMODE
    assert( inter.size() == 2 );
#else
/*  HOMOG2D_DEBUG_ASSERT(
        inter.size() == 2,
        "inter.size()=" << inter.size() << "\n-this=" << *this << "\n-other=" << other
        <<"\n-inter:" << inter
    );*/
#endif
    const auto& r1 = *this;
    const auto& r2 = other;
//  HOMOG2D_LOG( "r1="<<r1 << " r2="<<r2 );
    auto v1 = r1.p_pointsInside( r2 );
    auto v2 = r2.p_pointsInside( r1 );
    auto c1 = v1.size();
    auto c2 = v2.size();
//  HOMOG2D_LOG( "c1=" << c1 << " c2=" << c2 );

    if( c1==0 && c2==0 ) // unable, rectangles share a segment
        return detail::RectArea<FPT>();

    assert(
        ( c1==1 && c2==1 )
        ||
        ( c1==0 && c2==2 )
        ||
        ( c2==0 && c1==2 )
    );
    if( c1==1 || c2==1 ) // only 1 point inside => the rectangle is defined by the intersection points
        return detail::RectArea<FPT>( FRect_<FPT>( inter.get().at(0), inter.get().at(1) ) );

// here: 2 points inside, then build rectangle using the 4 points:
// the 2 inside, and the two intersection points
    assert( c1 == 2 || c2 == 2 );

    if( c1 == 2 )
        return detail::RectArea<FPT>(
            FRect_<FPT>(
                inter.get().at(0),
                inter.get().at(1),
                v1.at(0),
                v1.at(1)
            )
        );
    return detail::RectArea<FPT>(
        FRect_<FPT>(
            inter.get().at(0),
            inter.get().at(1),
            v2.at(0),
            v2.at(1)
        )
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

intersects() [1/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::FRect_< FPT >::intersects ( const Line2d_< FPT2 > &  line ) const

inline

FRect/Line intersection.

    {
        return line.intersects( *this );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

intersects() [2/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::FRect_< FPT >::intersects ( const Segment_< FPT2 > &  seg ) const

inline

FRect/Segment intersection.

    {
        detail::IntersectM<FPT> out;
        for( const auto& rseg: getSegs() )
        {
            auto inters = rseg.intersects( seg ); // call of Segment/Segment
            if( inters() )
            {
                auto pt =  inters.get();
                bool addPoint = true;
                if( out.size() == 1 ) // if we have already one
                    if( out.get()[0] == pt )
                        addPoint = false;
                if( addPoint )
                    out.add( pt );
                if( out.size() == 2 )
                    break;
            }
        }
        return out;
    }

Here is the call graph for this function:

intersects() [3/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::FRect_< FPT >::intersects ( const Circle_< FPT2 > &  circle ) const

inline

FRect/Circle intersection.

    {
//      HOMOG2D_START;
        return p_intersects_R_C( circle );
    }

intersects() [4/5]

template<typename FPT>

template<typename PLT2 , typename FPT2 >

detail::IntersectM<FPT> h2d::FRect_< FPT >::intersects ( const base::PolylineBase< PLT2, FPT2 > &  pl ) const

inline

FRect/Polyline intersection.

    {
//      HOMOG2D_START;
        return pl.intersects( *this );
    }

Here is the call graph for this function:

intersects() [5/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::FRect_< FPT >::intersects ( const FRect_< FPT2 > &  rect ) const

inline

FRect/FRect intersection.

    {
//      HOMOG2D_START;
        if( *this == rect )                    // if rectangles are the same,
            return detail::IntersectM<FPT>();  // no intersection
        return p_intersects_R_C( rect );
    }

isInside() [1/3]

template<typename FPT>

template<typename T >

bool h2d::FRect_< FPT >::isInside ( const T &  shape ) const

inline

Returns true if rectangle is inside shape (Circle_ or FRect_ or base::Polyline)

Todo:

add some SFINAE to enable only for allowed types?

    {
        HOMOG2D_START;
        for( const auto& pt: get4Pts() )
            if( !pt.isInside( shape ) )
                return false;
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

isInside() [2/3]

template<typename FPT>

template<typename FPT2 >

constexpr bool h2d::FRect_< FPT >::isInside ( const OPolyline_< FPT2 > &  ) const

inline

A FRect is never inside an open polyline.

    {
        return false;
    }

isInside() [3/3]

template<typename FPT>

template<typename FPT2 >

bool h2d::FRect_< FPT >::isInside ( const CPolyline_< FPT2 > &  poly ) const

inline

For a rectangle to be inside a closed Polyline, two conditions are necessary:

• all the points must be inside
• no intersections

    {
        for( const auto& seg: getSegs() )
            if( seg.intersects(poly)() )
                return false;

        for( const auto& pt: get4Pts() )
            if( !pt.isInside( poly ) )
                return false;
        return true;
    }

Here is the call graph for this function:

length()

template<typename FPT>

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

inlinevirtual

Implements h2d::rtp::Root.

{ return 2.*height() + 2.*width(); }

Here is the call graph for this function:

Here is the caller graph for this function:

moveTo() [1/2]

template<typename FPT>

template<typename TX , typename TY >

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

inline

Move FRect to other location.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );

        auto s = size();
        _ptR1.set(x,y);
        _ptR2.set( _ptR1.getX() + s.first, _ptR1.getY() + s.second );
    }

Here is the call graph for this function:

moveTo() [2/2]

template<typename FPT>

template<typename T1 >

void h2d::FRect_< FPT >::moveTo ( const Point2d_< T1 > &  pt )

inline

Move FRect to other location, given by pt.

    {
        auto s = size();
        _ptR1 = pt;
        _ptR2.set( _ptR1.getX() + s.first, _ptR1.getY() + s.second );
    }

Here is the call graph for this function:

operator!=()

template<typename FPT>

template<typename FPT2 >

bool h2d::FRect_< FPT >::operator!= ( const FRect_< FPT2 > &  other ) const

inline

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

Here is the call graph for this function:

operator&()

template<typename FPT>

template<typename FPT2 >

detail::RectArea<FPT> h2d::FRect_< FPT >::operator & ( const FRect_< FPT2 > &  other ) const

inline

    {
        return this->intersectArea( other );
    }

Here is the call graph for this function:

operator==()

template<typename FPT>

template<typename FPT2 >

bool h2d::FRect_< FPT >::operator== ( const FRect_< FPT2 > &  other ) const

inline

    {
        if( _ptR1 != other._ptR1 )
            return false;
        if( _ptR2 != other._ptR2 )
            return false;
        return true;
    }

operator|()

template<typename FPT>

template<typename FPT2 >

CPolyline_<FPT> h2d::FRect_< FPT >::operator| ( const FRect_< FPT2 > &  other ) const

inline

    {
        return this->unionArea( other );
    }

Here is the call graph for this function:

rotate() [1/2]

template<typename FPT >

template<typename FPT2 >

void h2d::FRect_< FPT >::rotate	(	Rotate	rot,
		const Point2d_< FPT2 > &	refpt
	)

Rotates the rectangle by either 90°, 180°, 270° (-90°) at point refpt.

For an arbitrary angle alpha (rad.), you can write:

auto r2 = Homogr(alpha) * rect;

See also

FRect_<FPT>::rotate( Rotate )

h2d::rotate()

{
    translate( -refpt.getX(), -refpt.getY() );
    this->rotate( rot );
    translate( refpt.getX(), refpt.getY() );
}

Here is the call graph for this function:

rotate() [2/2]

template<typename FPT >

void h2d::FRect_< FPT >::rotate

(

Rotate

rot

)

Rotates the rectangle by either 90°, 180°, 270° (-90°) at point (0,0)

For an arbitrary angle alpha (rad.), you can write:

auto r2 = Homogr(alpha) * rect;

See also

FRect_<FPT>::rotate( Rotate, const Point2d_<FPT2>& )

h2d::rotate()

Note

This function converts the FRect to a CPolyline_, rotates it, and builds the output rectangle by getting the bounding box. This is because we cannot directly rotate the points, because the two points of a FRect_ are switched so that the smallest point is always in _ptR1.

{
    CPolyline_<HOMOG2D_INUMTYPE> pol( *this );
    pol.rotate( rot );
    *this = pol.getBB();
}

Here is the call graph for this function:

set() [1/2]

template<typename FPT>

template<typename FPT1 , typename FPT2 >

void h2d::FRect_< FPT >::set ( const Point2d_< FPT1 > &  pa, const Point2d_< FPT2 > &  pb  )

inline

Assigns points pa and pb to rectangle.

    {
        auto ppts = detail::getCorrectPoints( pa, pb );
        _ptR1 = ppts.first;
        _ptR2 = ppts.second;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set() [2/2]

template<typename FPT>

template<typename T >

void h2d::FRect_< FPT >::set ( T  x1, T  y1, T  x2, T  y2  )

inline

Assigns points (x1,y1) and (x2,y2) to rectangle.

    {
        set( Point2d_<T>(x1,y1), Point2d_<T>(x2,y2) );
    }

size()

template<typename FPT>

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

inlinevirtual

Implements h2d::rtp::Root.

    {
        return 4;
    }

Here is the caller graph for this function:

translate() [1/2]

template<typename FPT>

template<typename TX , typename TY >

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

inline

Translate FRect.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        _ptR1.set( _ptR1.getX() + dx, _ptR1.getY() + dy );
        _ptR2.set( _ptR2.getX() + dx, _ptR2.getY() + dy );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

translate() [2/2]

template<typename FPT>

template<typename T1 , typename T2 >

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

inline

Translate FRect.

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

Here is the call graph for this function:

type()

template<typename FPT>

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

inlinevirtual

Implements h2d::rtp::Root.

    {
        return Type::FRect;
    }

unionArea()

template<typename FPT >

template<typename FPT2 >

CPolyline_< FPT > h2d::FRect_< FPT >::unionArea

(

const FRect_< FPT2 > &

other

)

const

Computes the CPolyline of the union of two rectangles.

Algorithm:

1. build vectors of x and y coordinates (4 elements)
2. build table x-y (4x4), with corners tagged
3. parse the table by turning right at each corner, and left if position is not one the outside row/col
4. convert back indexes to real coordinates, to build the final CPolyline object

Two examples:

9      +----+              +-------+
       |    |              |       |
8  +---+----+---+      +---+---+   |
   |   |    |   |      |   |   |   |
7  +---+----+---+      +---+---+   |
       |    |              |       |
6      +----+              +-------+
   1   2    3   4      1   2   3   4

Step 1 will build (for both situations above):

• vx: 1,2,3,4
• vy: 6,7,8,9

Step 2 will build a table showing where the corners are:

  | 0 1 2 3             | 0 1 2 3
--|---------|         --|---------|
0 | . F F . |          0| . F . F
1 | F F F F |          1| F F . .
2 | F F F F |          2| F F . .
3 | . F F . |          3| . F . F

Step 3: parse that table and turn on each corner:

• left if "inner" corner (row and col = 1 or = 2)
• right if "outer" corner (row and col = 0 or = 3)

Final step: convert indexes to real coordinates

Special note: if the rectangles have an identical coordinate, as in this example:

9      +----+
       |    |
8  +---+----+
   |   |    |
7  +---+----+
       |    |
6      +----+
   1   2    3

Then the vectors are:

• vx: 1,2,3,3
• vy: 6,7,8,9

(notice the duped coordinate)

This will produce a Polyline_ with 2 extra points:
(1,7)-(1,8)-(2,8)-(2,9)-(3,9)-(3,8)-(3,7)-(3,6)-(2,6)-(2,7)
instead of:
(1,7)-(1,8)-(2,8)-(2,9)-(3,9)-(3,6)-(2,6)-(2,7)
We solve this by proceeding an extra Polyline minimization, see PolylineBase::minimize()

{
    using namespace priv::runion;

    if( *this == other )                  // if same rectangles, then
        return CPolyline_<FPT>( other );   // returns one of them

    if( !this->intersects(other)() )  // if no intersection,
    {
        if( this->isInside( other ) )
            return CPolyline_<FPT>(other);
        if( other.isInside( *this ) )
            return CPolyline_<FPT>(*this);
        return CPolyline_<FPT>();      // return empty polygon
    }

/* step 0: make sure the rect with highest x is first.
 This is needed to avoid this kind of situation in table:

  F F . .
  . . F F
  . . F F
  F F . .

  That would happen if we have an identical x in the two rect
  (thus, they DO intersect), because when sorting, the rect with smallest index
  (1 or 2) is placed first in the vector of coordinates */
    const auto* pr1 = this;
    const auto* pr2 = &other;
    if( pr1->getPts().first.getX() < pr2->getPts().first.getX() )
        std::swap( pr1, pr2 );
    const auto& r1 = *pr1;
    const auto& r2 = *pr2;

// step 1: build vectors of coordinates and sort them
    std::array<Index<FPT>,4> vx, vy;
    int i=0;
    vx[i++] = Index<FPT>( r1.getPts().first.getX(),  1 );
    vx[i++] = Index<FPT>( r1.getPts().second.getX(), 1 );
    vx[i++] = Index<FPT>( r2.getPts().first.getX(),  2 );
    vx[i++] = Index<FPT>( r2.getPts().second.getX(), 2 );

    i=0;
    vy[i++] = Index<FPT>( r1.getPts().first.getY(),  1 );
    vy[i++] = Index<FPT>( r1.getPts().second.getY(), 1 );
    vy[i++] = Index<FPT>( r2.getPts().first.getY(),  2 );
    vy[i++] = Index<FPT>( r2.getPts().second.getY(), 2 );

    std::sort( vx.begin(), vx.end() );
    std::sort( vy.begin(), vy.end() );
//  priv::printArray( vx, "vx" ); priv::printArray( vy, "vy");

// step 2: fill table\n";
    Table table;
    for( uint8_t r=0;r<4; r++ )
        for( uint8_t c=0;c<4; c++ )
            table[r][c] = Cell( vx[r], vy[c] );
//  printTable( table, "after step 2" );

// step 3: parse table
    auto vpts = parseTable( table );
//  priv::printVectorPairs( vpts );

// step 4: convert back vector of coordinates indexes into vector of coordinates
    auto res1 = convertToCoord( vpts, vx, vy );
    res1.minimize(); // remove unecessary points
    return res1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

width()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::FRect_< FPT >::width ( ) const

inline

{ return  _ptR2.getX() - _ptR1.getX(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

FRect_

template<typename FPT>

template<typename T >

friend class FRect_

friend

operator<<

template<typename FPT>

template<typename T >

std::ostream& operator<< ( std::ostream &  f, const FRect_< T > &  r  )

friend

{
    f << "pt1: " << r._ptR1 << " pt2: " << r._ptR2;
    return f;
}

---

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

• homog2d.hpp