void Mesh::reverseFaces()
{
Mesh::Face_iterator fit = faces_begin();
Mesh::Face_iterator fit_end = faces_end();
for (;fit != fit_end; fit++) {
fit->reverseOrder();
}
}
bool
Surface_mesh::
is_triangle_mesh() const
{
Face_iterator fit=faces_begin(), fend=faces_end();
for (; fit!=fend; ++fit)
if (valence(fit) != 3)
return false;
return true;
}
void
Surface_mesh::
triangulate()
{
/* The iterators will stay valid, even though new faces are added,
because they are now implemented index-based instead of
pointer-based.
*/
Face_iterator fit=faces_begin(), fend=faces_end();
for (; fit!=fend; ++fit)
triangulate(fit);
}
void Mesh::commitRemove()
{
// first go over all the points and tell them where they go
int count = 0;
for(int i = 0; i < numVtx(); ++i)
{
Vertex_handle v = find_vertex(i);
if (v->m_tran == -1)
v->m_index = count++;
else
v->m_index = -1; // to be removed
v->m_tran = -1;
}
// no go over the faces and transfer their point references
count = 0;
for(int i = 0; i < numFaces(); ++i)
{
Face_handle f = find_facet(i);
bool remove = false;
for(int ii = 0; ii < f->size(); ++ii)
{
int newvi = find_vertex(f->m_pi[ii])->m_index;
f->m_pi[ii] = newvi;
remove |= (newvi == -1);
}
if (!remove)
f->m_index = count++;
else
f->m_index = -1;
}
// actually remove the vertices
Vertex_iterator vit = vertices_begin();
while(vit != vertices_end())
{
if (vit->m_index == -1)
vit = m_vtx.erase(vit);
else
++vit;
}
// remove faces
Face_iterator fit = faces_begin();
while(fit != faces_end())
{
if (fit->m_index == -1)
fit = m_face.erase(fit);
else
++fit;
}
}
void
Surface_mesh::
update_face_normals()
{
if (!fnormal_)
fnormal_ = face_property<Normal>("f:normal");
Face_iterator fit, fend=faces_end();
for (fit=faces_begin(); fit!=fend; ++fit)
{
if (!is_deleted(fit))
fnormal_[fit] = compute_face_normal(fit);
}
}
void Mesh::reverseNormals()
{
Mesh::Vertex_iterator vit = vertices_begin();
Mesh::Vertex_iterator vit_end = vertices_end();
for (;vit != vit_end; vit++) {
vit->normal() *= -1.0f;
}
Mesh::Face_iterator fit = faces_begin();
Mesh::Face_iterator fit_end = faces_end();
for (;fit != fit_end; fit++) {
fit->normal() *= -1.0f;
}
}
void Mesh::compute_feature_range_on_facets(float& minVal, float& maxVal, float (Mesh::Face::*datgetter)() const)
{
float minFaceFeature = FLT_MAX;
float maxFaceFeature = -FLT_MAX;
Mesh::Face_const_iterator it = faces_begin();
Mesh::Face_const_iterator it_end = faces_end();
for (;it != it_end; it++)
{
if (((*it).*datgetter)() < minFaceFeature)
minFaceFeature = ((*it).*datgetter)();
if (((*it).*datgetter)() > maxFaceFeature)
maxFaceFeature = ((*it).*datgetter)();
}
minVal = minFaceFeature;
maxVal = maxFaceFeature;
}
Vec3 Mesh::polyCenterOfMass() const
{
float c[3] = { 0.0, 0.0, 0.0 };
float centerWeight = 0.0;
for (Mesh::Face_const_iterator f = faces_begin(); f != faces_end(); ++f)
{
//Mesh::Face_handle f = mesh->find_facet(m_facets[i]);
Vec3 fcenter = f->center();
float facetSurface = f->surface();
c[0] += fcenter.x * facetSurface;
c[1] += fcenter.y * facetSurface;
c[2] += fcenter.z * facetSurface;
centerWeight += facetSurface;
}
c[0] /= centerWeight;
c[1] /= centerWeight;
c[2] /= centerWeight;
return Vec3(c[0], c[1], c[2]);
}
void Mesh::computeCentricity(QWidget* guiParent)
{
// float maxCentricity = -FLT_MAX;
// float minCentricity = FLT_MAX;
QProgressDialog *prog = NULL;
if (guiParent)
prog = new QProgressDialog("Building centricity", "Stop", 0, numVtx(), guiParent);
int counter = 0;
int total = size_of_vertices();
for (Mesh::Vertex_iterator it = vertices_begin(); it != vertices_end(); ++it)
{
if (guiParent)
{
prog->setValue(counter);
QCoreApplication::processEvents();
if (prog->wasCanceled())
return;
}
counter++;
double distanceSum = 0.0;
int count = 0;
dijkstra(&*it);
for (Mesh::Vertex_iterator n = vertices_begin(); n != vertices_end(); ++n)
{
if (n->distance() != FLT_MAX)
{
count++;
distanceSum += n->distance();
}
}
it->centricity(distanceSum/(double)count);
// if (it->centricity() > maxCentricity) maxCentricity = it->centricity();
// if (it->centricity() < minCentricity) minCentricity = it->centricity();
// printf("%d = %f\n", counter, it->centricity());
}
delete prog;
//if (m_normalize )
//{
//report("normalizing values");
/*for (Mesh::Vertex_iterator it = m_mesh->vertices_begin();
it != m_mesh->vertices_end();
it++)
{
if (it->centricity() != FLT_MAX)
it->centricity() = (it->centricity() - minCentricity) / (maxCentricity - minCentricity);
}*/
//normalizeByComponents();
//}
// facet centricity is the average of the vertices.
float featureMin = FLT_MAX;
float featureMax = -FLT_MAX;
for (Mesh::Face_iterator fit = faces_begin(); fit != faces_end(); ++fit)
{
Face_handle fh = &*fit;
float val = 0.0;
for(int fii = 0; fii < fh->size(); ++fii)
{
Vertex_handle cv = fh->vertex(fii);
val += cv->centricity();
}
val /= fh->size();
fh->centricity() = val;
if (val < featureMin)
featureMin = val;
if (val > featureMax)
featureMax = val;
}
float divwith = 1.0 / (featureMax - featureMin);
for (Mesh::Face_iterator fit = faces_begin(); fit != faces_end(); ++fit)
{
Face_handle fh = &*fit;
fh->centricity() = (fh->centricity() - featureMin) * divwith;
}
m_hasCentricity = true;
}
void test( const std::string & meshFile )
{
auto mesh = make_shared< MeshType >();
mesh::readAndBroadcast( meshFile, *mesh);
auto aabb = computeAABB( *mesh );
using Scalar = typename MeshType::Scalar;
Vector3<Scalar> translation( numeric_cast<Scalar>( aabb.xSize() ) * Scalar(2) * Scalar( MPIManager::instance()->rank() ), Scalar(0), Scalar(0) );
translate( *mesh, translation );
mesh->request_face_normals();
mesh->request_vertex_normals();
mesh->update_normals();
mesh->request_face_status();
bool b = true;
for( auto it = mesh->faces_begin(); it != mesh->faces_end(); ++it )
{
mesh->status( *it ).set_tagged( b );
b = !b;
}
mesh->request_vertex_status();
b = true;
for( auto it = mesh->vertices_begin(); it != mesh->vertices_end(); ++it )
{
mesh->status( *it ).set_tagged( b );
b = !b;
}
std::vector< typename MeshType::Color > colors;
colors.push_back( typename MeshType::Color( 255,0,0 ) );
colors.push_back( typename MeshType::Color( 0,255,0 ) );
colors.push_back( typename MeshType::Color( 0,0,255 ) );
auto colorIt = colors.begin();
mesh->request_vertex_colors();
for( auto it = mesh->vertices_begin(); it != mesh->vertices_end(); ++it )
{
mesh->set_color( *it, *colorIt );
++colorIt;
if( colorIt == colors.end() )
colorIt = colors.begin();
}
mesh->request_face_colors();
for( auto it = mesh->faces_begin(); it != mesh->faces_end(); ++it )
{
mesh->set_color( *it, *colorIt );
++colorIt;
if( colorIt == colors.end() )
colorIt = colors.begin();
}
DistributedVTKMeshWriter< MeshType > meshWriter( mesh, "distributed_mesh_vtk_test_unfiltered", 1 );
meshWriter.addDataSource( make_shared< NormalsVertexDataSource< MeshType > >() );
meshWriter.addDataSource( make_shared< NormalsFaceDataSource < MeshType > >() );
meshWriter.addDataSource( make_shared< AreaFaceDataSource < MeshType > >() );
meshWriter.addDataSource( make_shared< StatusBitFaceDataSource < MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriter.addDataSource( make_shared< StatusBitVertexDataSource< MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriter.addDataSource( make_shared< ColorFaceDataSource < MeshType > >() );
meshWriter.addDataSource( make_shared< ColorVertexDataSource< MeshType > >() );
meshWriter.addDataSource( make_shared< IndexFaceDataSource < MeshType > >() );
meshWriter.addDataSource( make_shared< IndexVertexDataSource< MeshType > >() );
meshWriter.addDataSource( make_shared< RankFaceDataSource < MeshType > >() );
meshWriter.addDataSource( make_shared< RankVertexDataSource< MeshType > >() );
meshWriter();
DistributedVTKMeshWriter< MeshType > meshWriterAABBfiltered( mesh, "distributed_mesh_vtk_test_aabb_filter", 1 );
meshWriterAABBfiltered.addDataSource( make_shared< NormalsVertexDataSource< MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< NormalsFaceDataSource < MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< AreaFaceDataSource < MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< StatusBitFaceDataSource < MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriterAABBfiltered.addDataSource( make_shared< StatusBitVertexDataSource< MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriterAABBfiltered.addDataSource( make_shared< ColorFaceDataSource < MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< ColorVertexDataSource< MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< IndexFaceDataSource < MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< IndexVertexDataSource< MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< RankFaceDataSource < MeshType > >() );
meshWriterAABBfiltered.addDataSource( make_shared< RankVertexDataSource< MeshType > >() );
meshWriterAABBfiltered.setFaceFilter( mesh::AABBFaceFilter< MeshType >(aabb) );
meshWriterAABBfiltered();
DistributedVTKMeshWriter< MeshType > meshWriterStatusfiltered( mesh, "distributed_mesh_vtk_test_status_filter", 1 );
meshWriterStatusfiltered.addDataSource( make_shared< NormalsVertexDataSource< MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< NormalsFaceDataSource < MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< AreaFaceDataSource < MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< StatusBitFaceDataSource < MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriterStatusfiltered.addDataSource( make_shared< StatusBitVertexDataSource< MeshType > >( OpenMesh::Attributes::TAGGED, "tagged" ) );
meshWriterStatusfiltered.addDataSource( make_shared< ColorFaceDataSource < MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< ColorVertexDataSource< MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< IndexFaceDataSource < MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< IndexVertexDataSource< MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< RankFaceDataSource < MeshType > >() );
meshWriterStatusfiltered.addDataSource( make_shared< RankVertexDataSource< MeshType > >() );
meshWriterStatusfiltered.setFaceFilter( mesh::StatusFaceFilter< MeshType >( OpenMesh::Attributes::TAGGED ) );
meshWriterStatusfiltered();
}
