MOAB: Mesh Oriented datABase  (version 5.2.1)
moab::ReadSmf Class Reference

Read SMF (Simple Model Format) files. More...

#include <ReadSmf.hpp>

+ Inheritance diagram for moab::ReadSmf:
+ Collaboration diagram for moab::ReadSmf:

Classes

struct  cmd_entry

Public Types

typedef ErrorCode(ReadSmf::* read_cmd )(std::vector< std::string > &argv)

Public Member Functions

ErrorCode load_file (const char *file_name, const EntityHandle *file_set, const FileOptions &opts, const SubsetList *subset_list=0, const Tag *file_id_tag=0)
 load a file
ErrorCode read_tag_values (const char *file_name, const char *tag_name, const FileOptions &opts, std::vector< int > &tag_values_out, const SubsetList *subset_list=0)
 Read tag values from a file.
 ReadSmf (Interface *impl=NULL)
 Constructor.
virtual ~ReadSmf ()
 Destructor.
void init ()

Static Public Member Functions

static ReaderIfacefactory (Interface *)

Protected Member Functions

ErrorCode annotation (char *cmd, std::vector< std::string > &argv)
void bad_annotation (const char *cmd)
ErrorCode vertex (std::vector< std::string > &)
ErrorCode v_normal (std::vector< std::string > &)
ErrorCode v_color (std::vector< std::string > &)
ErrorCode f_color (std::vector< std::string > &)
ErrorCode face (std::vector< std::string > &)
ErrorCode begin (std::vector< std::string > &)
ErrorCode end (std::vector< std::string > &)
ErrorCode set (std::vector< std::string > &)
ErrorCode inc (std::vector< std::string > &)
ErrorCode dec (std::vector< std::string > &)
ErrorCode trans (std::vector< std::string > &)
ErrorCode scale (std::vector< std::string > &)
ErrorCode rot (std::vector< std::string > &)
ErrorCode mmult (std::vector< std::string > &)
ErrorCode mload (std::vector< std::string > &)
ErrorCode parse_line (char *line)
ErrorCode parse_doubles (int count, const std::vector< std::string > &argv, double results[])
ErrorCode parse_mat (const std::vector< std::string > &argv, AffineXform &mat_out)
ErrorCode check_length (int count, const std::vector< std::string > &argv)

Private Attributes

ReadUtilIfacereadMeshIface
Interface * mdbImpl
EntityHandle mCurrentMeshHandle
 Meshset Handle for the mesh that is currently being read.
std::string mPartitionTagName
char line [SMF_MAXLINE]
std::vector< SMF_Statestate
SMF_ivars ivar
int _numNodes
int _numFaces
std::vector< double > _coords
std::vector< int > _connec
int _numNodesInFile
int _numElementsInFile
size_t lineNo
size_t commandNo
int versionMajor
int versionMinor

Static Private Attributes

static cmd_entry read_cmds []

Detailed Description

Read SMF (Simple Model Format) files.

File format is documented at: http://people.sc.fsu.edu/~burkardt/data/smf/smf.txt

Definition at line 39 of file ReadSmf.hpp.


Member Typedef Documentation

typedef ErrorCode( ReadSmf::* moab::ReadSmf::read_cmd)(std::vector< std::string > &argv)

Definition at line 58 of file ReadSmf.hpp.


Constructor & Destructor Documentation

ReadSmf::ReadSmf ( Interface *  impl = NULL)
ReadSmf::~ReadSmf ( ) [virtual]

Destructor.

Definition at line 97 of file ReadSmf.cpp.

References mdbImpl, and readMeshIface.

{
    if( readMeshIface )
    {
        mdbImpl->release_interface( readMeshIface );
        readMeshIface = 0;
    }
}

Member Function Documentation

ErrorCode ReadSmf::annotation ( char *  cmd,
std::vector< std::string > &  argv 
) [protected]

Definition at line 200 of file ReadSmf.cpp.

References _numFaces, _numNodes, bad_annotation(), commandNo, lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, streq(), versionMajor, and versionMinor.

Referenced by parse_line().

{
    // Skip over the '#$' prefix
    cmd += 2;

    if( streq( cmd, "SMF" ) )
    {
        // If SMF version is specified, it must be the first
        // thing specified in the file.
        if( commandNo > 1 ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "SMF file version specified at line " << lineNo ); }

        if( 2 == sscanf( argv[0].c_str(), "%d.%d", &versionMajor, &versionMinor ) )
        {
            if( versionMajor != 1 || versionMinor != 0 )
            {
                MB_SET_ERR( MB_FILE_WRITE_ERROR,
                            "Unsupported SMF file version: " << versionMajor << "." << versionMinor );
            }
        }
        else
        {
            MB_SET_ERR( MB_FILE_WRITE_ERROR, "Invalid SMF version annotation" );
        }
    }
    else if( streq( cmd, "vertices" ) )
    {
        if( argv.size() == 1 )
            _numNodes = atoi( argv[0].c_str() );
        else
            bad_annotation( cmd );
    }
    else if( streq( cmd, "faces" ) )
    {
        if( argv.size() == 1 )
            _numFaces = atoi( argv[0].c_str() );
        else
            bad_annotation( cmd );
    }
    else if( streq( cmd, "BBox" ) )
    {
    }
    else if( streq( cmd, "BSphere" ) )
    {
    }
    else if( streq( cmd, "PXform" ) )
    {
        if( argv.size() == 16 )
        {
            // parse_mat(argv);
        }
        else
            bad_annotation( cmd );
    }
    else if( streq( cmd, "MXform" ) )
    {
        if( argv.size() == 16 )
        {
            // parse_mat(argv);
        }
        else
            bad_annotation( cmd );
    }

    return MB_SUCCESS;
}
void ReadSmf::bad_annotation ( const char *  cmd) [protected]

Definition at line 77 of file ReadSmf.cpp.

Referenced by annotation().

{
    std::cerr << "SMF: Malformed annotation [" << cmd << "]" << std::endl;
}
ErrorCode ReadSmf::begin ( std::vector< std::string > &  ) [protected]

Definition at line 405 of file ReadSmf.cpp.

References ivar, MB_SUCCESS, and state.

{
    state.push_back( SMF_State( ivar, &state.back() ) );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::check_length ( int  count,
const std::vector< std::string > &  argv 
) [protected]

Definition at line 330 of file ReadSmf.cpp.

References lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, and MB_SUCCESS.

Referenced by face(), parse_doubles(), and rot().

{
    if( ( argv.size() < (unsigned)count ) || ( argv.size() > (unsigned)count && argv[count][0] != '#' ) )
    { MB_SET_ERR( MB_FILE_WRITE_ERROR, "Expect " << count << " arguments at line " << lineNo ); }

    return MB_SUCCESS;
}
ErrorCode ReadSmf::dec ( std::vector< std::string > &  ) [protected]

Definition at line 443 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    // std::cerr << "SMF: DEC not yet implemented." << std::endl;
    return MB_SUCCESS;
}
ErrorCode ReadSmf::end ( std::vector< std::string > &  ) [protected]

Definition at line 412 of file ReadSmf.cpp.

References lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, and state.

{
    // There must always be at least one state on the stack.
    // Don't let mismatched begin/end statements cause us
    // to read from an empty vector.
    if( state.size() == 1 ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "End w/out Begin at line " << lineNo ); }

    state.pop_back();

    return MB_SUCCESS;
}
ErrorCode ReadSmf::f_color ( std::vector< std::string > &  ) [protected]

Definition at line 378 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}
ErrorCode ReadSmf::face ( std::vector< std::string > &  argv) [protected]

Definition at line 383 of file ReadSmf.cpp.

References _connec, _numElementsInFile, check_length(), ivar, lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, moab::SMF_ivars::next_face, and state.

{
    ErrorCode err = check_length( 3, argv );
    if( MB_SUCCESS != err ) return err;

    int vert[3] = {};
    char* endptr;
    for( unsigned int i = 0; i < argv.size(); i++ )
    {
        vert[i] = strtol( argv[i].c_str(), &endptr, 0 );
        if( *endptr ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "Invalid face spec at line " << lineNo ); }
    }

    state.back().face( vert, ivar );
    ivar.next_face++;
    for( int j = 0; j < 3; j++ )
        _connec.push_back( vert[j] );
    _numElementsInFile++;

    return MB_SUCCESS;
}
ReaderIface * ReadSmf::factory ( Interface *  iface) [static]

Definition at line 82 of file ReadSmf.cpp.

References ReadSmf().

Referenced by moab::ReaderWriterSet::ReaderWriterSet().

{
    return new ReadSmf( iface );
}
ErrorCode ReadSmf::inc ( std::vector< std::string > &  ) [protected]

Definition at line 437 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    // std::cerr << "SMF: INC not yet implemented." << std::endl;
    return MB_SUCCESS;
}
ErrorCode ReadSmf::load_file ( const char *  file_name,
const EntityHandle file_set,
const FileOptions opts,
const SubsetList subset_list = 0,
const Tag file_id_tag = 0 
) [virtual]

load a file

Implements moab::ReaderIface.

Definition at line 113 of file ReadSmf.cpp.

References _connec, _coords, _numElementsInFile, _numNodesInFile, moab::ReadUtilIface::assign_ids(), commandNo, moab::ReadUtilIface::get_element_connect(), moab::ReadUtilIface::get_node_coords(), moab::FileOptions::get_option(), ivar, line, lineNo, MB_FILE_DOES_NOT_EXIST, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_START_ID, MB_SUCCESS, MB_UNSUPPORTED_OPERATION, MBTRI, mPartitionTagName, moab::SMF_ivars::next_face, moab::SMF_ivars::next_vertex, parse_line(), readMeshIface, SMF_MAXLINE, state, moab::ReadUtilIface::update_adjacencies(), versionMajor, and versionMinor.

{
    ErrorCode result;
    lineNo       = 0;
    commandNo    = 0;
    versionMajor = 0;
    versionMinor = 0;

    if( subset_list ) { MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for VTK" ); }

    // Does the caller want a field to be used for partitioning the entities?
    // If not, we'll assume any scalar integer field named MATERIAL_SET specifies partitions.
    std::string partition_tag_name;
    result = opts.get_option( "PARTITION", partition_tag_name );
    if( result == MB_SUCCESS ) mPartitionTagName = partition_tag_name;

    std::ifstream smfFile( filename );
    if( !smfFile ) return MB_FILE_DOES_NOT_EXIST;

    ivar.next_face   = 1;
    ivar.next_vertex = 1;
    state.push_back( SMF_State( ivar ) );

    while( smfFile.getline( line, SMF_MAXLINE, '\n' ).good() )
    {
        ++lineNo;
        result = parse_line( line );
        if( MB_SUCCESS != result ) return result;
    }

    if( !smfFile.eof() )
    {
        // Parsing terminated for a reason other than EOF: signal failure.
        return MB_FILE_WRITE_ERROR;
    }

    // At this point we have _numNodesInFile vertices and _numElementsInFile triangles
    // the coordinates are in _coords, and connectivities in _connec
    // std::vector<double> _coords; // 3*numNodes; we might not know the number of nodes
    // std::vector<int> _connec; // 3*num of elements; we might not know them;

    // Create vertices
    std::vector< double* > arrays;
    EntityHandle start_handle_out;
    start_handle_out = 0;
    result           = readMeshIface->get_node_coords( 3, _numNodesInFile, MB_START_ID, start_handle_out, arrays );

    if( MB_SUCCESS != result ) return result;

    // Fill the arrays with data from _coords
    // Cppcheck warning (false positive): variable arrays is assigned a value that is never used
    for( int i = 0; i < _numNodesInFile; i++ )
    {
        int i3       = 3 * i;
        arrays[0][i] = _coords[i3];
        arrays[1][i] = _coords[i3 + 1];
        arrays[2][i] = _coords[i3 + 2];
    }
    // Elements

    EntityHandle start_handle_elem_out;
    start_handle_elem_out = 0;
    EntityHandle* conn_array_out;
    result = readMeshIface->get_element_connect( _numElementsInFile, 3,
                                                 MBTRI,  // EntityType
                                                 MB_START_ID, start_handle_elem_out, conn_array_out );
    if( MB_SUCCESS != result ) return result;
    for( int j = 0; j < _numElementsInFile * 3; j++ )
        conn_array_out[j] = _connec[j];

    // Notify MOAB of the new elements
    result = readMeshIface->update_adjacencies( start_handle_elem_out, _numElementsInFile, 3, conn_array_out );

    if( MB_SUCCESS != result ) return result;

    if( file_id_tag )
    {
        Range nodes( start_handle_out, start_handle_out + _numNodesInFile - 1 );
        Range elems( start_handle_elem_out, start_handle_elem_out + _numElementsInFile - 1 );
        readMeshIface->assign_ids( *file_id_tag, nodes );
        readMeshIface->assign_ids( *file_id_tag, elems );
    }

    return MB_SUCCESS;
}
ErrorCode ReadSmf::mload ( std::vector< std::string > &  argv) [protected]

Definition at line 521 of file ReadSmf.cpp.

References MB_SUCCESS, parse_mat(), and state.

{
    AffineXform mat;
    ErrorCode rval = parse_mat( argv, mat );
    if( MB_SUCCESS != rval ) return rval;

    state.back().mload( mat );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::mmult ( std::vector< std::string > &  argv) [protected]

Definition at line 510 of file ReadSmf.cpp.

References MB_SUCCESS, parse_mat(), and state.

{
    AffineXform mat;
    ErrorCode rval = parse_mat( argv, mat );
    if( MB_SUCCESS != rval ) return rval;

    state.back().mmult( mat );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::parse_doubles ( int  count,
const std::vector< std::string > &  argv,
double  results[] 
) [protected]

Definition at line 338 of file ReadSmf.cpp.

References check_length(), lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, and MB_SUCCESS.

Referenced by parse_mat(), rot(), scale(), trans(), and vertex().

{
    ErrorCode rval = check_length( count, argv );
    if( MB_SUCCESS != rval ) return rval;

    char* endptr;
    for( int i = 0; i < count; i++ )
    {
        results[i] = strtod( argv[i].c_str(), &endptr );
        if( *endptr ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "Invalid vertex coordinates at line " << lineNo ); }
    }

    return MB_SUCCESS;
}
ErrorCode ReadSmf::parse_line ( char *  line) [protected]

Definition at line 266 of file ReadSmf.cpp.

References annotation(), moab::ReadSmf::cmd_entry::cmd, commandNo, lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, MB_UNSUPPORTED_OPERATION, moab::ReadSmf::cmd_entry::name, read_cmds, streq(), and versionMajor.

Referenced by load_file().

{
    char *cmd, *s;
    std::vector< std::string > argv;
    ErrorCode err;

    while( *ln == ' ' || *ln == '\t' )
        ln++;  // Skip initial white space

    // Ignore empty lines
    if( ln[0] == '\n' || ln[0] == '\0' ) return MB_SUCCESS;

    // Ignore comments
    if( ln[0] == '#' && ln[1] != '$' ) return MB_SUCCESS;

    // First, split the line into tokens
    cmd = strtok( ln, " \t\n" );

    while( ( s = strtok( NULL, " \t\n" ) ) )
    {
        std::string stg( s );
        argv.push_back( stg );
    }

    // Figure out what command it is and execute it
    if( cmd[0] == '#' && cmd[1] == '$' )
    {
        err = annotation( cmd, argv );
        if( MB_SUCCESS != err ) return err;
    }
    else
    {
        cmd_entry* entry = &read_cmds[0];
        bool handled     = 0;

        while( entry->name && !handled )
        {
            if( streq( entry->name, cmd ) )
            {
                err = ( this->*( entry->cmd ) )( argv );
                if( MB_SUCCESS != err ) return err;
                handled = 1;
                ++commandNo;
            }
            else
                entry++;
        }

        if( !handled )
        {
            // If the first command was invalid, this probably
            // wasn't an Smf file. Fail silently in this case.
            // If versionMajor is set, then we saw an initial #$SMF,
            // in which case it must be a SMF file.
            if( !versionMajor && !commandNo ) return MB_FILE_WRITE_ERROR;

            // Invalid command:
            MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Illegal SMF command at line " << lineNo << ": \"" << cmd << "\"" );
        }
    }

    return MB_SUCCESS;
}
ErrorCode ReadSmf::parse_mat ( const std::vector< std::string > &  argv,
AffineXform mat_out 
) [protected]

Definition at line 67 of file ReadSmf.cpp.

References MB_SUCCESS, and parse_doubles().

Referenced by mload(), and mmult().

{
    double values[12];
    ErrorCode err = parse_doubles( 12, argv, values );
    if( MB_SUCCESS != err ) return err;

    mat = AffineXform( values, values + 9 );
    return MB_SUCCESS;
}
ErrorCode ReadSmf::read_tag_values ( const char *  file_name,
const char *  tag_name,
const FileOptions opts,
std::vector< int > &  tag_values_out,
const SubsetList subset_list = 0 
) [virtual]

Read tag values from a file.

Read the list if all integer tag values from the file for a tag that is a single integer value per entity.

Parameters:
file_nameThe file to read.
tag_nameThe tag for which to read values
tag_values_outOutput: The list of tag values.
subset_listAn array of tag name and value sets specifying the subset of the file to read. If multiple tags are specified, the sets that match all tags (intersection) should be read.
subset_list_lengthThe length of the 'subset_list' array.

Implements moab::ReaderIface.

Definition at line 106 of file ReadSmf.cpp.

References MB_NOT_IMPLEMENTED.

{
    return MB_NOT_IMPLEMENTED;
}
ErrorCode ReadSmf::rot ( std::vector< std::string > &  argv) [protected]

Definition at line 475 of file ReadSmf.cpp.

References moab::angle(), check_length(), lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, parse_doubles(), moab::AffineXform::rotation(), and state.

{
    ErrorCode err = check_length( 2, argv );
    if( MB_SUCCESS != err ) return err;

    double axis[3]       = { 0., 0., 0. };
    std::string axisname = argv.front();
    argv.erase( argv.begin() );
    if( axisname.size() != 1 ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "Malformed rotation command at line " << lineNo ); }
    switch( axisname[0] )
    {
        case 'x':
            axis[0] = 1.;
            break;
        case 'y':
            axis[1] = 1.;
            break;
        case 'z':
            axis[2] = 1.;
            break;
        default:
            MB_SET_ERR( MB_FILE_WRITE_ERROR, "Malformed rotation command at line " << lineNo );
    }

    double angle;
    err = parse_doubles( 1, argv, &angle );
    if( MB_SUCCESS != err ) return err;
    angle *= M_PI / 180.0;

    AffineXform M = AffineXform::rotation( angle, axis );
    state.back().mmult( M );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::scale ( std::vector< std::string > &  argv) [protected]

Definition at line 462 of file ReadSmf.cpp.

References MB_SUCCESS, parse_doubles(), and state.

{
    double v3[3];
    ErrorCode err = parse_doubles( 3, argv, v3 );
    if( MB_SUCCESS != err ) return err;

    AffineXform M = AffineXform::scale( v3 );
    // Mat4 M = Mat4::scale(atof(argv(0)), atof(argv(1)), atof(argv(2)));
    state.back().mmult( M );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::set ( std::vector< std::string > &  argv) [protected]

Definition at line 424 of file ReadSmf.cpp.

References lineNo, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, and state.

{
    if( argv.size() < 2 || argv[0] != "vertex_coorection" ) return MB_SUCCESS;

    char* endptr;
    int val = strtol( argv[1].c_str(), &endptr, 0 );
    if( *endptr ) { MB_SET_ERR( MB_FILE_WRITE_ERROR, "Invalid value at line " << lineNo ); }

    state.back().set_vertex_correction( val );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::trans ( std::vector< std::string > &  argv) [protected]

Definition at line 449 of file ReadSmf.cpp.

References MB_SUCCESS, parse_doubles(), state, and moab::AffineXform::translation().

{
    double v3[3];
    ErrorCode err = parse_doubles( 3, argv, v3 );
    if( MB_SUCCESS != err ) return err;

    AffineXform M = AffineXform::translation( v3 );
    // Mat4 M = Mat4::trans(atof(argv(0)), atof(argv(1)), atof(argv(2)));
    state.back().mmult( M );

    return MB_SUCCESS;
}
ErrorCode ReadSmf::v_color ( std::vector< std::string > &  ) [protected]

Definition at line 373 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}
ErrorCode ReadSmf::v_normal ( std::vector< std::string > &  ) [protected]

Definition at line 368 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}
ErrorCode ReadSmf::vertex ( std::vector< std::string > &  argv) [protected]

Definition at line 353 of file ReadSmf.cpp.

References _coords, _numNodesInFile, ivar, MB_SUCCESS, moab::SMF_ivars::next_vertex, parse_doubles(), and state.

{
    double v[3];
    ErrorCode err = parse_doubles( 3, argv, v );
    if( MB_SUCCESS != err ) return err;

    state.back().vertex( v );
    ivar.next_vertex++;
    _numNodesInFile++;
    for( int j = 0; j < 3; j++ )
        _coords.push_back( v[j] );
    // model->in_Vertex(v);
    return MB_SUCCESS;
}

Member Data Documentation

std::vector< int > moab::ReadSmf::_connec [private]

Definition at line 118 of file ReadSmf.hpp.

Referenced by face(), and load_file().

std::vector< double > moab::ReadSmf::_coords [private]

Definition at line 117 of file ReadSmf.hpp.

Referenced by load_file(), and vertex().

Definition at line 120 of file ReadSmf.hpp.

Referenced by face(), load_file(), and ReadSmf().

int moab::ReadSmf::_numFaces [private]

Definition at line 116 of file ReadSmf.hpp.

Referenced by annotation(), and ReadSmf().

int moab::ReadSmf::_numNodes [private]

Definition at line 115 of file ReadSmf.hpp.

Referenced by annotation(), and ReadSmf().

Definition at line 119 of file ReadSmf.hpp.

Referenced by load_file(), ReadSmf(), and vertex().

size_t moab::ReadSmf::commandNo [private]

Definition at line 122 of file ReadSmf.hpp.

Referenced by annotation(), load_file(), and parse_line().

Definition at line 114 of file ReadSmf.hpp.

Referenced by begin(), face(), load_file(), ReadSmf(), and vertex().

Definition at line 112 of file ReadSmf.hpp.

Referenced by load_file().

size_t moab::ReadSmf::lineNo [private]

Definition at line 121 of file ReadSmf.hpp.

Referenced by annotation(), check_length(), end(), face(), load_file(), parse_doubles(), parse_line(), rot(), and set().

Meshset Handle for the mesh that is currently being read.

Definition at line 104 of file ReadSmf.hpp.

Interface* moab::ReadSmf::mdbImpl [private]

interface instance interface instance

Definition at line 101 of file ReadSmf.hpp.

Referenced by ReadSmf(), and ~ReadSmf().

std::string moab::ReadSmf::mPartitionTagName [private]

A field which, if present and having a single integer for storage, should be used to partition the mesh by range. Defaults to MATERIAL_SET_TAG_NAME

Definition at line 108 of file ReadSmf.hpp.

Referenced by load_file().

Initial value:
 { { "v", &ReadSmf::vertex },
                                            { ":vn", &ReadSmf::v_normal },
                                            { ":vc", &ReadSmf::v_color },
                                            { ":fc", &ReadSmf::f_color },
                                            { "t", &ReadSmf::face },
                                            { "f", &ReadSmf::face },

                                            { "begin", &ReadSmf::begin },
                                            { "end", &ReadSmf::end },
                                            { "set", &ReadSmf::set },
                                            { "inc", &ReadSmf::inc },
                                            { "dec", &ReadSmf::dec },

                                            { "mmult", &ReadSmf::mload },
                                            { "mload", &ReadSmf::mmult },
                                            { "trans", &ReadSmf::trans },
                                            { "scale", &ReadSmf::scale },
                                            { "rot", &ReadSmf::rot },

                                            { NULL, NULL } }

Definition at line 111 of file ReadSmf.hpp.

Referenced by parse_line().

Definition at line 95 of file ReadSmf.hpp.

Referenced by load_file(), ReadSmf(), and ~ReadSmf().

std::vector< SMF_State > moab::ReadSmf::state [private]

Definition at line 113 of file ReadSmf.hpp.

Referenced by begin(), end(), face(), load_file(), mload(), mmult(), rot(), scale(), set(), trans(), and vertex().

Definition at line 123 of file ReadSmf.hpp.

Referenced by annotation(), load_file(), and parse_line().

Definition at line 123 of file ReadSmf.hpp.

Referenced by annotation(), and load_file().

List of all members.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines