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

- decimater modules doesn't need a decimater type as template argument

Browse Source 
- add decimater base class

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@645 fdac6126-5c0c-442c-9429-916003d36597
This commit is contained in:
Matthias Möller
2012-08-08 13:43:05 +00:00
parent 34e3b8ee86
commit 1af3dcac53
9 changed files with 596 additions and 759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

312
src/OpenMesh/Tools/Decimater/BaseDecimaterT.cc Normal file
View File

@@ -0,0 +1,312 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2011 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 *
* 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 *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenMesh is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* *
\*===========================================================================*/
/** \file DecimaterT.cc
*/
//=============================================================================
//
// CLASS DecimaterT - IMPLEMENTATION
//
//=============================================================================
#define OPENMESH_BASE_DECIMATER_DECIMATERT_CC
//== INCLUDES =================================================================
#include <vector>
#if defined(OM_CC_MIPS)
# include <float.h>
#else
# include <cfloat>
#endif
//== NAMESPACE ===============================================================
namespace OpenMesh {
namespace Decimater {
//== IMPLEMENTATION ==========================================================
template<class Mesh>
BaseDecimaterT<Mesh>::BaseDecimaterT(Mesh& _mesh) :
mesh_(_mesh), cmodule_(NULL), initialized_(false) {
// default properties
mesh_.request_vertex_status();
mesh_.request_edge_status();
mesh_.request_face_status();
mesh_.request_face_normals();
}
//-----------------------------------------------------------------------------
template<class Mesh>
BaseDecimaterT<Mesh>::~BaseDecimaterT() {
// default properties
mesh_.release_vertex_status();
mesh_.release_edge_status();
mesh_.release_face_status();
mesh_.release_face_normals();
// dispose of modules
{
set_uninitialized();
typename ModuleList::iterator m_it, m_end = all_modules_.end();
for (m_it = all_modules_.begin(); m_it != m_end; ++m_it)
delete *m_it;
all_modules_.clear();
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool BaseDecimaterT<Mesh>::is_collapse_legal(const CollapseInfo& _ci) {
// std::clog << "McDecimaterT<>::is_collapse_legal()\n";
// locked ? deleted ?
if (mesh_.status(_ci.v0).locked() || mesh_.status(_ci.v0).deleted())
return false;
if (!mesh_.is_collapse_ok(_ci.v0v1))
return false;
if (_ci.vl.is_valid() && _ci.vr.is_valid()
&& mesh_.find_halfedge(_ci.vl, _ci.vr).is_valid()
&& mesh_.valence(_ci.vl) == 3 && mesh_.valence(_ci.vr) == 3) {
return false;
}
//--- feature test ---
if (mesh_.status(_ci.v0).feature()
&& !mesh_.status(mesh_.edge_handle(_ci.v0v1)).feature())
return false;
//--- test one ring intersection ---
typename Mesh::VertexVertexIter vv_it;
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(false);
for (vv_it = mesh_.vv_iter(_ci.v1); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(true);
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
if (mesh_.status(vv_it).tagged() && vv_it.handle() != _ci.vl
&& vv_it.handle() != _ci.vr)
return false;
// if both are invalid OR equal -> fail
if (_ci.vl == _ci.vr)
return false;
//--- test boundary cases ---
if (mesh_.is_boundary(_ci.v0)) {
if (!mesh_.is_boundary(_ci.v1)) { // don't collapse a boundary vertex to an inner one
return false;
} else { // edge between two boundary vertices has to be a boundary edge
if (!(mesh_.is_boundary(_ci.v0v1) || mesh_.is_boundary(_ci.v1v0)))
return false;
}
// only one one ring intersection
if (_ci.vl.is_valid() && _ci.vr.is_valid())
return false;
}
// v0vl and v1vl must not both be boundary edges
if (_ci.vl.is_valid() && mesh_.is_boundary(_ci.vlv1)
&& mesh_.is_boundary(_ci.v0vl))
return false;
// v0vr and v1vr must not be both boundary edges
if (_ci.vr.is_valid() && mesh_.is_boundary(_ci.vrv0)
&& mesh_.is_boundary(_ci.v1vr))
return false;
// there have to be at least 2 incident faces at v0
if (mesh_.cw_rotated_halfedge_handle(
mesh_.cw_rotated_halfedge_handle(_ci.v0v1)) == _ci.v0v1)
return false;
// collapse passed all tests -> ok
return true;
}
//-----------------------------------------------------------------------------
template<class Mesh>
float BaseDecimaterT<Mesh>::collapse_priority(const CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it) {
if ((*m_it)->collapse_priority(_ci) < 0.0)
return ModBaseT< Mesh >::ILLEGAL_COLLAPSE;
}
return cmodule_->collapse_priority(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void BaseDecimaterT<Mesh>::postprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void BaseDecimaterT<Mesh>::preprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->preprocess_collapse(_ci);
cmodule_->preprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void BaseDecimaterT<Mesh>::info(std::ostream& _os) {
if (initialized_) {
_os << "initialized : yes" << std::endl;
_os << "binary modules: " << bmodules_.size() << std::endl;
for (ModuleListIterator m_it = bmodules_.begin(); m_it != bmodules_.end();
++m_it) {
_os << " " << (*m_it)->name() << std::endl;
}
_os << "priority module: " << cmodule_->name().c_str() << std::endl;
} else {
_os << "initialized : no" << std::endl;
_os << "available modules: " << all_modules_.size() << std::endl;
for (ModuleListIterator m_it = all_modules_.begin();
m_it != all_modules_.end(); ++m_it) {
_os << " " << (*m_it)->name() << " : ";
if ((*m_it)->is_binary()) {
_os << "binary";
if ((*m_it)->name() == "Quadric") {
_os << " and priority (special treatment)";
}
} else {
_os << "priority";
}
_os << std::endl;
}
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool BaseDecimaterT<Mesh>::initialize() {
if (initialized_) {
return true;
}
// FIXME: quadric module shouldn't be treated specially.
// Q: Why?
// A: It isn't generic and breaks encapsulation. Also, using string
// name comparison is not reliable, since you can't guarantee that
// no one else will name their custom module "Quadric".
// Q: What should be done instead?
// A: ModBaseT API should support modules that can be both binary
// and priority, or BETTER YET, let the DecimaterT API specify the
// priority module explicitly.
// find the priority module: either the only non-binary module in the list, or "Quadric"
Module *quadric = NULL;
Module *pmodule = NULL;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
if ((*m_it)->name() == "Quadric")
quadric = *m_it;
if (!(*m_it)->is_binary()) {
if (pmodule) {
// only one priority module allowed!
set_uninitialized();
return false;
}
pmodule = *m_it;
}
}
// Quadric is used as default priority module (even if it is set to be binary)
if (!pmodule && quadric) {
pmodule = quadric;
}
if (!pmodule) {
// At least one priority module required
set_uninitialized();
return false;
}
// set pmodule as the current priority module
cmodule_ = pmodule;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
// every module gets initialized
(*m_it)->initialize();
if (*m_it != pmodule) {
// all other modules are binary, and go into bmodules_ list
bmodules_.push_back(*m_it);
}
}
return initialized_ = true;
}
//=============================================================================
}// END_NS_DECIMATER
} // END_NS_OPENMESH
//=============================================================================

230
src/OpenMesh/Tools/Decimater/BaseDecimaterT.hh Normal file
View File

@@ -0,0 +1,230 @@
/*===========================================================================*\
* *
* OpenMesh *
* Copyright (C) 2001-2011 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 *
* 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 *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenMesh is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* *
\*===========================================================================*/
/** \file BaseDecimaterT.hh
*/
//=============================================================================
//
// CLASS McDecimaterT
//
//=============================================================================
#ifndef OPENMESH_BASE_DECIMATER_DECIMATERT_HH
#define OPENMESH_BASE_DECIMATER_DECIMATERT_HH
//== INCLUDES =================================================================
#include <memory>
#include <OpenMesh/Core/Utils/Property.hh>
#include <OpenMesh/Tools/Decimater/ModBaseT.hh>
#include <OpenMesh/Core/Utils/Noncopyable.hh>
//== NAMESPACE ================================================================
namespace OpenMesh {
namespace Decimater {
//== CLASS DEFINITION =========================================================
/** base class decimater framework
\see BaseDecimaterT, \ref decimater_docu
*/
class BaseDecimaterModule
{
};
template < typename MeshT >
class BaseDecimaterT : private Utils::Noncopyable
{
public: //-------------------------------------------------------- public types
typedef BaseDecimaterT< MeshT > Self;
typedef MeshT Mesh;
typedef CollapseInfoT<MeshT> CollapseInfo;
typedef ModBaseT<MeshT> Module;
typedef std::vector< Module* > ModuleList;
typedef typename ModuleList::iterator ModuleListIterator;
public: //------------------------------------------------------ public methods
BaseDecimaterT(Mesh& _mesh);
~BaseDecimaterT();
/** Initialize decimater and decimating modules.
Return values:
true ok
false No ore more than one non-binary module exist. In that case
the decimater is uninitialized!
*/
bool initialize();
/// Returns whether decimater has been successfully initialized.
bool is_initialized() const { return initialized_; }
/// Print information about modules to _os
void info( std::ostream& _os );
public: //--------------------------------------------------- module management
/// access mesh. used in modules.
Mesh& mesh() { return mesh_; }
/// add module to decimater
template < typename _Module >
bool add( ModHandleT<_Module>& _mh )
{
if (_mh.is_valid())
return false;
_mh.init( new _Module(mesh()) );
all_modules_.push_back( _mh.module() );
set_uninitialized();
return true;
}
/// remove module
template < typename _Module >
bool remove( ModHandleT<_Module>& _mh )
{
if (!_mh.is_valid())
return false;
typename ModuleList::iterator it = std::find(all_modules_.begin(),
all_modules_.end(),
_mh.module() );
if ( it == all_modules_.end() ) // module not found
return false;
delete *it;
all_modules_.erase( it ); // finally remove from list
_mh.clear();
set_uninitialized();
return true;
}
/// get module referenced by handle _mh
template < typename Module >
Module& module( ModHandleT<Module>& _mh )
{
assert( _mh.is_valid() );
return *_mh.module();
}
protected:
// Reset the initialized flag, and clear the bmodules_ and cmodule_
void set_uninitialized() {
initialized_ = false;
cmodule_ = 0;
bmodules_.clear();
}
void update_modules(CollapseInfo& _ci)
{
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
protected: //---------------------------------------------------- private methods
/// Is an edge collapse legal? Performs topological test only.
/// The method evaluates the status bit Locked, Deleted, and Feature.
/// \attention The method temporarily sets the bit Tagged. After usage
/// the bit will be disabled!
bool is_collapse_legal(const CollapseInfo& _ci);
/// Calculate priority of an halfedge collapse (using the modules)
float collapse_priority(const CollapseInfo& _ci);
/// Pre-process a collapse
void preprocess_collapse(CollapseInfo& _ci);
/// Post-process a collapse
void postprocess_collapse(CollapseInfo& _ci);
private: //------------------------------------------------------- private data
// reference to mesh
Mesh& mesh_;
// list of binary modules
ModuleList bmodules_;
// the current priority module
Module* cmodule_;
// list of all allocated modules (including cmodule_ and all of bmodules_)
ModuleList all_modules_;
bool initialized_;
};
//=============================================================================
} // END_NS_DECIMATER
} // END_NS_OPENMESH
//=============================================================================
#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_BASE_DECIMATER_DECIMATERT_CC)
#define OPENMESH_BASE_DECIMATER_TEMPLATES
#include "BaseDecimaterT.cc"
#endif
//=============================================================================
#endif // OPENMESH_BASE_DECIMATER_DECIMATERT_HH defined
//=============================================================================

240
src/OpenMesh/Tools/Decimater/DecimaterT.cc
View File

@@ -69,12 +69,8 @@ namespace Decimater {
template<class Mesh>
DecimaterT<Mesh>::DecimaterT(Mesh& _mesh) :
mesh_(_mesh), heap_(NULL), cmodule_(NULL), initialized_(false) {
// default properties
mesh_.request_vertex_status();
mesh_.request_edge_status();
mesh_.request_face_status();
mesh_.request_face_normals();
BaseDecimaterT<Mesh>(_mesh),
mesh_(_mesh), heap_(NULL) {
// private vertex properties
mesh_.add_property(collapse_target_);
@@ -86,208 +82,12 @@ DecimaterT<Mesh>::DecimaterT(Mesh& _mesh) :
template<class Mesh>
DecimaterT<Mesh>::~DecimaterT() {
// default properties
mesh_.release_vertex_status();
mesh_.release_edge_status();
mesh_.release_face_status();
mesh_.release_face_normals();
// private vertex properties
mesh_.remove_property(collapse_target_);
mesh_.remove_property(priority_);
mesh_.remove_property(heap_position_);
// dispose of modules
{
set_uninitialized();
typename ModuleList::iterator m_it, m_end = all_modules_.end();
for (m_it = all_modules_.begin(); m_it != m_end; ++m_it)
delete *m_it;
all_modules_.clear();
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
void DecimaterT<Mesh>::info(std::ostream& _os) {
if (initialized_) {
_os << "initialized : yes" << std::endl;
_os << "binary modules: " << bmodules_.size() << std::endl;
for (ModuleListIterator m_it = bmodules_.begin(); m_it != bmodules_.end();
++m_it) {
_os << " " << (*m_it)->name() << std::endl;
}
_os << "priority module: " << cmodule_->name().c_str() << std::endl;
} else {
_os << "initialized : no" << std::endl;
_os << "available modules: " << all_modules_.size() << std::endl;
for (ModuleListIterator m_it = all_modules_.begin();
m_it != all_modules_.end(); ++m_it) {
_os << " " << (*m_it)->name() << " : ";
if ((*m_it)->is_binary()) {
_os << "binary";
if ((*m_it)->name() == "Quadric") {
_os << " and priority (special treatment)";
}
} else {
_os << "priority";
}
_os << std::endl;
}
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool DecimaterT<Mesh>::initialize() {
if (initialized_) {
return true;
}
// FIXME: quadric module shouldn't be treated specially.
// Q: Why?
// A: It isn't generic and breaks encapsulation. Also, using string
// name comparison is not reliable, since you can't guarantee that
// no one else will name their custom module "Quadric".
// Q: What should be done instead?
// A: ModBaseT API should support modules that can be both binary
// and priority, or BETTER YET, let the DecimaterT API specify the
// priority module explicitly.
// find the priority module: either the only non-binary module in the list, or "Quadric"
Module *quadric = NULL;
Module *pmodule = NULL;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
if ((*m_it)->name() == "Quadric")
quadric = *m_it;
if (!(*m_it)->is_binary()) {
if (pmodule) {
// only one priority module allowed!
set_uninitialized();
return false;
}
pmodule = *m_it;
}
}
// Quadric is used as default priority module (even if it is set to be binary)
if (!pmodule && quadric) {
pmodule = quadric;
}
if (!pmodule) {
// At least one priority module required
set_uninitialized();
return false;
}
// set pmodule as the current priority module
cmodule_ = pmodule;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
// every module gets initialized
(*m_it)->initialize();
if (*m_it != pmodule) {
// all other modules are binary, and go into bmodules_ list
bmodules_.push_back(*m_it);
}
}
return initialized_ = true;
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool DecimaterT<Mesh>::is_collapse_legal(const CollapseInfo& _ci) {
// std::clog << "DecimaterT<>::is_collapse_legal()\n";
// locked ? deleted ?
if (mesh_.status(_ci.v0).locked() || mesh_.status(_ci.v0).deleted())
return false;
if (!mesh_.is_collapse_ok(_ci.v0v1))
return false;
if (_ci.vl.is_valid() && _ci.vr.is_valid()
&& mesh_.find_halfedge(_ci.vl, _ci.vr).is_valid()
&& mesh_.valence(_ci.vl) == 3 && mesh_.valence(_ci.vr) == 3) {
return false;
}
//--- feature test ---
if (mesh_.status(_ci.v0).feature()
&& !mesh_.status(mesh_.edge_handle(_ci.v0v1)).feature())
return false;
//--- test one ring intersection ---
typename Mesh::VertexVertexIter vv_it;
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(false);
for (vv_it = mesh_.vv_iter(_ci.v1); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(true);
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
if (mesh_.status(vv_it).tagged() && vv_it.handle() != _ci.vl
&& vv_it.handle() != _ci.vr)
return false;
// if both are invalid OR equal -> fail
if (_ci.vl == _ci.vr)
return false;
//--- test boundary cases ---
if (mesh_.is_boundary(_ci.v0)) {
if (!mesh_.is_boundary(_ci.v1)) { // don't collapse a boundary vertex to an inner one
return false;
} else { // edge between two boundary vertices has to be a boundary edge
if (!(mesh_.is_boundary(_ci.v0v1) || mesh_.is_boundary(_ci.v1v0)))
return false;
}
// only one one ring intersection
if (_ci.vl.is_valid() && _ci.vr.is_valid())
return false;
}
// v0vl and v1vl must not both be boundary edges
if (_ci.vl.is_valid() && mesh_.is_boundary(_ci.vlv1)
&& mesh_.is_boundary(_ci.v0vl))
return false;
// v0vr and v1vr must not be both boundary edges
if (_ci.vr.is_valid() && mesh_.is_boundary(_ci.vrv0)
&& mesh_.is_boundary(_ci.v1vr))
return false;
// there have to be at least 2 incident faces at v0
if (mesh_.cw_rotated_halfedge_handle(
mesh_.cw_rotated_halfedge_handle(_ci.v0v1)) == _ci.v0v1)
return false;
// collapse passed all tests -> ok
return true;
}
//-----------------------------------------------------------------------------
template<class Mesh>
float DecimaterT<Mesh>::collapse_priority(const CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it) {
if ((*m_it)->collapse_priority(_ci) < 0.0)
return ModBaseT<DecimaterT<Mesh> >::ILLEGAL_COLLAPSE;
}
return cmodule_->collapse_priority(_ci);
}
//-----------------------------------------------------------------------------
@@ -305,8 +105,8 @@ void DecimaterT<Mesh>::heap_vertex(VertexHandle _vh) {
heh = voh_it.handle();
CollapseInfo ci(mesh_, heh);
if (is_collapse_legal(ci)) {
prio = collapse_priority(ci);
if (this->is_collapse_legal(ci)) {
prio = this->collapse_priority(ci);
if (prio >= 0.0 && prio < best_prio) {
best_prio = prio;
collapse_target = heh;
@@ -337,34 +137,10 @@ void DecimaterT<Mesh>::heap_vertex(VertexHandle _vh) {
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
void DecimaterT<Mesh>::postprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void DecimaterT<Mesh>::preprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->preprocess_collapse(_ci);
cmodule_->preprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
size_t DecimaterT<Mesh>::decimate(size_t _n_collapses) {
if (!is_initialized())
if (!this->is_initialized())
return 0;
typename Mesh::VertexIter v_it, v_end(mesh_.vertices_end());
@@ -406,7 +182,7 @@ size_t DecimaterT<Mesh>::decimate(size_t _n_collapses) {
CollapseInfo ci(mesh_, v0v1);
// check topological correctness AGAIN !
if (!is_collapse_legal(ci))
if (!this->is_collapse_legal(ci))
continue;
// store support (= one ring of *vp)
@@ -426,7 +202,7 @@ size_t DecimaterT<Mesh>::decimate(size_t _n_collapses) {
mesh_.set_normal(vf_it, mesh_.calc_face_normal(vf_it.handle()));
// post-process collapse
postprocess_collapse(ci);
this->postprocess_collapse(ci);
// update heap (former one ring of decimated vertex)
for (s_it = support.begin(), s_end = support.end(); s_it != s_end; ++s_it) {
@@ -446,7 +222,7 @@ size_t DecimaterT<Mesh>::decimate(size_t _n_collapses) {
template<class Mesh>
size_t DecimaterT<Mesh>::decimate_to_faces(size_t _nv, size_t _nf) {
if (!is_initialized())
if (!this->is_initialized())
return 0;
if (_nv >= mesh_.n_vertices() || _nf >= mesh_.n_faces())

140
src/OpenMesh/Tools/Decimater/DecimaterT.hh
View File

@@ -58,7 +58,7 @@
#include <OpenMesh/Core/Utils/Property.hh>
#include <OpenMesh/Tools/Utils/HeapT.hh>
#include <OpenMesh/Tools/Decimater/ModBaseT.hh>
#include <OpenMesh/Tools/Decimater/BaseDecimaterT.hh>
@@ -75,15 +75,15 @@ namespace Decimater {
\see BaseModT, \ref decimater_docu
*/
template < typename MeshT >
class DecimaterT
class DecimaterT : public BaseDecimaterT<MeshT>
{
public: //-------------------------------------------------------- public types
typedef DecimaterT< MeshT > Self;
typedef MeshT Mesh;
typedef CollapseInfoT<MeshT> CollapseInfo;
typedef ModBaseT<Self> Module;
typedef std::vector< Module* > ModuleList;
typedef DecimaterT< MeshT > Self;
typedef MeshT Mesh;
typedef CollapseInfoT<MeshT> CollapseInfo;
typedef ModBaseT<MeshT> Module;
typedef std::vector< Module* > ModuleList;
typedef typename ModuleList::iterator ModuleListIterator;
public: //------------------------------------------------------ public methods
@@ -94,76 +94,6 @@ public: //------------------------------------------------------ public methods
/// Destructor
~DecimaterT();
/** Initialize decimater and decimating modules.
Return values:
true ok
false No ore more than one non-binary module exist. In that case
the decimater is uninitialized!
*/
bool initialize();
/// Returns whether decimater has been successfully initialized.
bool is_initialized() const { return initialized_; }
/// Print information about modules to _os
void info( std::ostream& _os );
public: //--------------------------------------------------- module management
/// access mesh. used in modules.
Mesh& mesh() { return mesh_; }
/// add module to decimater
template < typename _Module >
bool add( ModHandleT<_Module>& _mh )
{
if (_mh.is_valid())
return false;
_mh.init( new _Module(*this) );
all_modules_.push_back( _mh.module() );
set_uninitialized();
return true;
}
/// remove module
template < typename _Module >
bool remove( ModHandleT<_Module>& _mh )
{
if (!_mh.is_valid())
return false;
typename ModuleList::iterator it = std::find(all_modules_.begin(),
all_modules_.end(),
_mh.module() );
if ( it == all_modules_.end() ) // module not found
return false;
delete *it;
all_modules_.erase( it ); // finally remove from list
_mh.clear();
set_uninitialized();
return true;
}
/// get module referenced by handle _mh
template < typename Module >
Module& module( ModHandleT<Module>& _mh )
{
assert( _mh.is_valid() );
return *_mh.module();
}
public:
/** Decimate (perform _n_collapses collapses). Return number of
@@ -174,8 +104,8 @@ public:
/// Decimate to target complexity, returns number of collapses
size_t decimate_to( size_t _n_vertices )
{
return ( (_n_vertices < mesh().n_vertices()) ?
decimate( mesh().n_vertices() - _n_vertices ) : 0 );
return ( (_n_vertices < this->mesh().n_vertices()) ?
decimate( this->mesh().n_vertices() - _n_vertices ) : 0 );
}
/** Decimate to target complexity (vertices and faces).
@@ -183,16 +113,6 @@ public:
*/
size_t decimate_to_faces( size_t _n_vertices=0, size_t _n_faces=0 );
private:
void update_modules(CollapseInfo& _ci)
{
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
public:
typedef typename Mesh::VertexHandle VertexHandle;
@@ -240,29 +160,6 @@ private: //---------------------------------------------------- private methods
/// Insert vertex in heap
void heap_vertex(VertexHandle _vh);
/// Is an edge collapse legal? Performs topological test only.
/// The method evaluates the status bit Locked, Deleted, and Feature.
/// \attention The method temporarily sets the bit Tagged. After usage
/// the bit will be disabled!
bool is_collapse_legal(const CollapseInfo& _ci);
/// Calculate priority of an halfedge collapse (using the modules)
float collapse_priority(const CollapseInfo& _ci);
/// Pre-process a collapse
void preprocess_collapse(CollapseInfo& _ci);
/// Post-process a collapse
void postprocess_collapse(CollapseInfo& _ci);
// Reset the initialized flag, and clear the bmodules_ and cmodule_
void set_uninitialized() {
initialized_ = false;
cmodule_ = 0;
bmodules_.clear();
}
private: //------------------------------------------------------- private data
@@ -272,30 +169,11 @@ private: //------------------------------------------------------- private data
// heap
std::auto_ptr<DeciHeap> heap_;
// list of binary modules
ModuleList bmodules_;
// the current priority module
Module* cmodule_;
// list of all allocated modules (including cmodule_ and all of bmodules_)
ModuleList all_modules_;
bool initialized_;
// vertex properties
VPropHandleT<HalfedgeHandle> collapse_target_;
VPropHandleT<float> priority_;
VPropHandleT<int> heap_position_;
private: // Noncopyable
DecimaterT(const Self&);
Self& operator = (const Self&);
};
//=============================================================================

232
src/OpenMesh/Tools/Decimater/McDecimaterT.cc
View File

@@ -69,7 +69,8 @@ namespace Decimater {
template<class Mesh>
McDecimaterT<Mesh>::McDecimaterT(Mesh& _mesh) :
mesh_(_mesh), cmodule_(NULL), initialized_(false),randomSamples_(10) {
BaseDecimaterT<Mesh>(_mesh),
mesh_(_mesh), randomSamples_(10) {
// default properties
mesh_.request_vertex_status();
@@ -91,228 +92,13 @@ McDecimaterT<Mesh>::~McDecimaterT() {
mesh_.release_face_status();
mesh_.release_face_normals();
// dispose of modules
{
set_uninitialized();
typename ModuleList::iterator m_it, m_end = all_modules_.end();
for (m_it = all_modules_.begin(); m_it != m_end; ++m_it)
delete *m_it;
all_modules_.clear();
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
void McDecimaterT<Mesh>::info(std::ostream& _os) {
if (initialized_) {
_os << "initialized : yes" << std::endl;
_os << "binary modules: " << bmodules_.size() << std::endl;
for (ModuleListIterator m_it = bmodules_.begin(); m_it != bmodules_.end();
++m_it) {
_os << " " << (*m_it)->name() << std::endl;
}
_os << "priority module: " << cmodule_->name().c_str() << std::endl;
} else {
_os << "initialized : no" << std::endl;
_os << "available modules: " << all_modules_.size() << std::endl;
for (ModuleListIterator m_it = all_modules_.begin();
m_it != all_modules_.end(); ++m_it) {
_os << " " << (*m_it)->name() << " : ";
if ((*m_it)->is_binary()) {
_os << "binary";
if ((*m_it)->name() == "Quadric") {
_os << " and priority (special treatment)";
}
} else {
_os << "priority";
}
_os << std::endl;
}
}
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool McDecimaterT<Mesh>::initialize() {
if (initialized_) {
return true;
}
// FIXME: quadric module shouldn't be treated specially.
// Q: Why?
// A: It isn't generic and breaks encapsulation. Also, using string
// name comparison is not reliable, since you can't guarantee that
// no one else will name their custom module "Quadric".
// Q: What should be done instead?
// A: ModBaseT API should support modules that can be both binary
// and priority, or BETTER YET, let the McDecimaterT API specify the
// priority module explicitly.
// find the priority module: either the only non-binary module in the list, or "Quadric"
Module *quadric = NULL;
Module *pmodule = NULL;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
if ((*m_it)->name() == "Quadric")
quadric = *m_it;
if (!(*m_it)->is_binary()) {
if (pmodule) {
// only one priority module allowed!
set_uninitialized();
return false;
}
pmodule = *m_it;
}
}
// Quadric is used as default priority module (even if it is set to be binary)
if (!pmodule && quadric) {
pmodule = quadric;
}
if (!pmodule) {
// At least one priority module required
set_uninitialized();
return false;
}
// set pmodule as the current priority module
cmodule_ = pmodule;
for (ModuleListIterator m_it = all_modules_.begin(), m_end =
all_modules_.end(); m_it != m_end; ++m_it) {
// every module gets initialized
(*m_it)->initialize();
if (*m_it != pmodule) {
// all other modules are binary, and go into bmodules_ list
bmodules_.push_back(*m_it);
}
}
return initialized_ = true;
}
//-----------------------------------------------------------------------------
template<class Mesh>
bool McDecimaterT<Mesh>::is_collapse_legal(const CollapseInfo& _ci) {
// std::clog << "McDecimaterT<>::is_collapse_legal()\n";
// locked ? deleted ?
if (mesh_.status(_ci.v0).locked() || mesh_.status(_ci.v0).deleted())
return false;
if (!mesh_.is_collapse_ok(_ci.v0v1))
return false;
if (_ci.vl.is_valid() && _ci.vr.is_valid()
&& mesh_.find_halfedge(_ci.vl, _ci.vr).is_valid()
&& mesh_.valence(_ci.vl) == 3 && mesh_.valence(_ci.vr) == 3) {
return false;
}
//--- feature test ---
if (mesh_.status(_ci.v0).feature()
&& !mesh_.status(mesh_.edge_handle(_ci.v0v1)).feature())
return false;
//--- test one ring intersection ---
typename Mesh::VertexVertexIter vv_it;
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(false);
for (vv_it = mesh_.vv_iter(_ci.v1); vv_it; ++vv_it)
mesh_.status(vv_it).set_tagged(true);
for (vv_it = mesh_.vv_iter(_ci.v0); vv_it; ++vv_it)
if (mesh_.status(vv_it).tagged() && vv_it.handle() != _ci.vl
&& vv_it.handle() != _ci.vr)
return false;
// if both are invalid OR equal -> fail
if (_ci.vl == _ci.vr)
return false;
//--- test boundary cases ---
if (mesh_.is_boundary(_ci.v0)) {
if (!mesh_.is_boundary(_ci.v1)) { // don't collapse a boundary vertex to an inner one
return false;
} else { // edge between two boundary vertices has to be a boundary edge
if (!(mesh_.is_boundary(_ci.v0v1) || mesh_.is_boundary(_ci.v1v0)))
return false;
}
// only one one ring intersection
if (_ci.vl.is_valid() && _ci.vr.is_valid())
return false;
}
// v0vl and v1vl must not both be boundary edges
if (_ci.vl.is_valid() && mesh_.is_boundary(_ci.vlv1)
&& mesh_.is_boundary(_ci.v0vl))
return false;
// v0vr and v1vr must not be both boundary edges
if (_ci.vr.is_valid() && mesh_.is_boundary(_ci.vrv0)
&& mesh_.is_boundary(_ci.v1vr))
return false;
// there have to be at least 2 incident faces at v0
if (mesh_.cw_rotated_halfedge_handle(
mesh_.cw_rotated_halfedge_handle(_ci.v0v1)) == _ci.v0v1)
return false;
// collapse passed all tests -> ok
return true;
}
//-----------------------------------------------------------------------------
template<class Mesh>
float McDecimaterT<Mesh>::collapse_priority(const CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it) {
if ((*m_it)->collapse_priority(_ci) < 0.0)
return ModBaseT<McDecimaterT<Mesh> >::ILLEGAL_COLLAPSE;
}
return cmodule_->collapse_priority(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void McDecimaterT<Mesh>::postprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
void McDecimaterT<Mesh>::preprocess_collapse(CollapseInfo& _ci) {
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->preprocess_collapse(_ci);
cmodule_->preprocess_collapse(_ci);
}
//-----------------------------------------------------------------------------
template<class Mesh>
size_t McDecimaterT<Mesh>::decimate(size_t _n_collapses) {
if (!is_initialized())
if (!this->is_initialized())
return 0;
unsigned int n_collapses(0);
@@ -335,8 +121,8 @@ size_t McDecimaterT<Mesh>::decimate(size_t _n_collapses) {
CollapseInfo ci(mesh_, tmpHandle);
// Check if legal we analyze the priority of this collapse operation
if (is_collapse_legal(ci)) {
double energy = collapse_priority(ci);
if (this->is_collapse_legal(ci)) {
double energy = this->collapse_priority(ci);
// Check if the current samples energy is better than any energy before
if ( energy < bestEnergy ) {
@@ -357,11 +143,11 @@ size_t McDecimaterT<Mesh>::decimate(size_t _n_collapses) {
CollapseInfo ci(mesh_, bestHandle);
// check topological correctness AGAIN !
if (!is_collapse_legal(ci))
if (!this->is_collapse_legal(ci))
continue;
// pre-processing
preprocess_collapse(ci);
this->preprocess_collapse(ci);
// perform collapse
mesh_.collapse(bestHandle);
@@ -374,7 +160,7 @@ size_t McDecimaterT<Mesh>::decimate(size_t _n_collapses) {
mesh_.set_normal(vf_it, mesh_.calc_face_normal(vf_it.handle()));
// post-process collapse
postprocess_collapse(ci);
this->postprocess_collapse(ci);
}
@@ -388,7 +174,7 @@ size_t McDecimaterT<Mesh>::decimate(size_t _n_collapses) {
template<class Mesh>
size_t McDecimaterT<Mesh>::decimate_to_faces(size_t _nv, size_t _nf) {
if (!is_initialized())
if (!this->is_initialized())
return 0;
unsigned int nv = mesh_.n_vertices();

154
src/OpenMesh/Tools/Decimater/McDecimaterT.hh
View File

@@ -55,9 +55,7 @@
//== INCLUDES =================================================================
#include <memory>
#include <OpenMesh/Core/Utils/Property.hh>
#include <OpenMesh/Tools/Decimater/ModBaseT.hh>
#include <OpenMesh/Tools/Decimater/BaseDecimaterT.hh>
@@ -74,14 +72,14 @@ namespace Decimater {
\see BaseModT, \ref decimater_docu
*/
template < typename MeshT >
class McDecimaterT
class McDecimaterT : public BaseDecimaterT<MeshT>
{
public: //-------------------------------------------------------- public types
typedef McDecimaterT< MeshT > Self;
typedef MeshT Mesh;
typedef CollapseInfoT<MeshT> CollapseInfo;
typedef ModBaseT<Self> Module;
typedef ModBaseT<MeshT> Module;
typedef std::vector< Module* > ModuleList;
typedef typename ModuleList::iterator ModuleListIterator;
@@ -93,76 +91,6 @@ public: //------------------------------------------------------ public methods
/// Destructor
~McDecimaterT();
/** Initialize decimater and decimating modules.
Return values:
true ok
false No ore more than one non-binary module exist. In that case
the decimater is uninitialized!
*/
bool initialize();
/// Returns whether decimater has been successfully initialized.
bool is_initialized() const { return initialized_; }
/// Print information about modules to _os
void info( std::ostream& _os );
public: //--------------------------------------------------- module management
/// access mesh. used in modules.
Mesh& mesh() { return mesh_; }
/// add module to decimater
template < typename _Module >
bool add( ModHandleT<_Module>& _mh )
{
if (_mh.is_valid())
return false;
_mh.init( new _Module(*this) );
all_modules_.push_back( _mh.module() );
set_uninitialized();
return true;
}
/// remove module
template < typename _Module >
bool remove( ModHandleT<_Module>& _mh )
{
if (!_mh.is_valid())
return false;
typename ModuleList::iterator it = std::find(all_modules_.begin(),
all_modules_.end(),
_mh.module() );
if ( it == all_modules_.end() ) // module not found
return false;
delete *it;
all_modules_.erase( it ); // finally remove from list
_mh.clear();
set_uninitialized();
return true;
}
/// get module referenced by handle _mh
template < typename Module >
Module& module( ModHandleT<Module>& _mh )
{
assert( _mh.is_valid() );
return *_mh.module();
}
public:
/** Decimate (perform _n_collapses collapses). Return number of
@@ -173,8 +101,8 @@ public:
/// Decimate to target complexity, returns number of collapses
size_t decimate_to( size_t _n_vertices )
{
return ( (_n_vertices < mesh().n_vertices()) ?
decimate( mesh().n_vertices() - _n_vertices ) : 0 );
return ( (_n_vertices < this->mesh().n_vertices()) ?
decimate( this->mesh().n_vertices() - _n_vertices ) : 0 );
}
/** Decimate to target complexity (vertices and faces).
@@ -182,84 +110,14 @@ public:
*/
size_t decimate_to_faces( size_t _n_vertices=0, size_t _n_faces=0 );
private:
void update_modules(CollapseInfo& _ci)
{
typename ModuleList::iterator m_it, m_end = bmodules_.end();
for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
(*m_it)->postprocess_collapse(_ci);
cmodule_->postprocess_collapse(_ci);
}
public:
typedef typename Mesh::VertexHandle VertexHandle;
typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
/// Heap interface
class HeapInterface
{
public:
HeapInterface(Mesh& _mesh)
: mesh_(_mesh)
{ }
private:
Mesh& mesh_;
};
private: //---------------------------------------------------- private methods
/// Is an edge collapse legal? Performs topological test only.
/// The method evaluates the status bit Locked, Deleted, and Feature.
/// \attention The method temporarily sets the bit Tagged. After usage
/// the bit will be disabled!
bool is_collapse_legal(const CollapseInfo& _ci);
/// Calculate priority of an halfedge collapse (using the modules)
float collapse_priority(const CollapseInfo& _ci);
/// Pre-process a collapse
void preprocess_collapse(CollapseInfo& _ci);
/// Post-process a collapse
void postprocess_collapse(CollapseInfo& _ci);
// Reset the initialized flag, and clear the bmodules_ and cmodule_
void set_uninitialized() {
initialized_ = false;
cmodule_ = 0;
bmodules_.clear();
}
private: //------------------------------------------------------- private data
// reference to mesh
Mesh& mesh_;
// list of binary modules
ModuleList bmodules_;
// the current priority module
Module* cmodule_;
// list of all allocated modules (including cmodule_ and all of bmodules_)
ModuleList all_modules_;
bool initialized_;
unsigned int randomSamples_;
private: // Noncopyable
McDecimaterT(const Self&);
Self& operator = (const Self&);
};
//=============================================================================
@@ -271,6 +129,6 @@ private: // Noncopyable
#include "McDecimaterT.cc"
#endif
//=============================================================================
#endif // OPENMESH_DECIMATER_DECIMATERT_HH defined
#endif // OPENMESH_MC_DECIMATER_DECIMATERT_HH defined
//=============================================================================

39
src/OpenMesh/Tools/Decimater/ModBaseT.hh
View File

@@ -68,8 +68,7 @@ namespace Decimater {
//== FORWARD DECLARATIONS =====================================================
template <typename Mesh> class DecimaterT;
template <typename Mesh> class McDecimaterT;
template <typename Mesh> class BaseDecimaterT;
//== CLASS DEFINITION =========================================================
@@ -77,6 +76,7 @@ template <typename Mesh> class McDecimaterT;
/** Handle for mesh decimation modules
\internal
*/
template <typename Module>
class ModHandleT : private Utils::Noncopyable
{
@@ -100,11 +100,9 @@ public:
private:
#if defined(OM_CC_MSVC)
friend class DecimaterT;
friend class McDecimaterT;
friend class BaseDecimaterT;
#else
template <typename Mesh> friend class DecimaterT;
template <typename Mesh> friend class McDecimaterT;
template <typename Mesh> friend class BaseDecimaterT;
#endif
void clear() { mod_ = NULL; }
@@ -146,10 +144,10 @@ private:
* template parameter passed to ModBaseT.
* \param Name Give the module a name.
*/
#define DECIMATING_MODULE(Classname, DecimaterT, Name) \
typedef Classname < DecimaterT > Self; \
#define DECIMATING_MODULE(Classname, MeshT, Name) \
typedef Classname < MeshT > Self; \
typedef OpenMesh::Decimater::ModHandleT< Self > Handle; \
typedef OpenMesh::Decimater::ModBaseT< DecimaterT > Base; \
typedef OpenMesh::Decimater::ModBaseT< MeshT > Base; \
typedef typename Base::Mesh Mesh; \
typedef typename Base::CollapseInfo CollapseInfo; \
DECIMATER_MODNAME( Name )
@@ -187,13 +185,13 @@ private:
\todo "Tutorial on building a custom decimation module."
*/
template <typename DecimaterType>
template <typename MeshT>
class ModBaseT
{
public:
typedef typename DecimaterType::Mesh Mesh;
typedef CollapseInfoT<Mesh> CollapseInfo;
typedef MeshT Mesh;
typedef CollapseInfoT<MeshT> CollapseInfo;
enum {
ILLEGAL_COLLAPSE = -1, ///< indicates an illegal collapse
@@ -204,8 +202,8 @@ protected:
/// Default constructor
/// \see \ref decimater_docu
ModBaseT(DecimaterType& _dec, bool _is_binary)
: dec_(_dec), is_binary_(_is_binary) {}
ModBaseT(MeshT& _mesh, bool _is_binary)
: mesh_(_mesh), is_binary_(_is_binary) {}
public:
@@ -242,19 +240,19 @@ public: // common interface
* \return Collapse priority in the range [0,inf),
* \c LEGAL_COLLAPSE or \c ILLEGAL_COLLAPSE.
*/
virtual float collapse_priority(const CollapseInfoT<Mesh>& /* _ci */)
virtual float collapse_priority(const CollapseInfoT<MeshT>& /* _ci */)
{ return LEGAL_COLLAPSE; }
/** Before _from_vh has been collapsed into _to_vh, this method
will be called.
*/
virtual void preprocess_collapse(const CollapseInfoT<Mesh>& /* _ci */)
virtual void preprocess_collapse(const CollapseInfoT<MeshT>& /* _ci */)
{}
/** After _from_vh has been collapsed into _to_vh, this method
will be called.
*/
virtual void postprocess_collapse(const CollapseInfoT<Mesh>& /* _ci */)
virtual void postprocess_collapse(const CollapseInfoT<MeshT>& /* _ci */)
{}
@@ -262,7 +260,7 @@ public: // common interface
protected:
/// Access the mesh associated with the decimater.
Mesh& mesh() { return dec_.mesh(); }
MeshT& mesh() { return mesh_; }
private:
@@ -270,8 +268,7 @@ private:
ModBaseT(const ModBaseT& _cpy);
ModBaseT& operator=(const ModBaseT& );
// reference to decimater
DecimaterType &dec_;
MeshT& mesh_;
bool is_binary_;
};

4
src/Unittests/unittests_decimater.hh
View File

@@ -42,8 +42,8 @@ TEST_F(OpenMeshDecimater, DecimateMesh) {
ASSERT_TRUE(ok);
typedef OpenMesh::Decimater::DecimaterT< Mesh > Decimater;
typedef OpenMesh::Decimater::ModQuadricT< Decimater >::Handle HModQuadric;
typedef OpenMesh::Decimater::ModNormalFlippingT< Decimater >::Handle HModNormal;
typedef OpenMesh::Decimater::ModQuadricT< Mesh >::Handle HModQuadric;
typedef OpenMesh::Decimater::ModNormalFlippingT< Mesh >::Handle HModNormal;
Decimater decimaterDBG(mesh_);
HModQuadric hModQuadricDBG;

4
src/Unittests/unittests_mc_decimater.hh
View File

@@ -42,8 +42,8 @@ TEST_F(OpenMeshMultipleChoiceDecimater, DecimateMesh) {
ASSERT_TRUE(ok);
typedef OpenMesh::Decimater::McDecimaterT< Mesh > Decimater;
typedef OpenMesh::Decimater::ModQuadricT< Decimater >::Handle HModQuadric;
typedef OpenMesh::Decimater::ModNormalFlippingT< Decimater >::Handle HModNormal;
typedef OpenMesh::Decimater::ModQuadricT< Mesh >::Handle HModQuadric;
typedef OpenMesh::Decimater::ModNormalFlippingT< Mesh >::Handle HModNormal;
Decimater decimaterDBG(mesh_);
HModQuadric hModQuadricDBG;