Pixyco-XYZ/openmesh
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Commit of the debugged version of Alex' improvement to OpenMesh. File i/o is now done via istream/ostream instances such that direct buffer writing to files (serialization) will also be possible in future releases.

Browse Source 
Code is tested.

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@221 fdac6126-5c0c-442c-9429-916003d36597
This commit is contained in:
Mike Kremer
2009-11-17 13:54:16 +00:00
parent 86b53bf930
commit efa67fbcfc
24 changed files with 512 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/OpenMesh/Core/IO/reader/BaseReader.hh
View File

@@ -110,6 +110,14 @@ public:
virtual bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt) = 0;
/** Reads a mesh given by a std::stream. This method usually uses the same stream reading method
that read uses. Options can be passed via _opt. After execution _opt contains the Options
that were available
*/
virtual bool read(std::istream& _is,
BaseImporter& _bi,
Options& _opt) = 0;
/// Returns true if reader can parse _filename (checks extension)

13
src/OpenMesh/Core/IO/reader/OBJReader.cc
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -112,7 +112,7 @@ read(const std::string& _filename, BaseImporter& _bi, Options& _opt)
{
std::fstream in( _filename.c_str(), std::ios_base::in );
if (!in)
if (!in.is_open() || !in.good())
{
omerr() << "[OBJReader] : cannot not open file "
<< _filename
@@ -137,7 +137,6 @@ read(const std::string& _filename, BaseImporter& _bi, Options& _opt)
return result;
}
//-----------------------------------------------------------------------------
bool
@@ -264,7 +263,7 @@ read_material(std::fstream& _in)
bool
_OBJReader_::
read(std::fstream& _in, BaseImporter& _bi, Options& _opt)
read(std::istream& _in, BaseImporter& _bi, Options& _opt)
{
omlog() << "[OBJReader] : read file\n";

14
src/OpenMesh/Core/IO/reader/OBJReader.hh
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -94,6 +94,10 @@ public:
BaseImporter& _bi,
Options& _opt);
bool read(std::istream& _in,
BaseImporter& _bi,
Options& _opt);
private:
#ifndef DOXY_IGNORE_THIS
@@ -163,8 +167,6 @@ private:
private:
bool read(std::fstream& _in, BaseImporter& _bi, Options& _opt);
std::string path_;
};

105
src/OpenMesh/Core/IO/reader/OFFReader.cc
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -57,6 +57,8 @@
#include <OpenMesh/Core/IO/SR_store.hh>
//STL
#include <iostream>
#include <ios>
#include <fstream>
#include <memory>
@@ -84,48 +86,55 @@ _OFFReader_& OFFReader() { return __OFFReaderInstance; }
_OFFReader_::_OFFReader_()
{
IOManager().register_module(this);
_OFFReader_::_OFFReader_()
{
IOManager().register_module(this);
}
//-----------------------------------------------------------------------------
bool
_OFFReader_::read(const std::string& _filename, BaseImporter& _bi,
bool
_OFFReader_::read(const std::string& _filename, BaseImporter& _bi,
Options& _opt)
{
std::fstream in(_filename.c_str(), (options_.is_binary() ? std::ios_base::binary | std::ios_base::in
: std::ios_base::in) );
std::ifstream ifile(_filename.c_str(), (options_.is_binary() ? std::ios::binary | std::ios::in
: std::ios::in) );
if (!in)
if (!ifile.is_open() || !ifile.good())
{
omerr() << "[OFFReader] : cannot not open file "
omerr() << "[OFFReader] : cannot not open file "
<< _filename
<< std::endl;
return false;
}
assert(ifile);
bool result = read(in, _bi, _opt);
bool result = read(ifile, _bi, _opt);
in.close();
ifile.close();
return result;
}
//-----------------------------------------------------------------------------
bool
_OFFReader_::read(std::fstream& _in, BaseImporter& _bi, Options& _opt ) const
bool
_OFFReader_::read(std::istream& _in, BaseImporter& _bi, Options& _opt )
{
if (!_in.good())
{
omerr() << "[OMReader] : cannot not use stream "
<< std::endl;
return false;
}
// filter relevant options for reading
bool swap = _opt.check( Options::Swap );
userOptions_ = _opt;
@@ -152,13 +161,13 @@ _OFFReader_::read(std::fstream& _in, BaseImporter& _bi, Options& _opt ) const
//-----------------------------------------------------------------------------
bool
_OFFReader_::read_ascii(std::fstream& _in, BaseImporter& _bi) const
bool
_OFFReader_::read_ascii(std::istream& _in, BaseImporter& _bi) const
{
omlog() << "[OFFReader] : read ascii file\n";
unsigned int i, j, k, l, idx;
unsigned int nV, nF, dummy;
OpenMesh::Vec3f v, n;
@@ -186,9 +195,9 @@ omlog() << "[OFFReader] : read ascii file\n";
{
// Always read VERTEX
_in >> v[0]; _in >> v[1]; _in >> v[2];
vh = _bi.add_vertex(v);
//perhaps read NORMAL
if ( options_.vertex_has_normal() ){
@@ -236,7 +245,7 @@ omlog() << "[OFFReader] : read ascii file\n";
_bi.set_color( vh, color_cast<Vec4uc, Vec4f>(c4f) );
break;
default:
default:
std::cerr << "Error in file format (colorType = " << colorType << ")\n";
}
}
@@ -266,7 +275,7 @@ omlog() << "[OFFReader] : read ascii file\n";
vhandles[1] = VertexHandle(k);
vhandles[2] = VertexHandle(l);
}
else
else
{
vhandles.clear();
for (j=0; j<nV; ++j)
@@ -275,7 +284,7 @@ omlog() << "[OFFReader] : read ascii file\n";
vhandles.push_back(VertexHandle(idx));
}
}
FaceHandle fh = _bi.add_face(vhandles);
//perhaps read face COLOR
@@ -287,7 +296,7 @@ omlog() << "[OFFReader] : read ascii file\n";
int colorType = getColorType(line, false );
std::stringstream stream( line );
std::stringstream stream( line );
std::string trash;
@@ -316,7 +325,7 @@ omlog() << "[OFFReader] : read ascii file\n";
_bi.set_color( fh, color_cast<Vec4uc, Vec4f>(c4f) );
break;
default:
default:
std::cerr << "Error in file format (colorType = " << colorType << ")\n";
}
}
@@ -369,7 +378,7 @@ int _OFFReader_::getColorType(std::string& _line, bool _texCoordsAvailable) cons
//get first item
found = _line.find(" ");
std::string c1 = _line.substr (0,found);
if (c1.find(".") != std::string::npos){
if (count == 3)
count = 5;
@@ -380,32 +389,32 @@ int _OFFReader_::getColorType(std::string& _line, bool _texCoordsAvailable) cons
return count;
}
void _OFFReader_::readValue(std::fstream& _in, float& _value) const{
void _OFFReader_::readValue(std::istream& _in, float& _value) const{
float32_t tmp;
restore( _in , tmp, false ); //assuming LSB byte order
_value = tmp;
}
void _OFFReader_::readValue(std::fstream& _in, int& _value) const{
void _OFFReader_::readValue(std::istream& _in, int& _value) const{
uint32_t tmp;
restore( _in , tmp, false ); //assuming LSB byte order
_value = tmp;
}
void _OFFReader_::readValue(std::fstream& _in, unsigned int& _value) const{
void _OFFReader_::readValue(std::istream& _in, unsigned int& _value) const{
uint32_t tmp;
restore( _in , tmp, false ); //assuming LSB byte order
_value = tmp;
}
bool
_OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) const
bool
_OFFReader_::read_binary(std::istream& _in, BaseImporter& _bi, bool /*_swap*/) const
{
omlog() << "[OFFReader] : read binary file\n";
unsigned int i, j, k, l, idx;
unsigned int nV, nF, dummy;
OpenMesh::Vec3f v, n;
@@ -426,16 +435,16 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
_bi.reserve(nV, 3*nV, nF);
// read vertices: coord [hcoord] [normal] [color] [texcoord]
// read vertices: coord [hcoord] [normal] [color] [texcoord]
for (i=0; i<nV && !_in.eof(); ++i)
{
// Always read Vertex
readValue(_in, v[0]);
readValue(_in, v[1]);
readValue(_in, v[2]);
vh = _bi.add_vertex(v);
if ( options_.vertex_has_normal() ) {
readValue(_in, n[0]);
readValue(_in, n[1]);
@@ -444,7 +453,7 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
if ( userOptions_.vertex_has_normal() )
_bi.set_normal(vh, n);
}
if ( options_.vertex_has_color() ) {
//with alpha
if ( options_.color_has_alpha() ){
@@ -465,7 +474,7 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
_bi.set_color( vh, Vec3uc( c ) );
}
}
if ( options_.vertex_has_texcoord()) {
readValue(_in, t[0]);
readValue(_in, t[1]);
@@ -474,7 +483,7 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
_bi.set_texcoord(vh, t);
}
}
// faces
// #N <v1> <v2> .. <v(n-1)> [color spec]
// So far color spec is unsupported!
@@ -494,7 +503,7 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
vhandles[1] = VertexHandle(k);
vhandles[2] = VertexHandle(l);
}
else
else
{
vhandles.clear();
for (j=0; j<nV; ++j)
@@ -503,7 +512,7 @@ _OFFReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) c
vhandles.push_back(VertexHandle(idx));
}
}
FaceHandle fh = _bi.add_face(vhandles);
//face color
@@ -550,7 +559,7 @@ bool _OFFReader_::can_u_read(const std::string& _filename) const
{
ifs.close();
return true;
}
}
}
return false;
}
@@ -558,7 +567,7 @@ bool _OFFReader_::can_u_read(const std::string& _filename) const
//-----------------------------------------------------------------------------
bool _OFFReader_::can_u_read(std::istream& _is) const
{
options_.cleanup();
@@ -589,7 +598,7 @@ bool _OFFReader_::can_u_read(std::istream& _is) const
if ( ( remainingChars > 0 ) && ( p[0] == 'n') )
{ vertexDimensionTooHigh = true; ++p; --remainingChars; }
if ( ( remainingChars < 3 ) || (!(p[0] == 'O' && p[1] == 'F' && p[2] == 'F') ) )
return false;

35
src/OpenMesh/Core/IO/reader/OFFReader.hh
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -83,8 +83,8 @@ class BaseImporter;
//== IMPLEMENTATION ===========================================================
/**
Implementation of the OFF format reader. This class is singleton'ed by
/**
Implementation of the OFF format reader. This class is singleton'ed by
SingletonT to OFFReader.
By passing Options to the read function you can manipulate the reading behavoir.
@@ -123,29 +123,28 @@ public:
std::string get_description() const { return "Object File Format"; }
std::string get_extensions() const { return "off"; }
std::string get_magic() const { return "OFF"; }
bool read(const std::string& _filename,
BaseImporter& _bi,
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
bool can_u_read(const std::string& _filename) const;
bool read(std::istream& _in, BaseImporter& _bi, Options& _opt );
private:
bool can_u_read(std::istream& _is) const;
bool read(std::fstream& _in, BaseImporter& _bi, Options& _opt ) const;
bool read_ascii(std::fstream& _in, BaseImporter& _bi) const;
bool read_binary(std::fstream& _in, BaseImporter& _bi, bool swap) const;
void readValue(std::fstream& _in, float& _value) const;
void readValue(std::fstream& _in, int& _value) const;
void readValue(std::fstream& _in, unsigned int& _value) const;
bool read_ascii(std::istream& _in, BaseImporter& _bi) const;
bool read_binary(std::istream& _in, BaseImporter& _bi, bool swap) const;
void readValue(std::istream& _in, float& _value) const;
void readValue(std::istream& _in, int& _value) const;
void readValue(std::istream& _in, unsigned int& _value) const;
int getColorType(std::string & _line, bool _texCoordsAvailable) const;
//available options for reading
mutable Options options_;
//options that the user wants to read

172
src/OpenMesh/Core/IO/reader/OMReader.cc
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -75,15 +75,15 @@ _OMReader_& OMReader() { return __OMReaderInstance; }
_OMReader_::_OMReader_()
{
IOManager().register_module(this);
IOManager().register_module(this);
}
//-----------------------------------------------------------------------------
bool
_OMReader_::read(const std::string& _filename,
bool
_OMReader_::read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt)
{
@@ -95,42 +95,58 @@ _OMReader_::read(const std::string& _filename,
// Open file
std::ifstream ifs( _filename.c_str(), std::ios::binary );
if (!ifs.is_open())
if (!ifs.is_open() || !ifs.good())
{
omerr() << "[OMReader] : cannot not open file "
omerr() << "[OMReader] : cannot not open file "
<< _filename
<< std::endl;
return false;
}
// Pass stream to read method, remember result
bool result = read(ifs, _bi, _opt);
// close input stream
ifs.close();
return result;
}
//-----------------------------------------------------------------------------
bool
_OMReader_::read(std::istream& _is,
BaseImporter& _bi,
Options& _opt)
{
// check whether importer can give us an OpenMesh BaseKernel
if (!_bi.kernel()) return false;
_opt += Options::Binary; // only binary format supported!
if (!_is.good())
{
omerr() << "[OMReader] : cannot read from stream "
<< std::endl;
return false;
}
// Pass stream to read method, remember result
bool result = read_binary(_is, _bi, _opt);
if(result) _opt += Options::Binary;
return result;
}
//-----------------------------------------------------------------------------
bool
_OMReader_::read(std::istream& _is, BaseImporter& _bi, Options& _opt ) const
{
// currently only binary file format is supported
_opt += Options::Binary;
return read_binary( _is, _bi, _opt );
}
//-----------------------------------------------------------------------------
bool
_OMReader_::read_ascii( std::istream& /* _is */, BaseImporter& /* _bi */,
bool
_OMReader_::read_ascii( std::istream& /* _is */, BaseImporter& /* _bi */,
Options& /* _opt */) const
{
// not supported yet!
@@ -140,14 +156,14 @@ _OMReader_::read_ascii( std::istream& /* _is */, BaseImporter& /* _bi */,
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary( std::istream& _is, BaseImporter& _bi,
bool
_OMReader_::read_binary( std::istream& _is, BaseImporter& _bi,
Options& _opt) const
{
bool swap = _opt.check(Options::Swap) || (Endian::local() == Endian::MSB);
// intialize byte counter
bytes_ = 0;
bytes_ = 0;
bytes_ += restore( _is, header_, swap );
@@ -172,7 +188,7 @@ _OMReader_::read_binary( std::istream& _is, BaseImporter& _bi,
data_bytes = bytes_;
switch( chunk_header_.entity_ )
{
case OMFormat::Chunk::Entity_Vertex:
case OMFormat::Chunk::Entity_Vertex:
if (!read_binary_vertex_chunk( _is, _bi, _opt, swap ))
return false;
break;
@@ -214,13 +230,13 @@ _OMReader_::can_u_read(const std::string& _filename) const
{
std::ifstream ifile( _filename.c_str() );
if ( ifile && can_u_read( ifile ) )
return true;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
bool
_OMReader_::can_u_read(std::istream& _is) const
{
@@ -231,7 +247,7 @@ _OMReader_::can_u_read(std::istream& _is) const
while( evt.size() < 4 )
evt.push_back( static_cast<char>(_is.get()) );
// put back all read characters
// put back all read characters
std::vector<char>::reverse_iterator it = evt.rbegin();
while (it != evt.rend() )
_is.putback( *it++ );
@@ -254,14 +270,14 @@ _OMReader_::can_u_read(std::istream& _is) const
default: // ?
return false;
}
// 4th characters encodes the version
return supports( hdr->version_ );
}
//-----------------------------------------------------------------------------
bool
bool
_OMReader_::supports( const OMFormat::uint8 /* version */ ) const
{
return true;
@@ -270,16 +286,16 @@ _OMReader_::supports( const OMFormat::uint8 /* version */ ) const
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary_vertex_chunk( std::istream &_is,
BaseImporter &_bi,
bool
_OMReader_::read_binary_vertex_chunk( std::istream &_is,
BaseImporter &_bi,
Options &_opt,
bool _swap) const
{
using OMFormat::Chunk;
assert( chunk_header_.entity_ == Chunk::Entity_Vertex );
OpenMesh::Vec3f v3f;
OpenMesh::Vec2f v2f;
OpenMesh::Vec3uc v3uc; // rgb
@@ -290,7 +306,7 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
switch (chunk_header_.type_)
{
case Chunk::Type_Pos:
assert( OMFormat::dimensions(chunk_header_)
assert( OMFormat::dimensions(chunk_header_)
== size_t(OpenMesh::Vec3f::dim()) );
for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx)
@@ -300,9 +316,9 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
}
break;
case Chunk::Type_Normal:
assert( OMFormat::dimensions(chunk_header_)
assert( OMFormat::dimensions(chunk_header_)
== size_t(OpenMesh::Vec3f::dim()) );
_opt += Options::VertexNormal;
@@ -313,9 +329,9 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
}
break;
case Chunk::Type_Texcoord:
assert( OMFormat::dimensions(chunk_header_)
assert( OMFormat::dimensions(chunk_header_)
== size_t(OpenMesh::Vec2f::dim()) );
_opt += Options::VertexTexCoord;
@@ -324,14 +340,14 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
bytes_ += vector_restore( _is, v2f, _swap );
_bi.set_texcoord(VertexHandle(vidx), v2f);
}
break;
break;
case Chunk::Type_Color:
assert( OMFormat::dimensions(chunk_header_) == 3 );
_opt += Options::VertexColor;
for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx)
{
bytes_ += vector_restore( _is, v3uc, _swap );
@@ -340,8 +356,8 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
break;
case Chunk::Type_Custom:
bytes_ +=
bytes_ +=
restore_binary_custom_data( _is,
_bi.kernel()->_get_vprop( property_name_ ),
header_.n_vertices_,
@@ -354,7 +370,7 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
default: // skip unknown chunks
{
omerr() << "Unknown chunk type ignored!\n";
size_t size_of = header_.n_vertices_
size_t size_of = header_.n_vertices_
* OMFormat::vector_size(chunk_header_);
_is.ignore( size_of );
bytes_ += size_of;
@@ -369,8 +385,8 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is,
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary_face_chunk( std::istream &_is,
BaseImporter &_bi,
_OMReader_::read_binary_face_chunk( std::istream &_is,
BaseImporter &_bi,
Options &_opt,
bool _swap ) const
{
@@ -395,7 +411,7 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
case 'T': nV = 3; break;
case 'Q': nV = 4; break;
}
for (; fidx < header_.n_faces_; ++fidx)
{
if ( header_.mesh_ == 'P' )
@@ -403,8 +419,8 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
vhandles.clear();
for (size_t j=0; j<nV; ++j)
{
bytes_ += restore( _is, vidx,
{
bytes_ += restore( _is, vidx,
Chunk::Integer_Size(chunk_header_.bits_),
_swap );
@@ -418,7 +434,7 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
case Chunk::Type_Normal:
assert( OMFormat::dimensions(chunk_header_)
assert( OMFormat::dimensions(chunk_header_)
== size_t(OpenMesh::Vec3f::dim()) );
_opt += Options::FaceNormal;
@@ -434,7 +450,7 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
assert( OMFormat::dimensions(chunk_header_) == 3 );
_opt += Options::FaceColor;
_opt += Options::FaceColor;
for (; fidx < header_.n_faces_ && !_is.eof(); ++fidx)
{
bytes_ += vector_restore( _is, v3uc, _swap );
@@ -444,8 +460,8 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
case Chunk::Type_Custom:
bytes_ +=
bytes_ +=
restore_binary_custom_data( _is,
_bi.kernel()->_get_fprop( property_name_ ),
header_.n_faces_,
@@ -454,13 +470,13 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
fidx = header_.n_faces_;
break;
default: // skip unknown chunks
{
omerr() << "Unknown chunk type ignore!\n";
size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_);
_is.ignore( size_of );
bytes_ += size_of;
bytes_ += size_of;
}
}
return fidx == header_.n_faces_;
@@ -470,8 +486,8 @@ _OMReader_::read_binary_face_chunk( std::istream &_is,
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary_edge_chunk( std::istream &_is,
BaseImporter &_bi,
_OMReader_::read_binary_edge_chunk( std::istream &_is,
BaseImporter &_bi,
Options &/*_opt */,
bool _swap ) const
{
@@ -483,9 +499,9 @@ _OMReader_::read_binary_edge_chunk( std::istream &_is,
switch( chunk_header_.type_ )
{
case Chunk::Type_Custom:
case Chunk::Type_Custom:
bytes_ +=
bytes_ +=
restore_binary_custom_data( _is,
_bi.kernel()->_get_eprop( property_name_ ),
header_.n_edges_,
@@ -507,8 +523,8 @@ _OMReader_::read_binary_edge_chunk( std::istream &_is,
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary_halfedge_chunk( std::istream &_is,
BaseImporter &_bi,
_OMReader_::read_binary_halfedge_chunk( std::istream &_is,
BaseImporter &_bi,
Options &/* _opt */,
bool _swap ) const
{
@@ -522,11 +538,11 @@ _OMReader_::read_binary_halfedge_chunk( std::istream &_is,
{
case Chunk::Type_Custom:
bytes_ +=
bytes_ +=
restore_binary_custom_data( _is,
_bi.kernel()->_get_hprop( property_name_ ),
2*header_.n_edges_,
_swap );
_swap );
break;
default:
@@ -544,8 +560,8 @@ _OMReader_::read_binary_halfedge_chunk( std::istream &_is,
//-----------------------------------------------------------------------------
bool
_OMReader_::read_binary_mesh_chunk( std::istream &_is,
BaseImporter &_bi,
_OMReader_::read_binary_mesh_chunk( std::istream &_is,
BaseImporter &_bi,
Options & /* _opt */,
bool _swap ) const
{
@@ -558,13 +574,13 @@ _OMReader_::read_binary_mesh_chunk( std::istream &_is,
switch( chunk_header_.type_ )
{
case Chunk::Type_Custom:
bytes_ +=
bytes_ +=
restore_binary_custom_data( _is,
_bi.kernel()->_get_mprop( property_name_ ),
1,
_swap );
break;
default:
@@ -581,10 +597,10 @@ _OMReader_::read_binary_mesh_chunk( std::istream &_is,
//-----------------------------------------------------------------------------
size_t
size_t
_OMReader_::restore_binary_custom_data( std::istream& _is, BaseProperty* _bp,
size_t _n_elem, bool _swap) const
{
{
assert( !_bp || (_bp->name() == property_name_) );
using OMFormat::Chunk;
@@ -605,7 +621,7 @@ _OMReader_::restore_binary_custom_data( std::istream& _is, BaseProperty* _bp,
if ( ((n_bytes == BaseProperty::UnknownSize) || (n_bytes == block_size)) &&
(_bp->element_size() == BaseProperty::UnknownSize ||
(_n_elem * _bp->element_size() == block_size) ) )
(_n_elem * _bp->element_size() == block_size) ) )
{
#if defined(OM_DEBUG)
bytes += (b=_bp->restore( _is, _swap ));
@@ -621,7 +637,7 @@ _OMReader_::restore_binary_custom_data( std::istream& _is, BaseProperty* _bp,
}
else
{
omerr() << "Warning! Property " << _bp->name() << " not loaded: "
omerr() << "Warning! Property " << _bp->name() << " not loaded: "
<< "Mismatching data sizes!n";
}
}

6
src/OpenMesh/Core/IO/reader/OMReader.hh
View File

@@ -95,6 +95,11 @@ public:
BaseImporter& _bi,
Options& _opt );
//! Stream Reader for std::istream input in binary format
bool read(std::istream& _is,
BaseImporter& _bi,
Options& _opt );
virtual bool can_u_read(const std::string& _filename) const;
virtual bool can_u_read(std::istream& _is) const;
@@ -103,7 +108,6 @@ private:
bool supports( const OMFormat::uint8 version ) const;
bool read(std::istream& _is, BaseImporter& _bi, Options& _opt ) const;
bool read_ascii(std::istream& _is, BaseImporter& _bi, Options& _opt) const;
bool read_binary(std::istream& _is, BaseImporter& _bi, Options& _opt) const;

23
src/OpenMesh/Core/IO/reader/PLYReader.cc
View File

@@ -87,10 +87,11 @@ _PLYReader_::_PLYReader_() {
bool _PLYReader_::read(const std::string& _filename, BaseImporter& _bi, Options& _opt) {
std::fstream in(_filename.c_str(), (options_.is_binary() ? std::ios_base::binary | std::ios_base::in
: std::ios_base::in));
if (!in) {
if (!in.is_open() || !in.good()) {
omerr() << "[PLYReader] : cannot not open file " << _filename << std::endl;
return false;
}
@@ -104,7 +105,13 @@ bool _PLYReader_::read(const std::string& _filename, BaseImporter& _bi, Options&
//-----------------------------------------------------------------------------
bool _PLYReader_::read(std::fstream& _in, BaseImporter& _bi, Options& _opt) const {
bool _PLYReader_::read(std::istream& _in, BaseImporter& _bi, Options& _opt) {
if (!_in.good()) {
omerr() << "[PLYReader] : cannot not use stream" << std::endl;
return false;
}
// filter relevant options for reading
bool swap = _opt.check(Options::Swap);
@@ -137,9 +144,11 @@ bool _PLYReader_::read(std::fstream& _in, BaseImporter& _bi, Options& _opt) cons
}
//-----------------------------------------------------------------------------
bool _PLYReader_::read_ascii(std::fstream& _in, BaseImporter& _bi) const {
bool _PLYReader_::read_ascii(std::istream& _in, BaseImporter& _bi) const {
omlog() << "[PLYReader] : read ascii file\n";
@@ -269,7 +278,7 @@ bool _PLYReader_::read_ascii(std::fstream& _in, BaseImporter& _bi) const {
//-----------------------------------------------------------------------------
bool _PLYReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap*/) const {
bool _PLYReader_::read_binary(std::istream& _in, BaseImporter& _bi, bool /*_swap*/) const {
omlog() << "[PLYReader] : read binary file format\n";
@@ -394,7 +403,7 @@ bool _PLYReader_::read_binary(std::fstream& _in, BaseImporter& _bi, bool /*_swap
//-----------------------------------------------------------------------------
void _PLYReader_::readValue(ValueType _type, std::fstream& _in, float& _value) const {
void _PLYReader_::readValue(ValueType _type, std::istream& _in, float& _value) const {
switch (_type) {
case ValueTypeFLOAT32:
@@ -410,7 +419,7 @@ void _PLYReader_::readValue(ValueType _type, std::fstream& _in, float& _value) c
}
}
void _PLYReader_::readValue(ValueType _type, std::fstream& _in, unsigned int& _value) const {
void _PLYReader_::readValue(ValueType _type, std::istream& _in, unsigned int& _value) const {
int32_t tmp_int32_t;
uint8_t tmp_uchar;
@@ -432,7 +441,7 @@ void _PLYReader_::readValue(ValueType _type, std::fstream& _in, unsigned int& _v
}
}
void _PLYReader_::readValue(ValueType _type, std::fstream& _in, int& _value) const {
void _PLYReader_::readValue(ValueType _type, std::istream& _in, int& _value) const {
int32_t tmp_int32_t;
uint8_t tmp_uchar;

15
src/OpenMesh/Core/IO/reader/PLYReader.hh
View File

@@ -103,6 +103,10 @@ public:
BaseImporter& _bi,
Options& _opt);
bool read(std::istream& _is,
BaseImporter& _bi,
Options& _opt);
bool can_u_read(const std::string& _filename) const;
enum ValueType {
@@ -116,15 +120,14 @@ private:
bool can_u_read(std::istream& _is) const;
bool read(std::fstream& _in, BaseImporter& _bi, Options& _opt ) const;
bool read_ascii(std::fstream& _in, BaseImporter& _bi) const;
bool read_binary(std::fstream& _in, BaseImporter& _bi, bool swap) const;
bool read_ascii(std::istream& _in, BaseImporter& _bi) const;
bool read_binary(std::istream& _in, BaseImporter& _bi, bool swap) const;
float readToFloatValue(ValueType _type , std::fstream& _in) const;
void readValue(ValueType _type , std::fstream& _in, float& _value) const;
void readValue(ValueType _type , std::fstream& _in, unsigned int& _value) const;
void readValue(ValueType _type , std::fstream& _in, int& _value) const;
void readValue(ValueType _type , std::istream& _in, float& _value) const;
void readValue(ValueType _type , std::istream& _in, unsigned int& _value) const;
void readValue(ValueType _type , std::istream& _in, int& _value) const;
//available options for reading
mutable Options options_;

67
src/OpenMesh/Core/IO/reader/STLReader.cc
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -76,17 +76,17 @@ _STLReader_& STLReader() { return __STLReaderInstance; }
_STLReader_::
_STLReader_()
_STLReader_()
: eps_(FLT_MIN)
{
IOManager().register_module(this);
IOManager().register_module(this);
}
//-----------------------------------------------------------------------------
bool
bool
_STLReader_::
read(const std::string& _filename, BaseImporter& _bi, Options& _opt)
{
@@ -118,15 +118,15 @@ read(const std::string& _filename, BaseImporter& _bi, Options& _opt)
_opt -= Options::Binary;
break;
}
case STLB:
{
result = read_stlb(_filename, _bi);
_opt += Options::Binary;
break;
}
default:
default:
{
result = false;
break;
@@ -137,6 +137,17 @@ read(const std::string& _filename, BaseImporter& _bi, Options& _opt)
return result;
}
bool
_STLReader_::read(std::istream& _is,
BaseImporter& _bi,
Options& _opt)
{
omerr() << "[OMReader] : STL Streams are not supported " << std::endl;
return false;
}
//-----------------------------------------------------------------------------
@@ -151,9 +162,9 @@ public:
bool operator()( const Vec3f& _v0, const Vec3f& _v1 ) const
{
if (fabs(_v0[0] - _v1[0]) <= eps_)
if (fabs(_v0[0] - _v1[0]) <= eps_)
{
if (fabs(_v0[1] - _v1[1]) <= eps_)
if (fabs(_v0[1] - _v1[1]) <= eps_)
{
return (_v0[2] < _v1[2] - eps_);
}
@@ -172,17 +183,16 @@ private:
//-----------------------------------------------------------------------------
bool
bool
_STLReader_::
read_stla(const std::string& _filename, BaseImporter& _bi) const
{
omlog() << "[STLReader] : read ascii file\n";
FILE* in = fopen(_filename.c_str(), "r");
if (!in)
{
omerr() << "[STLReader] : cannot not open file "
omerr() << "[STLReader] : cannot not open file "
<< _filename
<< std::endl;
return false;
@@ -200,15 +210,15 @@ read_stla(const std::string& _filename, BaseImporter& _bi) const
std::map<Vec3f, VertexHandle, CmpVec> vMap(comp);
std::map<Vec3f, VertexHandle, CmpVec>::iterator vMapIt;
while (in && !feof(in) && fgets(line, 100, in))
{
for (p=line; isspace(*p) && *p!='\0'; ++p) {}; // skip white-space
if ((strncmp(p, "outer", 5) == 0) || (strncmp(p, "OUTER", 5) == 0))
{
{
vhandles.clear();
for (i=0; i<3; ++i)
{
fgets(line, 100, in);
@@ -223,7 +233,7 @@ read_stla(const std::string& _filename, BaseImporter& _bi) const
vhandles.push_back(VertexHandle(cur_idx));
vMap[v] = VertexHandle(cur_idx++);
}
else
else
// Yes : get index from map
vhandles.push_back(vMapIt->second);
}
@@ -248,17 +258,16 @@ read_stla(const std::string& _filename, BaseImporter& _bi) const
//-----------------------------------------------------------------------------
bool
bool
_STLReader_::
read_stlb(const std::string& _filename, BaseImporter& _bi) const
{
omlog() << "[STLReader] : read binary file\n";
FILE* in = fopen(_filename.c_str(), "rb");
if (!in)
{
omerr() << "[STLReader] : cannot not open file "
omerr() << "[STLReader] : cannot not open file "
<< _filename
<< std::endl;
return false;
@@ -275,7 +284,7 @@ read_stlb(const std::string& _filename, BaseImporter& _bi) const
std::map<Vec3f, VertexHandle, CmpVec> vMap;
std::map<Vec3f, VertexHandle, CmpVec>::iterator vMapIt;
// check size of types
if ((sizeof(float) != 4) || (sizeof(int) != 4)) {
omerr() << "[STLReader] : wrong type size\n";
@@ -286,11 +295,11 @@ read_stlb(const std::string& _filename, BaseImporter& _bi) const
union { unsigned int i; unsigned char c[4]; } endian_test;
endian_test.i = 1;
swapFlag = (endian_test.c[3] == 1);
// read number of triangles
fread(dummy, 1, 80, in);
nT = read_int(in, swapFlag);
// read triangles
while (nT)
{
@@ -314,18 +323,18 @@ read_stlb(const std::string& _filename, BaseImporter& _bi) const
vhandles.push_back(VertexHandle(cur_idx));
vMap[v] = VertexHandle(cur_idx++);
}
else
else
// Yes : get index from map
vhandles.push_back(vMapIt->second);
}
// Add face only if it is not degenerated
if ((vhandles[0] != vhandles[1]) &&
(vhandles[0] != vhandles[2]) &&
(vhandles[1] != vhandles[2]))
_bi.add_face(vhandles);
fread(dummy, 1, 2, in);
--nT;
}
@@ -355,7 +364,7 @@ check_stl_type(const std::string& _filename) const
endian_test.i = 1;
bool swapFlag = (endian_test.c[3] == 1);
// read number of triangles
char dummy[100];
fread(dummy, 1, 80, in);

21
src/OpenMesh/Core/IO/reader/STLReader.hh
View File

@@ -4,10 +4,10 @@
* Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
* *
* OpenMesh is free software: you can redistribute it and/or modify *
* OpenMesh 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 3 of *
* the License, or (at your option) any later version with the *
@@ -30,10 +30,10 @@
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
\*===========================================================================*/
/*===========================================================================*\
* *
* *
* $Revision$ *
* $Date$ *
* *
@@ -79,8 +79,8 @@ class BaseImporter;
//== IMPLEMENTATION ===========================================================
/**
Implementation of the STL format reader. This class is singleton'ed by
/**
Implementation of the STL format reader. This class is singleton'ed by
SingletonT to STLReader.
*/
class _STLReader_ : public BaseReader
@@ -94,14 +94,17 @@ public:
virtual ~_STLReader_() {};
std::string get_description() const
std::string get_description() const
{ return "Stereolithography Interface Format"; }
std::string get_extensions() const { return "stl stla stlb"; }
bool read(const std::string& _filename,
bool read(const std::string& _filename,
BaseImporter& _bi,
Options& _opt);
bool read(std::istream& _in,
BaseImporter& _bi,
Options& _opt);
/** Set the threshold to be used for considering two point to be equal.
Can be used to merge small gaps */
@@ -111,7 +114,7 @@ public:
float epsilon() const { return eps_; }
private:
enum STL_Type { STLA, STLB, NONE };