#include "ObjectPosSelector.h"

Classes
struct	UsedPos

Public Types
typedef std::multimap< float, UsedPos >	UsedPosList

Public Member Functions
	ObjectPosSelector (float x, float y, float size, float dist)

void	AddUsedPos (float size, float angle, float dist)

void	InitializeAngle ()

bool	FirstAngle (float &angle)

bool	NextAngle (float &angle)

bool	NextUsedAngle (float &angle)

bool	NextPosibleAngle (float &angle)

bool	CheckAngle (UsedPosList::value_type const &nextUsedPos, float sign, float angle) const

bool	CheckOriginal () const

bool	IsNonBalanced () const

bool	NextAngleFor (UsedPosList::value_type const &usedPos, float sign, UsedPosType uptype, float &angle)

bool	NextSmallStepAngle (float sign, UsedPosType uptype, float &angle)

UsedPosList::value_type const *	nextUsedPos (UsedPosType uptype)

float	GetAngle (UsedPos const &usedPos) const

Public Attributes
float	m_center_x

float	m_center_y

float	m_size

float	m_dist

float	m_anglestep

UsedPosList	m_UsedPosLists [2]

UsedPosList::const_iterator	m_nextUsedPos [2]

float	m_smallStepAngle [2]

bool	m_smallStepOk [2]

UsedPosList::value_type const *	m_smallStepNextUsedPos [2]

Detailed Description

Member Typedef Documentation

◆ UsedPosList

typedef std::multimap<float, UsedPos> ObjectPosSelector::UsedPosList

Constructor & Destructor Documentation

◆ ObjectPosSelector()

ObjectPosSelector::ObjectPosSelector	(	float	x,
		float	y,
		float	size,
		float	dist
	)

    : m_center_x(x), m_center_y(y), m_size(size), m_dist(dist)
{
    m_anglestep = acos(m_dist / (m_dist + 2 * m_size));
 
    m_nextUsedPos[USED_POS_PLUS]  = m_UsedPosLists[USED_POS_PLUS].end();
    m_nextUsedPos[USED_POS_MINUS] = m_UsedPosLists[USED_POS_MINUS].end();
 
    m_smallStepAngle[USED_POS_PLUS]  = 0;
    m_smallStepAngle[USED_POS_MINUS] = 0;
 
    m_smallStepOk[USED_POS_PLUS]  = false;
    m_smallStepOk[USED_POS_MINUS] = false;
 
    m_smallStepNextUsedPos[USED_POS_PLUS]  = nullptr;
    m_smallStepNextUsedPos[USED_POS_MINUS] = nullptr;
}

References m_anglestep, m_dist, m_nextUsedPos, m_size, m_smallStepAngle, m_smallStepNextUsedPos, m_smallStepOk, m_UsedPosLists, USED_POS_MINUS, and USED_POS_PLUS.

Member Function Documentation

◆ AddUsedPos()

void ObjectPosSelector::AddUsedPos	(	float	size,
		float	angle,
		float	dist
	)

{
    if (angle >= 0)
        m_UsedPosLists[USED_POS_PLUS].insert(UsedPosList::value_type(angle, UsedPos(1.0f, size, dist)));
    else
        m_UsedPosLists[USED_POS_MINUS].insert(UsedPosList::value_type(-angle, UsedPos(-1.0f, size, dist)));
}

References m_UsedPosLists, USED_POS_MINUS, and USED_POS_PLUS.

◆ CheckAngle()

bool ObjectPosSelector::CheckAngle	(	UsedPosList::value_type const &	nextUsedPos,
		float	sign,
		float	angle
	)		const

inline

    {
        float angle_step2  = GetAngle(nextUsedPos.second);
 
        float next_angle = nextUsedPos.first;
        if (nextUsedPos.second.sign * sign < 0)             // last node from diff. list (-pi+alpha)
            next_angle = 2 * M_PI - next_angle;             // move to positive
 
        return std::fabs(angle) + angle_step2 <= next_angle;
    }

References GetAngle(), and nextUsedPos().

Referenced by CheckOriginal(), NextAngleFor(), and NextSmallStepAngle().

◆ CheckOriginal()

bool ObjectPosSelector::CheckOriginal ( ) const

inline

    {
        return (m_UsedPosLists[USED_POS_PLUS].empty() || CheckAngle(*m_UsedPosLists[USED_POS_PLUS].begin(), 1.0f, 0)) &&
               (m_UsedPosLists[USED_POS_MINUS].empty() || CheckAngle(*m_UsedPosLists[USED_POS_MINUS].begin(), -1.0f, 0));
    }

References CheckAngle(), m_UsedPosLists, USED_POS_MINUS, and USED_POS_PLUS.

◆ FirstAngle()

bool ObjectPosSelector::FirstAngle ( float & angle )

{
    if (m_UsedPosLists[USED_POS_PLUS].empty() && !m_UsedPosLists[USED_POS_MINUS].empty())
        return NextAngleFor(*m_UsedPosLists[USED_POS_MINUS].begin(), 1.0f, USED_POS_PLUS, angle);
    else if (m_UsedPosLists[USED_POS_MINUS].empty() && !m_UsedPosLists[USED_POS_PLUS].empty())
        return NextAngleFor(*m_UsedPosLists[USED_POS_PLUS].begin(), -1.0f, USED_POS_MINUS, angle);
 
    return false;
}

References m_UsedPosLists, NextAngleFor(), USED_POS_MINUS, and USED_POS_PLUS.

◆ GetAngle()

float ObjectPosSelector::GetAngle ( UsedPos const & usedPos ) const

inline

139{ return acos(m_dist / (usedPos.dist + usedPos.size + m_size)); }

References ObjectPosSelector::UsedPos::dist, m_dist, m_size, and ObjectPosSelector::UsedPos::size.

Referenced by CheckAngle(), and NextAngleFor().

◆ InitializeAngle()

void ObjectPosSelector::InitializeAngle ( )

{
    m_nextUsedPos[USED_POS_PLUS]  = m_UsedPosLists[USED_POS_PLUS].begin();
    m_nextUsedPos[USED_POS_MINUS] = m_UsedPosLists[USED_POS_MINUS].begin();
 
    m_smallStepAngle[USED_POS_PLUS]  = 0;
    m_smallStepAngle[USED_POS_MINUS] = 0;
 
    m_smallStepOk[USED_POS_PLUS]  = true;
    m_smallStepOk[USED_POS_MINUS] = true;
}

References m_nextUsedPos, m_smallStepAngle, m_smallStepOk, m_UsedPosLists, USED_POS_MINUS, and USED_POS_PLUS.

◆ IsNonBalanced()

bool ObjectPosSelector::IsNonBalanced ( ) const

inline

75{ return m_UsedPosLists[USED_POS_PLUS].empty() != m_UsedPosLists[USED_POS_MINUS].empty(); }

References m_UsedPosLists, USED_POS_MINUS, and USED_POS_PLUS.

◆ NextAngle()

bool ObjectPosSelector::NextAngle ( float & angle )

{
    while (m_nextUsedPos[USED_POS_PLUS] != m_UsedPosLists[USED_POS_PLUS].end() ||
            m_nextUsedPos[USED_POS_MINUS] != m_UsedPosLists[USED_POS_MINUS].end() ||
            m_smallStepOk[USED_POS_PLUS] || m_smallStepOk[USED_POS_MINUS] )
    {
        // calculate next possible angle
        if (NextPosibleAngle(angle))
            return true;
    }
 
    return false;
}

References m_nextUsedPos, m_smallStepOk, m_UsedPosLists, NextPosibleAngle(), USED_POS_MINUS, and USED_POS_PLUS.

◆ NextAngleFor()

bool ObjectPosSelector::NextAngleFor	(	UsedPosList::value_type const &	usedPos,
		float	sign,
		UsedPosType	uptype,
		float &	angle
	)

inline

    {
        float angle_step  = GetAngle(usedPos.second);
 
        // next possible angle
        angle  = usedPos.first * usedPos.second.sign + angle_step * sign;
 
        UsedPosList::value_type const* nextNode = nextUsedPos(uptype);
        if (nextNode)
        {
            // if next node permit use selected angle, then do it
            if (!CheckAngle(*nextNode, sign, angle))
            {
                m_smallStepOk[uptype] = false;
                return false;
            }
        }
 
        // possible more points
        m_smallStepOk[uptype] = true;
        m_smallStepAngle[uptype] = angle;
        m_smallStepNextUsedPos[uptype] = nextNode;
 
        return true;
    }

References CheckAngle(), GetAngle(), m_smallStepAngle, m_smallStepNextUsedPos, m_smallStepOk, and nextUsedPos().

Referenced by FirstAngle(), and NextPosibleAngle().

◆ NextPosibleAngle()

bool ObjectPosSelector::NextPosibleAngle ( float & angle )

{
    // ++ direction less updated
    if (m_nextUsedPos[USED_POS_PLUS] != m_UsedPosLists[USED_POS_PLUS].end() &&
            (m_nextUsedPos[USED_POS_MINUS] == m_UsedPosLists[USED_POS_MINUS].end() || m_nextUsedPos[USED_POS_PLUS]->first <= m_nextUsedPos[USED_POS_MINUS]->first))
    {
        bool ok;
        if (m_smallStepOk[USED_POS_PLUS])
            ok = NextSmallStepAngle(1.0f, USED_POS_PLUS, angle);
        else
            ok = NextAngleFor(*m_nextUsedPos[USED_POS_PLUS], 1.0f, USED_POS_PLUS, angle);
 
        if (!ok)
            ++m_nextUsedPos[USED_POS_PLUS];                 // increase. only at fail (original or checked)
        return ok;
    }
    // -- direction less updated
    else if (m_nextUsedPos[USED_POS_MINUS] != m_UsedPosLists[USED_POS_MINUS].end())
    {
        bool ok;
        if (m_smallStepOk[USED_POS_MINUS])
            ok = NextSmallStepAngle(-1.0f, USED_POS_MINUS, angle);
        else
            ok = NextAngleFor(*m_nextUsedPos[USED_POS_MINUS], -1.0f, USED_POS_MINUS, angle);
 
        if (!ok)
            ++m_nextUsedPos[USED_POS_MINUS];
        return ok;
    }
    else                                                    // both list empty
    {
        if (m_smallStepOk[USED_POS_PLUS] && (!m_smallStepOk[USED_POS_MINUS] || m_smallStepAngle[USED_POS_PLUS] <= m_smallStepAngle[USED_POS_MINUS]))
            return NextSmallStepAngle(1.0f, USED_POS_PLUS, angle);
        // -- direction less updated
        else if (m_smallStepOk[USED_POS_MINUS])
            return NextSmallStepAngle(-1.0f, USED_POS_MINUS, angle);
    }
 
    // no angles
    return false;
}

References m_nextUsedPos, m_smallStepAngle, m_smallStepOk, m_UsedPosLists, NextAngleFor(), NextSmallStepAngle(), USED_POS_MINUS, and USED_POS_PLUS.

Referenced by NextAngle(), and NextUsedAngle().

◆ NextSmallStepAngle()

bool ObjectPosSelector::NextSmallStepAngle	(	float	sign,
		UsedPosType	uptype,
		float &	angle
	)

inline

    {
        // next possible angle
        angle  = m_smallStepAngle[uptype] + m_anglestep * sign;
 
        if (std::fabs(angle) > M_PI)
        {
            m_smallStepOk[uptype] = false;
            return false;
        }
 
        if (m_smallStepNextUsedPos[uptype])
        {
            if (std::fabs(angle) >= m_smallStepNextUsedPos[uptype]->first)
            {
                m_smallStepOk[uptype] = false;
                return false;
            }
 
            // if next node permit use selected angle, then do it
            if (!CheckAngle(*m_smallStepNextUsedPos[uptype], sign, angle))
            {
                m_smallStepOk[uptype] = false;
                return false;
            }
        }
 
        // possible more points
        m_smallStepAngle[uptype] = angle;
        return true;
    }

References CheckAngle(), m_anglestep, m_smallStepAngle, m_smallStepNextUsedPos, and m_smallStepOk.

Referenced by NextPosibleAngle().

◆ NextUsedAngle()

bool ObjectPosSelector::NextUsedAngle ( float & angle )

{
    while (m_nextUsedPos[USED_POS_PLUS] != m_UsedPosLists[USED_POS_PLUS].end() ||
            m_nextUsedPos[USED_POS_MINUS] != m_UsedPosLists[USED_POS_MINUS].end())
    {
        // calculate next possible angle
        if (!NextPosibleAngle(angle))
            return true;
    }
 
    return false;
}

References m_nextUsedPos, m_UsedPosLists, NextPosibleAngle(), USED_POS_MINUS, and USED_POS_PLUS.

◆ nextUsedPos()

ObjectPosSelector::UsedPosList::value_type const * ObjectPosSelector::nextUsedPos ( UsedPosType uptype )

{
    UsedPosList::const_iterator itr = m_nextUsedPos[uptype];
    if (itr != m_UsedPosLists[uptype].end())
        ++itr;
 
    if (itr == m_UsedPosLists[uptype].end())
    {
        if (!m_UsedPosLists[~uptype].empty())
            return &*m_UsedPosLists[~uptype].rbegin();
        else
            return nullptr;
    }
    else
        return &*itr;
}