src/rcrt/lights/sampling/AreaLightSampler.cpp

Go to the documentation of this file.

#include "AreaLightSampler.h"

using namespace std;

namespace rcrt
{


LSTreeLeaf::LSTreeLeaf(LightSample sa, const Point2D& uvMi, const Point2D& uvMa,
                const Point2D& uv, LSTreeNode* p)
        :LSTree(sa.power() == RGBColor(0,0,0) ? FULL : NONE, 1, p)
        ,sample(sa),uvMin(uvMi), uvMax(uvMa), uvs(uv)
{
}

const RGBColor& LSTreeLeaf::getMean() const
{
        return sample.power();
}

const RGBColor& LSTreeLeaf::getVariance() const
{
        return RGBColor::BLACK;
}

const float& LSTreeLeaf::getWeight() const
{
        return sample.weight();
}

void LSTreeLeaf::setWeight(const float& w)
{
        sample.setWeight(w);
}

void LSTreeLeaf::getSamples(std::vector<LightSample>& samples) const
{
        samples.push_back(sample);
}

bool LSTreeLeaf::isLeaf()
{
        return true;
}

LSTreeLeaf* LSTreeLeaf::refine()
{
        return this;
}

/*LSTreeNode Methods*/

LSTreeNode::LSTreeNode(const Point2D& uvMi, const Point2D& uvMa, LSTreeNode* p)
        :LSTree(p),lc(0), rc(0), uvMin(uvMi), uvMax(uvMa)
{
}

LSTreeNode::LSTreeNode(LSTree* l, LSTree* r, LSTreeNode* p, const Point2D& uvMi, const Point2D& uvMa)
        :LSTree(p),lc(l), rc(r), uvMin(uvMi), uvMax(uvMa)
{
        update();
}

void LSTreeNode::setLeft(LSTree* l)
{
        lc = l;
        update();
}

void LSTreeNode::setRight(LSTree* r)
{
        rc = r;
        update();
}

void LSTreeNode::update(){
        weight = lc->getWeight()+rc->getWeight();
        mean = lc->getMean() * lc->getWeight() + rc->getMean()*rc->getWeight();
        mean = mean / weight;
        size = lc->getSize() + rc->getSize();//number of leafs
        if(lc->getType() == rc->getType() && lc->getType() != PENUMBRA){
                type = lc->getType();
                variance = 0;
        }
        else
        {
                const float& lw = lc->getWeight();
                const float& rw = rc->getWeight();
                RGBColor lv = lc->getMean() - mean;
                lv = lv * lv * lc->getWeight();
                RGBColor rv = rc->getMean() - mean;
                rv = rv * rv * rc->getWeight();                 
                variance = weight/(weight*weight - lw * lw - rw * rw);
                variance = (lv + rv) * variance;
                type = PENUMBRA;
        }
        if(parent)
                parent->update();
}

LSTreeLeaf* LSTreeNode::refine()
{
        //enforce minimum difference in subdivision level between
        //subtrees.
        if(fabs(lc->getSize() - rc->getSize()) > 2){
                if(lc->getSize() < rc->getSize())
                        return lc->refine();
                else
                        return rc->refine();
        }       
        
        if(lc->getType() == PENUMBRA || rc->getType() == PENUMBRA){
                if(lc->getType() != PENUMBRA)
                        return rc->refine();
                else if(rc->getType() != PENUMBRA)
                        return lc->refine();
                else{
                        if(lc->getSize() < rc->getSize())
                                return lc->refine();
                        else
                                return rc->refine();
                }
        }
        else if(parent != 0){
                //compare with nodes at same subdivision level
                //refine the node with the type that differs most
                //from the rest, or the one that has the least size
                LSTree* other = parent->getOtherChild(this);
                if(other->isLeaf()){
                        if(lc->getType() != rc->getType() &&
                                        lc->getType() == other->getType())
                                        return rc->refine();
                }
                else {
                        LSTree* olc = ((LSTreeNode*)other)->lc;
                        LSTree* orc = ((LSTreeNode*)other)->rc;
                        if(lc->getType() != rc->getType()){
                                int lcount, rcount;
                                lcount = rcount = 0;
                                if(lc->getType() != olc->getType())
                                        lcount++;
                                if(lc->getType() != orc->getType())
                                        lcount++;
                                if(rc->getType() != olc->getType())
                                        rcount++;
                                if(rc->getType() != orc->getType())
                                        rcount++;
                                if(rcount > lcount)
                                        return rc->refine();
                                else if(lcount > rcount)
                                        return lc->refine();
                        }
                }
        }        
        if(lc->getSize() > rc->getSize())
                return rc->refine();
        return lc->refine();
}

LSTree* LSTreeNode::getOtherChild(LSTree* c)
{
        if(lc != c)
                return lc;
        else
                return rc;
}
        
const RGBColor& LSTreeNode::getMean() const
{
        return mean;
}
        
const float& LSTreeNode::getWeight() const
{
        return weight;
}

void LSTreeNode::setWeight(const float& w)
{
        weight = w;
}

void LSTreeNode::getSamples(std::vector<LightSample>& samples) const
{
        lc->getSamples(samples);
        rc->getSamples(samples);
}
        
const RGBColor& LSTreeNode::getVariance() const
{
        return variance;
}

/*AreaLightSampler methods*/

AreaLightSampler::AreaLightSampler(AreaLight* l)
        :light(l),root(0)
{
}

void AreaLightSampler::subdivide(LSTreeLeaf* leaf, vector<LightSample>& samples,
                const Point3D& p, const Vec3D& no, Scene* scene)
{
        //cout << "[AreaLightSampler] subdivide:" << endl;
        LSTreeNode* parent = leaf->getParent();
        const Point2D& uvMin = leaf->uvMin;
        const Point2D& uvMax = leaf->uvMax;
        float length[2] = {
                        uvMax.x()-uvMin.x(),
                        uvMax.y()-uvMin.y()
                };
        int splitAxis = length[0] < length[1] ? 1/*y*/ : 0/*x*/;
        float split = uvMin[splitAxis] + 0.5 * length[splitAxis];
        
        //generate a new subdivided node and insert it
        //cout << "[AreaLightSampler]            generating new parent node" << endl;
        LSTreeNode* newParent = 0;
        if(parent->lc == leaf){
                parent->lc = new LSTreeNode(uvMin,uvMax,parent);
                newParent = (LSTreeNode*) parent->lc;
        }else{
                parent->rc = new LSTreeNode(uvMin,uvMax,parent);
                newParent = (LSTreeNode*) parent->rc;
        }
        //cout << "[AreaLightSampler]            setting parent " << newParent << " on leaf" << endl;
        leaf->parent = newParent;
        float leafWeight = leaf->sample.weight()*0.5;
        leaf->setWeight(leafWeight);
        
        //insert the previous sample and a new sample
        //cout << "[AreaLightSampler]            inserting samples" << endl;
        if(leaf->uvs[splitAxis] < split){
                Point2D ruvMin = uvMin;
                ruvMin[splitAxis] = split;
                Point2D rLeafPos = uvMin;
                rLeafPos[splitAxis] += 0.75*length[splitAxis];
                rLeafPos[1-splitAxis] += 0.5*length[1-splitAxis];
                
                newParent->rc = new LSTreeLeaf(
                                light->getSample(rLeafPos,no,p,scene),
                                ruvMin,uvMax, rLeafPos, newParent);
                newParent->rc->setWeight(leafWeight);
                leaf->uvMax[splitAxis] = split;
                newParent->lc = leaf;
        } else {
                Point2D luvMax = uvMax;
                luvMax[splitAxis] = split;
                Point2D rLeafPos = uvMin;
                rLeafPos[splitAxis] += 0.25*length[splitAxis];
                rLeafPos[1-splitAxis] += 0.5*length[1-splitAxis];
                newParent->lc = new LSTreeLeaf(
                                light->getSample(rLeafPos,no,p,scene),
                                uvMin,luvMax, rLeafPos, newParent);
                newParent->lc->setWeight(leafWeight);
                leaf->uvMin[splitAxis] = split;
                newParent->rc = leaf;
        }
        //cout << "[AreaLightSampler]            updating parent " << endl;
        
        newParent->update();
        
}
        
void AreaLightSampler::sample(const Point3D& p, const Vec3D& no,
                vector<LightSample>& samples, const int& maxSamples, Scene* scene)
{
        //cout << "[AreaLightSampler] sample:" << endl;
        
        const Point3D& base = light->base;
        const Vec3D& span1 = light->span1;
        const Vec3D& span2 = light->span2;
        
        //TODO reuse of previous sampling pattern if lastPos near p, for now, recalculate
        if(root != 0){
                //cout << "[AreaLightSampler]         deleting current tree" << endl;
                delete root;
        }

        //do initial sampling
        int count = 0;
        
        //use a 2x2 rotated grid
        Point2D uvs[4] = {
                        Point2D(0.375, 0.125),
                        Point2D(0.875, 0.375),
                        Point2D(0.625, 0.875),
                        Point2D(0.125, 0.625)                   
                };
        Point3D loc[4] = {
                        Point3D(base+uvs[0].x()*span1+uvs[0].y()*span2),
                        Point3D(base+uvs[1].x()*span1+uvs[1].y()*span2),
                        Point3D(base+uvs[2].x()*span1+uvs[2].y()*span2),
                        Point3D(base+uvs[3].x()*span1+uvs[3].y()*span2)
                        };
        LightSample initSamples[4] = {
                        light->getSample(p,no,loc[0],scene),
                        light->getSample(p,no,loc[1],scene),
                        light->getSample(p,no,loc[2],scene),
                        light->getSample(p,no,loc[3],scene)
                };
        for(int s = 0; s < 4; s++){
                initSamples[s].setWeight(0.25f);
                count++;
        }
        //construct initial tree
        root = new LSTreeNode(Point2D(0,0),Point2D(1,1));
        root->lc = new LSTreeNode(Point2D(0,0), Point2D(1,0.5), root);
        root->rc = new LSTreeNode(Point2D(0,0.5), Point2D(1,1), root);
        LSTreeNode* rlc = (LSTreeNode*)root->lc;
        LSTreeNode* rrc = (LSTreeNode*)root->rc;
        rlc->lc = new LSTreeLeaf(initSamples[0], Point2D(0,0), Point2D(0.5,0.5), uvs[0], rlc);
        rlc->rc = new LSTreeLeaf(initSamples[1], Point2D(0.5,0), Point2D(1,0.5), uvs[1], rlc);
        rlc->update();
        rrc->lc = new LSTreeLeaf(initSamples[2], Point2D(0.5,0.5), Point2D(1,1), uvs[2], rrc);
        rrc->rc = new LSTreeLeaf(initSamples[3], Point2D(0,0.5), Point2D(0.5,1), uvs[3], rrc);
        rrc->update();
        //cout << "[AreaLightSampler]         generated initial tree" << endl;
        //refine the tree until maximum samples reached
        //or variance small enough      
        RGBColor lastMean = root->getMean();
        float minSamples = maxSamples/2;
        while(count < maxSamples){
                //get the leaf that we want to refine
                //cout << "[AreaLightSampler]         getting leaf to refine" << endl;
                LSTreeLeaf* leaf = root->refine();
                //cout << "[AreaLightSampler]         subdividing leaf" << endl;
                subdivide(leaf, samples, p, no, scene);
                count++;
                RGBColor difference = root->getMean() - lastMean;
                if(count > minSamples
                                && fabs(difference.r()) < 0.00001f
                                && fabs(difference.g()) < 0.00001f
                                && fabs(difference.b()) < 0.00001f)
                        break;
                lastMean = root->getMean();
        }
        
        root->getSamples(samples);
        /*
        cout << "[AreaLightSampler]         got "<<count <<" samples:" << endl;
        cout << "[AreaLightSampler]         ";
        float totalW = 0;
        for(unsigned int i = 0; i < samples.size(); i++){
                totalW += samples[i].weight();
                cout << " w=" << samples[i].weight();
        }
        cout << endl << "[AreaLightSampler]         total weight="<<totalW<<endl;
        */
}



} //Namespace

---