vcglib/vcg/complex/algorithms/local_optimization.h

305 lines
11 KiB
C++

/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004-2016 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCGLIB_LOCALOPTIMIZATION
#define __VCGLIB_LOCALOPTIMIZATION
#include <vcg/complex/complex.h>
#include <time.h>
namespace vcg{
// Base class for Parameters
// all parameters must be derived from this.
class BaseParameterClass { };
template<class MeshType>
class LocalOptimization;
enum ModifierType{ TetraEdgeCollapseOp, TriEdgeSwapOp, TriVertexSplitOp,
TriEdgeCollapseOp,TetraEdgeSpliOpt,TetraEdgeSwapOp, TriEdgeFlipOp,
QuadDiagCollapseOp, QuadEdgeCollapseOp};
/** \addtogroup tetramesh */
/*@{*/
/// This abstract class define which functions a local modification class must have to be used in the LocalOptimization framework.
template <class MeshType>
class LocalModification
{
public:
typedef typename LocalOptimization<MeshType>::HeapType HeapType;
typedef typename MeshType::ScalarType ScalarType;
inline LocalModification(){}
virtual ~LocalModification(){}
/// return the type of operation
virtual ModifierType IsOfType() = 0 ;
/// return true if the data have not changed since it was created
virtual bool IsUpToDate() const = 0 ;
/// return true if no constraint disallow this operation to be performed (ex: change of topology in edge collapses)
virtual bool IsFeasible(BaseParameterClass *pp) = 0;
/// Compute the priority to be used in the heap
virtual ScalarType ComputePriority(BaseParameterClass *pp)=0;
/// Return the priority to be used in the heap (implement static priority)
virtual ScalarType Priority() const =0;
/// Perform the operation
virtual void Execute(MeshType &m, BaseParameterClass *pp)=0;
/// perform initialization
static void Init(MeshType &m, HeapType&, BaseParameterClass *pp);
/// An approximation of the size of the heap with respect of the number of simplex
/// of the mesh. When this number is exceeded a clear heap purging is performed.
/// so it is should be reasonably larger than the minimum expected size to avoid too frequent clear heap
/// For example for symmetric edge collapse a 5 is a good guess.
/// while for non symmetric edge collapse a larger number like 9 is a better choice
static float HeapSimplexRatio(BaseParameterClass *) {return 6.0f;}
virtual const char *Info(MeshType &) {return 0;}
/// Update the heap as a consequence of this operation
virtual void UpdateHeap(HeapType&, BaseParameterClass *pp)=0;
}; //end class local modification
/// LocalOptimization:
/// This class implements the algorihms running on 0-1-2-3-simplicial complex that are based on local modification
/// The local modification can be and edge_collpase, or an edge_swap, a vertex plit...as far as they implement
/// the interface defined in LocalModification.
/// Implementation note: in order to keep the local modification itself indepented by its use in this class, they are not
/// really derived by LocalModification. Instead, a wrapper is done to this purpose (see vcg/complex/tetramesh/decimation/collapse.h)
template<class MeshType>
class LocalOptimization
{
public:
LocalOptimization(MeshType &mm, BaseParameterClass *_pp): m(mm){ ClearTermination();HeapSimplexRatio=5; pp=_pp;}
struct HeapElem;
typedef typename MeshType::ScalarType ScalarType;
typedef typename std::vector<HeapElem> HeapType;
typedef LocalModification <MeshType> LocModType;
/// termination conditions
enum LOTermination {
LOnSimplices = 0x01, // test number of simplicies
LOnVertices = 0x02, // test number of verticies
LOnOps = 0x04, // test number of operations
LOMetric = 0x08, // test Metric (error, quality...instance dependent)
LOTime = 0x10 // test how much time is passed since the start
} ;
int tf; // Termination Flag
int nPerformedOps,
nTargetOps,
nTargetSimplices,
nTargetVertices;
float timeBudget;
clock_t start;
ScalarType currMetric;
ScalarType targetMetric;
BaseParameterClass *pp;
// The ratio between Heap size and the number of simplices in the current mesh
// When this value is exceeded a ClearHeap Start;
float HeapSimplexRatio;
void SetTerminationFlag (int v){tf |= v;}
void ClearTerminationFlag (int v){tf &= ~v;}
bool IsTerminationFlag (int v){return ((tf & v)!=0);}
void SetTargetSimplices (int ts ){nTargetSimplices = ts; SetTerminationFlag(LOnSimplices); }
void SetTargetVertices (int tv ){nTargetVertices = tv; SetTerminationFlag(LOnVertices); }
void SetTargetOperations(int to ){nTargetOps = to; SetTerminationFlag(LOnOps); }
void SetTargetMetric (ScalarType tm ){targetMetric = tm; SetTerminationFlag(LOMetric); }
void SetTimeBudget (float tb ){timeBudget = tb; SetTerminationFlag(LOTime); }
void ClearTermination()
{
tf=0;
nTargetSimplices=0;
nTargetOps=0;
targetMetric=0;
timeBudget=0;
nTargetVertices=0;
}
/// the mesh to optimize
MeshType & m;
///the heap of operations
HeapType h;
///the element of the heap
// it is just a wrapper of the pointer to the localMod.
// std heap does not work for
// pointers and we want pointers to have heterogenous heaps.
struct HeapElem
{
inline HeapElem(){locModPtr = NULL;}
~HeapElem(){}
///pointer to instance of local modifier
LocModType *locModPtr;
float pri;
inline HeapElem( LocModType *_locModPtr)
{
locModPtr = _locModPtr;
pri=float(locModPtr->Priority());
}
/// STL heap has the largest element as the first one.
/// usually we mean priority as an error so we should invert the comparison
inline bool operator <(const HeapElem & h) const
{
return (pri > h.pri);
//return (locModPtr->Priority() < h.locModPtr->Priority());
}
bool IsUpToDate() const
{
return locModPtr->IsUpToDate();
}
};
/// Default distructor
~LocalOptimization(){
typename HeapType::iterator i;
for(i = h.begin(); i != h.end(); i++)
delete (*i).locModPtr;
}
/// main cycle of optimization
bool DoOptimization()
{
assert ( ( ( tf & LOnSimplices )==0) || ( nTargetSimplices!= -1));
assert ( ( ( tf & LOnVertices )==0) || ( nTargetVertices != -1));
assert ( ( ( tf & LOnOps )==0) || ( nTargetOps != -1));
assert ( ( ( tf & LOMetric )==0) || ( targetMetric != -1));
assert ( ( ( tf & LOTime )==0) || ( timeBudget != -1));
start=clock();
nPerformedOps =0;
while( !GoalReached() && !h.empty())
{
if(h.size()> m.SimplexNumber()*HeapSimplexRatio ) ClearHeap();
std::pop_heap(h.begin(),h.end());
LocModType *locMod = h.back().locModPtr;
currMetric=h.back().pri;
h.pop_back();
if( locMod->IsUpToDate() )
{
//printf("popped out: %s\n",locMod->Info(m));
if (locMod->IsFeasible(this->pp))
{
nPerformedOps++;
locMod->Execute(m,this->pp);
locMod->UpdateHeap(h,this->pp);
}
}
delete locMod;
}
return !(h.empty());
}
// It removes from the heap all the operations that are no more 'uptodate'
// (e.g. collapses that have some recently modified vertices)
// This function is called from time to time by the doOptimization (e.g. when the heap is larger than fn*3)
void ClearHeap()
{
// int sz=h.size(); int t0=clock();
for(auto hi=h.begin();hi!=h.end();)
{
if(!(*hi).locModPtr->IsUpToDate())
{
delete (*hi).locModPtr;
*hi=h.back();
if(&*hi==&h.back())
{
hi=h.end();
h.pop_back();
break;
}
h.pop_back();
continue;
}
++hi;
}
// printf("\nReduced heap from %7i to %7i (fn %7i) in %7.2f \n",sz,h.size(),m.fn,float(clock()-t0)/CLOCKS_PER_SEC);
make_heap(h.begin(),h.end());
}
///initialize for all vertex the temporary mark must call only at the start of decimation
///by default it takes the first element in the heap and calls Init (static funcion) of that type
///of local modification.
template <class LocalModificationType> void Init()
{
vcg::tri::InitVertexIMark(m);
// The expected size of heap depends on the type of the local modification we are using..
HeapSimplexRatio = LocalModificationType::HeapSimplexRatio(pp);
LocalModificationType::Init(m,h,pp);
std::make_heap(h.begin(),h.end());
if(!h.empty()) currMetric=h.front().pri;
}
template <class LocalModificationType> void Finalize()
{
LocalModificationType::Finalize(m,h,pp);
}
/// say if the process is to end or not: the process ends when any of the termination conditions is verified
/// override this function to implemetn other tests
bool GoalReached(){
if ( IsTerminationFlag(LOnSimplices) && ( m.SimplexNumber()<= nTargetSimplices)) return true;
if ( IsTerminationFlag(LOnVertices) && ( m.VertexNumber() <= nTargetVertices)) return true;
if ( IsTerminationFlag(LOnOps) && (nPerformedOps == nTargetOps)) return true;
if ( IsTerminationFlag(LOMetric) && ( currMetric > targetMetric)) return true;
if ( IsTerminationFlag(LOTime) )
{
clock_t cur = clock();
if(cur<start) // overflow of tick counter;
return true; // panic
else
if ( (cur - start)/(double)CLOCKS_PER_SEC > timeBudget) return true;
}
return false;
}
};//end class decimation
}//end namespace
#endif