h2d::priv::runion Namespace Reference

Common stuff for FRect_ union, see FRect_::unionArea() More...

Classes
struct	Cell
	A wrapper around a bool, that gets set if that point defined by indexes ix and iy is a corner in the table. More...
struct	Index
	Holds x or y coordinate value of rectangle during computation of intersection area. More...

Typedefs
using	PCoord = std::pair< uint8_t, uint8_t >
using	Table = std::array< std::array< Cell, 4 >, 4 >

Enumerations
enum	Direction : uint8_t { Direction::N, Direction::E, Direction::S, Direction::W }
enum	Turn : uint8_t { Turn::Left, Turn::Right }

Functions
template<typename FPT >
CPolyline_< FPT >	convertToCoord (const std::vector< PCoord > &v_coord, const std::array< Index< FPT >, 4 > &v_x, const std::array< Index< FPT >, 4 > &v_y)
	Helper function, used in FRect_<FPT>::unionArea() More...
void	moveToNextCell (uint8_t &row, uint8_t &col, const Direction &dir)
std::vector< PCoord >	parseTable (Table &table)
	Helper function for FRect_<FPT>::unionArea() More...
Direction	turn (Direction dir, Turn turn)

Detailed Description

Common stuff for FRect_ union, see FRect_::unionArea()

Typedef Documentation

PCoord

using h2d::priv::runion::PCoord = typedef std::pair<uint8_t,uint8_t>

Table

using h2d::priv::runion::Table = typedef std::array<std::array<Cell,4>,4>

Enumeration Type Documentation

Direction

enum h2d::priv::runion::Direction : uint8_t

strong

Enumerator
N
E
S
W

: uint8_t { N, E, S, W };

Turn

enum h2d::priv::runion::Turn : uint8_t

strong

Enumerator
Left
Right

: uint8_t { Left, Right };

Function Documentation

convertToCoord()

template<typename FPT >

CPolyline_<FPT> h2d::priv::runion::convertToCoord ( const std::vector< PCoord > &  v_coord, const std::array< Index< FPT >, 4 > &  v_x, const std::array< Index< FPT >, 4 > &  v_y  )

inline

Helper function, used in FRect_<FPT>::unionArea()

Parameters

v_coord	vector of coordinate indexes
v_x	holds x-coordinates
v_y	holds y-coordinates

{
    std::vector<Point2d_<FPT>> v_pts;
    for( const auto& elem: v_coord )
    {
        auto id_x = elem.first;
        auto id_y = elem.second;
        assert( id_x<4 && id_y<4 );

        auto pt = Point2d_<FPT>( v_x[id_x]._value, v_y[id_y]._value );
        if( v_pts.empty() )
            v_pts.push_back( pt );
        else                             // add to vector only  if not same as previous
        {                                // and not same as first
            if( v_pts.back() != pt && v_pts.front() != pt )
                v_pts.push_back( pt );
        }
    }
//  printVector( v_pts, "polyline" );
    return CPolyline_<FPT>( v_pts );//, IsClosed::Yes );
}

Here is the caller graph for this function:

moveToNextCell()

void h2d::priv::runion::moveToNextCell ( uint8_t &  row, uint8_t &  col, const Direction &  dir  )

inline

{
    switch( dir )
    {
        case Direction::N: row--; break;
        case Direction::S: row++; break;
        case Direction::E: col++; break;
        case Direction::W: col--; break;
    }
}

Here is the caller graph for this function:

parseTable()

std::vector<PCoord> h2d::priv::runion::parseTable ( Table &  table )

inline

Helper function for FRect_<FPT>::unionArea()

• Start from 0,0, direction East

{
    bool firstTime = true;
    bool done = false;
    uint8_t row = 0;
    uint8_t col = 0;
    Direction dir = Direction::E;
    std::vector<PCoord> out;
    do
    {
        if( table[row][col]._isCorner )
        {
            auto new_pair = std::make_pair(row,col);
            if( out.size() > 0 )
                if( new_pair == out.front() && out.size() > 2 )
                    done = true;
            if( !done )
                out.push_back( new_pair );
            if( firstTime )
                firstTime = false;
            else
                dir = turn( dir, Turn::Right );
        }
        else
        {
            if( ( row==2 || row==1 ) && ( col==2 || col==1 ) )
            {
                out.push_back( std::make_pair(row,col) );
                dir = turn( dir, Turn::Left );
            }
        }
        moveToNextCell( row, col, dir );
    }
    while( !done );
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

turn()

Direction h2d::priv::runion::turn ( Direction  dir, Turn  turn  )

inline

{
    switch( dir )
    {
        case Direction::W:
            return turn == Turn::Left ? Direction::S : Direction::N;
        case Direction::S:
            return turn == Turn::Left ? Direction::E : Direction::W;
        case Direction::E:
            return turn == Turn::Left ? Direction::N : Direction::S;
        case Direction::N:
            return turn == Turn::Left ? Direction::W : Direction::E;
    }
    return Direction::N; // to avoid a warning
}

Here is the caller graph for this function: