random_racer/src/ControlPointContainer.cpp

Go to the documentation of this file.

#include <math.h>
#include <assert.h>

#include "ControlPointContainer.h"


using namespace VRS;

namespace random_racer
{

ControlPointContainer::ControlPointContainer(
    unsigned int p_numControlPoints, unsigned int p_blocksize,
    SO<Callback1<std::vector<Vector>* > > p_genPointCallback,
    int p_minY, int p_maxY)
{
    assert( p_minY < p_maxY );
    
    m_callback          = p_genPointCallback;
    m_blocksize         = p_blocksize;
    m_numControlPoints  = p_numControlPoints;
    m_minY              = p_minY;
    m_maxY              = p_maxY;
    m_absHeight         = calculateAbsHeight(m_minY, m_maxY);
}

ControlPointContainer::~ControlPointContainer()
{
}

int
ControlPointContainer::mapToKey(double p_value)
{
    return int(floor(p_value/m_blocksize));
}

int 
ControlPointContainer::getOffset(int p_key)
{
    return p_key*(int)m_blocksize;
}

unsigned char 
ControlPointContainer::mapToHashMapHeight(double p_height)
{    
    return (unsigned char)(round(p_height * 254.0));
}

double 
ControlPointContainer::mapHeightBack(unsigned char p_height)
{
    if(m_calcMinus)
    {
        return ((double)p_height/254.0 * (double)m_absHeight) - 
                (double)abs(m_minY);
    }
    else
    {
        return ((double)p_height/254.0 * (double)m_absHeight) + 
                (double)abs(m_minY);        
    }
}

unsigned int 
ControlPointContainer::calculateAbsHeight(int p_minHeight, int p_maxHeight)
{
    if(p_minHeight <= 0 && p_maxHeight > 0)
    {
        m_calcMinus = true;
        return (p_maxHeight + abs(p_minHeight));
    }
    if(p_minHeight > 0 && p_maxHeight > 0)
    {
        m_calcMinus = false;
        return (p_maxHeight - p_minHeight);
    }
    if(p_minHeight < 0 && p_maxHeight < 0)
    {
        m_calcMinus = true;
        return (p_maxHeight + abs(p_minHeight));
    }
    else
        return 0;
}

void 
ControlPointContainer::getFourBlocks(double p_valueX, double p_valueZ, 
                                                            int* p_blockList)
{       
    int roundedX = (int)round(p_valueX/m_blocksize);
    int roundedZ = (int)round(p_valueZ/m_blocksize);
    
    p_blockList[0] = roundedX;
    p_blockList[1] = roundedZ;
    p_blockList[2] = roundedX-1;
    p_blockList[3] = roundedZ-1;
    p_blockList[4] = roundedX-1;
    p_blockList[5] = roundedZ;
    p_blockList[6] = roundedX;
    p_blockList[7] = roundedZ-1;
}

void 
ControlPointContainer::generateBlock(int p_valueX, int p_valueZ)
{
    m_genPointCache.clear();
    
    m_callback->callback(&m_genPointCache);
        
    std::vector<unsigned char>* tempBlock;
    tempBlock = new std::vector<unsigned char>( (m_numControlPoints * 
                                                    m_numControlPoints), 255);
                
    for( std::vector<Vector>::iterator i = m_genPointCache.begin(); i != 
            m_genPointCache.end(); i++)
    {
        if((*i)[0] >= 0 && (*i)[0] <= m_numControlPoints &&
           (*i)[1] >= 0 && (*i)[1] <= 1 &&
           (*i)[2] >= 0 && (*i)[2] <= m_numControlPoints)
        {
            (*tempBlock)[mapsIndex((*i)[0], (*i)[2])] = 
                                            mapToHashMapHeight((*i)[1]);
        }
    } 
    
    (*(m_hashMap[p_valueX]))[p_valueZ] = tempBlock;
}

unsigned int 
ControlPointContainer::mapsIndexBackToX(unsigned int p_index)
{
    return unsigned(floor(p_index/m_numControlPoints));
}

unsigned int 
ControlPointContainer::mapsIndexBackToZ(unsigned int p_index, 
                                                    unsigned int p_valueX)
{
    return p_index - (p_valueX*m_numControlPoints);
}

} // namespace random_racer

---