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 ReaderIface *	factory (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
ReadUtilIface *	readMeshIface
Interface *	mdbImpl
	interface instance interface instance
EntityHandle	mCurrentMeshHandle
	Meshset Handle for the mesh that is currently being read.
std::string	mPartitionTagName
	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.
char	line [SMF_MAXLINE]
std::vector< SMF_State >	state
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 64 of file ReadSmf.hpp.

Constructor & Destructor Documentation

ReadSmf::ReadSmf ( Interface * impl = NULL )

Constructor.

Definition at line 87 of file ReadSmf.cpp.

References _numElementsInFile, _numFaces, _numNodes, _numNodesInFile, ivar, mdbImpl, moab::SMF_ivars::next_face, moab::SMF_ivars::next_vertex, moab::Interface::query_interface(), and readMeshIface.

Referenced by factory().

    : mdbImpl( impl ), mCurrentMeshHandle( 0 ), lineNo( 0 ), commandNo( 0 ), versionMajor( 0 ), versionMinor( 0 )
{
    mdbImpl->query_interface( readMeshIface );
    ivar.next_vertex = 0;
    ivar.next_face   = 0;
    _numNodes = _numFaces = 0;
    _numNodesInFile = _numElementsInFile = 0;
}

ReadSmf::~ReadSmf ( ) [virtual]

Destructor.

Definition at line 97 of file ReadSmf.cpp.

References mdbImpl, readMeshIface, and moab::Interface::release_interface().

{
    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 208 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 424 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 341 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 468 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 431 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 394 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}

ErrorCode ReadSmf::face ( std::vector< std::string > & argv ) [protected]

Definition at line 399 of file ReadSmf.cpp.

References _connec, _numElementsInFile, check_length(), ErrorCode, 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 462 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    // std::cerr << "SMF: INC not yet implemented." << std::endl;
    return MB_SUCCESS;
}

void moab::ReadSmf::init ( )

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 115 of file ReadSmf.cpp.

References _connec, _coords, _numElementsInFile, _numNodesInFile, moab::ReadUtilIface::assign_ids(), commandNo, ErrorCode, 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 _coords; // 3*numNodes; we might not know the number of nodes
    // std::vector _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 549 of file ReadSmf.cpp.

References ErrorCode, 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 538 of file ReadSmf.cpp.

References ErrorCode, 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 351 of file ReadSmf.cpp.

References check_length(), ErrorCode, 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 277 of file ReadSmf.cpp.

References annotation(), moab::ReadSmf::cmd_entry::cmd, commandNo, ErrorCode, 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     = false;

        while( entry->name && !handled )
        {
            if( streq( entry->name, cmd ) )
            {
                err = ( this->*( entry->cmd ) )( argv );
                if( MB_SUCCESS != err ) return err;
                handled = true;
                ++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 ErrorCode, 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_name	The file to read.
tag_name	The tag for which to read values
tag_values_out	Output: The list of tag values.
subset_list	An 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_length	The 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 500 of file ReadSmf.cpp.

References moab::angle(), check_length(), ErrorCode, 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 487 of file ReadSmf.cpp.

References ErrorCode, 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 446 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 474 of file ReadSmf.cpp.

References ErrorCode, 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 389 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}

ErrorCode ReadSmf::v_normal ( std::vector< std::string > & ) [protected]

Definition at line 384 of file ReadSmf.cpp.

References MB_SUCCESS.

{
    return MB_SUCCESS;
}

ErrorCode ReadSmf::vertex ( std::vector< std::string > & argv ) [protected]

Definition at line 369 of file ReadSmf.cpp.

References _coords, _numNodesInFile, ErrorCode, 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 124 of file ReadSmf.hpp.

Referenced by face(), and load_file().

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

Definition at line 123 of file ReadSmf.hpp.

Referenced by load_file(), and vertex().

int moab::ReadSmf::_numElementsInFile [private]

Definition at line 126 of file ReadSmf.hpp.

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

int moab::ReadSmf::_numFaces [private]

Definition at line 122 of file ReadSmf.hpp.

Referenced by annotation(), and ReadSmf().

int moab::ReadSmf::_numNodes [private]

Definition at line 121 of file ReadSmf.hpp.

Referenced by annotation(), and ReadSmf().

int moab::ReadSmf::_numNodesInFile [private]

Definition at line 125 of file ReadSmf.hpp.

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

size_t moab::ReadSmf::commandNo [private]

Definition at line 128 of file ReadSmf.hpp.

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

SMF_ivars moab::ReadSmf::ivar [private]

Definition at line 120 of file ReadSmf.hpp.

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

char moab::ReadSmf::line[SMF_MAXLINE] [private]

Definition at line 118 of file ReadSmf.hpp.

Referenced by load_file().

size_t moab::ReadSmf::lineNo [private]

Definition at line 127 of file ReadSmf.hpp.

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

EntityHandle moab::ReadSmf::mCurrentMeshHandle [private]

Meshset Handle for the mesh that is currently being read.

Definition at line 110 of file ReadSmf.hpp.

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

interface instance interface instance

Definition at line 107 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 114 of file ReadSmf.hpp.

Referenced by load_file().

ReadSmf::cmd_entry ReadSmf::read_cmds [static, private]

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 } }