Added class HalfedgeQuadClean
This commit is contained in:
parent
2984bda3c8
commit
183f106f23
|
|
@ -0,0 +1,712 @@
|
||||||
|
#ifndef HALFEDGEQUADCLEAN_H
|
||||||
|
#define HALFEDGEQUADCLEAN_H
|
||||||
|
|
||||||
|
#include <vcg/complex/trimesh/update/halfedge_topology.h>
|
||||||
|
#include <queue>
|
||||||
|
#include <set>
|
||||||
|
#include<vcg/math/base.h>
|
||||||
|
#include<valarray>
|
||||||
|
#include<cmath>
|
||||||
|
|
||||||
|
|
||||||
|
namespace vcg
|
||||||
|
{
|
||||||
|
namespace tri
|
||||||
|
{
|
||||||
|
/*!
|
||||||
|
* \brief The class provides methods for detecting doublets and singlets and removing them
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
template<class MeshType> class HalfedgeQuadClean
|
||||||
|
{
|
||||||
|
|
||||||
|
protected:
|
||||||
|
|
||||||
|
typedef typename MeshType::VertexPointer VertexPointer;
|
||||||
|
typedef typename MeshType::EdgePointer EdgePointer;
|
||||||
|
typedef typename MeshType::HEdgePointer HEdgePointer;
|
||||||
|
typedef typename MeshType::FacePointer FacePointer;
|
||||||
|
|
||||||
|
typedef typename MeshType::VertexIterator VertexIterator;
|
||||||
|
typedef typename MeshType::EdgeIterator EdgeIterator;
|
||||||
|
typedef typename MeshType::HEdgeIterator HEdgeIterator;
|
||||||
|
typedef typename MeshType::FaceIterator FaceIterator;
|
||||||
|
|
||||||
|
/*! Adds to a queue all faces on the 1-ring of a given vertex
|
||||||
|
*
|
||||||
|
* \param q Queue of faces
|
||||||
|
* \param vp Pointer to the vertex
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void add_faces(queue<FacePointer> &q, VertexPointer vp)
|
||||||
|
{
|
||||||
|
vector<FacePointer> faces = HalfEdgeTopology<MeshType>::get_incident_faces(vp);
|
||||||
|
|
||||||
|
for(typename vector<FacePointer>::iterator fi = faces.begin(); fi != faces.end(); ++fi)
|
||||||
|
{
|
||||||
|
if(*fi)
|
||||||
|
q.push(*fi);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Removes doublets from all the faces into a queue until the queue empties
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param faces Set of all faces modified by the removals
|
||||||
|
* \param q Queue of faces to clean
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void remove_doublets(MeshType &m, set<FacePointer> &faces, queue<FacePointer> &q)
|
||||||
|
{
|
||||||
|
|
||||||
|
while(!q.empty())
|
||||||
|
{
|
||||||
|
FacePointer fp = q.front();
|
||||||
|
q.pop();
|
||||||
|
|
||||||
|
if( !fp->IsD() )
|
||||||
|
{
|
||||||
|
faces.insert(remove_doublet(m,fp, &q));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Removes a doublet and all the other ones that the removal may have generated
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param fp Pointer to the face to clean from doublets
|
||||||
|
* \param Queue of faces to check for new doublets
|
||||||
|
*
|
||||||
|
* \return The new face generated after doublet removal
|
||||||
|
*/
|
||||||
|
static FacePointer remove_doublet(MeshType &m, FacePointer fp, queue<FacePointer> *q = NULL)
|
||||||
|
{
|
||||||
|
vector<HEdgePointer> hedges = HalfEdgeTopology<MeshType>::find_doublet_hedges_quad(fp);
|
||||||
|
|
||||||
|
assert(hedges.size() <= 4);
|
||||||
|
|
||||||
|
switch(hedges.size())
|
||||||
|
{
|
||||||
|
// No doublets
|
||||||
|
case 0:
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
// A single doublet
|
||||||
|
case 1:
|
||||||
|
if(q)
|
||||||
|
{
|
||||||
|
add_faces(*q, hedges[0]->HNp()->HVp());
|
||||||
|
|
||||||
|
add_faces(*q, hedges[0]->HPp()->HVp());
|
||||||
|
}
|
||||||
|
|
||||||
|
return HalfEdgeTopology<MeshType>::doublet_remove_quad(m, hedges[0]->HVp());
|
||||||
|
|
||||||
|
// Two doublets on the same face
|
||||||
|
case 2:
|
||||||
|
{
|
||||||
|
|
||||||
|
if(q)
|
||||||
|
{
|
||||||
|
add_faces(*q, hedges[0]->HNp()->HVp());
|
||||||
|
|
||||||
|
add_faces(*q, hedges[0]->HPp()->HVp());
|
||||||
|
}
|
||||||
|
|
||||||
|
FacePointer fp1 = HalfEdgeTopology<MeshType>::doublet_remove_quad(m, hedges[0]->HVp());
|
||||||
|
|
||||||
|
// Removal of the doublet may generate a singlet
|
||||||
|
if(HalfEdgeTopology<MeshType>::is_singlet_quad(fp1))
|
||||||
|
{
|
||||||
|
|
||||||
|
HEdgePointer hp = HalfEdgeTopology<MeshType>::singlet_remove_quad(m, fp1);
|
||||||
|
|
||||||
|
if(hp)
|
||||||
|
{
|
||||||
|
if(q)
|
||||||
|
{
|
||||||
|
if(hp->HFp())
|
||||||
|
q->push(hp->HFp());
|
||||||
|
if(hp->HOp()->HFp())
|
||||||
|
q->push(hp->HOp()->HFp());
|
||||||
|
}
|
||||||
|
|
||||||
|
int valence1, valence2;
|
||||||
|
|
||||||
|
valence1 = HalfEdgeTopology<MeshType>::vertex_valence(hp->HVp());
|
||||||
|
valence2 = HalfEdgeTopology<MeshType>::vertex_valence(hp->HOp()->HVp());
|
||||||
|
|
||||||
|
// Check if the removal of the singlet generated other singlets, then iteratively remove them
|
||||||
|
while(valence1 == 1 || valence2 == 1)
|
||||||
|
{
|
||||||
|
|
||||||
|
assert(! (valence1 == 1 && valence2 == 1));
|
||||||
|
|
||||||
|
FacePointer singlet_pointer;
|
||||||
|
|
||||||
|
if(valence1 == 1 )
|
||||||
|
singlet_pointer = hp->HFp();
|
||||||
|
else
|
||||||
|
singlet_pointer = hp->HOp()->HFp();
|
||||||
|
|
||||||
|
hp = HalfEdgeTopology<MeshType>::singlet_remove_quad(m, singlet_pointer);
|
||||||
|
|
||||||
|
if(!hp)
|
||||||
|
break;
|
||||||
|
|
||||||
|
if(q)
|
||||||
|
{
|
||||||
|
if(hp->HFp())
|
||||||
|
q->push(hp->HFp());
|
||||||
|
if(hp->HOp()->HFp())
|
||||||
|
q->push(hp->HOp()->HFp());
|
||||||
|
}
|
||||||
|
|
||||||
|
valence1 = HalfEdgeTopology<MeshType>::vertex_valence(hp->HVp());
|
||||||
|
valence2 = HalfEdgeTopology<MeshType>::vertex_valence(hp->HOp()->HVp());
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return fp1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Four doublets: simply remove one of the two faces
|
||||||
|
case 4:
|
||||||
|
HalfEdgeTopology<MeshType>::remove_face(m,fp->FHp()->HOp()->HFp());
|
||||||
|
return fp;
|
||||||
|
|
||||||
|
default:
|
||||||
|
assert(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
public:
|
||||||
|
|
||||||
|
/*! Removes doublets from all the faces on the 1-ring of the given vertices
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param Set of all faces modified by the removals
|
||||||
|
* \param vertices Vector of vertices that will be
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void remove_doublets(MeshType &m, set<FacePointer> &faces, vector<VertexPointer> vertices)
|
||||||
|
{
|
||||||
|
queue<FacePointer> q;
|
||||||
|
|
||||||
|
for(typename vector<VertexPointer>::iterator vi = vertices.begin(); vi != vertices.end(); ++vi)
|
||||||
|
{
|
||||||
|
vector<FacePointer> inc_faces = HalfEdgeTopology<MeshType>::get_incident_faces(*vi);
|
||||||
|
|
||||||
|
for(typename vector<FacePointer>::iterator fi = inc_faces.begin(); fi != inc_faces.end(); ++fi)
|
||||||
|
{
|
||||||
|
if(*fi)
|
||||||
|
if( !((*fi)->IsD()) )
|
||||||
|
q.push(*fi);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
remove_doublets(m, faces, q);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Removes doublets from all the faces on the 1-ring of the given vertices
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param vertices Vector of vertices that will be
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void remove_doublets(MeshType &m, vector<VertexPointer> vertices)
|
||||||
|
{
|
||||||
|
set<FacePointer> faces;
|
||||||
|
|
||||||
|
remove_doublets(m,faces,vertices);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Removes doublets from a set of faces
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param set of faces to clean
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
static void remove_doublets(MeshType &m, set<FacePointer> &faces)
|
||||||
|
{
|
||||||
|
|
||||||
|
queue<FacePointer> q;
|
||||||
|
|
||||||
|
for(typename set<FacePointer>::iterator fi = faces.begin(); fi != faces.end(); ++fi)
|
||||||
|
{
|
||||||
|
if(*fi)
|
||||||
|
if( !((*fi)->IsD()) )
|
||||||
|
q.push(*fi);
|
||||||
|
}
|
||||||
|
|
||||||
|
remove_doublets(m, faces, q);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*! Removes all doublets from a mesh
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
*
|
||||||
|
* \return Number of doublets removed
|
||||||
|
*/
|
||||||
|
static int remove_doublets(MeshType &m)
|
||||||
|
{
|
||||||
|
int count;
|
||||||
|
int removed = 0;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
count = 0;
|
||||||
|
for(FaceIterator fi = m.face.begin(); fi != m.face.end(); ++fi)
|
||||||
|
{
|
||||||
|
if( !((*fi).IsD()) )
|
||||||
|
{
|
||||||
|
if(remove_doublet(m, &(*fi)))
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
removed += count;
|
||||||
|
|
||||||
|
}while(count != 0);
|
||||||
|
|
||||||
|
return removed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Removes all singlets from a mesh
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
*
|
||||||
|
* \return Number of singlets removed
|
||||||
|
*/
|
||||||
|
static int remove_singlets(MeshType &m)
|
||||||
|
{
|
||||||
|
int removed = 0;
|
||||||
|
int count;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
count = 0;
|
||||||
|
for(FaceIterator fi = m.face.begin(); fi != m.face.end(); ++fi)
|
||||||
|
{
|
||||||
|
if( !((*fi).IsD()) )
|
||||||
|
{
|
||||||
|
if( HalfEdgeTopology<MeshType>::is_singlet(&(*fi)) )
|
||||||
|
{
|
||||||
|
HalfEdgeTopology<MeshType>::singlet_remove(m, &(*fi));
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
removed += count;
|
||||||
|
|
||||||
|
}while(count != 0);
|
||||||
|
|
||||||
|
return removed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Checks if a mesh has singlets
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
*
|
||||||
|
* \return Value indicating whether mesh has singlets
|
||||||
|
*/
|
||||||
|
static bool has_singlets(MeshType &m)
|
||||||
|
{
|
||||||
|
|
||||||
|
for(FaceIterator fi = m.face.begin(); fi != m.face.end(); ++fi)
|
||||||
|
{
|
||||||
|
if( !((*fi).IsD()) )
|
||||||
|
{
|
||||||
|
if( HalfEdgeTopology<MeshType>::is_singlet_quad(&(*fi)) )
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Checks if a mesh has doublets
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
*
|
||||||
|
* \return Value indicating whether mesh has doublets
|
||||||
|
*/
|
||||||
|
static bool has_doublets(MeshType &m)
|
||||||
|
{
|
||||||
|
|
||||||
|
for(FaceIterator fi = m.face.begin(); fi != m.face.end(); ++fi)
|
||||||
|
{
|
||||||
|
if( !((*fi).IsD()) )
|
||||||
|
{
|
||||||
|
if( HalfEdgeTopology<MeshType>::has_doublet_quad(&(*fi)) )
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Performs rotation of selected edges computing the best rotation
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
* \param hedges Vector of halfedges representing the edges to rotate
|
||||||
|
* \param faces Set of modified faces (every modified face will be inserted into this set)
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
template<class PriorityType>
|
||||||
|
static void flip_edges(MeshType &m, vector<HEdgePointer> &hedges, set<FacePointer> &faces)
|
||||||
|
{
|
||||||
|
|
||||||
|
for(typename vector<HEdgePointer>::iterator hi = hedges.begin(); hi != hedges.end(); ++hi)
|
||||||
|
{
|
||||||
|
// edge must be shared by two faces
|
||||||
|
if((*hi)->HFp() && (*hi)->HOp()->HFp())
|
||||||
|
{
|
||||||
|
if(!(*hi)->IsD() && !(*hi)->HFp()->IsD() && !(*hi)->HOp()->HFp()->IsD())
|
||||||
|
{
|
||||||
|
typename PriorityType::FlipType fliptype = PriorityType::best_flip( *hi );
|
||||||
|
|
||||||
|
if(fliptype != PriorityType::NO_FLIP)
|
||||||
|
{
|
||||||
|
|
||||||
|
vector<VertexPointer> vertices;
|
||||||
|
|
||||||
|
// Record old vertices for future removal of doublets
|
||||||
|
vertices.push_back((*hi)->HVp());
|
||||||
|
vertices.push_back((*hi)->HOp()->HVp());
|
||||||
|
|
||||||
|
// Add modified faces into the set of faces
|
||||||
|
faces.insert((*hi)->HFp());
|
||||||
|
faces.insert((*hi)->HOp()->HFp());
|
||||||
|
|
||||||
|
bool cw = (fliptype == PriorityType::CW_FLIP);
|
||||||
|
HalfEdgeTopology<MeshType>::edge_rotate_quad((*hi),cw);
|
||||||
|
|
||||||
|
// After a rotation doublets may have generated
|
||||||
|
remove_doublets(m, faces, vertices);
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*! Performs edge rotations on the entire mesh computing the best rotation for each edge
|
||||||
|
*
|
||||||
|
*
|
||||||
|
* \param m Mesh
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
template <class PriorityType>
|
||||||
|
static int flip_edges(MeshType &m)
|
||||||
|
{
|
||||||
|
int count;
|
||||||
|
int ret=0;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
count = 0;
|
||||||
|
for(typename MeshType::EdgeIterator ei = m.edge.begin(); ei != m.edge.end(); ++ei)
|
||||||
|
{
|
||||||
|
|
||||||
|
if( !(ei->IsD()) )
|
||||||
|
{
|
||||||
|
HEdgePointer hp = ei->EHp();
|
||||||
|
|
||||||
|
if(hp->HFp() && hp->HOp()->HFp())
|
||||||
|
{
|
||||||
|
typename PriorityType::FlipType fliptype = PriorityType::best_flip( hp );
|
||||||
|
|
||||||
|
if(fliptype != PriorityType::NO_FLIP)
|
||||||
|
{
|
||||||
|
vector<VertexPointer> vertices;
|
||||||
|
|
||||||
|
// Record old vertices for future removal of doublets
|
||||||
|
vertices.push_back(hp->HVp());
|
||||||
|
vertices.push_back(hp->HOp()->HVp());
|
||||||
|
|
||||||
|
bool cw = (fliptype == PriorityType::CW_FLIP);
|
||||||
|
HalfEdgeTopology<MeshType>::edge_rotate_quad(hp,cw);
|
||||||
|
|
||||||
|
// After a rotation doublets may have generated
|
||||||
|
remove_doublets(m, vertices);
|
||||||
|
|
||||||
|
count++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ret+=count;
|
||||||
|
|
||||||
|
}while(count != 0);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Generic priority for edge rotations
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
template <class MeshType> class EdgeFlipPriority
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef typename MeshType::HEdgePointer HEdgePointer;
|
||||||
|
|
||||||
|
/// Possible types of rotation
|
||||||
|
enum FlipType { NO_FLIP, CW_FLIP, CCW_FLIP};
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* Computes the best rotation to perform
|
||||||
|
*
|
||||||
|
* \param hp Pointer to an halfedge representing the edge to rotate
|
||||||
|
*
|
||||||
|
* \return The best type of rotation
|
||||||
|
*/
|
||||||
|
static FlipType best_flip( HEdgePointer hp);
|
||||||
|
};
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Priority based on maximizing vertices regularity
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
template <class MeshType> class VertReg: public EdgeFlipPriority<MeshType>
|
||||||
|
{
|
||||||
|
|
||||||
|
public:
|
||||||
|
|
||||||
|
typedef typename MeshType::VertexPointer VertexPointer;
|
||||||
|
typedef typename MeshType::EdgePointer EdgePointer;
|
||||||
|
typedef typename MeshType::HEdgePointer HEdgePointer;
|
||||||
|
typedef typename MeshType::FacePointer FacePointer;
|
||||||
|
|
||||||
|
typedef EdgeFlipPriority<MeshType> Base;
|
||||||
|
typedef typename Base::FlipType FlipType;
|
||||||
|
|
||||||
|
/// Default Constructor
|
||||||
|
VertReg(){}
|
||||||
|
|
||||||
|
~VertReg(){}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* Computes the best rotation to perform for maximizing vertices regularity
|
||||||
|
*
|
||||||
|
* \param hp Pointer to an halfedge representing the edge to rotate
|
||||||
|
*
|
||||||
|
* \return The best type of rotation
|
||||||
|
*/
|
||||||
|
static FlipType best_flip( HEdgePointer hp)
|
||||||
|
{
|
||||||
|
assert(hp);
|
||||||
|
assert(!hp->IsD());
|
||||||
|
|
||||||
|
vector<VertexPointer> vps1 = HalfEdgeTopology<MeshType>::getVertices(hp->HFp(), hp);
|
||||||
|
|
||||||
|
vector<VertexPointer> vps2 = HalfEdgeTopology<MeshType>::getVertices(hp->HOp()->HFp(), hp->HOp());
|
||||||
|
|
||||||
|
valarray<double> valences(6);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Indices of vertices into vector valences:
|
||||||
|
|
||||||
|
3-------2
|
||||||
|
| |
|
||||||
|
| f1 |
|
||||||
|
| |
|
||||||
|
0-------1
|
||||||
|
| |
|
||||||
|
| f2 |
|
||||||
|
| |
|
||||||
|
4-------5
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
// Compute valencies of vertices
|
||||||
|
for(int i=0; i<4; i++)
|
||||||
|
valences[i] = HalfEdgeTopology<MeshType>::vertex_valence(vps1[i]) - 4 ;
|
||||||
|
|
||||||
|
valences[4] = HalfEdgeTopology<MeshType>::vertex_valence(vps2[2]) - 4;
|
||||||
|
valences[5] = HalfEdgeTopology<MeshType>::vertex_valence(vps2[3]) - 4;
|
||||||
|
|
||||||
|
|
||||||
|
// Vector containing sums of the valencies in all the possible cases: no rotation, ccw rotation, cw rotation
|
||||||
|
vector<int> sums;
|
||||||
|
|
||||||
|
// positions:
|
||||||
|
// sums[0]: now (No rotation)
|
||||||
|
// sums[1]: flipping ccw
|
||||||
|
// sums[2]: flipping cw
|
||||||
|
|
||||||
|
// No rotation
|
||||||
|
sums.push_back( pow(valences, 2.0).sum() );
|
||||||
|
|
||||||
|
// CCW
|
||||||
|
valences[0]--;
|
||||||
|
valences[1]--;
|
||||||
|
valences[2]++;
|
||||||
|
valences[4]++;
|
||||||
|
|
||||||
|
sums.push_back( pow(valences, 2.0).sum() );
|
||||||
|
|
||||||
|
// CW
|
||||||
|
valences[2]--;
|
||||||
|
valences[4]--;
|
||||||
|
valences[3]++;
|
||||||
|
valences[5]++;
|
||||||
|
|
||||||
|
sums.push_back( pow(valences, 2.0).sum() );
|
||||||
|
|
||||||
|
|
||||||
|
if( sums[2]<= sums[1] && sums[2]< sums[0] )
|
||||||
|
return Base::CW_FLIP;
|
||||||
|
|
||||||
|
else if( sums[1]< sums[2] && sums[1]< sums[0] )
|
||||||
|
return Base::CCW_FLIP;
|
||||||
|
|
||||||
|
return Base::NO_FLIP;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Priority based on minimizing homeometry
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
template <class MeshType> class Homeometry: public EdgeFlipPriority<MeshType>
|
||||||
|
{
|
||||||
|
|
||||||
|
public:
|
||||||
|
|
||||||
|
typedef typename MeshType::VertexPointer VertexPointer;
|
||||||
|
typedef typename MeshType::EdgePointer EdgePointer;
|
||||||
|
typedef typename MeshType::HEdgePointer HEdgePointer;
|
||||||
|
typedef typename MeshType::FacePointer FacePointer;
|
||||||
|
|
||||||
|
|
||||||
|
typedef EdgeFlipPriority<MeshType> Base;
|
||||||
|
typedef typename Base::FlipType FlipType;
|
||||||
|
|
||||||
|
/// Default Constructor
|
||||||
|
Homeometry(){}
|
||||||
|
|
||||||
|
~Homeometry(){}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* Computes the best rotation to perform for minimizing the distance from homeometry
|
||||||
|
*
|
||||||
|
* \param hp Pointer to an halfedge representing the edge to rotate
|
||||||
|
*
|
||||||
|
* \return The best type of rotation
|
||||||
|
*/
|
||||||
|
static FlipType best_flip( HEdgePointer hp)
|
||||||
|
{
|
||||||
|
assert(hp);
|
||||||
|
assert(!hp->IsD());
|
||||||
|
|
||||||
|
vector<VertexPointer> face1 = HalfEdgeTopology<MeshType>::getVertices(hp->HFp(), hp);
|
||||||
|
vector<VertexPointer> face2 = HalfEdgeTopology<MeshType>::getVertices(hp->HOp()->HFp(), hp->HOp());
|
||||||
|
|
||||||
|
// Vector containing sums of the valencies in all the possible cases: no rotation, ccw rotation, cw rotation
|
||||||
|
vector<int> sums;
|
||||||
|
|
||||||
|
// positions:
|
||||||
|
// sums[0]: now (No rotation)
|
||||||
|
// sums[1]: flipping ccw
|
||||||
|
// sums[2]: flipping cw
|
||||||
|
|
||||||
|
// No rotation
|
||||||
|
sums.push_back( distance_from_homeometry(face1, face2, 0) );
|
||||||
|
|
||||||
|
// CCW
|
||||||
|
face1[1] = face2[2];
|
||||||
|
face2[1] = face1[2];
|
||||||
|
|
||||||
|
sums.push_back( distance_from_homeometry(face1, face2, 1) );
|
||||||
|
|
||||||
|
// CW
|
||||||
|
face1[2] = face2[3];
|
||||||
|
face2[2] = face1[3];
|
||||||
|
|
||||||
|
sums.push_back( distance_from_homeometry(face1, face2, 2) );
|
||||||
|
|
||||||
|
|
||||||
|
if( sums[2]<= sums[1] && sums[2]< sums[0] )
|
||||||
|
return Base::CW_FLIP;
|
||||||
|
|
||||||
|
else if( sums[1]< sums[2] && sums[1]< sums[0] )
|
||||||
|
return Base::CCW_FLIP;
|
||||||
|
|
||||||
|
return Base::NO_FLIP;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* Computes the area of a quad
|
||||||
|
*
|
||||||
|
* \param vertices Vector of the four vertices of the quad
|
||||||
|
*
|
||||||
|
* \return Area of the quad
|
||||||
|
*/
|
||||||
|
static float area(vector<VertexPointer> &vertices)
|
||||||
|
{
|
||||||
|
|
||||||
|
assert(vertices.size() == 4);
|
||||||
|
|
||||||
|
float tri1 = Norm( (vertices[1]->cP() - vertices[0]->cP()) ^ (vertices[2]->cP() - vertices[0]->cP()) );
|
||||||
|
float tri2 = Norm( (vertices[2]->cP() - vertices[0]->cP()) ^ (vertices[3]->cP() - vertices[0]->cP()) );
|
||||||
|
|
||||||
|
return (tri1+tri2) / 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* Computes the distance of two faces from being homeometirc
|
||||||
|
*
|
||||||
|
* \param face1 Vector of vertices belonging to the first face
|
||||||
|
* \param face2 Vector of vertices belonging to the second face
|
||||||
|
* \param i Index of the edge to compute
|
||||||
|
*
|
||||||
|
* \return The computed homeometry
|
||||||
|
*/
|
||||||
|
static float distance_from_homeometry(vector<VertexPointer> &face1, vector<VertexPointer> &face2, int i)
|
||||||
|
{
|
||||||
|
// Ideal edge length
|
||||||
|
float mu = sqrt( (area(face1) + area(face2)) / 2 );
|
||||||
|
|
||||||
|
// Length of the i-th edge (the edge changed with a rotation)
|
||||||
|
float edge_length = Distance( face1[i]->cP(), face1[i+1]->cP() );
|
||||||
|
|
||||||
|
// Length of the diagonals
|
||||||
|
valarray<float> diagonals(4);
|
||||||
|
|
||||||
|
diagonals[0] = Distance( face1[0]->cP(), face1[2]->cP() );
|
||||||
|
diagonals[1] = Distance( face1[1]->cP(), face1[3]->cP() );
|
||||||
|
diagonals[2] = Distance( face2[0]->cP(), face2[2]->cP() );
|
||||||
|
diagonals[3] = Distance( face2[1]->cP(), face2[3]->cP() );
|
||||||
|
|
||||||
|
// Ideal diagonal length
|
||||||
|
float ideal_diag_length = SQRT_TWO*mu;
|
||||||
|
|
||||||
|
float sum_diagonals = pow(diagonals - ideal_diag_length, 2.0).sum();
|
||||||
|
|
||||||
|
return (pow (edge_length - mu , static_cast<float>(2.0)) + sum_diagonals);
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif // HALFEDGEQUADCLEAN_H
|
||||||
Loading…
Reference in New Issue