WriteSTL.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.
 *
 */
 
/**
 * \class WriteSTL
 * \brief ASCII and Binary Stereo Lithography File writers.
 * \author Jason Kraftcheck
 */
 
#include "WriteSTL.hpp"
#include "moab/CN.hpp"
#include "moab/Interface.hpp"
#include "moab/Range.hpp"
#include "moab/WriteUtilIface.hpp"
#include "moab/FileOptions.hpp"
#include "SysUtil.hpp"
 
#include <cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include <cerrno>
#include <cmath>
#include <fcntl.h>
#include <climits>
 
namespace moab
{
 
#if defined( _MSC_VER ) || defined( __MINGW32__ ) /* windows */
#include <io.h>
#ifndef __MINGW32__
typedef unsigned __int32 uint32_t;
#endif
#else /* posix */
#include <unistd.h>
#define _S_IREAD ( S_IRUSR | S_IRGRP | S_IROTH )
#define _S_IWRITE ( S_IWUSR | S_IWGRP | S_IWOTH )
#endif
 
const int DEFAULT_PRECISION = 6;
 
WriterIface* WriteSTL::factory( Interface* iface )
{
 return new WriteSTL( iface );
}
 
WriteSTL::WriteSTL( Interface* impl ) : mbImpl( impl )
{
 impl->query_interface( mWriteIface );
}
 
WriteSTL::~WriteSTL()
{
 mbImpl->release_interface( mWriteIface );
}
 
ErrorCode WriteSTL::write_file( const char* file_name,
 const bool overwrite,
 const FileOptions& opts,
 const EntityHandle* ent_handles,
 const int num_sets,
 const std::vector< std::string >& qa_list,
 const Tag* tag_list,
 int num_tags,
 int /* export_dimension */ )
{
 char header[81];
 Range triangles;
 ErrorCode rval;
 
 if( tag_list && num_tags )
 {
 MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "STL file does not support tag data" );
 }
 
 rval = make_header( header, qa_list );
 if( MB_SUCCESS != rval ) return rval;
 
 rval = get_triangles( ent_handles, num_sets, triangles );
 if( MB_SUCCESS != rval ) return rval;
 
 if( triangles.empty() )
 {
 MB_SET_ERR( MB_ENTITY_NOT_FOUND, "No triangles to write" );
 }
 
 bool is_ascii = false, is_binary = false;
 if( MB_SUCCESS == opts.get_null_option( "ASCII" ) ) is_ascii = true;
 if( MB_SUCCESS == opts.get_null_option( "BINARY" ) ) is_binary = true;
 if( is_ascii && is_binary )
 {
 MB_SET_ERR( MB_FAILURE, "Conflicting options: BINARY ASCII" );
 }
 
 bool big_endian = false, little_endian = false;
 if( MB_SUCCESS == opts.get_null_option( "BIG_ENDIAN" ) ) big_endian = true;
 if( MB_SUCCESS == opts.get_null_option( "LITTLE_ENDIAN" ) ) little_endian = true;
 if( big_endian && little_endian )
 {
 MB_SET_ERR( MB_FAILURE, "Conflicting options: BIG_ENDIAN LITTLE_ENDIAN" );
 }
 ByteOrder byte_order = big_endian ? STL_BIG_ENDIAN : little_endian ? STL_LITTLE_ENDIAN : STL_UNKNOWN_BYTE_ORDER;
 
 FILE* file = open_file( file_name, overwrite, is_binary );
 if( !file ) return MB_FILE_DOES_NOT_EXIST;
 
 if( is_binary )
 rval = binary_write_triangles( file, header, byte_order, triangles );
 else
 {
 // Get precision for node coordinates
 int precision;
 if( MB_SUCCESS != opts.get_int_option( "PRECISION", precision ) ) precision = DEFAULT_PRECISION;
 
 rval = ascii_write_triangles( file, header, triangles, precision );
 }
 
 fclose( file );
 return rval;
}
 
FILE* WriteSTL::open_file( const char* name, bool overwrite, bool binary )
{
 // Open file with write access, and create it if it doesn't exist.
 int flags = O_WRONLY | O_CREAT;
 // Select behavior if the named file already exists. If
 // overwrite is true, truncate the file. If it is false,
 // make the call to open() fail.
 if( overwrite )
 flags |= O_TRUNC;
 else
 flags |= O_EXCL;
 // If platform defines a "binary" bit in the file access
 // flags (i.e. we're building on windows), then set it
 // if we're writing a binary file.
#ifdef O_BINARY
 if( binary ) flags |= O_BINARY;
#endif
 
 // Give everyone read and write, but not execute, permission.
 // These are not the final permissions for the file. Permissions
 // are removed according to the user's umask. All we want to
 // say here is that the executable bits should not be set because
 // this isn't an executable file. Everything else is a user
 // preference and should be left up to the umask.
 int creat_mode = _S_IREAD | _S_IWRITE;
 
 // Open the file.
 int fd = open( name, flags, creat_mode );
 if( fd < 0 )
 {
 MB_SET_ERR_RET_VAL( name << ": " << strerror( errno ), NULL );
 }
 FILE* result = fdopen( fd, binary ? "wb" : "w" );
 if( !result ) close( fd );
 
 return result;
}
 
ErrorCode WriteSTL::make_header( char header[81], const std::vector< std::string >& qa_list )
{
 memset( header, 0, 81 );
 
 std::string result;
 for( std::vector< std::string >::const_iterator i = qa_list.begin(); i != qa_list.end(); ++i )
 {
 result += " ";
 result += *i;
 }
 
 size_t len = result.size();
 if( len > 80 ) len = 80;
 memcpy( header, result.c_str(), len );
 
 return MB_SUCCESS;
}
 
ErrorCode WriteSTL::get_triangles( const EntityHandle* set_array, int set_array_length, Range& triangles )
{
 if( !set_array || 0 == set_array_length ) return mbImpl->get_entities_by_type( 0, MBTRI, triangles );
 
 const EntityHandle* iter = set_array;
 const EntityHandle* end = iter + set_array_length;
 for( ; iter != end; ++iter )
 {
 Range r;
 ErrorCode rval = mbImpl->get_entities_by_type( *iter, MBTRI, r, true );
 if( MB_SUCCESS != rval ) return rval;
 triangles.merge( r );
 }
 
 return MB_SUCCESS;
}
 
ErrorCode WriteSTL::get_triangle_data( const double coords[9], float v1[3], float v2[3], float v3[3], float n[3] )
{
 CartVect cv1, cv2, cv3, cn;
 ErrorCode rval = get_triangle_data( coords, cv1, cv2, cv3, cn );
 if( MB_SUCCESS != rval ) return rval;
 
 cv1.get( v1 );
 cv2.get( v2 );
 cv3.get( v3 );
 cn.get( n );
 
 return MB_SUCCESS;
}
 
ErrorCode WriteSTL::get_triangle_data( const double coords[9], CartVect& v1, CartVect& v2, CartVect& v3, CartVect& n )
{
 v1 = coords;
 v2 = coords + 3;
 v3 = coords + 6;
 
 n = ( v2 - v1 ) * ( v3 - v1 );
 
 n.normalize();
 
 return MB_SUCCESS;
}
 
ErrorCode WriteSTL::ascii_write_triangles( FILE* file, const char header[81], const Range& triangles, int prec )
{
 const char solid_name[] = "MOAB";
 
 char myheader[81] = "solid ";
 strcat( myheader, solid_name );
 strncat( myheader, header, 80 );
 
 if( EOF == fputs( myheader, file ) || EOF == fputs( "\n", file ) ) return MB_FILE_WRITE_ERROR;
 
 ErrorCode rval;
 double coords[9];
 CartVect v1, v2, v3, n;
 for( Range::const_iterator iter = triangles.begin(); iter != triangles.end(); ++iter )
 {
 const EntityHandle* conn;
 int num_vtx;
 
 rval = mbImpl->get_connectivity( *iter, conn, num_vtx );
 if( MB_SUCCESS != rval ) return rval;
 if( num_vtx != 3 ) return MB_FAILURE;
 
 rval = mbImpl->get_coords( conn, 3, coords );
 if( MB_SUCCESS != rval ) return rval;
 
 rval = get_triangle_data( coords, v1, v2, v3, n );
 if( MB_SUCCESS != rval ) return rval;
 
 fprintf( file, "facet normal %e %e %e\n", n[0], n[1], n[2] );
 fprintf( file, "outer loop\n" );
 fprintf( file, "vertex %.*e %.*e %.*e\n", prec, (float)v1[0], prec, (float)v1[1], prec, (float)v1[2] );
 fprintf( file, "vertex %.*e %.*e %.*e\n", prec, (float)v2[0], prec, (float)v2[1], prec, (float)v2[2] );
 fprintf( file, "vertex %.*e %.*e %.*e\n", prec, (float)v3[0], prec, (float)v3[1], prec, (float)v3[2] );
 fprintf( file, "endloop\n" );
 fprintf( file, "endfacet\n" );
 }
 
 fprintf( file, "endsolid %s\n", solid_name );
 return MB_SUCCESS;
}
 
struct BinTri
{
 float normal[3];
 float vertex1[3];
 float vertex2[3];
 float vertex3[3];
 char pad[2];
};
 
ErrorCode WriteSTL::binary_write_triangles( FILE* file,
 const char header[81],
 ByteOrder byte_order,
 const Range& triangles )
{
 ErrorCode rval;
 if( 1 != fwrite( header, 80, 1, file ) ) return MB_FILE_WRITE_ERROR;
 
 // Default to little endian if byte_order == UNKNOWN_BYTE_ORDER
 const bool want_big_endian = ( byte_order == STL_BIG_ENDIAN );
 const bool am_big_endian = !SysUtil::little_endian();
 const bool swap_bytes = ( want_big_endian == am_big_endian );
 
 if( triangles.size() > INT_MAX ) // Can't write that many triangles
 return MB_FAILURE;
 
 uint32_t count = (uint32_t)triangles.size();
 if( swap_bytes ) SysUtil::byteswap( &count, 1 );
 if( 1 != fwrite( &count, 4, 1, file ) ) return MB_FILE_WRITE_ERROR;
 
 double coords[9];
 BinTri tri;
 tri.pad[0] = tri.pad[1] = '\0';
 for( Range::const_iterator iter = triangles.begin(); iter != triangles.end(); ++iter )
 {
 const EntityHandle* conn;
 int num_vtx;
 
 rval = mbImpl->get_connectivity( *iter, conn, num_vtx );
 if( MB_SUCCESS != rval ) return rval;
 if( num_vtx != 3 ) return MB_FAILURE;
 
 rval = mbImpl->get_coords( conn, 3, coords );
 if( MB_SUCCESS != rval ) return rval;
 
 rval = get_triangle_data( coords, tri.vertex1, tri.vertex2, tri.vertex3, tri.normal );
 if( MB_SUCCESS != rval ) return rval;
 
 if( swap_bytes )
 {
 SysUtil::byteswap( tri.normal, 3 );
 SysUtil::byteswap( tri.vertex1, 3 );
 SysUtil::byteswap( tri.vertex2, 3 );
 SysUtil::byteswap( tri.vertex3, 3 );
 }
 
 if( 1 != fwrite( &tri, 50, 1, file ) ) return MB_FILE_WRITE_ERROR;
 }
 
 return MB_SUCCESS;
}
 
} // namespace moab