LoaderOBJ.cpp

Go to the documentation of this file.

#include <fstream>
#include <string>
#include <sstream>
#include "LoaderOBJ.h"

using namespace vis2;

LoaderOBJ::LoaderOBJ(const std::string & _file_path) : file_path(_file_path), file_type(VIS2_FILE_TYPE_OBJ)
{
    // check file extension
    if (_file_path.size() > 4 && !_file_path.substr(_file_path.size()-4).compare(".obj")) {
        this->file_type = VIS2_FILE_TYPE_OBJ;
    }
    else if (_file_path.size() > 4 && !_file_path.substr(_file_path.size()-4).compare(".dat"))
    {
        this->file_type = VIS2_FILE_TYPE_DAT;
    }
    else
    {
        std::cout << "Valid file extensions are \"obj\" and \"dat\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }
}

LoaderOBJ::~LoaderOBJ()
{
    if (vert_positions)
        delete [] vert_positions;
    if (vert_normals)
        delete [] vert_normals;
    if (vert_uvs)
        delete [] vert_uvs;
    if (face_ind)
        delete [] face_ind;
}

int LoaderOBJ::obj2Container()
{
    
    std::cout << "Loading geometry from file \"" << file_path << "\"." << std::endl;
    if (file_type == VIS2_FILE_TYPE_OBJ)
    {
        readDataFromOBJ();
        writeDataToDAT();
    }
    else
        readDataFromDAT();

    return 0;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ---------------------------- FILE HANDLING --------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

int LoaderOBJ::readDataFromOBJ()
{
    std::FILE *f;
    fopen_s(&f,file_path.c_str(),"r");
    if(!f)
    {
        std::cout << "Failed to open file \"" << file_path << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    // read and save content
    parseOBJ(f);

    // close file
    if (f)
    {
        std::fclose(f);
    }
    return 0;
}

int LoaderOBJ::readDataFromDAT()
{
    // open stream
    std::ifstream binary_file;
    binary_file.open(this->file_path, std::ofstream::binary | std::ofstream::in);
    checkForErrors(binary_file);
    
    // read
    binary_file.read(reinterpret_cast< char *>(&single_ind), sizeof(unsigned int)); // vertex nr
    binary_file.read(reinterpret_cast< char *>(&nr_face_ind), sizeof(unsigned int)); // index nr
    
    // allocate enough memory for the arrays
    vert_positions = new GLfloat[single_ind * 3];
    vert_normals = new GLfloat[single_ind * 3];
    vert_uvs = new GLfloat[single_ind * 3];
    face_ind = new GLuint[nr_face_ind];

    // read arrays
    binary_file.read(reinterpret_cast< char *>(vert_positions), single_ind * 3 * sizeof(GLfloat));
    // std::cout << "test: " << vert_positions[0] << " " << vert_positions[1] << " " << vert_positions[2] << std::endl;
    // std::cout << "vert_positions pos: " << binary_file.tellg() << std::endl;
    binary_file.read(reinterpret_cast< char *>(vert_normals), single_ind * 3 * sizeof(GLfloat));
    // std::cout << "vert_normals pos: " << binary_file.tellg() << std::endl;
    binary_file.read(reinterpret_cast< char *>(vert_uvs), single_ind * 3 * sizeof(GLfloat));
    // std::cout << "vert_uvs pos: " << binary_file.tellg() << std::endl;
    binary_file.read(reinterpret_cast< char *>(face_ind), nr_face_ind * sizeof(GLuint));
    // std::cout << "face_ind pos: " << binary_file.tellg() << std::endl;
    checkForErrors(binary_file);

    // close
    binary_file.close();
    checkForErrors(binary_file);
    return 0;
}

int LoaderOBJ::writeDataToDAT()
{
    // extract directory name
    int last_slash = this->file_path.find_last_of("/\\");
    std::string dir_name = file_path.substr(0,last_slash);
    std::string file_name_ext = file_path.substr(last_slash + 1);

    int last_dot = file_name_ext.find_last_of(".");
    std::string file_name = file_name_ext.substr(0,last_dot);
    std::string file_ext = file_name_ext.substr(last_dot + 1);

    std::string binary_file_name = dir_name + "/" + file_name + ".dat";
    std::cout << "Writing to file : \"" << binary_file_name << "\" ..." << std::endl;
    
    // open stream
    std::ofstream binary_file;
    binary_file.open(binary_file_name, std::ofstream::binary | std::ofstream::out);
    checkForErrors(binary_file);

    // write
    binary_file.write(reinterpret_cast<const char *>(&single_ind), sizeof(unsigned int)); // vertex nr
    binary_file.write(reinterpret_cast<const char *>(&nr_face_ind), sizeof(unsigned int)); // index nr
    binary_file.write(reinterpret_cast<const char *>(vert_positions), single_ind * 3 * sizeof(GLfloat));
    binary_file.write(reinterpret_cast<const char *>(vert_normals), single_ind * 3 * sizeof(GLfloat));
    binary_file.write(reinterpret_cast<const char *>(vert_uvs), single_ind * 3 * sizeof(GLfloat));
    binary_file.write(reinterpret_cast<const char *>(face_ind), nr_face_ind * sizeof(GLuint));
    checkForErrors(binary_file);

    // close
    binary_file.close();
    checkForErrors(binary_file);
    return 0;
}


void LoaderOBJ::checkForErrors(std::ios & _ofs)
{
    if (_ofs.fail())
    {
    switch (errno)
        {
        case EACCES:
            // this is set if the drive is not ready in DOS
            std::cout << "Drive not ready or permission denied" << std::endl;
            break;
        case ENOENT:
            std::cout << "Could not find this file" << std::endl;
            break;
        default:
            perror("opening data file");
            break;
        }
        system("PAUSE");
        exit(-1);
    }
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //
// %% ------------------------------- OBJ PARSER --------------------------- %% //
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //

void LoaderOBJ::parseOBJ(std::FILE* _f)
{
    // file->stream
    std::ifstream file_stream(_f);
    std::string file_line;
    while (!file_stream.eof())
    {
        std::getline(file_stream, file_line);
        
        // --------------- EXTRACT VERTEX POSITIONS ----------------- //
        if (!file_line.substr(0,2).compare("v "))
        {
            vertAttribContainer vert_pos = string2VertAttr(file_line);
            for (unsigned int i = 0; i < vert_pos.size(); i++)
            {
                vert_positions_OBJ.push_back(vert_pos.at(i));
            }
        }
        // ---------------- EXTRACT VERTEX NORMALS ------------------ //
        else if (!file_line.substr(0,3).compare("vn "))
        {
            vertAttribContainer vert_norm = string2VertAttr(file_line);
            for (unsigned int i = 0; i < vert_norm.size(); i++)
            {
                vert_normals_OBJ.push_back(vert_norm.at(i));
            }
        }
        // ------------ EXTRACT TEXTURE COORDINATES  ---------------- //
        else if (!file_line.substr(0,3).compare("vt "))
        {
            vertAttribContainer text_coord = string2VertAttr(file_line);
            for (unsigned int i = 0; i < text_coord.size(); i++)
            {
                // discard the third coord as it is a 2-dim value
                if (i % 3 != 2)
                {
                    vert_uvs_OBJ.push_back(text_coord.at(i));
                }
            }
        }
        // ----------------- EXTRACT FACE INDICES ------------------- //
        else if (!file_line.substr(0,2).compare("f "))
        {
            indexContainer indices = string2Index(file_line);
            for (unsigned int i = 0; i < indices.size(); i++)
            {
                face_ind_OBJ.push_back(indices.at(i));
            }
        }

    }
    // std::cout << "Found " << vert_positions_OBJ.size() / 3 << " vert positions." << std::endl;
    // std::cout << "Found " << vert_normals_OBJ.size() / 3 << " vert normals." << std::endl;
    // std::cout << "Found " << vert_uvs_OBJ.size() / 2 << " texture coordinates." << std::endl;
    // std::cout << "Found " << face_ind_OBJ.size() / 9 << " face indices." << std::endl;

    // ----------- CONVERT TO SINGLE INDEX GEOMETRY ------------- //
    // i.e. a singe index per face vertex addresses all vertex attribute arrays
    mult2singleIndex();
}

vertAttribContainer LoaderOBJ::string2VertAttr(std::string & _line)
{
    // prepare a container for the floats
    vertAttribContainer vert_pos;
    
    // open a string stream
    std::stringstream line_ss(_line);

    // split the string along the SPACE delimiter
    std::string str_item;
    while(std::getline(line_ss,str_item,' '))
    {
        GLfloat num;
        std::stringstream item_ss(str_item);
        if (!(item_ss>>num).fail())
        {
            vert_pos.push_back(num);
        }
    }

    return vert_pos;
}

indexContainer LoaderOBJ::string2Index(std::string & _line){

    // prepare a container for the unsigned ints
    indexContainer face_ind;

    // open a string stream
    std::stringstream line_ss(_line);

    // split the string along the SPACE delimiter to get to an index
    // containg [position index]/[texture coordinate index]/[normal index] for one face vertex
    // of a triangular face 
    std::string str_item;
    while(std::getline(line_ss,str_item,' '))
    {
        std::stringstream item_ss(str_item);
        std::string str_single_index;
        while(std::getline(item_ss,str_single_index,'/'))
        {
            GLuint ind;
            std::stringstream single_index_ss(str_single_index);
            if (!(single_index_ss>>ind).fail())
            {
                face_ind.push_back(ind);
            }
        }
    }

    return face_ind;
}

bool LoaderOBJ::iCareEqual(const indexContainer & _ic1, const indexContainer & _ic2)
{
    if (_ic1.size() < 2 || _ic2.size() < 2 || _ic1.size() != _ic2.size())
        return false;
    
    bool equal = true;
    // first 3 entries should be the old multi-index -> they should be compared
    // excluding the last entry as it is the new unique single-index
    for (unsigned int i = 0; i < _ic1.size()-1; i++)
    {
        equal = equal && (_ic1.at(i) == _ic2.at(i));
    }
    return equal;
}

void LoaderOBJ::mult2singleIndex()
{

    // each face index in the OBJ file is a multi-index,
    // consisting originally of 3 subindices [position index]/[texture coordinate index]/[normal index]
    nr_face_ind = face_ind_OBJ.size() / 3;
    face_ind = new GLuint[nr_face_ind];

    vert_positions = new GLfloat[nr_face_ind * 3];
    vert_normals = new GLfloat[nr_face_ind * 3];
    vert_uvs = new GLfloat[nr_face_ind * 2];

    // start a new indexing process
    single_ind = 0;
    for (unsigned int i = 0; i < nr_face_ind; i++)
    {

        unsigned int ind_vertex_pos = face_ind_OBJ.at(i * 3);
        unsigned int ind_texture_coord = face_ind_OBJ.at(i * 3 + 1);
        unsigned int ind_vertex_normal = face_ind_OBJ.at(i * 3 + 2);
        // std::cout << "at " << single_ind << ": " << ind_vertex_pos << "/" << ind_texture_coord << "/" << ind_vertex_normal << std::endl;
        
        // get next multi-index
        indexContainer next_mult_index;
        next_mult_index.push_back(ind_vertex_pos);
        next_mult_index.push_back(ind_texture_coord);
        next_mult_index.push_back(ind_vertex_normal);
        next_mult_index.push_back(single_ind); // possibly new single index

        // if this multi-index was encountered already, copy its nr as a single index to the new face index array
        // otherwise:   add new entries in the new vertex attribute arrays
        //              add new single index in the new face index array
        bool already_used = false;
        for (unsigned int n = 0;  n < new_mult_indices.size(); n++)
        {
            if (iCareEqual(new_mult_indices.at(n), next_mult_index))
            {
                already_used = true;
                // copy the single index saved with the found multi-index
                face_ind[i] = new_mult_indices.at(n).at(3);
                break;
            }
        }
        if (!already_used)
        {
            // record index combination for later usage (to avoid duplicates)
            new_mult_indices.push_back(next_mult_index);
            // add new single index to the new face index array
            face_ind[i] = single_ind;
            
            // add new attribute records in the vertex attribute arrays
            vert_positions[single_ind * 3] = vert_positions_OBJ.at((ind_vertex_pos - 1) * 3);
            vert_positions[single_ind * 3 + 1] = vert_positions_OBJ.at((ind_vertex_pos - 1) * 3 + 1);
            vert_positions[single_ind * 3 + 2] = vert_positions_OBJ.at((ind_vertex_pos - 1) * 3 + 2);

            vert_uvs[single_ind * 2] = vert_uvs_OBJ.at((ind_texture_coord - 1) * 2);
            vert_uvs[single_ind * 2 + 1] = -vert_uvs_OBJ.at((ind_texture_coord - 1) * 2 + 1); 

            vert_normals[single_ind * 3] = vert_normals_OBJ.at((ind_vertex_normal - 1) * 3);
            vert_normals[single_ind * 3 + 1] = vert_normals_OBJ.at((ind_vertex_normal - 1) * 3 + 1);
            vert_normals[single_ind * 3 + 2] = vert_normals_OBJ.at((ind_vertex_normal - 1) * 3 + 2);

            single_ind++;
        }

    }
}