src/rcrt/RCRTTrace.cpp

Go to the documentation of this file.

#include <iostream>
#include <ctime>
#include <string>
#include "loaders/AnimLoader.h"
#include "cameras/Camera.h"
#include "Scene.h"
#include "tracing/SimpleTracer.h"
#include "tracing/ThreadedMetaTracer.h"
#include "tracing/SuperMetaTracer.h"
#include "textures/Image.h"

#include "gi/PhotonMap.h"
#include "tracing/PhotonTracer.h"

/*
#include <iostream>
#include <exception>
#include <ctime>
#include <string>
#include <limits>
#include "math/rcrtmath.h"
#include "RGBAColor.h"
#include "primitives/Triangle.h"
#include "primitives/Sphere.h"
#include "BIH.hpp"
#include "loaders/ObjectLoader.h"
#include "loaders/SceneLoader.h"
#include "loaders/AnimLoader.h"
#include "lights/lights.h"
#include "lights/sampling/AreaLightSampler.h"
#include "cameras/PerspectiveCamera.h"
#include "Scene.h"
#include "textures/Texture.hpp"
#include "tracing/DebugTracer.h"
#include "tracing/RayCaster.h"
#include "tracing/SimpleTracer.h"
#include "tracing/BIHTracer.h"
#include "tracing/StereoMetaTracer.h"
#include "tracing/ThreadedMetaTracer.h"
#include "textures/Image.h"
#include "materials/Material.h"
#include "materials/BSDFMaterial.h"
#include "materials/DebugMaterial.h"
#include "materials/BlackMaterial.h"
#include "materials/MirrorMaterial.h"
#include "materials/DielectricMaterial.h"
#include "bxdf/BSDF.h"
#include "bxdf/Lambertian.h"
#include "bxdf/Phong.h"
#include "bxdf/CookTorrance.h"
#include "primitives/ConvexQuad.h"
#include "primitives/DisplacedTriangle.h"
#include "textures/ImageTexture.h"
*/

using namespace rcrt;
using namespace std;

//void testDispl() 
//{
//      //ConvexQuad quad(0,Point3D(-1,0,0), Point3D(-1,0,1), Point3D(1,0,1), Point3D(1,0,0));
//      vector<Traceable*>* list = new vector<Traceable*>();
//      //list->push_back(&quad);
//      
//      Image texIm;
//              
//      std::cout << "reading texture" << std::endl;
//      bool success = texIm.ReadPNG("StoneWall5.png");
//      std::cout << "textureread " << success << std::endl;
//      
//      ImageTexture tex(&texIm);
//      
//      AffineObject bumpTest("hurz");
//      
//      bumpTest.setDisplMap(&tex);
//      bumpTest.setDisplDens(3);
//      bumpTest.setMaxDispl(0.2);
//      
//      bumpTest.setWorldMatrix(Matrix4D::identity());
//      
//      Vec3D vn1 = Vec3D(-0.2,1,-0.2).normalize();
//      Vec3D vn2 = Vec3D(0.2,1,-0.2).normalize();
//      Vec3D vn3 = Vec3D(0.2,1,0.2).normalize();
//      
//      
//      DisplacedTriangle t(new Vertex(Point3D(-2,0,-2),vn1,Point2D(0.1,0.1)),new Vertex(Point3D(2,0,-1),vn2,Point2D(0.1,0.9)),new Vertex(Point3D(1,0,2),vn3,Point2D(0.9,0.9)),&bumpTest);
//      vector<Primitive*>* prList = new vector<Primitive*>();
//      prList->push_back(&t);
//      
//      BSDF lambert;
//      BSDF phong;
//      lambert.addBXDF(new Lambertian(RGBColor(0.6,0.5,0.9)));
//      phong.addBXDF(new Phong(RGBColor(0.6,0.5,0.9),0.6,0.4,10));
//      BSDFMaterial matP = BSDFMaterial(phong);
//      BSDFMaterial matL = BSDFMaterial(lambert);
//      
//      
//      DebugMaterial dm;
//      
//      
//      bumpTest.setMaterial(&dm);
//      bumpTest.setPrimitives(prList);
//      
//      list->push_back(&bumpTest);
//      
//      Scene scene(list);
//      
//      PointLight* light1 = new PointLight(RGBColor(15,15,15),Point3D(0.25,2,0));
//      scene.addLight(light1);
//      
//      DebugTracer rt(&scene);
//      PerspectiveCamera cam(60, Point3D(4,2,0), Vec3D(-1,-0.5,0), Vec3D(0,1,0), 640, 480);
//      std::cout << "tracing" << std::endl;
//      Ray r = cam.getRay(Point2D(540,360));
//      //rt.trace(r);
//      Image img = rt.trace(&cam);
//      std::cout << "blubb" << std::endl;
//      img.WritePNG("displ.png");
//      //Ray r(Point3D(0,5,0),Vec3D(0,-1,0))
//}

void rcrtAnim()
{
        cout << "[RCRT]: Loading animation rcrt.xml" << endl;
        AnimLoader animL("rcrt.xml");
        Scene* scene = animL.getScene();
        scene->setShadows(true);
        Camera* cam = animL.getCamera();
        cout << "[RCRT]: Initialising multithreaded simple tracer" << endl;
        SimpleTracer rt(scene);
        ThreadedMetaTracer st(&rt);
        double tracingTime = 0;
        int frames = 0;
        do{
                clock_t start = clock();
                cout << "[RCRT]: tracing frame: "<< animL.getFrame() << endl;
                Image img = st.trace(cam);
                clock_t end = clock();
                float dif = end-start;
                cout << "        finished frame in " << (dif / CLOCKS_PER_SEC) << endl;
                string no(toString(animL.getFrame()));
                string zeros("");
                for(int i = 0; i < 5 - int(no.length()); i++)
                        zeros.append("0");
                
                string file("rcrtAnim-"+zeros+no+".png"); 
                //img.ToneMapping(0.);
                img.WritePNG(file.c_str());
                
                tracingTime += dif;
                frames++;
        }while(animL.nextFrame());
        int rays = frames * cam->getResolutionX() * cam->getResolutionY();
        cout << "[RCRT]: finished rendering " << endl;
        cout << "        traced an average of "<< (tracingTime / CLOCKS_PER_SEC)/frames << " seconds per frame" << endl;
        cout << "        traced an average of "<< (rays / (tracingTime / CLOCKS_PER_SEC)) << " rays per second" << endl;
}

void testPhoton()
{
        cout << "[RCRT]: Loading animation" << endl;
        AnimLoader animL("pmaptest.xml");
        Scene* scene = animL.getScene();
        scene->setShadows(true);
        Camera* cam = animL.getCamera();
        cout << "[RCRT]: Initialising photon map tracing" << endl;
        PhotonMap pMap(scene, 0.50, 15);
        cout << "[RCRT]:     generating Photonmap..." << endl;
        clock_t start = clock();
        int photons = 400000;
        //pMap.generate(photons);
        clock_t end = clock();
        cout << "[RCRT]: Photonmap of size " << photons << " took " << double(end-start) / CLOCKS_PER_SEC << " seconds" << endl;
        //PhotonTracer rt(scene, &pMap, 1500, 600);
        SimpleTracer rt(scene);
        //SuperMetaTracer smt(&rt);
        ThreadedMetaTracer tmt(&rt);
        double tracingTime = 0;
        int frames = 0;
        do{
                clock_t start = clock();
                cout << "[RCRT]: tracing frame: "<< animL.getFrame() << endl;
                Image img = tmt.trace(cam);
                clock_t end = clock();
                float dif = end-start;
                cout << "        finished frame in " << (dif / CLOCKS_PER_SEC) << endl;
                string no(toString(animL.getFrame()));
                string zeros("");
                for(int i = 0; i < 5 - int(no.length()); i++)
                        zeros.append("0");
                
                string file("photon-"+zeros+no+".png"); 
                img.WritePNG(file.c_str());
                
                tracingTime += dif;
                frames++;
        }while(animL.nextFrame());
        int rays = frames * cam->getResolutionX() * cam->getResolutionY();
        cout << "[RCRT]: finished rendering " << endl;
        cout << "        traced an average of "<< (tracingTime / CLOCKS_PER_SEC)/frames << " seconds per frame" << endl;
        cout << "        traced an average of "<< (rays / (tracingTime / CLOCKS_PER_SEC)) << " primary rays per second" << endl;
}

void testPhotonRCRT()
{
        cout << "[RCRT]: Loading animation" << endl;
        AnimLoader animL("rcrt5.xml");
        Scene* scene = animL.getScene();
        scene->setShadows(false);
        Camera* cam = animL.getCamera();
        cout << "[RCRT]: Initialising photon map tracing" << endl;
        PhotonMap pMap(scene, 0.250, 10);
        cout << "[RCRT]:     generating Photonmap..." << endl;
        clock_t start = clock();
        int photons = 500000;
        pMap.generate(photons);
        clock_t end = clock();
        cout << "[RCRT]: Photonmap of size " << photons << " took " << double(end-start) / CLOCKS_PER_SEC << " seconds" << endl;
        PhotonTracer rt(scene, &pMap, 1500, 600);
        //SimpleTracer rt(scene);
        //SuperMetaTracer smt(&rt);
        ThreadedMetaTracer tmt(&rt);
        double tracingTime = 0;
        int frames = 0;
        do{
                clock_t start = clock();
                cout << "[RCRT]: tracing frame: "<< animL.getFrame() << endl;
                Image img = tmt.trace(cam);
                clock_t end = clock();
                float dif = end-start;
                cout << "        finished frame in " << (dif / CLOCKS_PER_SEC) << endl;
                string no(toString(animL.getFrame()));
                string zeros("");
                for(int i = 0; i < 5 - int(no.length()); i++)
                        zeros.append("0");
                
                string file("rcrtphoton-"+zeros+no+".png"); 
                img.WritePNG(file.c_str());
                
                tracingTime += dif;
                frames++;
        }while(animL.nextFrame());
        int rays = frames * cam->getResolutionX() * cam->getResolutionY();
        cout << "[RCRT]: finished rendering " << endl;
        cout << "        traced an average of "<< (tracingTime / CLOCKS_PER_SEC)/frames << " seconds per frame" << endl;
        cout << "        traced an average of "<< (rays / (tracingTime / CLOCKS_PER_SEC)) << " primary rays per second" << endl;
}

int main(int argc, char *argv[]){
        //testDispl();
        //testPhoton();
        
        rcrtAnim();
                
        return 0;
}

---