tuto_englobant.cpp File Reference

#include <algorithm>
#include <vector>
#include <cfloat>
#include <chrono>
#include "vec.h"
#include "mat.h"
#include "color.h"
#include "image.h"
#include "image_io.h"
#include "image_hdr.h"
#include "orbiter.h"
#include "mesh.h"
#include "wavefront.h"

Go to the source code of this file.

Classes
struct	RayHit
struct	BBox
	boite englobante. More...
struct	Triangle
	triangle pour le bvh, cf fonction bounds() et intersect(). More...
struct	triangle_less1
struct	ray_less1

Functions
void	direct (const std::vector< Triangle > &triangles, const int tbegin, const int tend, std::vector< RayHit > &rays, const int rbegin, const int rend)
void	divide (const BBox &bounds, std::vector< Triangle > &triangles, const int tbegin, const int tend, std::vector< RayHit > &rays, const int rbegin, const int rend)
int	main (const int argc, const char **argv)

Function Documentation

direct()

void direct	(	const std::vector< Triangle > &	triangles,
		const int	tbegin,
		const int	tend,
		std::vector< RayHit > &	rays,
		const int	rbegin,
		const int	rend )

Definition at line 121 of file tuto_englobant.cpp.

{
    for(int i= rbegin; i < rend; i++)
    for(int k= tbegin; k < tend; k++)
        triangles[k].intersect(rays[i]);
}

divide()

void divide	(	const BBox &	bounds,
		std::vector< Triangle > &	triangles,
		const int	tbegin,
		const int	tend,
		std::vector< RayHit > &	rays,
		const int	rbegin,
		const int	rend )

Definition at line 158 of file tuto_englobant.cpp.

{
    if(tbegin == tend || rbegin == rend)
        // plus de triangles ou de rayons, rien a faire...
        return;
        
    // il ne reste plus que quelques triangles, finir les calculs d'intersection...
    if(tend - tbegin <= 4)
    {
        direct(triangles, tbegin, tend, rays, rbegin, rend);
        return;
    }
    
    // axe le plus etire de l'englobant
    Vector d= Vector(bounds.pmin, bounds.pmax);
    int axis;
    if(d.x > d.y && d.x > d.z)  // x plus grand que y et z ?
        axis= 0;
    else if(d.y > d.z)          // y plus grand que z ? (et que x implicitement)
        axis= 1;
    else                        // x et y ne sont pas les plus grands...
        axis= 2;
 
    // coupe l'englobant au milieu
    float cut= bounds.centroid(axis);
    
    // repartit les triangles 
    Triangle *pm= std::partition(triangles.data() + tbegin, triangles.data() + tend, triangle_less1(axis, cut));
    int m= std::distance(triangles.data(), pm);
    
    // la repartition des triangles peut echouer, et tous les triangles sont dans la meme partie... 
    // forcer quand meme un decoupage en 2 ensembles 
    if(m == tbegin || m == tend)
        m= (tbegin + tend) / 2;
    assert(m != tbegin);
    assert(m != tend);
    
    // construit les englobants
    BBox left= triangles[tbegin].bounds();
    for(int i= tbegin+1; i < m; i++)
        left.insert(triangles[i].bounds());
    
    // repartit les rayons
    RayHit *prleft= std::partition(rays.data() + rbegin, rays.data() + rend, ray_less1(left));
    int rleft= std::distance(rays.data(), prleft);
    
    divide(left, triangles, tbegin, m, rays, rbegin, rleft);
    
    // on recommence pour la droite
    BBox right= triangles[m].bounds();
    for(int i= m+1; i < tend; i++)
        right.insert(triangles[i].bounds());
    
    RayHit *prright= std::partition(rays.data() + rbegin, rays.data() + rend, ray_less1(right));
    int rright= std::distance(rays.data(), prright);
    
    divide(right, triangles, m, tend, rays, rbegin, rright);
}

main()

int main	(	const int	argc,
		const char **	argv )

Definition at line 220 of file tuto_englobant.cpp.

{
    const char *mesh_filename= "data/cornell.obj";
    if(argc > 1)
        mesh_filename= argv[1];
        
    const char *orbiter_filename= "data/cornell_orbiter.txt";
    if(argc > 2)
        orbiter_filename= argv[2];
    
    Orbiter camera;
    if(camera.read_orbiter(orbiter_filename) < 0)
        return 1;
 
    Mesh mesh= read_mesh(mesh_filename);
    BBox bounds;
    mesh.bounds(bounds.pmin, bounds.pmax);
    
    // recupere les triangles
    std::vector<Triangle> triangles;
    {
        int n= mesh.triangle_count();
        for(int i= 0; i < n; i++)
            triangles.emplace_back(mesh.triangle(i), i);
    }
    
    Image image(1024, 768);
 
    // recupere les transformations
    camera.projection(image.width(), image.height(), 45);
    Transform model= Identity();
    Transform view= camera.view();
    Transform projection= camera.projection();
    Transform viewport= camera.viewport();
    Transform inv= Inverse(viewport * projection * view * model);
    
    // genere un rayon par pixel de l'image
    std::vector<RayHit> rays;
    for(unsigned y= 0; y < image.height(); y++)
    for(unsigned x= 0; x < image.width(); x++)
    {
        // generer le rayon
        Point origine= inv(Point(x + .5f, y + .5f, 0));
        Point extremite= inv(Point(x + .5f, y + .5f, 1));
        
        rays.emplace_back(origine, extremite, x, y);
    }
    
// mesure les temps d'execution 
#if 0
    {
        auto start= std::chrono::high_resolution_clock::now();
        direct(triangles, 0, int(triangles.size()), rays, 0, int(rays.size()));
        
        auto stop= std::chrono::high_resolution_clock::now();
        int cpu= std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
        printf("direct %dms\n", cpu);
    }
#endif
 
    {
        auto start= std::chrono::high_resolution_clock::now();
        divide(bounds, triangles, 0, int(triangles.size()), rays, 0, int(rays.size()));
        
        auto stop= std::chrono::high_resolution_clock::now();
        int cpu= std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count();
        printf("divide %dms\n", cpu);
    }
    
    // reconstruit l'image
    for(unsigned i= 0; i < rays.size(); i++)
    {
        if(rays[i])
        {
            int x= rays[i].x;
            int y= rays[i].y;
            float u= rays[i].u;
            float v= rays[i].v;
            float w= 1 - u - v;
            image(x, y)= Color(w, u, v);
        }
    }
    write_image(image, "divide.png");
    
    
    return 0;
}