ReadOBJ.cpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#include "ReadOBJ.hpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <cstdlib>
#include <map>
#include <cassert>
#include <cmath>
 
#include "moab/Core.hpp"
#include "moab/Interface.hpp"
#include "moab/ReadUtilIface.hpp"
#include "Internals.hpp"
#include "moab/Range.hpp"
#include "moab/CartVect.hpp"
#include "moab/FileOptions.hpp"
#include "FileTokenizer.hpp"
#include "MBTagConventions.hpp"
#include "moab/CN.hpp"
#include "moab/GeomTopoTool.hpp"
 
namespace moab
{
 
ReaderIface* ReadOBJ::factory( Interface* iface )
{
    return new ReadOBJ( iface );
}
 
// Subset of starting tokens currently supported
const char* ReadOBJ::delimiters = " ";
const char* object_start_token  = "o";
const char* group_start_token   = "g";
const char* vertex_start_token  = "v";
const char* face_start_token    = "f";
 
#define OBJ_AMBIGUOUS "AMBIGUOUS"
#define OBJ_UNDEFINED "UNDEFINED"
 
// Name of geometric entities
const char* const geom_name[] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0" };
 
// Geometric Categories
const char geom_category[][CATEGORY_TAG_SIZE] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0", "Group\0" };
 
// Constructor
ReadOBJ::ReadOBJ( Interface* impl )
    : MBI( impl ), geom_tag( 0 ), id_tag( 0 ), name_tag( 0 ), category_tag( 0 ), faceting_tol_tag( 0 ),
      geometry_resabs_tag( 0 ), obj_name_tag( 0 )
{
    assert( NULL != impl );
    MBI->query_interface( readMeshIface );
    myGeomTool = new GeomTopoTool( impl );
    assert( NULL != readMeshIface );
 
    // Get all handles
    int negone = -1;
    ErrorCode rval;
    rval = MBI->tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geom_tag, MB_TAG_SPARSE | MB_TAG_CREAT,
                                &negone );
    MB_CHK_ERR_RET( rval );
 
    id_tag = MBI->globalId_tag();
 
    rval = MBI->tag_get_handle( NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE, name_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
    MB_CHK_ERR_RET( rval );
 
    rval = MBI->tag_get_handle( CATEGORY_TAG_NAME, CATEGORY_TAG_SIZE, MB_TYPE_OPAQUE, category_tag,
                                MB_TAG_SPARSE | MB_TAG_CREAT );
    MB_CHK_ERR_RET( rval );
 
    rval = MBI->tag_get_handle( "OBJECT_NAME", 32, MB_TYPE_OPAQUE, obj_name_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
    MB_CHK_ERR_RET( rval );
 
    rval = MBI->tag_get_handle( "FACETING_TOL", 1, MB_TYPE_DOUBLE, faceting_tol_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
    MB_CHK_ERR_RET( rval );
 
    rval =
        MBI->tag_get_handle( "GEOMETRY_RESABS", 1, MB_TYPE_DOUBLE, geometry_resabs_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
    MB_CHK_ERR_RET( rval );
}
 
// Destructor
ReadOBJ::~ReadOBJ()
{
    if( readMeshIface )
    {
        MBI->release_interface( readMeshIface );
        readMeshIface = 0;
    }
 
    delete myGeomTool;
}
 
ErrorCode ReadOBJ::read_tag_values( const char* /*file_name*/,
                                    const char* /*tag_name*/,
                                    const FileOptions& /*opts*/,
                                    std::vector< int >& /*tag_values_out*/,
                                    const SubsetList* /*subset_list*/ )
{
    return MB_NOT_IMPLEMENTED;
}
 
// Load the file as called by the Interface function
ErrorCode ReadOBJ::load_file( const char* filename,
                              const EntityHandle*,
                              const FileOptions&,
                              const ReaderIface::SubsetList* subset_list,
                              const Tag* /*file_id_tag*/ )
{
    int ignored = 0;   // Number of lines not beginning with o, v, or f
    std::string line;  // The current line being read
    EntityHandle vert_meshset;
    EntityHandle curr_meshset;  // Current object meshset
    std::string object_name;
    std::vector< EntityHandle > vertex_list;
    int object_id = 0, group_id = 0;  // ID number for each volume/surface
    int num_groups;
 
    // At this time, there is no support for reading a subset of the file
    if( subset_list )
    {
        MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for OBJ." );
    }
 
    std::ifstream input_file( filename );  // Filestream for OBJ file
 
    // Check that the file can be read
    if( !input_file.good() )
    {
        std::cout << "Problems reading file = " << filename << std::endl;
        return MB_FILE_DOES_NOT_EXIST;
    }
 
    // If the file can be read
    if( input_file.is_open() )
    {
 
        // create meshset for global vertices
        MB_CHK_SET_ERR( MBI->create_meshset( MESHSET_SET, vert_meshset ), "Failed to create global vert meshset." );
 
        while( std::getline( input_file, line ) )
        {
            // Skip blank lines in file
            if( line.length() == 0 ) continue;
 
            // Tokenize the line
            std::vector< std::string > tokens;
            tokenize( line, tokens, delimiters );
 
            // Each group and object line must have a name, token size is at least 2
            // Each vertex and face line should have token size of at least 4
            if( tokens.size() < 2 ) continue;
 
            switch( get_keyword( tokens ) )
            {
                // Object line
                case object_start: {
                    object_id++;
                    object_name = tokens[1];  // Get name of object
 
                    // Create new meshset for object
                    MB_CHK_ERR( create_new_object( object_name, object_id, curr_meshset ) );
                    break;
                }
 
                // Group line
                case group_start: {
                    group_id++;
                    num_groups             = tokens.size() - 1;
                    std::string group_name = "Group";
                    for( int i = 0; i < num_groups; i++ )
                    {
                        group_name = group_name + '_' + tokens[i + 1];
                    }
 
                    // Create new meshset for group
                    MB_CHK_ERR( create_new_group( group_name, group_id, curr_meshset ) );
                    break;
                }
 
                // Vertex line
                case vertex_start: {
                    // Read vertex and return EH
                    EntityHandle new_vertex_eh;
                    MB_CHK_ERR( create_new_vertex( tokens, new_vertex_eh ) );
 
                    // Add new vertex EH to list
                    vertex_list.push_back( new_vertex_eh );
 
                    // Add new vertex EH to the meshset
                    MB_CHK_SET_ERR( MBI->add_entities( vert_meshset, &new_vertex_eh, 1 ),
                                    "Failed to add vertex to global meshset." );
                    break;
                }
 
                // Face line
                case face_start: {
                    // Faces in .obj file can have 2, 3, or 4 vertices. If the face has
                    // 3 vertices, the EH will be immediately added to the meshset.
                    // If 4, face is split into triangles.  Anything else is ignored.
                    EntityHandle new_face_eh;
 
                    if( tokens.size() == 4 )
                    {
                        MB_CHK_ERR( create_new_face( tokens, vertex_list, new_face_eh ) );
 
                        // Add new face EH to the meshset
                        MBI->add_entities( curr_meshset, &new_face_eh, 1 );
                    }
 
                    else if( tokens.size() == 5 )
                    {
                        // Split_quad fxn will create 2 new triangles from 1 quad
                        Range new_faces_eh;
                        MB_CHK_ERR( split_quad( tokens, vertex_list, new_faces_eh ) );
 
                        // Add new faces created by split quad to meshset
                        MBI->add_entities( curr_meshset, new_faces_eh );
                    }
 
                    else
                    {
                        std::cout << "Neither tri nor a quad: " << line << std::endl;
                    }
 
                    break;
                }
 
                case valid_unsupported: {
                    // First token is not recognized as a supported character
                    ++ignored;
                    break;
                }
 
                default: {
                    MB_SET_ERR( MB_FAILURE, "Invalid/unrecognized line" );
                }
            }
        }
    }
 
    // If no object lines are read (those beginning w/ 'o'), file is not obj type
    if( object_id == 0 && group_id == 0 )
    {
        MB_SET_ERR( MB_FAILURE, "This is not an obj file. " );
    }
 
    std::cout << "There were " << ignored << " ignored lines in this file." << std::endl;
 
    input_file.close();
 
    return MB_SUCCESS;
}
 
/* The tokenize function will split an input line
 * into a vector of strings based upon the delimiter
 */
void ReadOBJ::tokenize( const std::string& str, std::vector< std::string >& tokens, const char* delimiters2 )
{
    tokens.clear();
 
    std::string::size_type next_token_end, next_token_start = str.find_first_not_of( delimiters2, 0 );
 
    while( std::string::npos != next_token_start )
    {
        next_token_end = str.find_first_of( delimiters2, next_token_start );
        if( std::string::npos == next_token_end )
        {
            tokens.push_back( str.substr( next_token_start ) );
            next_token_start = std::string::npos;
        }
        else
        {
            tokens.push_back( str.substr( next_token_start, next_token_end - next_token_start ) );
            next_token_start = str.find_first_not_of( delimiters2, next_token_end );
        }
    }
}
 
keyword_type ReadOBJ::get_keyword( std::vector< std::string > tokens )
{
    std::map< std::string, keyword_type > keywords;
 
    // currently supported
    keywords["o"] = object_start;
    keywords["g"] = group_start;
    keywords["f"] = face_start;
    keywords["v"] = vertex_start;
 
    // not currently supported, will be ignored
    keywords["vn"]         = valid_unsupported;
    keywords["vt"]         = valid_unsupported;
    keywords["vp"]         = valid_unsupported;
    keywords["s"]          = valid_unsupported;
    keywords["mtllib"]     = valid_unsupported;
    keywords["usemtl"]     = valid_unsupported;
    keywords["#"]          = valid_unsupported;
    keywords["cstype"]     = valid_unsupported;
    keywords["deg"]        = valid_unsupported;
    keywords["bmat"]       = valid_unsupported;
    keywords["step"]       = valid_unsupported;
    keywords["p"]          = valid_unsupported;
    keywords["l"]          = valid_unsupported;
    keywords["curv"]       = valid_unsupported;
    keywords["curv2"]      = valid_unsupported;
    keywords["surf"]       = valid_unsupported;
    keywords["parm"]       = valid_unsupported;
    keywords["trim"]       = valid_unsupported;
    keywords["hole"]       = valid_unsupported;
    keywords["scrv"]       = valid_unsupported;
    keywords["sp"]         = valid_unsupported;
    keywords["end"]        = valid_unsupported;
    keywords["mg"]         = valid_unsupported;
    keywords["bevel"]      = valid_unsupported;
    keywords["c_interp"]   = valid_unsupported;
    keywords["d_interp"]   = valid_unsupported;
    keywords["lod"]        = valid_unsupported;
    keywords["shadow_obj"] = valid_unsupported;
    keywords["trace_obj"]  = valid_unsupported;
    keywords["ctech"]      = valid_unsupported;
    keywords["stech"]      = valid_unsupported;
 
    return keywords[match( tokens[0], keywords )];
}
 
template < typename T >
std::string ReadOBJ::match( const std::string& token, std::map< std::string, T >& tokenList )
{
    // Initialize with no match and obj_undefined as return string
    std::string best_match = OBJ_UNDEFINED;
 
    // Search the map
    for( typename std::map< std::string, T >::iterator thisToken = tokenList.begin(); thisToken != tokenList.end();
         ++thisToken )
    {
        // If a perfect match break the loop (assume keyword list is unambiguous)
        if( token == ( *thisToken ).first )
        {
            best_match = token;
            break;
        }
    }
 
    // Possible return values: OBJ_UNDEFINED, keyword from list
    return best_match;
}
 
/*
 * The create_new_object function starts a new meshset for each object
 * that will contain all faces that make up the object.
 */
ErrorCode ReadOBJ::create_new_object( std::string object_name, int curr_object, EntityHandle& object_meshset )
{
    // Create meshset to store object
    // This is also referred to as the surface meshset
    MB_CHK_SET_ERR( MBI->create_meshset( MESHSET_SET, object_meshset ), "Failed to generate object mesh set." );
 
    // Set surface meshset tags
    MB_CHK_SET_ERR( MBI->tag_set_data( name_tag, &object_meshset, 1, object_name.c_str() ),
                    "Failed to set mesh set name tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( id_tag, &object_meshset, 1, &( curr_object ) ),
                    "Failed to set mesh set ID tag." );
 
    int dim = 2;
    MB_CHK_SET_ERR( MBI->tag_set_data( geom_tag, &object_meshset, 1, &( dim ) ), "Failed to set mesh set dim tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( category_tag, &object_meshset, 1, geom_category[2] ),
                    "Failed to set mesh set category tag." );
 
    /* Create volume entity set corresponding to surface
       The volume meshset will have one child--
       the meshset of the surface that bounds the object.
     */
    EntityHandle vol_meshset;
    MB_CHK_SET_ERR( MBI->create_meshset( MESHSET_SET, vol_meshset ), "Failed to create volume mesh set." );
 
    MB_CHK_SET_ERR( MBI->add_parent_child( vol_meshset, object_meshset ),
                    "Failed to add object mesh set as child of volume mesh set." );
 
    /* Set volume meshset tags
       The volume meshset is tagged with the same name as the surface meshset
       for each object because of the direct relation between these entities.
     */
    MB_CHK_SET_ERR( MBI->tag_set_data( obj_name_tag, &vol_meshset, 1, object_name.c_str() ),
                    "Failed to set mesh set name tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( id_tag, &vol_meshset, 1, &( curr_object ) ), "Failed to set mesh set ID tag." );
 
    dim = 3;
    MB_CHK_SET_ERR( MBI->tag_set_data( geom_tag, &vol_meshset, 1, &( dim ) ), "Failed to set mesh set dim tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( name_tag, &vol_meshset, 1, geom_name[3] ), "Failed to set mesh set name tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( category_tag, &vol_meshset, 1, geom_category[3] ),
                    "Failed to set mesh set category tag." );
 
    MB_CHK_SET_ERR( myGeomTool->set_sense( object_meshset, vol_meshset, SENSE_FORWARD ),
                    "Failed to set surface sense." );
 
    return moab::MB_SUCCESS;
}
 
/*
 * The create_new_group function starts a new meshset for each group
 * that will contain all faces that make up the group
 */
ErrorCode ReadOBJ::create_new_group( std::string group_name, int curr_group, EntityHandle& group_meshset )
{
    // Create meshset to store group
    MB_CHK_SET_ERR( MBI->create_meshset( MESHSET_SET, group_meshset ), "Failed to generate group mesh set." );
 
    // Set meshset tags
    MB_CHK_SET_ERR( MBI->tag_set_data( name_tag, &group_meshset, 1, group_name.c_str() ),
                    "Failed to set mesh set name tag." );
 
    MB_CHK_SET_ERR( MBI->tag_set_data( id_tag, &group_meshset, 1, &( curr_group ) ), "Failed to set mesh set ID tag." );
 
    return moab::MB_SUCCESS;
}
 
/* The create_new_vertex function converts a vector
   of tokens (v x y z) to
   the vertex format; a structure that has the three
   coordinates as members.
 */
ErrorCode ReadOBJ::create_new_vertex( std::vector< std::string > v_tokens, EntityHandle& vertex_eh )
{
    vertex next_vertex;
 
    for( int i = 1; i < 4; i++ )
        next_vertex.coord[i - 1] = atof( v_tokens[i].c_str() );
 
    MB_CHK_SET_ERR( MBI->create_vertex( next_vertex.coord, vertex_eh ), "Unbale to create vertex." );
 
    return moab::MB_SUCCESS;
}
 
/* The create_new_face function converts a vector
   of tokens ( f v1 v2 v3) ) to the face format;
   a structure that has the three
   connectivity points as members.
 */
ErrorCode ReadOBJ::create_new_face( std::vector< std::string > f_tokens,
                                    const std::vector< EntityHandle >& vertex_list,
                                    EntityHandle& face_eh )
{
    face next_face;
 
    for( int i = 1; i < 4; i++ )
    {
        int vertex_id = atoi( f_tokens[i].c_str() );
 
        // Some faces contain format 'vertex/texture'
        // Remove the '/texture' and add the vertex to the list
        std::size_t slash = f_tokens[i].find( '/' );
        if( slash != std::string::npos )
        {
            std::string face = f_tokens[i].substr( 0, slash );
            vertex_id        = atoi( face.c_str() );
        }
 
        next_face.conn[i - 1] = vertex_list[vertex_id - 1];
    }
 
    MB_CHK_SET_ERR( MBI->create_element( MBTRI, next_face.conn, 3, face_eh ), "Unable to create new face." );
 
    return moab::MB_SUCCESS;
}
 
// The split_quad function divides a quad face into 4 tri faces.
ErrorCode ReadOBJ::split_quad( std::vector< std::string > f_tokens,
                               std::vector< EntityHandle >& vertex_list,
                               Range& face_eh )
{
    std::vector< EntityHandle > quad_vert_eh;
 
    // Loop over quad connectivity getting vertex EHs
    for( int i = 1; i < 5; i++ )
    {
        int vertex_id     = atoi( f_tokens[i].c_str() );
        std::size_t slash = f_tokens[i].find( '/' );
        if( slash != std::string::npos )
        {
            std::string face = f_tokens[i].substr( 0, slash );
            vertex_id        = atoi( face.c_str() );
        }
 
        quad_vert_eh.push_back( vertex_list[vertex_id - 1] );
    }
 
    // Create new tri faces
    MB_CHK_SET_ERR( create_tri_faces( quad_vert_eh, face_eh ), "Failed to create triangles when splitting quad." );
 
    return moab::MB_SUCCESS;
}
 
ErrorCode ReadOBJ::create_tri_faces( std::vector< EntityHandle > quad_vert_eh,
                                     //                    EntityHandle center_vertex_eh,
                                     Range& face_eh )
{
    EntityHandle connectivity[3];
    EntityHandle new_face;
 
    connectivity[0] = quad_vert_eh[0];
    connectivity[1] = quad_vert_eh[1];
    connectivity[2] = quad_vert_eh[2];
    MB_CHK_SET_ERR( MBI->create_element( MBTRI, connectivity, 3, new_face ), "failed to create triangle" );
    face_eh.insert( new_face );
 
    connectivity[0] = quad_vert_eh[2];
    connectivity[1] = quad_vert_eh[3];
    connectivity[2] = quad_vert_eh[0];
    MB_CHK_SET_ERR( MBI->create_element( MBTRI, connectivity, 3, new_face ), "failed to create second triangle" );
    face_eh.insert( new_face );
 
    return moab::MB_SUCCESS;
}
 
}  // namespace moab