MC_io_off.cpp

Go to the documentation of this file.

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

#include <MC_io_off.hpp>

namespace mesh_conv
{

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

        const int SIZE_BUFFER=2048;
        std::vector <char> c_buffer(SIZE_BUFFER);
        std::string buffer;

        int N_vertex=0,N_polygon=0,N_edge=0;

        // look for *OFF*
        bool is_loop=true;
        while(stream.good() && is_loop==true)
        {
            std::getline(stream,buffer);
            if(buffer.length()>0
               && buffer[0]!='#'
               && buffer.find("OFF")!=std::string::npos)
                is_loop=false;
        }
        if(stream.good()==false && is_loop==true)
        {std::cout<<"ERROR in MC_io_off::read_off(istream), cannot find OFF header"<<std::endl;exit(-1);}

        // look for N_vertex N_polygon N_edges
        is_loop=true;
        while(stream.good() && is_loop==true)
        {
            std::getline(stream,buffer);

            //std::cout<<buffer<<std::endl;
            if(buffer.length()>0 && buffer[0]!='#')
            {
                std::vector <std::string> token=MC_string_tokenizer::tokenize(buffer);
                if(token.size()>=3)
                {
                    bool vertex_converted=false;
                    bool polygon_converted=false;
                    bool edge_converted=false;
                    N_vertex  = MC_string_converter::value_of<int>(token[0],&vertex_converted);
                    N_polygon = MC_string_converter::value_of<int>(token[1],&polygon_converted);
                    N_edge    = MC_string_converter::value_of<int>(token[2],&edge_converted);

                    if(vertex_converted==true && polygon_converted==true && edge_converted==true)
                        is_loop=false;
                }
            }
        }
        if(stream.good()==false && is_loop==true)
        {std::cout<<"ERROR in MC_io_off::read_off(istream), cannot read N_vertex/N_polygon/N_edge <<"<<buffer<<std::endl;exit(-1);}


        if(N_vertex<=0 || N_polygon<=0)
        {std::cout<<"Something wrong in MC_io_off::read_off(istream), N_vertex="<<N_vertex<<", N_polygon="<<N_polygon<<std::endl;exit(-1);}


        MC_v3d_vector point_set;

        //now read N_vertex positions
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
        {
            if(stream.good()==false)
            {std::cout<<"Error in MC_io_off::read_off(istream) at vertex"<<k_vertex<<" EOF found"<<std::endl;exit(-1);}

            std::getline(stream,buffer);
            if(buffer.size()>0 && buffer[0]!='#')
            {
                std::vector<std::string> v_token=MC_string_converter::delete_empty(MC_string_tokenizer::tokenize(buffer));
                if(v_token.size()<3)
                {std::cout<<"Error in MC_io_off::read_off(istream), something wrong at vertex "<<k_vertex<<", size of token="<<v_token.size()<<", "<<buffer<<std::endl;exit(-1);}

                bool converted_x0=false,converted_x1=false,converted_x2=false;
                double x0=MC_string_converter::value_of<double>(v_token[0],&converted_x0);
                double x1=MC_string_converter::value_of<double>(v_token[1],&converted_x1);
                double x2=MC_string_converter::value_of<double>(v_token[2],&converted_x2);

                if(converted_x0==false || converted_x1==false || converted_x2==false)
                {std::cout<<"Something wrong in MC_io_off::read_off(istream), cannot convert at vertex "<<k_vertex<<","<<buffer<<std::endl;exit(-1);}

                point_set.add(MC_v3d(x0,x1,x2));
            }
            else
                --k_vertex;
        }

        
        MC_connectivity_index connectivity;
        //now read N_polygons
        for(int k_polygon=0;k_polygon<N_polygon;++k_polygon)
        {
            std::getline(stream,buffer);
            if(buffer.size()>0 && buffer[0]!='#')
            {
                std::vector <std::string> v_token=MC_string_tokenizer::tokenize(buffer);
                if(v_token.size()>=4)
                {
                    // get the size
                    bool poly_size_convert=false;
                    int poly_size=MC_string_converter::value_of<int>(v_token[0],&poly_size_convert);
                    if(poly_size_convert==false)
                    {std::cout<<"Something wrong in MC_io_off::read_off(istream), cannot load polygon size at polygon "<<k_polygon<<" polygon of size<3 "<<buffer<<std::endl;exit(-1);}

                    if(poly_size<3)
                    {std::cout<<"Something wrong in MC_io_off::read_off(istream), cannot load polygon size at polygon "<<k_polygon<<" polygon size="<<poly_size<<"<3 "<<buffer<<std::endl;exit(-1);}

                    MC_int_vector temp_poly;
                    if(int(v_token.size()-1)<poly_size)
                    {std::cout<<"Error in MC_io_off::read_off(istream), incompatible token and poly size at k_poly="<<k_polygon<<", "<<buffer<<std::endl;exit(-1);}

                    int counter=0;
                    for(int k_current_polygon=0;k_current_polygon<poly_size;++k_current_polygon)
                    {
                        ++counter;

                        bool index_converted=false;
                        if(v_token[counter]!="")
                        {
                            temp_poly.add(MC_string_converter::value_of<int>(v_token[counter],&index_converted));
                            if(index_converted==false)
                            {std::cout<<"Something wrong in MC_io_off::read_off(istream), cannot load polygon at polygon "<<k_polygon<<" polygon for index "<<k_current_polygon<<" ,"<<buffer<<std::endl;exit(-1);}
                        }
                        else
                            k_current_polygon--;
                    }
                    connectivity.add(temp_poly);
                }
                else
                {std::cout<<"Something wrong in MC_io_off::read_off(istream), cannot load at polygon "<<k_polygon<<" polygon of size<3 "<<buffer<<std::endl;exit(-1);}

            }
            else
                --k_polygon;

        }

        return std::pair <MC_v3d_vector,MC_connectivity_index> (point_set,connectivity);
    }

    std::ostream& MC_io_off::write_off(std::ostream& stream,const MC_mesh_index_vector& to_write)
    {
        stream<<"OFF"<<std::endl;
        stream<<to_write.vertex_number()<<" "<<to_write.polygon_number()<<" 0"<<std::endl;
        int N_vertex=to_write.vertex_number();
        for(int k_vertex=0;k_vertex<N_vertex;++k_vertex)
            stream<<to_write.point_set()(k_vertex)(0)<<" "<<to_write.point_set()(k_vertex)(1)<<" "<<to_write.point_set()(k_vertex)(2)<<std::endl;
        int N_polygon=to_write.polygon_number();

        for(int k_poly=0;k_poly<N_polygon;++k_poly)
        {
            MC_int_vector index=to_write.connectivity()(k_poly);
            int N_current=index.size();

            stream<<N_current<<" ";
            for(int k=0;k<N_current;++k)
                stream<<index[k]<<" ";
            stream<<std::endl;
        }

        return stream;
    }
    const MC_mesh_index_vector& MC_io_off::write_off_file(const std::string& string_file,const MC_mesh_index_vector& to_write)
    {
        std::ofstream ofile(string_file.c_str());
        if(ofile.good()!=true)
        {std::cout<<"Error in MC_io_off::write_off_file("<<string_file<<",MC_mesh_index_vector), cannot open the file"<<std::endl;exit(-1);}

        MC_io_off::write_off(ofile,to_write);
        ofile.close();
        return to_write;
    }

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

        std::pair <MC_v3d_vector,MC_connectivity_index> input=MC_io_off::read_off(ifile);
        ifile.close();

        return input;
    }




}