random_racer/src/Nurbs.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <stdarg.h>
#include <assert.h>

#include "Nurbs.h"


namespace random_racer
{
    
Nurbs::Nurbs(unsigned int p_dimension,float p_spacing,unsigned int p_bufferZone)
{
    // p_dimension have to be even
    assert( p_dimension % 2 == 0 );
    
    m_dimension     = p_dimension;
    m_spacing       = p_spacing;
    m_bufferZone    = p_bufferZone;
    
    m_controlPoints = new float[(m_dimension + 2*m_bufferZone) * 
                                (m_dimension + 2*m_bufferZone)];
    
    m_degree = 2;
    m_order  = m_degree + 1;
    m_numCvs = m_dimension + (2*m_bufferZone);

    m_numKnots = m_order + m_dimension + (2*m_bufferZone);
    m_knots    = new float[ m_numKnots ];
    fillKnotsVector( m_order, (m_dimension + (2*m_bufferZone)), m_knots ); 

    // uses the evaluate method
    m_tempPoints = new Point[ m_numCvs ];

    m_correctX   = m_correctY = 0.0;

    // intialize the controlpoints with 0.0
    clear();
}

Nurbs::~Nurbs()
{
    delete [] m_controlPoints;
    delete [] m_knots;
    delete [] m_tempPoints;
}

void
Nurbs::fillKnotsVector(unsigned int p_order, unsigned int p_numPoints, 
                       float* p_knots)
{
    unsigned int i;
    float j = 1.0;
    
    for (i = 0; i < p_order; i++)
    {
        p_knots[i] = 0.0;
    }
    for (;i < p_numPoints; i++, j += 1.0)
    {
        p_knots[i] = j;
    }
    for (;i < p_numPoints + p_order; i++)
    {
        p_knots[i] = j;
    }
}

void 
Nurbs::clear()
{
    for( unsigned int i = 0; i < ((m_dimension + (2*m_bufferZone)) * 
                                  (m_dimension + (2*m_bufferZone))); i++ )
    {
        m_controlPoints[i] = 0.0;
    }
}

void 
Nurbs::evaluate(unsigned int p_levelOfDetail,std::vector<VRS::Vector>* p_target)
{
    // p_levelOfDetail has to be even
    assert( p_levelOfDetail % 2 == 0 );
    
    VRS::Vector tempVector;
    Point p;
    
    unsigned int levelOfDetail = p_levelOfDetail + (2*m_bufferZone);
    
    bool firstTime = true;
    
    // Variables to move the final points to 0,0 and so on
    float x = 0.0;
    float y = 0.0;
    
    // store the maximal possible point, necessary to map the coordinates 
    // between 0 and (m_dimension * m_spacing)
    Point pMax;
    
    float uMax = (( max() - min() ) * (float)(levelOfDetail - m_bufferZone - 1) 
        / (float)(levelOfDetail-1)) + min();
    float vMax = (( max() - min() ) * (float)(levelOfDetail - m_bufferZone - 1) 
        / (float)(levelOfDetail-1)) + min();
    
    pMax = calculate( uMax, vMax, m_tempPoints );
            
    for( unsigned int i = 0; i != levelOfDetail; ++i ) 
    {
        // calculate the parametric u value
        float u = (( max() - min() ) * (float)i / (float)( levelOfDetail-1)) 
                  + min();

        for( unsigned int j = 0; j != levelOfDetail; ++j ) 
        {
            // calculate the parametric v value
            float v = (( max() - min() ) * (float)j / (float)( levelOfDetail-1)) 
                      + min();
            
            if( u > ( ((max() - min()) * (float)(m_bufferZone-1) / 
                  (float)(levelOfDetail-1)) + min() ) &&
                v > ( ((max() - min()) * (float)(m_bufferZone-1) / 
                  (float)(levelOfDetail-1)) + min()) &&
                u < ( ((max() - min()) * (float)(levelOfDetail-m_bufferZone) / 
                  (float)(levelOfDetail-1)) + min()) &&
                v < ( ((max() - min()) * (float)(levelOfDetail-m_bufferZone) / 
                  (float)(levelOfDetail-1)) + min()))
            {    
                // calculate the point on the surface
                p = calculate( u, v, m_tempPoints );
    
                // stores the first Point X- and Y-Value to move the point to 
                // 0,0 and so on
                if(firstTime)
                {
                    x = p.x;
                    y = p.y;
                }    
            
                firstTime = false;

                tempVector[0] = (p.x - x) / (pMax.x - x)  * 
                    ((float)m_dimension * m_spacing) - m_correctX;

                tempVector[2] = (p.y - y) / (pMax.y - y) * 
                    ((float)m_dimension * m_spacing) - m_correctY;

                tempVector[1] = p.z;
    
                p_target->push_back( tempVector );
            }
        }
    } 
}

//
// The following functions are based on the example written by Rob Bateman
//
 
float
Nurbs::min() 
{
    return m_knots[ m_degree ];
}

float 
Nurbs::max() 
{
    return m_knots[ m_numKnots - m_degree ];
}

float 
Nurbs::coxDeBoor(float p_u, int p_i, int p_k, const float* p_knots)
{
    if( p_k == 1 )
    {
        if( p_knots[ p_i ] <= p_u && p_u <= p_knots[ p_i + 1 ] ) 
            return 1.0;
            
        return 0.0;
    }
    
    float den1 = p_knots[ p_i + p_k-1 ] - p_knots[ p_i ];
    float den2 = p_knots[ p_i + p_k ] - p_knots[ p_i + 1 ];

    float eq1=0.0, eq2=0.0;
    
    if( den1 > 0 )
        eq1 = ( ( p_u - p_knots[ p_i ] ) / den1 ) *
                            coxDeBoor( p_u, p_i, p_k-1, p_knots );
    
    if( den2 > 0 )
        eq2 = ( p_knots[ p_i + p_k ] - p_u ) / den2 *           
                            coxDeBoor( p_u, p_i+1, p_k-1, p_knots );
    
    return eq1+eq2;
}

Nurbs::Point 
Nurbs::calculateU(float p_t, int p_row)
{
    Point p = {0,0,0};

    // sum the effect of all CV's on the curve at this point to 
    // get the evaluated curve point 
    for( unsigned int i = 0; i != m_numCvs; ++i ) 
    {
        // calculate the effect of this point on the curve
        float val = coxDeBoor( p_t, i, m_order, m_knots );

        if( val > 0.001f ) 
        {
            // sum effect of CV on this part of the curve
            p.x += val * ( p_row * m_spacing );
            p.y += val * ( i * m_spacing ); 
            p.z += val * m_controlPoints[ mapsIndex( p_row, i ) ];
        }
    }

    return p;
}

Nurbs::Point 
Nurbs::calculateV(float p_t, Point* p_pnts)
{
    Point p = {0,0,0};

    // sum the effect of all CV's on the curve at this point to 
    // get the evaluated curve point 
    for( unsigned int i = 0; i != m_numCvs; ++i ) 
    {
        // calculate the effect of this point on the curve
        float val = coxDeBoor( p_t, i, m_order, m_knots );

        if( val > 0.001f ) 
        {
            // sum effect of CV on this part of the curve
            p.x += val * p_pnts[i].x;
            p.y += val * p_pnts[i].y;
            p.z += val * p_pnts[i].z;
        }
    }

    return p;
}

Nurbs::Point
Nurbs::calculate(float p_u, float p_v, Point* p_tempPoints)
{
    for( unsigned int i = 0; i != m_numCvs; ++i ) 
    {
        // Calculate a point on each of the curves and store the result.
        p_tempPoints[i] = calculateU( p_u, i );
    }

    // to calculate the v direction
    Point p = calculateV( p_v, p_tempPoints );

    return p;
}

}

---