MC_mesh_index_vector_draw.cpp

Go to the documentation of this file.

#include <MC_segment.hpp>
#include <MC_io_off.hpp>
#include <MC_io_obj.hpp>
#include <MC_string_helper.hpp>

#include <MC_mesh_index_vector_draw.hpp>

namespace mesh_conv
{

    MC_mesh_index_vector_draw::MC_mesh_index_vector_draw()
            :MC_mesh_index_vector()
    {}
    MC_mesh_index_vector_draw::MC_mesh_index_vector_draw(const MC_v3d_vector& input_point_set,const MC_connectivity_index& input_connectivity)
            :MC_mesh_index_vector(input_point_set,MC_connectivity_index())
    {
        MC_connectivity_index temp_co=input_connectivity;
        temp_co.build_star();
        connectivity_mesh=temp_co;

        // automatically build normal per vertex
        normal_mesh=MC_mesh_index_vector::normal_vertex(point_set_mesh,temp_co);
    }
    MC_mesh_index_vector_draw::MC_mesh_index_vector_draw(const MC_mesh_index_vector& mesh)
            :MC_mesh_index_vector(mesh.point_set(),MC_connectivity_index())
    {
        MC_connectivity_index temp_co=mesh.connectivity();
        temp_co.build_star();
        connectivity_mesh=temp_co;


        // automatically build normal per vertex
        normal_mesh=MC_mesh_index_vector::normal_vertex(point_set_mesh,temp_co);
    }

    MC_v3d_vector& MC_mesh_index_vector_draw::normal(){return normal_mesh;}
    const MC_v3d_vector& MC_mesh_index_vector_draw::normal() const {return normal_mesh;}
    MC_v3d_vector& MC_mesh_index_vector_draw::color() {return color_mesh;}
    const MC_v3d_vector& MC_mesh_index_vector_draw::color() const {return color_mesh;}
    MC_v3d_vector& MC_mesh_index_vector_draw::texture() {return texture_mesh;}
    const MC_v3d_vector& MC_mesh_index_vector_draw::texture() const {return texture_mesh;}
    MC_double_vector& MC_mesh_index_vector_draw::alpha() {return alpha_mesh;}
    const MC_double_vector& MC_mesh_index_vector_draw::alpha() const {return alpha_mesh;}

    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::fill_color(const MC_v3d& input_color)
    {
        int N_vertex=vertex_number();
        color_mesh.resize(N_vertex);
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            color_mesh[k_vertex]=input_color;
        return *this;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::fill_color(const MC_v3d_vector& input_color)
    {
        if(input_color.size()==1)
            return fill_color(input_color.first());
        else if(input_color.size()==vertex_number())
        {
            int N_vertex=vertex_number();
            color_mesh.resize(N_vertex);
            for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
                color_mesh[k_vertex]=input_color[k_vertex];
            return *this;
        }
        else
        {std::cout<<"Error in MC_mesh_index_vector_draw::fill_color(MC_v3d_vector), input_color has size "<<input_color.size()<<" , and vertex_number="<<vertex_number()<<std::endl;exit(-1);}

    }



    std::vector <MC_mesh_index_vector_draw> MC_mesh_index_vector_draw::build_local_basis()
    {
        MC_mesh_index_vector_draw a_x=MC_mesh_index_vector::build_arrow(MC_segment(MC_v3d(0,0,0),MC_v3d(1,0,0)),0.05,15,15,0.15,0.25,15,15);
        a_x.fill_color(MC_v3d(1,0,0));

        MC_mesh_index_vector_draw a_y=MC_mesh_index_vector::build_arrow(MC_segment(MC_v3d(0,0,0),MC_v3d(0,1,0)),0.05,15,15,0.15,0.25,15,15);
        a_y.fill_color(MC_v3d(0,1,0));

        MC_mesh_index_vector_draw a_z=MC_mesh_index_vector::build_arrow(MC_segment(MC_v3d(0,0,0),MC_v3d(0,0,1)),0.05,15,15,0.15,0.25,15,15);
        a_z.fill_color(MC_v3d(0,0,1));



        MC_mesh_index_vector_draw sphere=MC_mesh_index_vector::build_sphere(3);


        int N=sphere.vertex_number();
        sphere.color().resize(N);
        for(int k=0;k<N;k++)
        {
            MC_v3d X=sphere.point_set()[k];
            double r=fabs(X[0]);
            double g=fabs(X[1]);
            double b=fabs(X[2]);
            sphere.color()(k)=MC_v3d(r,g,b);
        }

        a_x*=0.2;a_y*=0.2;a_z*=0.2;
        sphere*=0.04;


        std::vector <MC_mesh_index_vector_draw> v_mesh;
        v_mesh.push_back(a_x);
        v_mesh.push_back(a_y);
        v_mesh.push_back(a_z);
        v_mesh.push_back(sphere);
        return v_mesh;
    }


    MC_mesh_index_vector_draw operator<<(const MC_mesh_index_vector_draw& vec0,const MC_mesh_index_vector_draw& vec1)
    {
        MC_mesh_index_vector_draw new_vec;

        new_vec.point_set()=vec0.point_set()<<vec1.point_set();
        new_vec.color()=vec0.color()<<vec1.color();
        new_vec.texture()=vec0.texture()<<vec1.texture();
        new_vec.texture_connectivity()=vec0.texture_connectivity()<<(vec1.texture_connectivity()+vec0.texture().size());
        new_vec.alpha()=vec0.alpha()<<vec1.alpha();
        new_vec.normal()=vec0.normal()<<vec1.normal();
        new_vec.connectivity()=vec0.connectivity()<<(vec1.connectivity()+vec0.vertex_number());

        return new_vec;
    }

    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::concatenation(const MC_mesh_index_vector_draw& vec1)
    {
        int N_vertex=point_set().size();
        int N_texture=texture().size();

        point_set().add(vec1.point_set());
        color_mesh.add(vec1.color());
        texture_mesh.add(vec1.texture());
        alpha_mesh.add(vec1.alpha());
        normal_mesh.add(vec1.normal());
        connectivity().add(vec1.connectivity()+N_vertex);
        texture_connectivity_mesh.add(vec1.texture_connectivity()+N_texture);

        return *this;
    }

    const MC_connectivity_index& MC_mesh_index_vector_draw::texture_connectivity() const
    {return texture_connectivity_mesh;}

    MC_connectivity_index& MC_mesh_index_vector_draw::texture_connectivity()
    {return texture_connectivity_mesh;}

    MC_mesh_index_vector_draw operator*(const MC_matrix& M,const MC_mesh_index_vector_draw& mesh)
    {
        MC_mesh_index_vector_draw m1=mesh;
        m1.point_set()=M*m1.point_set();
        return m1;
    }
    MC_mesh_index_vector_draw operator*(const MC_mesh_index_vector_draw& mesh,const MC_matrix& M)
    {return M*mesh;}
    MC_mesh_index_vector_draw operator*(const double& s,const MC_mesh_index_vector_draw& mesh)
    {
        MC_mesh_index_vector_draw m1=mesh;
        m1.point_set()=s*m1.point_set();
        return m1;
    }
    MC_mesh_index_vector_draw operator*(const MC_mesh_index_vector_draw& mesh,const double& s)
    {return s*mesh;}


    MC_mesh_index_vector_draw operator+(const MC_mesh_index_vector_draw& vec,const MC_v3d& to_add)
    {MC_mesh_index_vector_draw res=vec;res.point_set()+=to_add;return res;}
    MC_mesh_index_vector_draw operator-(const MC_mesh_index_vector_draw& vec,const MC_v3d& to_sub)
    {MC_mesh_index_vector_draw res=vec;res.point_set()-=to_sub;return res;}
    MC_mesh_index_vector_draw operator+(const MC_mesh_index_vector_draw& vec,const MC_v3d_vector& to_add)
    {MC_mesh_index_vector_draw res=vec;res.point_set()+=to_add;return res;}
    MC_mesh_index_vector_draw operator-(const MC_mesh_index_vector_draw& vec,const MC_v3d_vector& to_sub)
    {MC_mesh_index_vector_draw res=vec;res.point_set()-=to_sub;return res;}

    MC_mesh_index_vector_draw operator+(const MC_v3d& to_add,const MC_mesh_index_vector_draw& vec)
    {return vec+to_add;}
    MC_mesh_index_vector_draw operator-(const MC_v3d& to_sub,const MC_mesh_index_vector_draw& vec)
    {return vec+to_sub;}
    MC_mesh_index_vector_draw operator+(const MC_v3d_vector& to_add,const MC_mesh_index_vector_draw& vec)
    {return vec+to_add;}
    MC_mesh_index_vector_draw operator-(const MC_v3d_vector& to_sub,const MC_mesh_index_vector_draw& vec)
    {return vec+to_sub;}

    MC_mesh_index_vector_draw operator/(const MC_mesh_index_vector_draw& vec,const double& to_subdiv)
    {MC_mesh_index_vector_draw res=vec;res.point_set()/=to_subdiv;return res;}

    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator+=(const MC_v3d& to_add)
    {
        point_set()+=to_add;
        return *this;
    }

    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator-=(const MC_v3d& to_sub)
    {
        point_set()-=to_sub;
        return *this;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator+=(const MC_v3d_vector& to_add)
    {
        point_set()+=to_add;
        return *this;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator-=(const MC_v3d_vector& to_sub)
    {
        point_set()-=to_sub;
        return *this;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator*=(const double& to_mult)
    {
        point_set()*=to_mult;
        return *this;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::operator/=(const double& to_subdiv)
    {
        point_set()/=to_subdiv;
        return *this;
    }

    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::normal_vertex_update()
    {
        int N=vertex_number();
        if(normal_mesh.size()!=N)
            normal_mesh.resize(N);

        MC_v3d* p_normal=normal_mesh.pointer_unprotected();
        const MC_v3d* p_vertex=point_set().pointer();
        const MC_int_vector* p_connectivity=connectivity().pointer();

        MC_v3d z(0,0,0);
        for(int k=0;k<N;++k)
            p_normal[k]=z;

        int N_poly=polygon_number();
        for(int k=0;k<N_poly;++k)
        {
            MC_int_vector current_index=p_connectivity[k];

            const MC_v3d* p_current_0=p_vertex+current_index[0];
            const MC_v3d* p_current_1=p_vertex+current_index[1];
            const MC_v3d* p_current_2=p_vertex+current_index[2];



            MC_v3d u0=(*p_current_1-*p_current_0).normalized();
            MC_v3d u1=(*p_current_2-*p_current_0).normalized();
            MC_v3d n=u0.cross(u1).normalized();

            for(int k_v=0,N_v=current_index.size();k_v<N_v;++k_v)
            {
                p_normal[current_index[k_v]] += n;
            }

        }
        for(int k=0;k<N;++k)
            p_normal[k]=p_normal[k].normalized();

        return *this;
    }

    MC_mesh_index_vector_draw::MC_mesh_index_vector_draw(const MC_mesh_index_vector_draw& mesh)
        :MC_mesh_index_vector(mesh),normal_mesh(mesh.normal_mesh),color_mesh(mesh.color_mesh),texture_mesh(mesh.texture_mesh),texture_connectivity_mesh(mesh.texture_connectivity_mesh),alpha_mesh(mesh.alpha_mesh)
    {}



    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::set_texture(const std::pair<MC_v3d_vector,MC_connectivity_index>& _texture)
    {
        texture()=_texture.first;
        texture_connectivity()=_texture.second;
        return *this;
    }

    MC_mesh_index_vector_draw MC_mesh_index_vector_draw::load_mesh_file(const std::string& filename)
    {
        MC_mesh_index_vector_draw mesh;

        //get extension
        std::vector<std::string> token=MC_string_tokenizer::tokenize(filename,".");
        std::string extension=token[token.size()-1];

        if(extension.find("off")!=std::string::npos)
            mesh=MC_mesh_index_vector_draw(MC_io_off::read_off_file(filename));
        else if(extension.find("obj")!=std::string::npos)
        {
            mesh=MC_mesh_index_vector_draw(MC_io_obj::read_obj_file(filename));
            mesh.set_texture(MC_io_obj::read_obj_texture_file(filename));
        }
        else
            std::cout<<"Warning in MC_mesh_index_vector_draw::load_mesh_file("<<filename<<"), extension "<<extension<<" not recognized"<<std::endl;

        return mesh;
    }


    MC_mesh_index_vector_draw MC_mesh_index_vector_draw::subdivide_mixed_mid_edge(const std::set<int>& subdivided_polygon) const
    {
        MC_mesh_index_vector_draw mesh2;
        mesh2=MC_mesh_index_vector::subdivide_mixed_mid_edge(subdivided_polygon);

        MC_mesh_index_vector mesh_tex(texture(),texture_connectivity());
        mesh_tex = mesh_tex.subdivide_mixed_mid_edge(subdivided_polygon);

        mesh2.set_texture(std::make_pair(mesh_tex.point_set(),mesh_tex.connectivity()));
        return mesh2;
    }
    MC_mesh_index_vector_draw& MC_mesh_index_vector_draw::set_texture(const MC_mesh_index_vector& texture_mesh)
    {
        return set_texture(std::make_pair(texture_mesh.point_set(),texture_mesh.connectivity()));
    }
}