IrradianceCache.cc

Go to the documentation of this file.

#include <esg/energy/IrradianceCache.h>
#include <sstream>

using namespace esg;

IrradianceCache::IrradianceCache(const float mError, const float rootSize)
    throw (out_of_range) : maxError(mError)
{
    if (mError <= 0.0f) {
        ostringstream message;
        message << "IrradianceCache::IrradianceCache(): mError: " << mError;
        throw out_of_range( message.str() );
    }

    if (rootSize <= 0.0f) {
        ostringstream message;
        message << "IrradianceCache::IrradianceCache(): rootSize: " << rootSize;
        throw out_of_range( message.str() );
    }

    root = new IrradianceCache::Node(rootSize, 0.0f, 0.0f, 0.0f);
}


IrradianceCache::~IrradianceCache()
{
    if (root != NULL) delete root;
    treeValuesBuffer.clear();
}


bool IrradianceCache::isInside(const Vector3& position) const
{
    float halfSize = root->getSize() / 2.0f + 0.0001f;

    return ((fabs(position.x) <= halfSize &&
             fabs(position.y) <= halfSize &&
             fabs(position.z) <= halfSize));
}


void IrradianceCache::addValue(const Vector3& pos,
                               const Vector3& normal,
                               const Color3f& irrad,
                               float meanDistance)  throw (out_of_range)
{
    if (meanDistance <= 0.0f) {
        ostringstream message;
        message << "IrradianceCache::addValue(): meanDistance: " << meanDistance;
        throw out_of_range( message.str() );
    }

    // check position of the new irradiance value
    if (!isInside(pos)) {
        ostringstream message;
        message << "IrradianceCache::addValue(): Irradiance " <<
            pos << " is located outside of the octree";
        throw out_of_range( message.str() );
    }

    // condition of the storage of new irradiance value to the root
    float minSize = 2.0f * maxError * meanDistance;
    if (minSize >= root->getSize()) {
        ostringstream message;
        message << "IrradianceCache::addValue(): Root's storage condition failed"
                << ": " << minSize << " >= " << root->getSize();
        throw out_of_range( message.str() );

    }

    root->addValue(pos, normal, irrad, meanDistance, minSize, minSize * 2.0f);
}


void IrradianceCache::getValue(const Vector3& pos,
                               const Vector3& normal,
                               vector<IrradianceCache::Value*>& buffer) const
    throw (out_of_range)
{
    if (!isInside(pos)) {
        ostringstream message;
        message << "IrradianceCache::getValue(): Point " <<
            pos << " is outside of the octree";
        throw out_of_range( message.str() );
    }
    buffer.clear();
    root->getValue(pos, normal, buffer, this->maxError);
}

unsigned int IrradianceCache::getNumStoredValues() const
{
    return root->getNumStoredValues();
}

unsigned int IrradianceCache::getNumNodes() const
{
    return (root->getNumNodes());
}

const IrradianceCache::Value* IrradianceCache::getNextValuePointer()
{
    static unsigned int nodeIndex  = 0;
    static unsigned int valueIndex = 0;

    if (treeValuesBuffer.size() == 0) {
        nodeIndex = valueIndex = 0;
        root->getNodeValues(treeValuesBuffer);
    }

    if (nodeIndex <  treeValuesBuffer.size()) {
        if (valueIndex < treeValuesBuffer[nodeIndex]->size()) {
            return (treeValuesBuffer[nodeIndex]->at(valueIndex++));
        } else {
            valueIndex = 0;
            nodeIndex++;
            return getNextValuePointer();
        }
    } else
        return NULL;
}














IrradianceCache::Value::Value()
    : position(0.0f, 0.0f, 0.0f),
      normal(0.0f, 0.0f, 0.0f),
      irradiance(0.0f, 0.0f, 0.0f),
      meanDistance(0.0f),
      weight(0.0f)
{
}


IrradianceCache::Value::Value(const Vector3& pos,
                              const Vector3& normal,
                              const Color3f& irrad,
                              float meanDistance)
    : position(pos),
      normal(normal),
      irradiance(irrad),
      meanDistance(meanDistance),
      weight(0.0f)
{
}


bool IrradianceCache::Value::checkDomain(const Vector3& position,
                                         const Vector3& normal,
                                         float          maxError)
{
    /*
     * w_i(P) = 1/ [(dist(P-P_i)/R_i) + sqrt(1- N(P)*N(P_i))]
     * w_i(P) > 1/maxError
     */

    weight = 0.0f;
    
    Vector3 d(position);
    d.sub(this->position);
    float denominator = d.length() / meanDistance;
    
    if (denominator >= maxError) return false;

    denominator += sqrtf(1.0f - normal.dot(this->normal));
    if (denominator >= maxError) return false; // weight w_i(P) <= 1/maxError

    weight = 1.0f / denominator;

    return true;

    /*
     * Geometry tests
     *
     * d_i(P) = (P-P_i) * [N(P)+N(P_i)]/2
     * d_i(P) >= 0
     */
    Vector3 n(normal);
    n.add(this->normal);
    n.scale(0.5);
    return (n.dot(d) >= -0.0001f); // epsilon
}










void IrradianceCache::Node::allocate(unsigned int nodeIndex)
{
    float newSize         = size / 2.0f;
    float add             = size / 4.0f;
    float leftCenterX     = center.x - add;
    float rightCenterX    = center.x + add;
    float upCenterY       = center.y + add;
    float downCenterY     = center.y - add;
    float forwardCenterZ  = center.z + add;
    float backwardCenterZ = center.z - add;


    switch (nodeIndex) {
        case 0:
            subnodes[0] = new Node(newSize, rightCenterX,
                                   downCenterY, backwardCenterZ);
            break;
        case 1:
            subnodes[1] = new Node(newSize, leftCenterX,
                                   downCenterY, backwardCenterZ);
            break;
        case 2:
            subnodes[2] = new Node(newSize, leftCenterX,
                                   downCenterY,  forwardCenterZ);
            break;
        case 3:
            subnodes[3] = new Node(newSize, rightCenterX,
                                   downCenterY,  forwardCenterZ);
            break;
        case 4:
            subnodes[4] = new Node(newSize, rightCenterX,
                                   upCenterY, backwardCenterZ);
            break;
        case 5:
            subnodes[5] = new Node(newSize, leftCenterX,
                                   upCenterY, backwardCenterZ);
            break;
        case 6:
            subnodes[6] = new Node(newSize,  leftCenterX,
                                   upCenterY,  forwardCenterZ);
            break;
        case 7:
            subnodes[7] = new Node(newSize, rightCenterX,
                                   upCenterY,  forwardCenterZ);
            break;
        default:
            break;
    }
}


unsigned int IrradianceCache::Node::selectSubnode(const Vector3& position) const
{
    /*
      indexovani nizsi ctverice uzlu z pohledu os xz
      | 1 | 0 |
      | 2 | 3 |
      
      indexovani vyzsi ctverice uzlu pohledu os xz
      | 5 | 4 |
      | 6 | 7 |
    */
    
    // rozdeleni podle osy y
    if ( position.y - center.y >= 0.0f ) {
        // rozdeleni podle osy x
        if ( position.x - center.x >= 0.0f )  {
            // rozdelení podle osy z
            if ( position.z - center.z >= 0.0f )
                return 7;
            else
                return 4;
        } else {
            // rozdeleni podle osy z
            if ( position.z - center.z >= 0.0f )
                return 6;
            else
                return 5;
        }
    } else {
        // rozdeleni podle osy x
        if ( position.x - center.x >= 0.0f ) {
            // rozdeleni podle osy z
            if ( position.z - center.z >= 0.0f )
                return 3;
            else
                return 0;
        } else {
            // rozdeleni podle osy z
            if ( position.z - center.z >= 0.0f )
                return 2;
            else
                return 1;
        }
    }
}

bool IrradianceCache::Node::necessaryToSearch(const Vector3& position) const
{
    return (fabs(center.x - position.x) <= size &&
            fabs(center.y - position.y) <= size &&
            fabs(center.z - position.z) <= size);
}

IrradianceCache::Node::Node(float s, float cX, float cY, float cZ):
    center(cX, cY, cZ), size(s)
{
    // inicializuje ukazatele na dceøiné uzly
    for (register unsigned int i = 0; i < 8; i++) subnodes[i] = NULL;
}


IrradianceCache::Node::~Node()
{
    // odstraní v¹echny primární hodnoty z uzlu
    for (vector<IrradianceCache::Value*>::iterator it = irradianceValues.begin();
         it != irradianceValues.end();
         it++)
    {
        delete (*it);
    }
    irradianceValues.clear();

    // uvolní pamì» v¹ech dceøiných uzlù
    for (register unsigned int i = 0; i < 8; i++) 
        if (subnodes[i] != NULL) delete subnodes[i];
}


void IrradianceCache::Node::addValue(const Vector3& position,
                                     const Vector3& normal,
                                     const Vector3& color,
                                     float          meanDistance,
                                     float          minSize,
                                     float          maxSize)
{
    // Rozhodne, zda primarni hodnota patri do uzlu v zavislosti
    // na této podmínce o ukládání primární hodnoty do uzlu:
    //
    // minSize = 2*maxError*meanDistance
    // maxSize = 4*maxError*meanDistance
    //
    // minSize < size <= maxSize
    //
    if (minSize < size && size <= maxSize) {
        // ulo¾í primární hodnotu do tohoto uzlu
        irradianceValues.push_back(new IrradianceCache::Value(position,
                                                              normal,
                                                              color,
                                                              meanDistance));
    } else {
        // vybere dceøiný uzel, do kterého hodnotu ulo¾í
        unsigned int index = selectSubnode(position);
        
        if (!isAllocated(index)) allocate(index);
        
        // ulozi primarni hodnotu do vybraneho poduzlu
        return subnodes[index]->addValue(position, normal, color,
                                         meanDistance, minSize, maxSize);
    }
}

void IrradianceCache::Node::getValue(const Vector3& position,
                                    const Vector3& normal,
                                    vector<IrradianceCache::Value*>& buffer,
                                    float maxError)
{
    // iteration through irradiances stored in the node
    for (vector<IrradianceCache::Value*>::iterator it = irradianceValues.begin();
         it != irradianceValues.end(); it++)
    {
        if ((*it)->checkDomain(position, normal, maxError))
            buffer.push_back(*it);
    } // for
    

    /*
     * recursion
     */
    for (register unsigned int i = 0; i < 8; i++) {
        // podminka pro nutnost vyhledani primarnich hodnot v dcerinem uzlu
        if (isAllocated(i) && subnodes[i]->necessaryToSearch(position))
            subnodes[i]->getValue(position, normal, buffer, maxError);
    }
}

unsigned int IrradianceCache::Node::getNumStoredValues() const
{
    unsigned int tmp = irradianceValues.size();
    
    for (register unsigned int i = 0; i < 8; i++) {
        if ( isAllocated(i) ) tmp += subnodes[i]->getNumStoredValues();
    }

    return tmp;
}


unsigned int IrradianceCache::Node::getNumNodes() const
{
    unsigned int tmp = 1;
    for (register unsigned int i = 0; i < 8; i++) 
        if (isAllocated(i)) tmp += subnodes[i]->getNumNodes();
    return tmp;
}


void IrradianceCache::Node::getNodeValues(vector<vector<IrradianceCache::Value*>*>& irValues) 
{
    irValues.push_back(&irradianceValues);
    for (register unsigned int i = 0; i < 8; i++) 
        if (isAllocated(i)) subnodes[i]->getNodeValues(irValues);
}

    

---