MC_mesh_fast_draw.cpp

Go to the documentation of this file.

#include <MC_connectivity_index.hpp>
#include <MC_v3d_vector.hpp>
#include <MC_mesh_index_vector.hpp>
#include <MC_mesh_index_vector_draw.hpp>

#include <MC_mesh_fast_draw.hpp>


namespace mesh_conv
{

    MC_mesh_fast_draw::MC_mesh_fast_draw(){}
    MC_mesh_fast_draw::~MC_mesh_fast_draw(){}

    MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_connectivity_index& input_connectivity,const MC_v3d_vector& input_point_set)
    {
        int N_large=10000;

        int N_polygon=input_connectivity.size();
        if(N_polygon>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh ..."<<std::endl;}

        set_connectivity(input_connectivity);
        set_point_set(input_point_set);

        // normal per vertex
        MC_v3d_vector normal = MC_mesh_index_vector::normal_vertex(input_point_set,input_connectivity);
        set_normal(normal);

    }
    MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_mesh_index_vector& mesh)
    {*this=MC_mesh_fast_draw(mesh.connectivity(),mesh.point_set());}
    MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_mesh_index_vector_draw& mesh)
    {
        int N_large=10000;
        
        int N_polygon=mesh.connectivity().size();
        if(N_polygon>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh ..."<<std::endl;}



        set_point_set(mesh.point_set());
        set_connectivity(mesh.connectivity());
        if(mesh.normal().size()==mesh.vertex_number())
            set_normal(mesh.normal());
        else
        {
            std::cout<<"Error: mesh.normal().size()="<<mesh.normal().size()<<std::endl;
            std::cout<<"Error: mesh.vertex_number()="<<mesh.vertex_number()<<std::endl;
            std::cout<<"Error in MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_mesh_index_vector_draw& mesh), should implement normal not per vertex"<<std::endl;
        }

        if(mesh.color().size()==mesh.vertex_number())
            set_color(mesh.color());
        else{}
        //{std::cout<<"Error in MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_mesh_index_vector_draw& mesh), should implement color not per vertex"<<std::endl;}

        if(mesh.texture().size()!=0)
            set_texture(mesh.texture());
        //else
        //{std::cout<<"Error in MC_mesh_fast_draw::MC_mesh_fast_draw(const MC_mesh_index_vector_draw& mesh), should implement texture not per vertex"<<std::endl;exit(-1);}


        if(N_polygon>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok normal]"<<std::endl;}

    }

    const std::map <int,MC_int_vector>& MC_mesh_fast_draw::connectivity() const
    {return connectivity_mesh;}
    const MC_double_vector& MC_mesh_fast_draw::point_set() const {return point_set_mesh;}
    MC_double_vector& MC_mesh_fast_draw::point_set() {return point_set_mesh;}
    const MC_double_vector& MC_mesh_fast_draw::color() const {return color_mesh;}
    const MC_double_vector& MC_mesh_fast_draw::texture() const {return texture_mesh;}
    const MC_double_vector& MC_mesh_fast_draw::normal() const {return normal_mesh;}
    MC_double_vector& MC_mesh_fast_draw::normal() {return normal_mesh;}


    MC_mesh_fast_draw& MC_mesh_fast_draw::set_point_set(const MC_v3d_vector& point_set)
    {
        int N_large=10000;
        int N_vertex=point_set.size();

        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build point_set for large mesh"<<std::endl;}


        // continuous point set
        point_set_mesh.resize(3*N_vertex);
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            for(int k_dim=0;k_dim<3;++k_dim)
                point_set_mesh[3*k_vertex+k_dim]=point_set[k_vertex][k_dim];

        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok point_set]"<<std::endl;}

        return *this;
    }
    MC_mesh_fast_draw& MC_mesh_fast_draw::set_connectivity(const MC_connectivity_index& input_connectivity)
    {
        int N_large=10000;
        int N_polygon=input_connectivity.size();

        if(N_polygon>N_large)
        {std::cout<<"MC_mesh_fast_draw build connectivity for large mesh"<<std::endl;}

        std::map <int,MC_int_vector> :: iterator it;
        // sort the connectivity depending on the size
        for(int k_polygon=0;k_polygon<N_polygon;++k_polygon)
        {
            int current_size=input_connectivity[k_polygon].size();
            it=connectivity_mesh.find(current_size);

            // must initialize this size
            if(it==connectivity_mesh.end())
            {
                connectivity_mesh.insert(std::pair <int,MC_int_vector>(current_size,MC_int_vector()));
                it=connectivity_mesh.find(current_size);
                if(it==connectivity_mesh.end())
                {std::cout<<"Error in MC_mesh_fast_draw::MC_mesh_fast_draw(connectivity,point_set), cannot create map"<<std::endl;exit(-1);}
            }
            // now add the polygon at the correct place
            it->second.add(input_connectivity[k_polygon]);
        }

        if(N_polygon>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok connectivity]"<<std::endl;}

        return *this;
    }
    MC_mesh_fast_draw& MC_mesh_fast_draw::set_color(const MC_v3d_vector& color)
    {

        int N_vertex=color.size();
        int N_large=10000;
        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build color for large mesh"<<std::endl;}


        color_mesh.resize(3*N_vertex);
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            for(int k_dim=0;k_dim<3;++k_dim)
                color_mesh[3*k_vertex+k_dim]=color[k_vertex][k_dim];

        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok color]"<<std::endl;}

        if(color_mesh.size()!=point_set_mesh.size())
        {std::cout<<"Error in MC_mesh_fast_draw::set_color(const MC_v3d_vector& color), color has size("<<color.size()<<"), and point_set has size("<<point_set_mesh.size()/3<<")"<<std::endl;exit(-1);}
        return *this;
    }
    MC_mesh_fast_draw& MC_mesh_fast_draw::set_normal(const MC_v3d_vector& normal)
    {
        int N_vertex=normal.size();
        int N_large=10000;
        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build normal for large mesh"<<std::endl;}


        normal_mesh.resize(3*N_vertex);
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            for(int k_dim=0;k_dim<3;++k_dim)
                normal_mesh[3*k_vertex+k_dim]=normal[k_vertex][k_dim];

        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok normal]"<<std::endl;}

        if(normal_mesh.size()!=point_set_mesh.size())
        {std::cout<<"Error in MC_mesh_fast_draw::set_normal(const MC_v3d_vector& normal), normal has size("<<normal.size()<<"), and point_set has size("<<point_set_mesh.size()/3<<")"<<std::endl;exit(-1);}
        return *this;
    }

    MC_mesh_fast_draw& MC_mesh_fast_draw::set_texture(const MC_v3d_vector& texture)
    {

        int N_vertex=texture.size();
        int N_large=10000;
        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build texture for large mesh"<<std::endl;}


        texture_mesh.resize(2*N_vertex);
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            for(int k_dim=0;k_dim<2;++k_dim)
                texture_mesh[2*k_vertex+k_dim]=texture[k_vertex][k_dim];

        if(N_vertex>N_large)
        {std::cout<<"MC_mesh_fast_draw build for large mesh [ok texture]"<<std::endl;}

//        if(texture_mesh.size()*3!=point_set_mesh.size()*2)
//        {std::cout<<"Error in MC_mesh_fast_draw::set_texture(const MC_v3d_vector& color), texture has size("<<texture.size()<<"), and point_set has size("<<point_set_mesh.size()/3<<")"<<std::endl;exit(-1);}
        return *this;
    }

}