From b1dfc573653b8a4251b8ba1fcb788ead17199d56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20M=C3=B6bius?= Date: Tue, 22 May 2012 09:15:15 +0000 Subject: [PATCH] Cleaned up indentation to be readable again git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@586 fdac6126-5c0c-442c-9429-916003d36597 --- src/OpenMesh/Core/IO/OMFormat.cc | 4 +- src/OpenMesh/Core/IO/reader/OMReader.cc | 396 +++++++++--------------- 2 files changed, 153 insertions(+), 247 deletions(-) diff --git a/src/OpenMesh/Core/IO/OMFormat.cc b/src/OpenMesh/Core/IO/OMFormat.cc index 6b617672..cec82416 100644 --- a/src/OpenMesh/Core/IO/OMFormat.cc +++ b/src/OpenMesh/Core/IO/OMFormat.cc @@ -62,14 +62,14 @@ namespace OMFormat { Chunk::Integer_Size needed_bits( size_t s ) { - if (s <= 0x000100) return Chunk::Integer_8; + if (s <= 0x000100) return Chunk::Integer_8; if (s <= 0x010000) return Chunk::Integer_16; #if 0 // !Not tested yet! This most probably won't work! // NEED a 64bit system! if ( (sizeof( size_t ) == 8) && (s >= 0x100000000) ) - return Chunk::Integer_64; + return Chunk::Integer_64; #endif return Chunk::Integer_32; diff --git a/src/OpenMesh/Core/IO/reader/OMReader.cc b/src/OpenMesh/Core/IO/reader/OMReader.cc index fc8e2837..16249362 100644 --- a/src/OpenMesh/Core/IO/reader/OMReader.cc +++ b/src/OpenMesh/Core/IO/reader/OMReader.cc @@ -82,24 +82,18 @@ _OMReader_::_OMReader_() //----------------------------------------------------------------------------- -bool -_OMReader_::read(const std::string& _filename, - BaseImporter& _bi, - Options& _opt) +bool _OMReader_::read(const std::string& _filename, BaseImporter& _bi, Options& _opt) { // check whether importer can give us an OpenMesh BaseKernel - if (!_bi.kernel()) return false; - + if (!_bi.kernel()) + return false; _opt += Options::Binary; // only binary format supported! // Open file - std::ifstream ifs( _filename.c_str(), std::ios::binary ); - if (!ifs.is_open() || !ifs.good()) - { - omerr() << "[OMReader] : cannot not open file " - << _filename - << std::endl; + std::ifstream ifs(_filename.c_str(), std::ios::binary); + if (!ifs.is_open() || !ifs.good()) { + omerr() << "[OMReader] : cannot not open file " << _filename << std::endl; return false; } @@ -115,28 +109,24 @@ _OMReader_::read(const std::string& _filename, //----------------------------------------------------------------------------- -bool -_OMReader_::read(std::istream& _is, - BaseImporter& _bi, - Options& _opt) +bool _OMReader_::read(std::istream& _is, BaseImporter& _bi, Options& _opt) { // check whether importer can give us an OpenMesh BaseKernel - if (!_bi.kernel()) return false; - + if (!_bi.kernel()) + return false; _opt += Options::Binary; // only binary format supported! - if (!_is.good()) - { - omerr() << "[OMReader] : cannot read from stream " - << std::endl; + 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; + if (result) + _opt += Options::Binary; return result; } @@ -145,9 +135,7 @@ _OMReader_::read(std::istream& _is, //----------------------------------------------------------------------------- -bool -_OMReader_::read_ascii( std::istream& /* _is */, BaseImporter& /* _bi */, - Options& /* _opt */) const +bool _OMReader_::read_ascii(std::istream& /* _is */, BaseImporter& /* _bi */, Options& /* _opt */) const { // not supported yet! return false; @@ -156,60 +144,55 @@ _OMReader_::read_ascii( std::istream& /* _is */, BaseImporter& /* _bi */, //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary( std::istream& _is, BaseImporter& _bi, - Options& _opt) const +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 + // Initialize byte counter bytes_ = 0; - bytes_ += restore( _is, header_, swap ); + bytes_ += restore(_is, header_, swap); size_t data_bytes; - while( !_is.eof() ) - { - bytes_ += restore( _is, chunk_header_, swap ); + while (!_is.eof()) { + bytes_ += restore(_is, chunk_header_, swap); - if ( _is.eof() ) + if (_is.eof()) break; // Is this a named property restore the name - if ( chunk_header_.name_ ) - { + if (chunk_header_.name_) { OMFormat::Chunk::PropertyName pn; - bytes_ += restore( _is, property_name_, swap ); + bytes_ += restore(_is, property_name_, swap); } // Read in the property data. If it is an anonymous or unknown named // property, then skip data. data_bytes = bytes_; - switch( chunk_header_.entity_ ) - { + switch (chunk_header_.entity_) { case OMFormat::Chunk::Entity_Vertex: - if (!read_binary_vertex_chunk( _is, _bi, _opt, swap )) - return false; - break; + if (!read_binary_vertex_chunk(_is, _bi, _opt, swap)) + return false; + break; case OMFormat::Chunk::Entity_Face: - if (!read_binary_face_chunk( _is, _bi, _opt, swap )) - return false; - break; + if (!read_binary_face_chunk(_is, _bi, _opt, swap)) + return false; + break; case OMFormat::Chunk::Entity_Edge: - if (!read_binary_edge_chunk( _is, _bi, _opt, swap )) - return false; - break; + if (!read_binary_edge_chunk(_is, _bi, _opt, swap)) + return false; + break; case OMFormat::Chunk::Entity_Halfedge: - if (!read_binary_halfedge_chunk( _is, _bi, _opt, swap )) - return false; - break; + if (!read_binary_halfedge_chunk(_is, _bi, _opt, swap)) + return false; + break; case OMFormat::Chunk::Entity_Mesh: - if (!read_binary_mesh_chunk( _is, _bi, _opt, swap )) - return false; - break; + if (!read_binary_mesh_chunk(_is, _bi, _opt, swap)) + return false; + break; default: - return false; + return false; } data_bytes = bytes_ - data_bytes; } @@ -221,15 +204,13 @@ _OMReader_::read_binary( std::istream& _is, BaseImporter& _bi, //----------------------------------------------------------------------------- -bool -_OMReader_::can_u_read(const std::string& _filename) const +bool _OMReader_::can_u_read(const std::string& _filename) const { // !!! Assuming BaseReader::can_u_parse( std::string& ) // does not call BaseReader::read_magic()!!! - if ( this->BaseReader::can_u_read( _filename ) ) - { - std::ifstream ifile( _filename.c_str() ); - if ( ifile && can_u_read( ifile ) ) + if (this->BaseReader::can_u_read(_filename)) { + std::ifstream ifile(_filename.c_str()); + if (ifile && can_u_read(ifile)) return true; } return false; @@ -237,32 +218,29 @@ _OMReader_::can_u_read(const std::string& _filename) const //----------------------------------------------------------------------------- -bool -_OMReader_::can_u_read(std::istream& _is) const +bool _OMReader_::can_u_read(std::istream& _is) const { std::vector evt; evt.reserve(20); // read first 4 characters into a buffer - while( evt.size() < 4 ) - evt.push_back( static_cast(_is.get()) ); + while (evt.size() < 4) + evt.push_back(static_cast(_is.get())); // put back all read characters std::vector::reverse_iterator it = evt.rbegin(); - while (it != evt.rend() ) - _is.putback( *it++ ); - + while (it != evt.rend()) + _is.putback(*it++); // evaluate header information - OMFormat::Header *hdr = (OMFormat::Header*)&evt[0]; + OMFormat::Header *hdr = (OMFormat::Header*) &evt[0]; // first two characters must be 'OM' if (hdr->magic_[0] != 'O' || hdr->magic_[1] != 'M') return false; // 3rd characters defines the mesh type: - switch(hdr->mesh_) - { + switch (hdr->mesh_) { case 'T': // Triangle Mesh case 'Q': // Quad Mesh case 'P': // Polygonal Mesh @@ -272,13 +250,12 @@ _OMReader_::can_u_read(std::istream& _is) const } // 4th characters encodes the version - return supports( hdr->version_ ); + return supports(hdr->version_); } //----------------------------------------------------------------------------- -bool -_OMReader_::supports( const OMFormat::uint8 /* version */ ) const +bool _OMReader_::supports(const OMFormat::uint8 /* version */) const { return true; } @@ -286,82 +263,64 @@ _OMReader_::supports( const OMFormat::uint8 /* version */ ) const //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary_vertex_chunk( std::istream &_is, - BaseImporter &_bi, - Options &_opt, - bool _swap) const +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 ); + assert( chunk_header_.entity_ == Chunk::Entity_Vertex); - OpenMesh::Vec3f v3f; - OpenMesh::Vec2f v2f; + OpenMesh::Vec3f v3f; + OpenMesh::Vec2f v2f; OpenMesh::Vec3uc v3uc; // rgb OMFormat::Chunk::PropertyName custom_prop; - size_t vidx=0; - switch (chunk_header_.type_) - { + size_t vidx = 0; + switch (chunk_header_.type_) { case Chunk::Type_Pos: - assert( OMFormat::dimensions(chunk_header_) - == size_t(OpenMesh::Vec3f::dim()) ); + assert( OMFormat::dimensions(chunk_header_) == size_t(OpenMesh::Vec3f::dim())); - for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) - { - bytes_ += vector_restore( _is, v3f, _swap ); - _bi.add_vertex(v3f); + for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) { + bytes_ += vector_restore(_is, v3f, _swap); + _bi.add_vertex(v3f); } break; - case Chunk::Type_Normal: - assert( OMFormat::dimensions(chunk_header_) - == size_t(OpenMesh::Vec3f::dim()) ); + assert( OMFormat::dimensions(chunk_header_) == size_t(OpenMesh::Vec3f::dim())); _opt += Options::VertexNormal; - for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) - { - bytes_ += vector_restore( _is, v3f, _swap ); - _bi.set_normal(VertexHandle(vidx), v3f); + for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) { + bytes_ += vector_restore(_is, v3f, _swap); + _bi.set_normal(VertexHandle(vidx), v3f); } break; - case Chunk::Type_Texcoord: - assert( OMFormat::dimensions(chunk_header_) - == size_t(OpenMesh::Vec2f::dim()) ); + assert( OMFormat::dimensions(chunk_header_) == size_t(OpenMesh::Vec2f::dim())); _opt += Options::VertexTexCoord; - for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) - { - bytes_ += vector_restore( _is, v2f, _swap ); - _bi.set_texcoord(VertexHandle(vidx), v2f); + for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) { + bytes_ += vector_restore(_is, v2f, _swap); + _bi.set_texcoord(VertexHandle(vidx), v2f); } break; case Chunk::Type_Color: - assert( OMFormat::dimensions(chunk_header_) == 3 ); + assert( OMFormat::dimensions(chunk_header_) == 3); _opt += Options::VertexColor; - for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) - { - bytes_ += vector_restore( _is, v3uc, _swap ); - _bi.set_color( VertexHandle(vidx), v3uc ); + for (; vidx < header_.n_vertices_ && !_is.eof(); ++vidx) { + bytes_ += vector_restore(_is, v3uc, _swap); + _bi.set_color(VertexHandle(vidx), v3uc); } break; case Chunk::Type_Custom: - bytes_ += - restore_binary_custom_data( _is, - _bi.kernel()->_get_vprop( property_name_ ), - header_.n_vertices_, - _swap ); + bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_vprop(property_name_), header_.n_vertices_, _swap); vidx = header_.n_vertices_; @@ -370,9 +329,8 @@ _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_ - * OMFormat::vector_size(chunk_header_); - _is.ignore( size_of ); + size_t size_of = header_.n_vertices_ * OMFormat::vector_size(chunk_header_); + _is.ignore(size_of); bytes_ += size_of; } } @@ -384,88 +342,71 @@ _OMReader_::read_binary_vertex_chunk( std::istream &_is, //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary_face_chunk( std::istream &_is, - BaseImporter &_bi, - Options &_opt, - bool _swap ) const +bool _OMReader_::read_binary_face_chunk(std::istream &_is, BaseImporter &_bi, Options &_opt, bool _swap) const { using OMFormat::Chunk; - assert( chunk_header_.entity_ == Chunk::Entity_Face ); + assert( chunk_header_.entity_ == Chunk::Entity_Face); - size_t fidx=0; - OpenMesh::Vec3f v3f; // normal + size_t fidx = 0; + OpenMesh::Vec3f v3f; // normal OpenMesh::Vec3uc v3uc; // rgb - switch( chunk_header_.type_ ) - { - case Chunk::Type_Topology: - { - BaseImporter::VHandles vhandles; - size_t nV = 0; - size_t vidx = 0; + switch (chunk_header_.type_) { + case Chunk::Type_Topology: { + BaseImporter::VHandles vhandles; + size_t nV = 0; + size_t vidx = 0; - switch( header_.mesh_ ) - { - case 'T': nV = 3; break; - case 'Q': nV = 4; break; + switch (header_.mesh_) { + case 'T': + nV = 3; + break; + case 'Q': + nV = 4; + break; } - for (; fidx < header_.n_faces_; ++fidx) - { - if ( header_.mesh_ == 'P' ) - bytes_ += restore( _is, nV, Chunk::Integer_16, _swap ); + for (; fidx < header_.n_faces_; ++fidx) { + if (header_.mesh_ == 'P') + bytes_ += restore(_is, nV, Chunk::Integer_16, _swap); - vhandles.clear(); - for (size_t j=0; j_get_fprop( property_name_ ), - header_.n_faces_, - _swap ); + bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_fprop(property_name_), header_.n_faces_, _swap); fidx = header_.n_faces_; @@ -475,7 +416,7 @@ _OMReader_::read_binary_face_chunk( std::istream &_is, { omerr() << "Unknown chunk type ignore!\n"; size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_); - _is.ignore( size_of ); + _is.ignore(size_of); bytes_ += size_of; } } @@ -485,34 +426,25 @@ _OMReader_::read_binary_face_chunk( std::istream &_is, //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary_edge_chunk( std::istream &_is, - BaseImporter &_bi, - Options &/*_opt */, - bool _swap ) const +bool _OMReader_::read_binary_edge_chunk(std::istream &_is, BaseImporter &_bi, Options &/*_opt */, bool _swap) const { using OMFormat::Chunk; - assert( chunk_header_.entity_ == Chunk::Entity_Edge ); + assert( chunk_header_.entity_ == Chunk::Entity_Edge); - size_t b=bytes_; + size_t b = bytes_; - switch( chunk_header_.type_ ) - { + switch (chunk_header_.type_) { case Chunk::Type_Custom: - bytes_ += - restore_binary_custom_data( _is, - _bi.kernel()->_get_eprop( property_name_ ), - header_.n_edges_, - _swap ); + bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_eprop(property_name_), header_.n_edges_, _swap); break; default: // skip unknown type size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_); - _is.ignore( size_of ); + _is.ignore(size_of); bytes_ += size_of; } @@ -522,34 +454,25 @@ _OMReader_::read_binary_edge_chunk( std::istream &_is, //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary_halfedge_chunk( std::istream &_is, - BaseImporter &_bi, - Options &/* _opt */, - bool _swap ) const +bool _OMReader_::read_binary_halfedge_chunk(std::istream &_is, BaseImporter &_bi, Options &/* _opt */, bool _swap) const { using OMFormat::Chunk; - assert( chunk_header_.entity_ == Chunk::Entity_Halfedge ); + assert( chunk_header_.entity_ == Chunk::Entity_Halfedge); size_t b = bytes_; - switch( chunk_header_.type_ ) - { + switch (chunk_header_.type_) { case Chunk::Type_Custom: - bytes_ += - restore_binary_custom_data( _is, - _bi.kernel()->_get_hprop( property_name_ ), - 2*header_.n_edges_, - _swap ); + bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_hprop(property_name_), 2 * header_.n_edges_, _swap); break; default: // skip unknown chunk omerr() << "Unknown chunk type ignored!\n"; size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_); - _is.ignore( size_of ); + _is.ignore(size_of); bytes_ += size_of; } @@ -559,34 +482,25 @@ _OMReader_::read_binary_halfedge_chunk( std::istream &_is, //----------------------------------------------------------------------------- -bool -_OMReader_::read_binary_mesh_chunk( std::istream &_is, - BaseImporter &_bi, - Options & /* _opt */, - bool _swap ) const +bool _OMReader_::read_binary_mesh_chunk(std::istream &_is, BaseImporter &_bi, Options & /* _opt */, bool _swap) const { using OMFormat::Chunk; - assert( chunk_header_.entity_ == Chunk::Entity_Mesh ); + assert( chunk_header_.entity_ == Chunk::Entity_Mesh); size_t b = bytes_; - switch( chunk_header_.type_ ) - { + switch (chunk_header_.type_) { case Chunk::Type_Custom: - bytes_ += - restore_binary_custom_data( _is, - _bi.kernel()->_get_mprop( property_name_ ), - 1, - _swap ); + bytes_ += restore_binary_custom_data(_is, _bi.kernel()->_get_mprop(property_name_), 1, _swap); break; default: // skip unknown chunk size_t size_of = OMFormat::chunk_data_size(header_, chunk_header_); - _is.ignore( size_of ); + _is.ignore(size_of); bytes_ += size_of; } @@ -597,53 +511,45 @@ _OMReader_::read_binary_mesh_chunk( std::istream &_is, //----------------------------------------------------------------------------- -size_t -_OMReader_::restore_binary_custom_data( std::istream& _is, BaseProperty* _bp, - size_t _n_elem, bool _swap) const +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_) ); + assert( !_bp || (_bp->name() == property_name_)); using OMFormat::Chunk; - size_t bytes = 0; - Chunk::esize_t block_size; + size_t bytes = 0; + Chunk::esize_t block_size; Chunk::PropertyName custom_prop; - bytes += binary::restore( _is, block_size, _swap ); + bytes += binary::restore(_is, block_size, _swap); + if (_bp) { + size_t n_bytes = _bp->size_of(_n_elem); - if ( _bp ) - { - size_t n_bytes = _bp->size_of( _n_elem ); - - if ( ((n_bytes == BaseProperty::UnknownSize) || (n_bytes == block_size)) && - (_bp->element_size() == BaseProperty::UnknownSize || - (_n_elem * _bp->element_size() == block_size) ) ) - { + if (((n_bytes == BaseProperty::UnknownSize) || (n_bytes == block_size)) + && (_bp->element_size() == BaseProperty::UnknownSize || (_n_elem * _bp->element_size() == block_size))) { #if defined(OM_DEBUG) size_t b; bytes += (b=_bp->restore( _is, _swap )); #else - bytes += _bp->restore( _is, _swap ); + bytes += _bp->restore(_is, _swap); #endif + #if defined(OM_DEBUG) assert( block_size == b ); #endif - assert( block_size == _bp->size_of() ); + + assert( block_size == _bp->size_of()); block_size = 0; - } - else - { - omerr() << "Warning! Property " << _bp->name() << " not loaded: " - << "Mismatching data sizes!n"; + } else { + omerr() << "Warning! Property " << _bp->name() << " not loaded: " << "Mismatching data sizes!n"; } } - if (block_size) - { - _is.ignore( block_size ); - bytes += block_size; + if (block_size) { + _is.ignore(block_size); + bytes += block_size; } return bytes;