MC_io_obj.cpp

Go to the documentation of this file.

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

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

namespace mesh_conv
{

    std::pair <MC_v3d_vector,MC_connectivity_index> MC_io_obj::read_obj(std::istream& stream)
    {

        MC_v3d_vector vertices;
        MC_connectivity_index connectivity;

        if(stream.good()==false)
        {std::cout<<"Error in MC_io_off::read_obj(istream), file cannot be read"<<std::endl;exit(-1);}

        std::string buffer;
        while(stream.good()==true)
        {
            if(stream.good())
                stream>>buffer;


            if(buffer=="v")//vertex
            {
                MC_v3d temp;
                for(int k_dim=0;k_dim<3;++k_dim){
                    if(stream.good()){
                        stream>>buffer;
                        temp[k_dim]=MC_string_converter::value_of<double>(buffer);
                    }
                }
                vertices.add(temp);
            }
            //face
            else if(buffer=="f")
            {
                MC_int_vector index;

                //take the whole line
                std::getline(stream,buffer);

                std::vector<std::string> vec=MC_string_converter::delete_empty(MC_string_tokenizer::tokenize(buffer," "));
                for(unsigned int k=0;k<vec.size();++k)
                {
                    std::vector<std::string> poly=MC_string_tokenizer::tokenize(vec[k],"/");

                    //vertex are in first place
                    index.add(MC_string_converter::value_of<int>(poly[0])-1);
                }
                connectivity.add(index);
            }
            else
                std::getline(stream,buffer);
        }


        return std::make_pair(vertices,connectivity);
    }


    std::pair <MC_v3d_vector,MC_connectivity_index> MC_io_obj::read_obj_texture(std::istream& stream)
    {

        MC_v3d_vector tex;
        MC_connectivity_index index_texture;

        if(stream.good()==false)
        {std::cout<<"Error in MC_io_off::read_obj_texture(istream), file cannot be read"<<std::endl;exit(-1);}

        std::string buffer;
        while(stream.good()==true)
        {
            if(stream.good())
                stream>>buffer;

            if(buffer[0]=='#')
                std::getline(stream,buffer);
            if(buffer=="vt")//vertex
            {
                MC_v3d temp;
                for(int k_dim=0;k_dim<2;++k_dim){
                    if(stream.good()){
                        stream>>buffer;
                        temp[k_dim]=MC_string_converter::value_of<double>(buffer);
                    }
                }
                //std::cout<<temp<<std::endl;
                tex.add(temp);
            }

            //face
            if(buffer=="f")
            {
                MC_int_vector index;

                //take the whole line
                std::getline(stream,buffer);

                std::vector<std::string> vec=MC_string_converter::delete_empty(MC_string_tokenizer::tokenize(buffer," "));
                for(unsigned int k=0;k<vec.size();++k)
                {
                    std::vector<std::string> poly=MC_string_converter::delete_empty(MC_string_tokenizer::tokenize(vec[k],"/"));

                    if(poly.size()==3)
                        index.add(MC_string_converter::value_of<int>(poly[1])-1);
                    else if(vec[k].find("/")!=std::string::npos)
                    {
                        poly=MC_string_converter::delete_empty(MC_string_tokenizer::tokenize(vec[k],"/"));
                        index.add(MC_string_converter::value_of<int>(poly[1])-1);
                    }
                }

                index_texture.add(index);
            }
        }

        return std::make_pair(tex,index_texture);
    }

    std::pair <MC_v3d_vector,MC_connectivity_index> MC_io_obj::read_obj_file(const std::string& string_file)
    {
        std::ifstream ifile(string_file.c_str());
        if(ifile.good()!=true)
        {std::cout<<"Error in MC_io_obj::read_obj_file("<<string_file<<"), cannot open the file"<<std::endl;exit(-1);}

        std::pair <MC_v3d_vector,MC_connectivity_index> input=MC_io_obj::read_obj(ifile);
        return input;
    }

    std::ostream& MC_io_obj::write_obj(std::ostream& stream,const MC_mesh_index_vector_draw& to_write)
    {
        bool is_normal=to_write.normal().size()==to_write.vertex_number();
        bool is_texture=to_write.texture_connectivity().size()>0;

        //vertices
        for(int k=0,N=to_write.vertex_number();k<N;++k)
        {
            MC_v3d x=to_write.point_set()(k);
            stream<<"v "<<x[0]<<" "<<x[1]<<" "<<x[2]<<std::endl;
        }
        //normal
        if(is_normal==true)
        {
            for(int k=0,N=to_write.normal().size();k<N;++k)
            {
                MC_v3d n=to_write.normal()(k);
                stream<<"vn "<<n[0]<<" "<<n[1]<<" "<<n[2]<<std::endl;
            }
        }
        //texture
        if(is_texture==true)
        {
            for(int k=0,N=to_write.texture().size();k<N;++k)
            {
                MC_v3d t=to_write.texture()(k);
                stream<<"vt "<<t[0]<<" "<<t[1]<<std::endl;
            }
        }



        //connectivity
        for(int k=0,N=to_write.polygon_number();k<N;++k)
        {
            MC_int_vector index=to_write.connectivity()(k)+1;
            stream<<"f ";

            if(is_normal==false && is_texture==false)
            {
                for(int k_v=0,N_v=index.size();k_v<N_v;++k_v)
                    stream<<index[k_v]<<" ";
            }
            if(is_normal==true && is_texture==false)
            {
                for(int k_v=0,N_v=index.size();k_v<N_v;++k_v)
                    stream<<index[k_v]<<"//"<<index[k_v]<<" ";
            }
            if(is_normal==false && is_texture==true)
            {
                MC_int_vector index_texture=to_write.texture_connectivity()(k)+1;
                for(int k_v=0,N_v=index.size();k_v<N_v;++k_v)
                {
                    stream<<index[k_v]<<"/"<<index_texture[k_v]<<" ";
                }
            }
            if(is_normal==true && is_texture==true)
            {
                MC_int_vector index_texture=to_write.texture_connectivity()(k)+1;
                for(int k_v=0,N_v=index.size();k_v<N_v;++k_v)
                {
                    stream<<index[k_v]<<"/"<<index_texture[k_v]<<"/"<<index[k_v]<<" ";
                }
            }

            stream<<std::endl;
        }
        return stream;
    }

    std::ostream& MC_io_obj::write_obj(std::ostream& stream,const MC_mesh_index_vector& to_write)
    {
        //vertices
        for(int k=0,N=to_write.vertex_number();k<N;++k)
        {
            MC_v3d x=to_write.point_set()(k);
            stream<<"v "<<x[0]<<" "<<x[1]<<" "<<x[2]<<std::endl;
        }
        //connectivity
        for(int k=0,N=to_write.polygon_number();k<N;++k)
        {
            MC_int_vector index=to_write.connectivity()(k)+1;
            stream<<"f ";
            for(int k_v=0,N_v=index.size();k_v<N_v;++k_v)
                stream<<index[k_v]<<" ";
            stream<<std::endl;
        }
        return stream;
    }


    std::pair <MC_v3d_vector,MC_connectivity_index> MC_io_obj::read_obj_texture_file(const std::string& file)
    {
        std::ifstream fid;
        fid.open(file.c_str(),std::ifstream::in);
        std::pair <MC_v3d_vector,MC_connectivity_index> tex=read_obj_texture(fid);
        fid.close();
        return tex;
    }



}