ReadSTL.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 ReadSTL
 * \brief ASCII and Binary Stereo Lithography File readers.
 * \author Jason Kraftcheck
 */

#include "ReadSTL.hpp"
#include "FileTokenizer.hpp"  // For FileTokenizer
#include "Internals.hpp"
#include "moab/Interface.hpp"
#include "moab/ReadUtilIface.hpp"
#include "moab/Range.hpp"
#include "moab/FileOptions.hpp"
#include "SysUtil.hpp"

#include <cerrno>
#include <cstring>
#include <climits>
#include <cassert>
#include <map>

namespace moab
{

ReadSTL::ReadSTL( Interface* impl ) : mdbImpl( impl )
{
    mdbImpl->query_interface( readMeshIface );
}

ReadSTL::~ReadSTL()
{
    if( readMeshIface )
    {
        mdbImpl->release_interface( readMeshIface );
        readMeshIface = NULL;
    }
}

// Used to put points in an STL tree-based container
bool ReadSTL::Point::operator<( const ReadSTL::Point& other ) const
{
    return 0 > memcmp( this, &other, sizeof( ReadSTL::Point ) );
}

ErrorCode ReadSTL::read_tag_values( const char* /* file_name */,
                                    const char* /* tag_name */,
                                    const FileOptions& /* opts */,
                                    std::vector< int >& /* tag_values_out */,
                                    const SubsetList* /* subset_list */ )
{
    return MB_NOT_IMPLEMENTED;
}

// Generic load function for both ASCII and binary. Calls
// pure-virtual function implemented in subclasses to read
// the data from the file.
ErrorCode ReadSTL::load_file( const char* filename,
                              const EntityHandle* /* file_set */,
                              const FileOptions& opts,
                              const ReaderIface::SubsetList* subset_list,
                              const Tag* file_id_tag )
{
    if( subset_list )
    {
        MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for STL" );
    }

    ErrorCode result;

    std::vector< ReadSTL::Triangle > triangles;

    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;

    if( is_ascii )
        result = ascii_read_triangles( filename, triangles );
    else if( is_binary )
        result = binary_read_triangles( filename, byte_order, triangles );
    else
    {
        // Try ASCII first
        result = ascii_read_triangles( filename, triangles );
        if( MB_SUCCESS != result )
            // ASCII failed, try binary
            result = binary_read_triangles( filename, byte_order, triangles );
    }
    if( MB_SUCCESS != result ) return result;

    // Create a std::map from position->handle, and such
    // that all positions are specified, and handles are zero.
    std::map< Point, EntityHandle > vertex_map;
    for( std::vector< Triangle >::iterator i = triangles.begin(); i != triangles.end(); ++i )
    {
        vertex_map[i->points[0]] = 0;
        vertex_map[i->points[1]] = 0;
        vertex_map[i->points[2]] = 0;
    }

    // Create vertices
    std::vector< double* > coord_arrays;
    EntityHandle vtx_handle = 0;
    result = readMeshIface->get_node_coords( 3, vertex_map.size(), MB_START_ID, vtx_handle, coord_arrays );
    if( MB_SUCCESS != result ) return result;

    // Copy vertex coordinates into entity sequence coordinate arrays
    // and copy handle into vertex_map.
    double *x = coord_arrays[0], *y = coord_arrays[1], *z = coord_arrays[2];
    for( std::map< Point, EntityHandle >::iterator i = vertex_map.begin(); i != vertex_map.end(); ++i )
    {
        i->second = vtx_handle;
        ++vtx_handle;
        *x = i->first.coords[0];
        ++x;
        *y = i->first.coords[1];
        ++y;
        *z = i->first.coords[2];
        ++z;
    }

    // Allocate triangles
    EntityHandle elm_handle = 0;
    EntityHandle* connectivity;
    result = readMeshIface->get_element_connect( triangles.size(), 3, MBTRI, MB_START_ID, elm_handle, connectivity );
    if( MB_SUCCESS != result ) return result;

    // Use vertex_map to recover triangle connectivity from
    // vertex coordinates.
    EntityHandle* conn_sav = connectivity;
    for( std::vector< Triangle >::iterator i = triangles.begin(); i != triangles.end(); ++i )
    {
        *connectivity = vertex_map[i->points[0]];
        ++connectivity;
        *connectivity = vertex_map[i->points[1]];
        ++connectivity;
        *connectivity = vertex_map[i->points[2]];
        ++connectivity;
    }

    // Notify MOAB of the new elements
    result = readMeshIface->update_adjacencies( elm_handle, triangles.size(), 3, conn_sav );
    if( MB_SUCCESS != result ) return result;

    if( file_id_tag )
    {
        Range vertices( vtx_handle, vtx_handle + vertex_map.size() - 1 );
        Range elements( elm_handle, elm_handle + triangles.size() - 1 );
        readMeshIface->assign_ids( *file_id_tag, vertices );
        readMeshIface->assign_ids( *file_id_tag, elements );
    }

    return MB_SUCCESS;
}

// Read ASCII file
ErrorCode ReadSTL::ascii_read_triangles( const char* name, std::vector< ReadSTL::Triangle >& tris )
{
    FILE* file = fopen( name, "r" );
    if( !file )
    {
        return MB_FILE_DOES_NOT_EXIST;
    }

    char header[81];
    if( !fgets( header, sizeof( header ), file ) ||  // Read header line
        strlen( header ) < 6 ||                      // Must be at least 6 chars
        header[strlen( header ) - 1] != '\n' ||      // Cannot exceed 80 chars
        memcmp( header, "solid", 5 ) ||              // Must begin with "solid"
        !isspace( header[5] ) )
    {  // Followed by a whitespace char
        fclose( file );
        return MB_FILE_WRITE_ERROR;
    }

    // Use tokenizer for remainder of parsing
    FileTokenizer tokens( file, readMeshIface );

    Triangle tri;
    float norm[3];

    // Read until end of file. If we reach "endsolid", read
    // was successful. If EOF before "endsolid", return error.
    for( ;; )
    {
        // Check for either another facet or the end of the list.
        const char* const expected[] = { "facet", "endsolid", 0 };
        switch( tokens.match_token( expected ) )
        {
            case 1:
                break;  // Found another facet
            case 2:
                return MB_SUCCESS;  // Found "endsolid" -- done
            default:
                return MB_FILE_WRITE_ERROR;  // Found something else, or EOF
        }

        if( !tokens.match_token( "normal" ) ||  // Expect "normal" keyword
            !tokens.get_floats( 3, norm ) ||    // Followed by normal vector
            !tokens.match_token( "outer" ) ||   // Followed by "outer loop"
            !tokens.match_token( "loop" ) )
            return MB_FILE_WRITE_ERROR;

        // For each of three triangle vertices
        for( int i = 0; i < 3; i++ )
        {
            if( !tokens.match_token( "vertex" ) || !tokens.get_floats( 3, tri.points[i].coords ) )
                return MB_FILE_WRITE_ERROR;
        }

        if( !tokens.match_token( "endloop" ) ||  // Facet ends with "endloop"
            !tokens.match_token( "endfacet" ) )  // and then "endfacet"
            return MB_FILE_WRITE_ERROR;

        tris.push_back( tri );
    }

    fclose( file );
    return MB_SUCCESS;
}

// Header block from binary STL file (84 bytes long)
struct BinaryHeader
{
    char comment[80];  // 80 byte comment string (null terminated?)
    uint32_t count;    // Number of triangles - 4 byte integer
};

// Triangle spec from file (50 bytes)
struct BinaryTri
{
    float normal[3];  // Normal as 3 4-byte little-endian IEEE floats
    float coords[9];  // Vertex coords as 9 4-byte little-endian IEEE floats
    char pad[2];
};

// Read a binary STL file
ErrorCode ReadSTL::binary_read_triangles( const char* name,
                                          ReadSTL::ByteOrder byte_order,
                                          std::vector< ReadSTL::Triangle >& tris )
{
    FILE* file = fopen( name, "rb" );
    if( !file )
    {
        return MB_FILE_DOES_NOT_EXIST;
    }

    // Read header block
    BinaryHeader header;
    if( fread( &header, 84, 1, file ) != 1 )
    {
        fclose( file );
        return MB_FILE_WRITE_ERROR;
    }

    // Allow user setting for byte order, default to little endian
    const bool want_big_endian = ( byte_order == STL_BIG_ENDIAN );
    const bool am_big_endian   = !SysUtil::little_endian();
    bool swap_bytes            = ( want_big_endian == am_big_endian );

    // Compare the number of triangles to the length of the file.
    // The file must contain an 80-byte description, a 4-byte
    // triangle count and 50 bytes per triangle.
    //
    // The triangle count *may* allow us to determine the byte order
    // of the file, if it is not an endian-symmetric value.
    //
    // We need to compare the expected size calculated from the triangle
    // count with the file size anyway, as an invalid file or a byte-
    // swapping issue could result in a very large (incorrect) value for
    // num_tri, resulting in a SEGFAULT.

    // Get expected number of triangles
    if( swap_bytes ) SysUtil::byteswap( &header.count, 1 );
    unsigned long num_tri = header.count;

    // Get the file length
    long filesize = SysUtil::filesize( file );
    if( filesize >= 0 )
    {  // -1 indicates could not determine file size (e.g. reading from FIFO)
        // Check file size, but be careful of numeric overflow
        if( ULONG_MAX / 50 - 84 < num_tri ||  // Next calc would have overflow
            84 + 50 * num_tri != (unsigned long)filesize )
        {
            // Unless the byte order was specified explicitly in the
            // tag, try the opposite byte order.
            uint32_t num_tri_tmp = header.count;
            SysUtil::byteswap( &num_tri_tmp, 1 );
            unsigned long num_tri_swap = num_tri_tmp;
            if( byte_order != STL_UNKNOWN_BYTE_ORDER ||  // If byte order was specified, fail now
                ULONG_MAX / 50 - 84 < num_tri_swap ||    // Watch for overflow in next line
                84 + 50 * num_tri_swap != (unsigned long)filesize )
            {
                fclose( file );
                return MB_FILE_WRITE_ERROR;
            }
            swap_bytes = !swap_bytes;
            num_tri    = num_tri_swap;
        }
    }

    // Allocate storage for triangles
    tris.resize( num_tri );

    // Read each triangle
    BinaryTri tri;  // Binary block read from file
    for( std::vector< Triangle >::iterator i = tris.begin(); i != tris.end(); ++i )
    {
        if( fread( &tri, 50, 1, file ) != 1 )
        {
            fclose( file );
            return MB_FILE_WRITE_ERROR;
        }

        if( swap_bytes ) SysUtil::byteswap( tri.coords, 9 );

        for( unsigned j = 0; j < 9; ++j )
            i->points[j / 3].coords[j % 3] = tri.coords[j];
    }

    fclose( file );
    return MB_SUCCESS;
}

ReaderIface* ReadSTL::factory( Interface* iface )
{
    return new ReadSTL( iface );
}

}  // namespace moab