src/rcrt/lights/AreaLight.cpp

Go to the documentation of this file.

#include "AreaLight.h"
#include <limits>
#include "../math/Matrix4D.h"

using namespace std;

namespace rcrt
{

AreaLight::AreaLight(const RGBColor& p, const Point3D& pos,
                const Vec3D& dir1, const Vec3D& dir2, const Vec3D& no):Light(p), base(pos),
                span1(dir1), span2(dir2), 
                normal(
                                ((dir1.crossP(dir2)).normalize() * no < 0 ?
                                                dir1.crossP(dir2) * -1
                                                : dir1.crossP(dir2))
                                                .normalized()
                                ),
                area(normal.norm()), object("arealight"), material(this),
                tri1(pos, pos+dir1, pos+dir1+dir2, normal,&object),
                tri2(pos+dir1+dir2, pos+dir2, pos, normal,&object)
                
{
        minSamples = 4;//(int)ceil(area*32);//TODO parameterize
        cout << "area = " << area << " light samplecount = " << minSamples << endl;
        object.setWorldMatrix(Matrix4D::identity());
        object.setMaterial(&material);
        triList.push_back(&tri1);
        triList.push_back(&tri2);
        object.setPrimitives(&triList);
        aspect = span2.norm()/span1.norm();
}

AreaLight::~AreaLight()
{
}

        
/* Light methods */

LightSample AreaLight::illuminate(const Point3D& p, const Vec3D& no) const
{
        const Point3D loc(getRandomPosition());
        return getSample(p,no,loc);
}

void AreaLight::illuminate(const Point3D& p, const Vec3D& no, std::vector<LightSample>& samples,
                        const int& noSamples, Scene* s) const
{
        if(noSamples == 1){
                samples.push_back(getSample(p,no,base+0.5*span1+0.5*span2,s));
        } else if (noSamples == 4) {
                samples.push_back(getSample(p,no,base+0.125*span1+0.375*span2,s));
                samples.push_back(getSample(p,no,base+0.625*span1+0.125*span2,s));
                samples.push_back(getSample(p,no,base+0.875*span1+0.625*span2,s));
                samples.push_back(getSample(p,no,base+0.375*span1+0.875*span2,s));
        }
        int sampY = (int)floor(sqrt(noSamples*aspect));
        int sampX = (int)ceil(noSamples/sampY);
        float weight = 1.0f/(sampY*sampX);
        float uDist = 1.0f/sampX;
        float vDist = 1.0f/sampY;
        for(float u = 0.5; u < sampX; u++){
                for(float v = 0.5; v < sampY; v++){
                        float xi1 = (float(rand()) / float(RAND_MAX) - 0.5) * uDist/4;
                        float xi2 = (float(rand()) / float(RAND_MAX) - 0.5) * vDist/4;
                        //cout << "u*D=" << u*uDist << " v*D=" << v*vDist << endl;
                        LightSample ls = getSample(
                                        p,no,base + (u*uDist+xi1)*span1 + (v*vDist+xi2)*span2,s);
                        //cout << "sample=" << ls.power() << endl;
                        if(ls.weight() != 0)
                                ls.setWeight(weight);
                        samples.push_back(ls);
                }
        }
}


Point3D AreaLight::getRandomPosition() const
{
        // compute random position of a point light on the quad
        float xi1 = float(rand()) / float(RAND_MAX);
        float xi2 = float(rand()) / float(RAND_MAX);
        return base + xi1 * span1 + xi2 * span2;
}

Object* AreaLight::getObject()
{
        return &object;
}

RGBColor AreaLight::getEmitted(const Vec3D& dir, const Point3D& pos) const
{
        float cosN = dir * normal;
        if (cosN < std::numeric_limits<float>::epsilon()){
                return 0;
        }
        // compute intensity based on the area of the light source
        return power * area * cosN;
}


void AreaLight::emitPhoton(Photon* photon) const
{
        float xi1 = float(rand()) / float(RAND_MAX);
        float xi2 = float(rand()) / float(RAND_MAX);
        float z2 = xi2 * 2.0f * M_PI;
        Vec3D outDir(span1.normalized() * cos(z2) + span2.normalized() * sin(z2) * sqrt(1-xi1) + normal * sqrt(xi1));
        
        //Vec3D outDir(float(rand()) / float(RAND_MAX),
//                                              float(rand()) / float(RAND_MAX),
//                                              float(rand()) / float(RAND_MAX));
        outDir.normalize();
        //if(outDir * normal < 0)
                //outDir = outDir * -1;
        
        photon->setDir(outDir);
        photon->setPos((base + span1 * xi1 + span2 * xi2)+normal*0.000001f);
        photon->setPower(power * area * (photon->getDir() * normal));
}

}

---