stl_test.cpp

Go to the documentation of this file.

#include "TestUtil.hpp"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include <cmath>
#include <algorithm>
 
using namespace moab;
 
/* Input test file: test/sample.stl
 *
 * Example ASCII STL file from:
 * http://people.sc.fsu.edu/~burkardt/data/stla/stla.html
 */
#ifdef MESHDIR
static const char sample[] = STRINGIFY( MESHDIR ) "/io/sample.stl";
#else
static const char sample[] = "sample.stl";
#endif
 
// Use static keyword so that tmp_file can only be accessed within this file
static const char* tmp_file = "test.stl";
 
void test_read_ascii();
void test_write_ascii();
void test_type_option();
void test_detect_type();
void test_endian_option();
void test_big_endian();
void test_little_endian();
void test_detect_byte_order();
 
void read_file( Interface& moab, const char* input_file, const char* options = "" );
void convert_file( const char* source_file, const char* dest_file, const char* options = "" );
// check that the mesh constains the simple tetrahedron defined
// in test/sample.stl
void check_mesh_is_tet( Interface& moab );
 
int main()
{
 int result = 0;
 
 result += RUN_TEST( test_read_ascii );
 result += RUN_TEST( test_write_ascii );
 result += RUN_TEST( test_type_option );
 result += RUN_TEST( test_detect_type );
 result += RUN_TEST( test_endian_option );
 result += RUN_TEST( test_big_endian );
 result += RUN_TEST( test_little_endian );
 result += RUN_TEST( test_detect_byte_order );
 
 remove( tmp_file );
 return result;
}
 
ErrorCode read_file_( Interface& moab, const char* input_file, const char* options = "" )
{
 ErrorCode rval = moab.load_file( input_file, 0, options );
 return rval;
}
 
void read_file( Interface& moab, const char* input_file, const char* options )
{
 ErrorCode rval = read_file_( moab, input_file, options );CHECK_ERR( rval );
}
 
void convert_file( const char* input_file, const char* output_file, const char* options )
{
 ErrorCode rval;
 Core moab;
 
 rval = moab.load_file( input_file );CHECK_ERR( rval );
 
 rval = moab.write_file( output_file, "STL", options );CHECK_ERR( rval );
}
 
void test_read_ascii()
{
 Core moab;
 read_file( moab, sample, "ASCII" );
 check_mesh_is_tet( moab );
}
 
void test_write_ascii()
{
 convert_file( sample, tmp_file, "ASCII" );
 Core moab;
 read_file( moab, tmp_file, "ASCII" );
 remove( tmp_file );
 check_mesh_is_tet( moab );
}
 
void test_type_option()
{
 ErrorCode rval;
 Core moab;
 
 rval = read_file_( moab, sample, "BINARY" );
 CHECK( MB_SUCCESS != rval );
 
 convert_file( sample, tmp_file, "BINARY" );
 rval = read_file_( moab, tmp_file, "ASCII" );
 CHECK( MB_SUCCESS != rval );
 
 remove( tmp_file );
}
 
void test_detect_type()
{
 Core moab;
 
 read_file( moab, sample );
 
 convert_file( sample, tmp_file, "BINARY" );
 read_file_( moab, tmp_file );
 
 remove( tmp_file );
}
 
void test_endian_option()
{
 ErrorCode rval;
 Core moab;
 
 convert_file( sample, tmp_file, "BINARY;BIG_ENDIAN" );
 rval = read_file_( moab, tmp_file, "BINARY;LITTLE_ENDIAN" );
 CHECK( MB_SUCCESS != rval );
 
 convert_file( sample, tmp_file, "BINARY;LITTLE_ENDIAN" );
 rval = read_file_( moab, tmp_file, "BINARY;BIG_ENDIAN" );
 CHECK( MB_SUCCESS != rval );
 
 remove( tmp_file );
}
 
void test_big_endian()
{
 Core moab;
 convert_file( sample, tmp_file, "BINARY;BIG_ENDIAN" );
 read_file( moab, tmp_file, "BINARY;BIG_ENDIAN" );
 check_mesh_is_tet( moab );
 remove( tmp_file );
}
 
void test_little_endian()
{
 Core moab;
 convert_file( sample, tmp_file, "BINARY;LITTLE_ENDIAN" );
 read_file( moab, tmp_file, "BINARY;LITTLE_ENDIAN" );
 check_mesh_is_tet( moab );
 remove( tmp_file );
}
 
void test_detect_byte_order()
{
 Core moab;
 
 convert_file( sample, tmp_file, "BINARY;LITTLE_ENDIAN" );
 read_file( moab, tmp_file, "BINARY" );
 
 convert_file( sample, tmp_file, "BINARY;BIG_ENDIAN" );
 read_file( moab, tmp_file, "BINARY" );
 
 remove( tmp_file );
}
 
void check_mesh_is_tet( Interface& moab )
{
 ErrorCode rval;
 Range verts, tris, other;
 rval = moab.get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 rval = moab.get_entities_by_type( 0, MBTRI, tris );CHECK_ERR( rval );
 rval = moab.get_entities_by_handle( 0, other );CHECK_ERR( rval );
 
 CHECK_EQUAL( 4, (int)verts.size() );
 CHECK_EQUAL( 4, (int)tris.size() );
 other = subtract( other, verts );
 other = subtract( other, tris );
 CHECK( other.all_of_type( MBENTITYSET ) );
 
 const double expt_coords[4][3] = { { 0, 0, 0 }, { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
 EntityHandle vert_handles[4] = { 0, 0, 0, 0 };
 for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
 {
 double coords[3];
 rval = moab.get_coords( &*i, 1, coords );CHECK_ERR( rval );
 
 bool found = false;
 for( int j = 0; j < 4; ++j )
 {
 double ds = 0;
 for( int d = 0; d < 3; ++d )
 {
 double dl = expt_coords[j][d] - coords[d];
 ds += dl * dl;
 }
 
 if( ds < 1e-6 )
 {
 CHECK_EQUAL( (EntityHandle)0, vert_handles[j] );
 vert_handles[j] = *i;
 found = true;
 break;
 }
 }
 CHECK( found );
 }
 
 const int expt_conn[4][3] = { { 0, 1, 3 }, { 0, 2, 1 }, { 0, 3, 2 }, { 1, 2, 3 } };
 EntityHandle tri_handles[4] = { 0, 0, 0, 0 };
 for( Range::iterator i = tris.begin(); i != tris.end(); ++i )
 {
 const EntityHandle* conn = 0;
 int len = 0;
 rval = moab.get_connectivity( *i, conn, len );CHECK_ERR( rval );
 CHECK_EQUAL( 3, len );
 
 int conn_idx[3] = { static_cast< int >( std::find( vert_handles, vert_handles + 4, conn[0] ) - vert_handles ),
 static_cast< int >( std::find( vert_handles, vert_handles + 4, conn[1] ) - vert_handles ),
 static_cast< int >( std::find( vert_handles, vert_handles + 4, conn[2] ) - vert_handles ) };
 CHECK( conn_idx[0] != 4 );
 CHECK( conn_idx[1] != 4 );
 CHECK( conn_idx[2] != 4 );
 
 bool found = false;
 for( int j = 0; j < 4; ++j )
 {
 int k = std::find( expt_conn[j], expt_conn[j] + 3, conn_idx[0] ) - expt_conn[j];
 if( k == 3 ) continue;
 
 if( expt_conn[j][( k + 1 ) % 3] == conn_idx[1] && expt_conn[j][( k + 2 ) % 3] == conn_idx[2] )
 {
 CHECK_EQUAL( (EntityHandle)0, tri_handles[j] );
 tri_handles[j] = *i;
 found = true;
 break;
 }
 }
 CHECK( found );
 }
}