altimetry_file_reader.cpp

Go to the documentation of this file.

 
#include <cassert>
 
#include <boost/foreach.hpp>
#include <boost/exception/errinfo_file_name.hpp>
#include <boost/exception/errinfo_at_line.hpp>
#include <boost/exception/errinfo_errno.hpp>
 
#include "rply.h"
 
#include "altimetry_file_reader_impl.h"
 
// section with C linkage for RPLY callbacks
extern "C"
{
    static int vertex_cb(p_ply_argument argument);
    static int face_cb(p_ply_argument argument);
    static int material_cb(p_ply_argument argument);
    static void error_cb(p_ply ply, const char* message);
} // extern C
 
static const double NaN = std::numeric_limits<double>::quiet_NaN();
 
namespace tympan
{
 
//========== Implementation of free functions ==========
 
std::unique_ptr<IMeshReader> make_altimetry_ply_reader(const std::string filename)
{
    return std::unique_ptr<IMeshReader>(new AltimetryPLYReader(filename));
} // make_altimetry_ply_reader
 
//========== Implementation of AltimetryPLYReader methods ==========
 
AltimetryPLYReader::AltimetryPLYReader(const std::string filename)
    : _filename(filename), _ply(nullptr), _nvertices(-1), _nfaces(-1), _nmaterials(-1)
{
    // Opens the PLY file, no error callback is given
    _ply = ply_open(_filename.c_str(), ::error_cb, 0 /*unused*/, this);
    if (_ply == NULL)
        throw mesh_io_error("Opening PLY file") << tympan_source_loc << boost::errinfo_file_name(filename);
    // Reads the header
    if (!ply_read_header(_ply))
        throw mesh_io_error("Reading the PLY header")
            << tympan_source_loc << boost::errinfo_file_name(filename);
}
 
AltimetryPLYReader::~AltimetryPLYReader()
{
    ply_close(_ply);
}
 
void AltimetryPLYReader::read()
{
    setup_callbacks();
    init_data();
    read_data();
    build_material_by_face();
}
 
void AltimetryPLYReader::setup_callbacks()
{
    long n = 0;
    assert(_nvertices == -1 && _nfaces == -1);
    n = ply_set_read_cb(_ply, "vertex", "x", ::vertex_cb, this, X);
    _nvertices = n;
    n = ply_set_read_cb(_ply, "vertex", "y", ::vertex_cb, this, Y);
    assert(n == _nvertices);
    n = ply_set_read_cb(_ply, "vertex", "z", ::vertex_cb, this, Z);
    assert(n == _nvertices);
    n = ply_set_read_cb(_ply, "face", "vertex_indices", ::face_cb, this, VertexIndices);
    _nfaces = n;
    n = ply_set_read_cb(_ply, "face", "material_index", ::face_cb, this, MaterialIndex);
    assert(n == _nfaces);
    _nmaterials = ply_set_read_cb(_ply, "material", "id", ::material_cb, this, MaterialID);
}
 
void AltimetryPLYReader::init_data()
{
    _material_indices.resize(_nfaces, -1);
}
 
void AltimetryPLYReader::read_data()
{
    if (!ply_read(_ply))
        throw mesh_io_error("Reading the PLY data")
            << tympan_source_loc << boost::errinfo_file_name(_filename);
}
 
void AltimetryPLYReader::build_material_by_face()
{
    assert(_material_by_face.empty());
    assert(_material_indices.size() == _nfaces);
    assert(_faces.size() == _nfaces);
    BOOST_FOREACH (int material_index, _material_indices)
    {
        if (material_index == -1) // No material attributed
            _material_by_face.push_back("");
        else if (material_index < _nmaterials)
            _material_by_face.push_back(_materials[material_index]);
        else
            throw mesh_io_error("Invalid material index")
                << tympan_source_loc << boost::errinfo_file_name(_filename);
    }
    assert(_material_by_face.size() == _nfaces);
}
 
bool AltimetryPLYReader::vertex_cb(vertex_properties property, unsigned vertex_index, double value)
{
    switch (property)
    {
        case X:
            // Insert a new point
            _points.push_back(OPoint3D(NaN, NaN, NaN));
            // Deliberate fall-through
        case Y:
        case Z:
            // Store the coordinate
            // NB the numerical value of ``property`` is the index of the vertex
            assert(_points.size() - 1 == vertex_index); // Index consistency
            _points.back()._value[(unsigned)property] = value;
            break;
        default:
            return false;
    }
    return true;
}
 
bool AltimetryPLYReader::face_cb(face_properties property, unsigned face_index, unsigned nproperties,
                                 int property_index, double value)
{
    switch (property)
    {
        case VertexIndices:
            // Reading vertices index for the face, expected to be a triangle
            if (nproperties != 3)
            {
                // Should probably NOT raise a exception from within a C callback
                // TODO properly report, e.g. with an error status in the reader
                return false;
            }
            if (property_index == -1)
            {                         // RPLY is giving us the length
                assert(value == 3.0); // Value should be equal to length
                _faces.push_back(OTriangle(-1, -1, -1));
            }
            else
            {
                assert(property_index < 3);
                assert(_faces.size() - 1 == face_index); // Index consistency
                const unsigned vertex_index = (unsigned)value;
                OTriangle& triangle = _faces.back();
                triangle.index(property_index) = vertex_index;
                // Ensure consistency of the OTriangle redundant representation
                triangle.vertex(property_index) = _points[vertex_index];
            }
            break;
        case MaterialIndex:
            assert(_material_indices[face_index] == -1);
            _material_indices[face_index] = (unsigned)value;
            break;
        default:
            return false;
    }
    return true;
}
 
bool AltimetryPLYReader::material_cb(material_properties property, unsigned material_index,
                                     unsigned nproperties, int property_index, double value)
{
    switch (property)
    {
        case MaterialID:
            if (property_index == -1)
            {                                 // RPLY is giving us the length of the ID
                assert(value == nproperties); // Value should be equal to length
                _materials.push_back(std::string(nproperties, '-'));
            }
            else
            {
                assert((unsigned)property_index < nproperties);
                assert(_materials.size() - 1 == material_index); // Index consistency
                _materials.back()[property_index] = (unsigned char)value;
            }
            break;
        default:
            return false;
    }
    return true;
}
 
void AltimetryPLYReader::error_cb(p_ply ply, const char* message)
{
    assert(_ply == NULL || ply == _ply);
    throw mesh_io_error(message) << tympan_source_loc << boost::errinfo_file_name(_filename);
}
 
}; // namespace tympan
 
//========== C callback must be defined outside the namespace tympan ==========
 
using namespace tympan;
 
#define DECLARE_AND_FETCH_PLY_CALLBACK_INFO                                                                  \
    long idata;                                                                                              \
    void* pdata;                                                                                             \
    tympan::AltimetryPLYReader* p_reader;                                                                    \
    long instance_index;                                                                                     \
    p_ply_element element;                                                                                   \
    double value;                                                                                            \
    ply_get_argument_user_data(argument, &pdata, &idata);                                                    \
    p_reader = (tympan::AltimetryPLYReader*)pdata;                                                           \
    ply_get_argument_element(argument, &element, &instance_index);                                           \
    value = ply_get_argument_value(argument);
// END OF DECLARE_AND_FETCH_PLY_CALLBACK_INFO
 
static int vertex_cb(p_ply_argument argument)
{
    DECLARE_AND_FETCH_PLY_CALLBACK_INFO
    AltimetryPLYReader::vertex_properties vertex_property;
    assert(0 <= idata && idata < AltimetryPLYReader::NUM_vertex_properties);
    vertex_property = (AltimetryPLYReader::vertex_properties)idata;
    return p_reader->vertex_cb(vertex_property, instance_index, value);
}
 
static int face_cb(p_ply_argument argument)
{
    DECLARE_AND_FETCH_PLY_CALLBACK_INFO
    AltimetryPLYReader::face_properties face_property;
    assert(0 <= idata && idata < AltimetryPLYReader::NUM_face_properties);
    face_property = (AltimetryPLYReader::face_properties)idata;
    // Access to property list
    long length = 0, value_index = 0;
    p_ply_property property = nullptr;
    ply_get_argument_property(argument, &property, &length, &value_index);
    return p_reader->face_cb(face_property, instance_index, length, value_index, value);
}
 
static int material_cb(p_ply_argument argument)
{
    DECLARE_AND_FETCH_PLY_CALLBACK_INFO
    AltimetryPLYReader::material_properties material_property;
    assert(0 <= idata && idata < AltimetryPLYReader::NUM_material_properties);
    material_property = (AltimetryPLYReader::material_properties)idata;
    // Access to property list
    long length = 0, value_index = 0;
    p_ply_property property = nullptr;
    ply_get_argument_property(argument, &property, &length, &value_index);
    return p_reader->material_cb(material_property, instance_index, length, value_index, value);
}
 
static void error_cb(p_ply ply, const char* message)
{
    long idata = 0;
    void* pdata = nullptr;
    tympan::AltimetryPLYReader* p_reader = nullptr;
    if (ply)
    {
        ply_get_ply_user_data(ply, &pdata, &idata);
        p_reader = (tympan::AltimetryPLYReader*)pdata;
        p_reader->error_cb(ply, message);
    }
}