|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
Inheritance diagram for iMeshTest: Collaboration diagram for iMeshTest:Definition at line 99 of file iMeshTest.cpp.
| iMeshTest::iMeshTest | ( | ) | [inline] |
Definition at line 126 of file iMeshTest.cpp.
: myMesh( 0 ) {}
| iMeshTest::CPPUNIT_TEST | ( | testVertexByte | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testFixedFlag | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testSlavedFlag | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testVertexAdjacency | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testElementConnectivity | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testElementTopology | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testIntTag | ) | [private] |
| iMeshTest::CPPUNIT_TEST | ( | testDoubleTag | ) | [private] |
| iMeshTest::CPPUNIT_TEST_SUITE | ( | iMeshTest | ) | [private] |
| iMeshTest::CPPUNIT_TEST_SUITE_END | ( | ) | [private] |
| bool iMeshTest::match_triangles | ( | const int * | tri1, |
| const Mesh::VertexHandle * | tri2_handles | ||
| ) | [private] |
Definition at line 286 of file iMeshTest.cpp.
{
int tri2[3] = { vtxHandleToIndex[tri2_handles[0]], vtxHandleToIndex[tri2_handles[1]],
vtxHandleToIndex[tri2_handles[2]] };
return ( tri1[0] == tri2[0] && tri1[1] == tri2[1] && tri1[2] == tri2[2] ) ||
( tri1[0] == tri2[1] && tri1[1] == tri2[2] && tri1[2] == tri2[0] ) ||
( tri1[0] == tri2[2] && tri1[1] == tri2[0] && tri1[2] == tri2[1] );
}
| void iMeshTest::matchElementConnectivity | ( | ) |
Definition at line 296 of file iMeshTest.cpp.
References MBMesquite::arrptr(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, and triangleConnectivity.
{
MsqPrintError err( cout );
const size_t num_tri = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// make sure this hasn't been called yet
CPPUNIT_ASSERT( 0 == triHandleToIndex.size() );
// initialize data
memset( triIndexToHandle, 0, sizeof( triIndexToHandle ) );
vector< Mesh::VertexHandle > vertices;
vector< Mesh::ElementHandle > elements;
vector< size_t > offsets;
myMesh->get_all_elements( elements, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( num_tri, elements.size() );
myMesh->elements_get_attached_vertices( arrptr( elements ), elements.size(), vertices, offsets, err );
CPPUNIT_ASSERT( !err );
// Make sure all are triangles
size_t i;
for( i = 0; i < elements.size(); ++i )
CPPUNIT_ASSERT_EQUAL( offsets[i] + 3, offsets[i + 1] );
// Match triangles
for( size_t i = 0; i < num_tri; ++i )
{
size_t j;
for( j = 0; j < elements.size(); ++j )
{
Mesh::VertexHandle verts[3] = { vertices[offsets[j]], vertices[offsets[j] + 1], vertices[offsets[j] + 2] };
if( match_triangles( triangleConnectivity + 3 * i, verts ) )
{
triIndexToHandle[i] = elements[j];
CPPUNIT_ASSERT( triHandleToIndex.find( elements[j] ) == triHandleToIndex.end() );
triHandleToIndex[elements[j]] = i;
break;
}
}
CPPUNIT_ASSERT( j < elements.size() ); // found a match
}
}
| void iMeshTest::matchVertexCoordinates | ( | ) |
Definition at line 243 of file iMeshTest.cpp.
References MBMesquite::arrptr(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, and vertexCoords.
{
MsqPrintError err( cout );
const size_t num_pts = sizeof( vertexCoords ) / ( 3 * sizeof( double ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// make sure this hasn't been called yet
CPPUNIT_ASSERT( 0 == vtxHandleToIndex.size() );
// initialize data
memset( vtxIndexToHandle, 0, sizeof( vtxIndexToHandle ) );
// Get vertex handles
vector< Mesh::VertexHandle > vertices;
myMesh->get_all_vertices( vertices, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( num_pts, vertices.size() );
// get vertex coordinates
vector< MsqVertex > coordinates( num_pts );
myMesh->vertices_get_coordinates( arrptr( vertices ), arrptr( coordinates ), num_pts, err );
CPPUNIT_ASSERT( !err );
// match vertex coordiantes
for( size_t i = 0; i < num_pts; ++i )
{
MBMesquite::Vector3D coord( vertexCoords[3 * i], vertexCoords[3 * i + 1], vertexCoords[3 * i + 2] );
size_t j;
for( j = 0; j < vertices.size(); ++j )
{
if( ( ( coordinates[j] ) - coord ).length() < DBL_EPSILON )
{
vtxIndexToHandle[i] = vertices[j];
CPPUNIT_ASSERT( vtxHandleToIndex.find( vertices[j] ) == vtxHandleToIndex.end() );
vtxHandleToIndex[vertices[j]] = i;
break;
}
}
CPPUNIT_ASSERT( j < vertices.size() ); // found a match
}
}
| void iMeshTest::setUp | ( | ) |
Definition at line 205 of file iMeshTest.cpp.
References ASSERT_NO_ERROR, CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, iBase_ALL_TYPES, iBase_SUCCESS, ierr, iMesh_getRootSet, iMesh_load, iMesh_newMesh, and root_set.
{
const char* TMP_FILE_NAME = "hexagon.vtk";
MsqPrintError err( cout );
int ierr;
CPPUNIT_ASSERT( writeVtkFile( TMP_FILE_NAME ) );
iMesh_newMesh( NULL, &myIMesh, &ierr, 0 );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
iMesh_load( myIMesh, 0, TMP_FILE_NAME, NULL, &ierr, strlen( TMP_FILE_NAME ), 0 );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
iBase_EntitySetHandle root_set;
iMesh_getRootSet( myIMesh, &root_set, &ierr );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
myMesh = new MsqIMesh( myIMesh, root_set, iBase_ALL_TYPES, err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT( myMesh != NULL );
matchVertexCoordinates();
matchElementConnectivity();
}
| void iMeshTest::tearDown | ( | ) |
Definition at line 231 of file iMeshTest.cpp.
References CPPUNIT_ASSERT_EQUAL, iBase_SUCCESS, and iMesh_dtor.
{
int err;
delete myMesh;
myMesh = 0;
if( myIMesh )
{
iMesh_dtor( myIMesh, &err );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, err );
}
}
| void iMeshTest::testDoubleTag | ( | ) |
Definition at line 665 of file iMeshTest.cpp.
References MBMesquite::arrptr(), MBMesquite::MsqError::clear(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, MBMesquite::Mesh::DOUBLE, MBMesquite::MsqError::error_code(), MBMesquite::length(), MBMesquite::MsqError::TAG_NOT_FOUND, tagname, u, and vertexCoords.
{
const char* tagname = "TEST_TEST_DOUBLE_TAG";
MsqPrintError err( cout );
const size_t num_pts = sizeof( vertexCoords ) / ( 3 * sizeof( double ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// create a tag
TagHandle tag = myMesh->tag_create( tagname, Mesh::DOUBLE, 1, NULL, err );
CPPUNIT_ASSERT( !err );
// get the tag
TagHandle tag2 = myMesh->tag_get( tagname, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( tag, tag2 );
// check tag metadata
string name;
Mesh::TagType type;
unsigned length;
myMesh->tag_properties( tag, name, type, length, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( name, std::string( tagname ) );
CPPUNIT_ASSERT_EQUAL( type, Mesh::DOUBLE );
CPPUNIT_ASSERT_EQUAL( length, 1u );
// set the tag on all vertices
std::vector< double > data1( num_pts ), data2( num_pts );
std::vector< double >::iterator iter1, iter2;
for( iter1 = data1.begin(); iter1 != data1.end(); ++iter1 )
*iter1 = sqrt( abs( rand() ) );
myMesh->tag_set_vertex_data( tag, num_pts, vtxIndexToHandle, arrptr( data1 ), err );
CPPUNIT_ASSERT( !err );
// get tag data from all vertices and compare
myMesh->tag_get_vertex_data( tag, num_pts, vtxIndexToHandle, arrptr( data2 ), err );
CPPUNIT_ASSERT( !err );
for( iter1 = data1.begin(), iter2 = data2.begin(); iter1 != data1.end(); ++iter1, ++iter2 )
CPPUNIT_ASSERT_EQUAL( *iter1, *iter2 );
// destroy the tag
myMesh->tag_delete( tag, err );
CPPUNIT_ASSERT( !err );
tag2 = myMesh->tag_get( tagname, err );
CPPUNIT_ASSERT_EQUAL( err.error_code(), MsqError::TAG_NOT_FOUND );
err.clear();
}
| void iMeshTest::testElementConnectivity | ( | ) |
Definition at line 563 of file iMeshTest.cpp.
References CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, and triangleConnectivity.
{
MsqPrintError err( cout );
// const size_t num_pts = sizeof(vertexCoords) / (3*sizeof(double));
const size_t num_tri = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// get element connectivity list
std::vector< Mesh::VertexHandle > vertices;
std::vector< size_t > offsets;
myMesh->elements_get_attached_vertices( triIndexToHandle, num_tri, vertices, offsets, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( offsets.size(), num_tri + 1 );
CPPUNIT_ASSERT_EQUAL( vertices.size(), 3 * num_tri );
// check each element's connectivity
Mesh::VertexHandle elem_vertices[3];
for( size_t i = 0; i < num_tri; ++i )
{
// check that connectivity list contains three vertices
CPPUNIT_ASSERT_EQUAL( offsets[i] + 3, offsets[i + 1] );
// get list of vertex indices from connectivity data
for( size_t j = 0; j < 3; j++ )
{
size_t offset = offsets[i] + j;
CPPUNIT_ASSERT( offset < vertices.size() );
elem_vertices[j] = vertices[offset];
}
// compare connectivity
CPPUNIT_ASSERT( match_triangles( triangleConnectivity + 3 * i, elem_vertices ) );
}
}
| void iMeshTest::testElementTopology | ( | ) |
Definition at line 600 of file iMeshTest.cpp.
References CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, MBMesquite::TRIANGLE, and triangleConnectivity.
{
MsqPrintError err( cout );
const size_t num_tri = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
EntityTopology topo[num_tri];
myMesh->elements_get_topologies( triIndexToHandle, topo, num_tri, err );
CPPUNIT_ASSERT( !err );
for( size_t i = 0; i < num_tri; ++i )
CPPUNIT_ASSERT_EQUAL( topo[i], MBMesquite::TRIANGLE );
}
| void iMeshTest::testFixedFlag | ( | ) | [inline] |
Definition at line 138 of file iMeshTest.cpp.
References iBase_INTEGER.
{
testVertexFlag( true, iBase_INTEGER );
}
| void iMeshTest::testFixedFlagByte | ( | ) | [inline] |
Definition at line 146 of file iMeshTest.cpp.
References iBase_BYTES.
{
testVertexFlag( true, iBase_BYTES );
}
| void iMeshTest::testFixedFlagNone | ( | ) | [inline] |
Definition at line 154 of file iMeshTest.cpp.
{
testVertexFlagNone( true );
}
| void iMeshTest::testIntTag | ( | ) |
Definition at line 615 of file iMeshTest.cpp.
References MBMesquite::arrptr(), MBMesquite::MsqError::clear(), CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, MBMesquite::MsqError::error_code(), MBMesquite::Mesh::INT, MBMesquite::length(), MBMesquite::MsqError::TAG_NOT_FOUND, tagname, triangleConnectivity, and u.
{
const char* tagname = "TEST_TEST_INT_TAG";
MsqPrintError err( cout );
const size_t num_tri = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// create a tag
TagHandle tag = myMesh->tag_create( tagname, Mesh::INT, 2, NULL, err );
CPPUNIT_ASSERT( !err );
// get the tag
TagHandle tag2 = myMesh->tag_get( tagname, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( tag, tag2 );
// check tag metadata
string name;
Mesh::TagType type;
unsigned length;
myMesh->tag_properties( tag, name, type, length, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( name, std::string( tagname ) );
CPPUNIT_ASSERT_EQUAL( type, Mesh::INT );
CPPUNIT_ASSERT_EQUAL( length, 2u );
// set the tag on all triangles
std::vector< int > data1( 2 * num_tri ), data2( 2 * num_tri );
std::vector< int >::iterator iter1, iter2;
for( iter1 = data1.begin(); iter1 != data1.end(); ++iter1 )
*iter1 = rand();
myMesh->tag_set_element_data( tag, num_tri, triIndexToHandle, arrptr( data1 ), err );
CPPUNIT_ASSERT( !err );
// get tag data from all triangles and compare
myMesh->tag_get_element_data( tag, num_tri, triIndexToHandle, arrptr( data2 ), err );
CPPUNIT_ASSERT( !err );
for( iter1 = data1.begin(), iter2 = data2.begin(); iter1 != data1.end(); ++iter1, ++iter2 )
CPPUNIT_ASSERT_EQUAL( *iter1, *iter2 );
// destroy the tag
myMesh->tag_delete( tag, err );
CPPUNIT_ASSERT( !err );
tag2 = myMesh->tag_get( tagname, err );
CPPUNIT_ASSERT_EQUAL( err.error_code(), MsqError::TAG_NOT_FOUND );
err.clear();
}
| void iMeshTest::testSlavedFlag | ( | ) | [inline] |
Definition at line 142 of file iMeshTest.cpp.
References iBase_INTEGER.
{
testVertexFlag( false, iBase_INTEGER );
}
| void iMeshTest::testSlavedFlagByte | ( | ) | [inline] |
Definition at line 150 of file iMeshTest.cpp.
References iBase_BYTES.
{
testVertexFlag( false, iBase_BYTES );
}
| void iMeshTest::testSlavedFlagNone | ( | ) | [inline] |
Definition at line 158 of file iMeshTest.cpp.
{
testVertexFlagNone( false );
}
| void iMeshTest::testVertexAdjacency | ( | ) |
Definition at line 517 of file iMeshTest.cpp.
References CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, size, triangleConnectivity, and vertexCoords.
{
MsqPrintError err( cout );
const size_t num_pts = sizeof( vertexCoords ) / ( 3 * sizeof( double ) );
const size_t num_tri = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// construct adjacency list from input data to compare against
std::set< int > adjset[num_pts];
size_t i;
for( i = 0; i < num_tri; ++i )
for( size_t j = 3 * i; j < 3 * i + 3; ++j )
adjset[triangleConnectivity[j]].insert( i );
std::vector< Mesh::ElementHandle > elements;
std::vector< size_t > offsets;
myMesh->vertices_get_attached_elements( vtxIndexToHandle, num_pts, elements, offsets, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( offsets.size(), num_pts + 1 );
// compare connectivity for each vertex
for( i = 0; i < num_pts; ++i )
{
size_t count = offsets[i + 1] - offsets[i];
CPPUNIT_ASSERT_EQUAL( adjset[i].size(), count );
Mesh::ElementHandle* elems = &elements[offsets[i]];
for( size_t j = 0; j < count; ++j )
{
// Get element index from handle
Mesh::ElementHandle handle = elems[j];
std::map< Mesh::ElementHandle, int >::iterator idx = triHandleToIndex.find( handle );
CPPUNIT_ASSERT( idx != triHandleToIndex.end() );
// Find element index in vertex adjacency set
std::set< int >::iterator iter = adjset[i].find( idx->second );
CPPUNIT_ASSERT( iter != adjset[i].end() );
adjset[i].erase( iter );
}
// Make sure we got all the adjacent elements
CPPUNIT_ASSERT_EQUAL( (size_t)0, adjset[i].size() );
}
}
| void iMeshTest::testVertexByte | ( | ) |
Definition at line 377 of file iMeshTest.cpp.
References CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, and vertexCoords.
{
MsqPrintError err( cout );
const size_t num_pts = sizeof( vertexCoords ) / ( 3 * sizeof( double ) );
// check if initialized properly
CPPUNIT_ASSERT( myMesh );
// set each one individually
unsigned char bytes[num_pts];
size_t i;
for( i = 0; i < num_pts; ++i )
{
bytes[i] = (unsigned char)( rand() % 128 );
myMesh->vertex_set_byte( vtxIndexToHandle[i], bytes[i], err );
CPPUNIT_ASSERT( !err );
}
for( i = 0; i < num_pts; ++i )
{
unsigned char byte = 0;
myMesh->vertex_get_byte( vtxIndexToHandle[i], &byte, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT_EQUAL( byte, bytes[i] );
}
// set all at once
for( i = 0; i < num_pts; ++i )
bytes[i] = (unsigned char)( rand() % 128 );
myMesh->vertices_set_byte( vtxIndexToHandle, bytes, num_pts, err );
CPPUNIT_ASSERT( !err );
unsigned char bytes2[num_pts];
myMesh->vertices_get_byte( vtxIndexToHandle, bytes2, num_pts, err );
CPPUNIT_ASSERT( !err );
CPPUNIT_ASSERT( !memcmp( bytes, bytes2, num_pts ) );
}
| void iMeshTest::testVertexFlag | ( | bool | fixed, |
| iBase_TagValueType | type | ||
| ) |
Definition at line 444 of file iMeshTest.cpp.
References MBMesquite::arrptr(), ASSERT_NO_ERROR, CPPUNIT_ASSERT, CPPUNIT_ASSERT_EQUAL, fixed, iBase_BYTES, iBase_INTEGER, iBase_SUCCESS, ierr, iMesh_createTag, iMesh_setArrData, and iMesh_setIntArrData.
{
int ierr;
MsqPrintError err( cout );
iBase_TagHandle tag;
const char* name = fixed ? "fixed" : "slaved";
iMesh_createTag( myIMesh, name, 1, type, &tag, &ierr, strlen( name ) );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
if( fixed )
{
myMesh->set_fixed_tag( tag, err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT( NULL != myMesh->get_fixed_tag() );
CPPUNIT_ASSERT_EQUAL( tag, *( myMesh->get_fixed_tag() ) );
}
else
{
myMesh->set_slaved_tag( tag, err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT( NULL != myMesh->get_slaved_tag() );
CPPUNIT_ASSERT_EQUAL( tag, *( myMesh->get_slaved_tag() ) );
}
// get all vertices
std::vector< Mesh::VertexHandle > handles;
myMesh->get_all_vertices( handles, err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT( !handles.empty() );
iBase_EntityHandle* ihandles = reinterpret_cast< iBase_EntityHandle* >( arrptr( handles ) );
if( type == iBase_INTEGER )
{
// define alternating values for flag
std::vector< int > values( handles.size(), !fixed );
for( size_t i = 0; i < handles.size(); i += 2 )
values[i] = fixed;
// set flag on vertices
iMesh_setIntArrData( myIMesh, ihandles, handles.size(), tag, arrptr( values ), values.size(), &ierr );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
}
else if( type == iBase_BYTES )
{
// define alternating values for flag
std::vector< char > values( handles.size(), !fixed );
for( size_t i = 0; i < handles.size(); i += 2 )
values[i] = fixed;
// set flag on vertices
iMesh_setArrData( myIMesh, ihandles, handles.size(), tag, arrptr( values ), values.size(), &ierr );
CPPUNIT_ASSERT_EQUAL( (int)iBase_SUCCESS, ierr );
}
else
{
CPPUNIT_ASSERT( !"Unexpected tag data type in test code" );
}
// get flag through MsqIMesh
std::vector< bool > flags;
if( fixed )
myMesh->vertices_get_fixed_flag( arrptr( handles ), flags, handles.size(), err );
else
myMesh->vertices_get_slaved_flag( arrptr( handles ), flags, handles.size(), err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT_EQUAL( handles.size(), flags.size() );
// check flag values
for( size_t i = 0; i < handles.size(); ++i )
CPPUNIT_ASSERT_EQUAL( ( ( !( i % 2 ) ) == fixed ), (bool)flags[i] );
}
| void iMeshTest::testVertexFlagNone | ( | bool | fixed | ) |
Definition at line 413 of file iMeshTest.cpp.
References MBMesquite::arrptr(), ASSERT_NO_ERROR, b, CPPUNIT_ASSERT, and CPPUNIT_ASSERT_EQUAL.
{
if( fixed )
{
myMesh->clear_fixed_tag();
CPPUNIT_ASSERT( NULL == myMesh->get_fixed_tag() );
}
else
{
myMesh->clear_slaved_tag();
CPPUNIT_ASSERT( NULL == myMesh->get_slaved_tag() );
}
// get all vertices
MsqPrintError err( cout );
std::vector< Mesh::VertexHandle > handles;
myMesh->get_all_vertices( handles, err );
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT( !handles.empty() );
std::vector< bool > b( handles.size(), true );
if( fixed )
myMesh->vertices_get_fixed_flag( arrptr( handles ), b, handles.size(), err );
else
myMesh->vertices_get_slaved_flag( arrptr( handles ), b, handles.size(), err );
CPPUNIT_ASSERT_EQUAL( handles.size(), b.size() );
size_t first_true = std::find( b.begin(), b.end(), true ) - b.begin();
ASSERT_NO_ERROR( err );
CPPUNIT_ASSERT_EQUAL( handles.size(), first_true );
}
| void iMeshTest::testVertexIterator | ( | ) |
| bool iMeshTest::writeVtkFile | ( | const char * | name | ) | [private] |
Definition at line 169 of file iMeshTest.cpp.
References triangleConnectivity, and vertexCoords.
{
int i;
FILE* file = fopen( filename, "w" );
if( !file )
{
perror( filename );
return false;
}
fputs( "# vtk DataFile Version 2.0\n"
"Mesquite Mesh\n"
"ASCII\n"
"DATASET UNSTRUCTURED_GRID\n",
file );
const int num_pts = sizeof( vertexCoords ) / ( 3 * sizeof( double ) );
fprintf( file, "POINTS %d float\n", num_pts );
for( i = 0; i < num_pts; ++i )
fprintf( file, "%f %f %f\n", vertexCoords[3 * i], vertexCoords[3 * i + 1], vertexCoords[3 * i + 2] );
int num_tris = sizeof( triangleConnectivity ) / ( 3 * sizeof( int ) );
fprintf( file, "CELLS %d %d\n", num_tris, 4 * num_tris );
for( i = 0; i < num_tris; ++i )
fprintf( file, "3 %d %d %d\n", triangleConnectivity[3 * i], triangleConnectivity[3 * i + 1],
triangleConnectivity[3 * i + 2] );
fprintf( file, "CELL_TYPES %d\n", num_tris );
for( i = 0; i < num_tris; ++i )
fprintf( file, "5\n" );
fclose( file );
return true;
}
iMesh_Instance iMeshTest::myIMesh [private] |
Definition at line 115 of file iMeshTest.cpp.
MsqIMesh* iMeshTest::myMesh [private] |
Definition at line 114 of file iMeshTest.cpp.
map< Mesh::ElementHandle, int > iMeshTest::triHandleToIndex [private] |
Definition at line 120 of file iMeshTest.cpp.
Mesh::ElementHandle iMeshTest::triIndexToHandle[7] [private] |
Definition at line 118 of file iMeshTest.cpp.
map< Mesh::VertexHandle, int > iMeshTest::vtxHandleToIndex [private] |
Definition at line 119 of file iMeshTest.cpp.
Mesh::VertexHandle iMeshTest::vtxIndexToHandle[7] [private] |
Definition at line 117 of file iMeshTest.cpp.
1.7.6.1