first release version of polygonal algorithms methods
This commit is contained in:
nico
parent
b482aa3cbe
commit
4b29ec5ef6
|
|
@ -10,3 +10,26 @@ release/
|
|||
|
||||
# Intermediate Files
|
||||
*.bc
|
||||
apps/sample/polygonmesh_dual/polygonmesh_base
|
||||
|
||||
*.stash
|
||||
|
||||
apps/sample/polygonmesh_dual/dual_dual.obj
|
||||
|
||||
apps/sample/polygonmesh_dual/dual.obj
|
||||
|
||||
apps/sample/polygonmesh_dual/Makefile
|
||||
|
||||
apps/sample/polygonmesh_dual/plylib.o
|
||||
|
||||
*.o
|
||||
|
||||
*.ply
|
||||
|
||||
*.obj
|
||||
|
||||
apps/sample/polygonmesh_optimize/polygonmesh_base
|
||||
|
||||
apps/sample/polygonmesh_optimize/Makefile
|
||||
|
||||
vcg/complex/algorithms/polygonal_algorithmsOLD.h
|
||||
|
|
|
|||
|
|
@ -0,0 +1,957 @@
|
|||
/****************************************************************************
|
||||
* 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_POLY_MESH_ALGORITHM
|
||||
#define __VCGLIB_POLY_MESH_ALGORITHM
|
||||
|
||||
#include <vcg/complex/algorithms/update/normal.h>
|
||||
#include <vcg/complex/complex.h>
|
||||
#include <vcg/space/polygon3.h>
|
||||
#include <vcg/complex/algorithms/update/color.h>
|
||||
#include <vcg/complex/algorithms/closest.h>
|
||||
#include <vcg/complex/algorithms/update/flag.h>
|
||||
#include <vcg/complex/algorithms/point_sampling.h>
|
||||
|
||||
//define a temporary triangle mesh type
|
||||
class TempFace;
|
||||
class TempVertex;
|
||||
|
||||
struct TempUsedTypes: public vcg::UsedTypes<vcg::Use<TempVertex>::AsVertexType,
|
||||
vcg::Use<TempFace>::AsFaceType>{};
|
||||
|
||||
class TempVertex:public vcg::Vertex<TempUsedTypes,
|
||||
vcg::vertex::Coord3d,
|
||||
vcg::vertex::Normal3d,
|
||||
vcg::vertex::BitFlags>
|
||||
{};
|
||||
|
||||
class TempFace:public vcg::Face<TempUsedTypes,
|
||||
vcg::face::VertexRef,
|
||||
vcg::face::BitFlags,
|
||||
vcg::face::FFAdj,
|
||||
vcg::face::Mark,
|
||||
vcg::face::Normal3d>
|
||||
{};
|
||||
|
||||
|
||||
class TempMesh: public vcg::tri::TriMesh< std::vector<TempVertex>,std::vector<TempFace > >
|
||||
{};
|
||||
|
||||
namespace vcg{
|
||||
|
||||
/*!
|
||||
\ingroup PolyMeshType
|
||||
|
||||
\headerfile color.h vcg/complex/algorithms/polygonal_algorithms.h
|
||||
|
||||
\brief processing and optimization of generic polygonal meshes.
|
||||
|
||||
This class is used to performs varisous kind of geometric optimization on generic polygonal mesh such as flattengin or imptove the shape of polygons.
|
||||
*/
|
||||
|
||||
template <class PolyMeshType>
|
||||
class PolygonalAlgorithm
|
||||
{
|
||||
typedef typename PolyMeshType::FaceType FaceType;
|
||||
typedef typename PolyMeshType::VertexType VertexType;
|
||||
typedef typename PolyMeshType::CoordType CoordType;
|
||||
typedef typename PolyMeshType::ScalarType ScalarType;
|
||||
|
||||
|
||||
static bool CollapseBorderSmallEdgesStep(PolyMeshType &poly_m,
|
||||
const ScalarType edge_limit)
|
||||
{
|
||||
bool collapsed=false;
|
||||
|
||||
//update topology
|
||||
vcg::tri::UpdateTopology<PolyMeshType>::FaceFace(poly_m);
|
||||
|
||||
//update border vertices
|
||||
//UpdateBorderVertexFromPFFAdj(poly_m);
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexBorderFromFaceAdj(poly_m);
|
||||
|
||||
//get border edges
|
||||
std::vector<std::vector<bool> > IsBorder;
|
||||
BorderEdgeFromPFFAdj(poly_m,IsBorder);
|
||||
|
||||
//deselect all vertices
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexClearS(poly_m);
|
||||
|
||||
//this set how to remap the vertices after deletion
|
||||
std::map<VertexType*,VertexType*> VertexRemap;
|
||||
|
||||
//go over all faces and check the ones needed to be deleted
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
int NumV=poly_m.face[i].VN();
|
||||
for (size_t j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v0=poly_m.face[i].V(j);
|
||||
VertexType *v1=poly_m.face[i].V((j+1)%NumV);
|
||||
assert(v0!=v1);
|
||||
|
||||
bool IsBV0=v0->IsB();
|
||||
bool IsBV1=v1->IsB();
|
||||
|
||||
//in these cases is not possible to collapse
|
||||
if ((!IsBV0)&&(!IsBV1))continue;
|
||||
if ((!IsBorder[i][j])&&(IsBV0)&&(IsBV1))continue;
|
||||
if (v0->IsS())continue;
|
||||
if (v1->IsS())continue;
|
||||
|
||||
assert((IsBV0)||(IsBV1));
|
||||
CoordType pos0=v0->P();
|
||||
CoordType pos1=v1->P();
|
||||
ScalarType currL=(pos0-pos1).Norm();
|
||||
if (currL>edge_limit)continue;
|
||||
|
||||
//then collapse the point
|
||||
CoordType InterpPos;
|
||||
if ((IsBV0)&&(!IsBV1))InterpPos=pos0;
|
||||
if ((!IsBV0)&&(IsBV1))InterpPos=pos1;
|
||||
if ((IsBV0)&&(IsBV1))InterpPos=(pos0+pos1)/2.0;
|
||||
|
||||
//put on the same position
|
||||
v0->P()=InterpPos;
|
||||
v1->P()=InterpPos;
|
||||
|
||||
//select the the two vertices
|
||||
v0->SetS();
|
||||
v1->SetS();
|
||||
|
||||
//set the remap
|
||||
VertexRemap[v1]=v0;
|
||||
|
||||
collapsed=true;
|
||||
}
|
||||
}
|
||||
|
||||
//then remap vertices
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
int NumV=poly_m.face[i].VN();
|
||||
for (int j=0;j<NumV;j++)
|
||||
{
|
||||
//get the two vertices of the edge
|
||||
VertexType *v0=poly_m.face[i].V(j);
|
||||
//see if it must substituted or not
|
||||
if (VertexRemap.count(v0)==0)continue;
|
||||
//in that case remap to the new one
|
||||
VertexType *newV=VertexRemap[v0];
|
||||
//assign new vertex
|
||||
poly_m.face[i].V(j)=newV;
|
||||
}
|
||||
}
|
||||
|
||||
//then re-elaborate the face
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
//get vertices of the face
|
||||
int NumV=poly_m.face[i].VN();
|
||||
std::vector<VertexType*> FaceV;
|
||||
for (int j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v0=poly_m.face[i].V(j);
|
||||
VertexType *v1=poly_m.face[i].V((j+1)%NumV);
|
||||
if(v0==v1)continue;
|
||||
FaceV.push_back(v0);
|
||||
}
|
||||
|
||||
//then deallocate face
|
||||
if ((int)FaceV.size()==NumV)continue;
|
||||
|
||||
//otherwise deallocate and set new vertices
|
||||
poly_m.face[i].Dealloc();
|
||||
poly_m.face[i].Alloc(FaceV.size());
|
||||
for (size_t j=0;j<FaceV.size();j++)
|
||||
poly_m.face[i].V(j)=FaceV[j];
|
||||
}
|
||||
|
||||
return collapsed;
|
||||
}
|
||||
|
||||
static void LaplacianPos(PolyMeshType &poly_m,std::vector<CoordType> &AvVert)
|
||||
{
|
||||
//cumulate step
|
||||
AvVert.clear();
|
||||
AvVert.resize(poly_m.vert.size(),CoordType(0,0,0));
|
||||
std::vector<ScalarType> AvSum(poly_m.vert.size(),0);
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
for (size_t j=0;j<(size_t)poly_m.face[i].VN();j++)
|
||||
{
|
||||
//get current vertex
|
||||
VertexType *currV=poly_m.face[i].V(j);
|
||||
//and its position
|
||||
CoordType currP=currV->P();
|
||||
//cumulate over other positions
|
||||
ScalarType W=vcg::PolyArea(poly_m.face[i]);
|
||||
//assert(W!=0);
|
||||
for (size_t k=0;k<(size_t)poly_m.face[i].VN();k++)
|
||||
{
|
||||
if (k==j)continue;
|
||||
int IndexV=vcg::tri::Index(poly_m,poly_m.face[i].V(k));
|
||||
AvVert[IndexV]+=currP*W;
|
||||
AvSum[IndexV]+=W;
|
||||
}
|
||||
}
|
||||
|
||||
//average step
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
if (AvSum[i]==0)continue;
|
||||
AvVert[i]/=AvSum[i];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void UpdateNormal(FaceType &F)
|
||||
{
|
||||
F.N()=vcg::PolygonNormal(F);
|
||||
}
|
||||
|
||||
static void UpdateNormalByFitting(FaceType &F)
|
||||
{
|
||||
UpdateNormal(F);
|
||||
vcg::Plane3<ScalarType> PlF;
|
||||
PlF=PolyFittingPlane(F);
|
||||
if ((PlF.Direction()*F.N())<0)
|
||||
F.N()=-PlF.Direction();
|
||||
else
|
||||
F.N()=PlF.Direction();
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
// static void GetFaceNormals(FaceType &F,
|
||||
// std::vector<CoordType> &Norms)
|
||||
// {
|
||||
// Norms.clear();
|
||||
// if (F.VN()<=2) return;
|
||||
// for (int i=0;i<F.VN();i++)
|
||||
// {
|
||||
// int index0=(i+F.VN()-1) % F.VN();
|
||||
// int index1=i;
|
||||
// int index2=(i+1) % F.VN();
|
||||
|
||||
// CoordType p0=F.P(index0);
|
||||
// CoordType p1=F.P(index1);
|
||||
// CoordType p2=F.P(index2);
|
||||
|
||||
// CoordType v0=p0-p1;
|
||||
// CoordType v1=p2-p1;
|
||||
// CoordType Ni=v1^v0;
|
||||
// Ni.Normalize();
|
||||
// // bool isOK=CheckCoords(Ni);
|
||||
// // if (isOK)
|
||||
// Norms.push_back(Ni);
|
||||
// }
|
||||
// }
|
||||
|
||||
static CoordType GetFaceGetBary(FaceType &F)
|
||||
{
|
||||
CoordType bary=PolyBarycenter(F);
|
||||
return bary;
|
||||
}
|
||||
|
||||
/*! \brief update the face normal by averaging among vertex's
|
||||
* normals computed between adjacent edges
|
||||
*/
|
||||
static void UpdateFaceNormals(PolyMeshType &poly_m)
|
||||
{
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
UpdateNormal(poly_m.face[i]);
|
||||
}
|
||||
|
||||
/*! \brief update the face normal by fitting a plane
|
||||
*/
|
||||
static void UpdateFaceNormalByFitting(PolyMeshType &poly_m)
|
||||
{
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
UpdateNormalByFitting(poly_m.face[i]);
|
||||
}
|
||||
|
||||
// ///METTERE SOTTO TOPOLOGY?
|
||||
// static void BorderEdgeFromPFFAdj(FaceType &F,std::vector<bool> &IsBorder)
|
||||
// {
|
||||
// IsBorder.resize(F.VN(),false);
|
||||
// for (int j=0;j<F.VN();j++)
|
||||
// IsBorder[j]=(F.FFp(j)==&F);
|
||||
// }
|
||||
|
||||
// static void BorderEdgeFromPFFAdj(PolyMeshType &poly_m,
|
||||
// std::vector<std::vector<bool> > &IsBorder)
|
||||
// {
|
||||
// IsBorder.resize(poly_m.face.size());
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// if (poly_m.face[i].IsD())continue;
|
||||
// BorderEdgeFromPFFAdj(poly_m.face[i],IsBorder[i]);
|
||||
// }
|
||||
// }
|
||||
|
||||
// static void UpdateBorderVertexFromPFFAdj(PolyMeshType &poly_m)
|
||||
// {
|
||||
// //get per edge border flag
|
||||
// std::vector<std::vector<bool> > IsBorderE;
|
||||
// BorderEdgeFromPFFAdj(poly_m,IsBorderE);
|
||||
|
||||
// //then update per vertex
|
||||
// vcg::tri::UpdateFlags<PolyMeshType>::VertexClearB(poly_m);
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// if (poly_m.face[i].IsD())continue;
|
||||
|
||||
// for (int j=0;j<poly_m.face[i].VN();j++)
|
||||
// {
|
||||
// if (!IsBorderE[i][j])continue;
|
||||
// poly_m.face[i].V0(j)->SetB();
|
||||
// poly_m.face[i].V1(j)->SetB();
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
// //METTERE IN QUALITY -> update quality
|
||||
// static void PerVertexValence(PolyMeshType &poly_m,
|
||||
// std::vector<unsigned int> &Valence)
|
||||
// {
|
||||
// Valence.resize(poly_m.vert.size(),0);
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// if (poly_m.face[i].IsD())continue;
|
||||
|
||||
// for (int j=0;j<poly_m.face[i].VN();j++)
|
||||
// {
|
||||
// VertexType *v=poly_m.face[i].V(j);
|
||||
// int Index=vcg::tri::Index(poly_m,v);
|
||||
|
||||
// Valence[Index]++;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
enum PolyQualityType{QAngle,QPlanar,QTemplate};
|
||||
|
||||
/*! \brief update the quality of the faces by considering different possibilities
|
||||
* QAngle = consider the angle deviation from ideal one (ex 90° quad, 60° triangle...)
|
||||
* QPlanar = consider the difference wrt interpolating plane
|
||||
* QTemplate= consider the difference wrt template polygon as in "Statics Aware Grid Shells"
|
||||
*/
|
||||
static void UpdateQuality(PolyMeshType &poly_m,
|
||||
const PolyQualityType &QType)
|
||||
{
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
if (poly_m.face[i].IsD())continue;
|
||||
switch (QType)
|
||||
{
|
||||
case QAngle:
|
||||
ScalarType AvgDev,WorstDev;
|
||||
vcg::PolyAngleDeviation(poly_m.face[i],AvgDev,WorstDev);
|
||||
poly_m.face[i].Q()=AvgDev;
|
||||
break;
|
||||
case QPlanar:
|
||||
poly_m.face[i].Q()=vcg::PolyFlatness(poly_m.face[i]);
|
||||
break;
|
||||
default:
|
||||
poly_m.face[i].Q()=vcg::PolyAspectRatio(poly_m.face[i],true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// //DELETE
|
||||
// static void ColorByQuality(PolyMeshType &poly_m,
|
||||
// const PolyQualityType &QType)
|
||||
// {
|
||||
// UpdateQuality(poly_m,QType);
|
||||
// vcg::tri::UpdateColor<PolyMeshType>::PerFaceQualityRamp(poly_m);
|
||||
// }
|
||||
|
||||
// static void ColorScatterByQuality(PolyMeshType &poly_m)
|
||||
// {
|
||||
// //get the max of quality
|
||||
// ScalarType MaxQ=0;
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// if (poly_m.face[i].Q()<MaxQ)continue;
|
||||
// MaxQ=poly_m.face[i].Q();
|
||||
// }
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// poly_m.face[i].C()=vcg::Color4b::Scatter(MaxQ+1,poly_m.face[i].Q());
|
||||
// }
|
||||
// }
|
||||
|
||||
// static void ColorRangeByQuality(PolyMeshType &poly_m,
|
||||
// ScalarType minV=0,
|
||||
// ScalarType maxV=1)
|
||||
// {
|
||||
// //get the max of quality
|
||||
// ScalarType testMin=std::min(minV,maxV);
|
||||
// ScalarType testMax=std::max(minV,maxV);
|
||||
// bool to_swap=minV>maxV;
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// {
|
||||
// ScalarType val=poly_m.face[i].Q();
|
||||
// if (val<testMin)val=testMin;
|
||||
// if (val>testMax)val=testMax;
|
||||
// if (!to_swap)
|
||||
// poly_m.face[i].C()=vcg::Color4b::ColorRamp(testMin,testMax,poly_m.face[i].Q());
|
||||
// else
|
||||
// poly_m.face[i].C()=vcg::Color4b::ColorRamp(testMax,testMin,poly_m.face[i].Q());
|
||||
|
||||
// }
|
||||
// }
|
||||
|
||||
// //DELETE
|
||||
// static void ColorUniformly(PolyMeshType &poly_m,
|
||||
// vcg::Color4b col=vcg::Color4b(200,200,200,255))
|
||||
// {
|
||||
// vcg::tri::UpdateColor<PolyMeshType>::PerFaceConstant(poly_m,col);
|
||||
// }
|
||||
|
||||
/*! \brief given a face this function returns the template positions as in "Statics Aware Grid Shells"
|
||||
*/
|
||||
static void GetRotatedTemplatePos(FaceType &f,
|
||||
std::vector<CoordType> &TemplatePos)
|
||||
{
|
||||
vcg::GetPolyTemplatePos(f,TemplatePos,true);
|
||||
|
||||
CoordType NormT=Normal(TemplatePos);
|
||||
//get the normal of vertices
|
||||
CoordType AVN(0,0,0);
|
||||
CoordType Origin(0,0,0);
|
||||
for (int j=0;j<f.VN();j++)
|
||||
AVN+=f.V(j)->N();
|
||||
|
||||
for (size_t j=0;j<TemplatePos.size();j++)
|
||||
Origin+=TemplatePos[j];
|
||||
|
||||
Origin/=(ScalarType)TemplatePos.size();
|
||||
AVN.Normalize();
|
||||
|
||||
//find rotation matrix
|
||||
vcg::Matrix33<ScalarType> Rot=vcg::RotationMatrix(NormT,AVN);
|
||||
|
||||
//apply transformation
|
||||
for (size_t j=0;j<TemplatePos.size();j++)
|
||||
{
|
||||
TemplatePos[j]-=Origin;
|
||||
TemplatePos[j]=Rot*TemplatePos[j];
|
||||
TemplatePos[j]+=Origin;
|
||||
}
|
||||
}
|
||||
|
||||
/*! \brief This function performs the polygon regularization as in "Statics Aware Grid Shells"
|
||||
*/
|
||||
static void SmoothPCA(PolyMeshType &poly_m,
|
||||
int relax_step=10,
|
||||
ScalarType Damp=0.5,
|
||||
bool fixIrr=false,
|
||||
bool isotropic=true,
|
||||
ScalarType smoothTerm=0.1,
|
||||
bool fixB=true)
|
||||
{
|
||||
(void)isotropic;
|
||||
typedef typename PolyMeshType::FaceType PolygonType;
|
||||
// // select irregular ones
|
||||
// if (fixIrr)
|
||||
// poly_m.NumIrregular(true);
|
||||
// compute the average edge
|
||||
ScalarType MeshArea=0;
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
MeshArea+=vcg::PolyArea(poly_m.face[i]);
|
||||
|
||||
ScalarType AvgArea=MeshArea/(ScalarType)poly_m.face.size();
|
||||
|
||||
for (size_t s=0;s<(size_t)relax_step;s++)
|
||||
{
|
||||
//initialize the accumulation vector
|
||||
std::vector<CoordType> avgPos(poly_m.vert.size(),CoordType(0,0,0));
|
||||
std::vector<ScalarType> weightSum(poly_m.vert.size(),0);
|
||||
//then compute the templated positions
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
std::vector<typename PolygonType::CoordType> TemplatePos;
|
||||
GetRotatedTemplatePos(poly_m.face[i],TemplatePos);
|
||||
//then cumulate the position per vertex
|
||||
ScalarType val=vcg::PolyArea(poly_m.face[i]);
|
||||
if (val<(AvgArea*0.00001))
|
||||
val=(AvgArea*0.00001);
|
||||
ScalarType W=1.0/val;//poly_m.face[i].Q();
|
||||
//ScalarType W=1;
|
||||
|
||||
for (size_t j=0;j<TemplatePos.size();j++)
|
||||
{
|
||||
int IndexV=vcg::tri::Index(poly_m,poly_m.face[i].V(j));
|
||||
CoordType Pos=TemplatePos[j];
|
||||
//sum up contributes
|
||||
avgPos[IndexV]+=Pos*W;
|
||||
weightSum[IndexV]+=W;
|
||||
}
|
||||
}
|
||||
|
||||
//get the laplacian contribute
|
||||
std::vector<CoordType> AvVert;
|
||||
LaplacianPos(poly_m,AvVert);
|
||||
//then update the position
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
ScalarType alpha=smoothTerm;//PolyNormDeviation(poly_m.face[i]);
|
||||
// if (alpha<0)alpha=0;
|
||||
// if (alpha>1)alpha=1;
|
||||
// if (isnan(alpha))alpha=1;
|
||||
CoordType newP=avgPos[i]/weightSum[i];
|
||||
newP=newP*(1-alpha)+AvVert[i]*alpha;
|
||||
if ((fixB)&&(poly_m.vert[i].IsB()))continue;
|
||||
if ((fixIrr)&&(poly_m.vert[i].IsS()))continue;
|
||||
poly_m.vert[i].P()=poly_m.vert[i].P()*Damp+
|
||||
newP*(1-Damp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*! \brief This function smooth the borders of the polygonal mesh and reproject back to the triangolar one
|
||||
* except the vertices that are considered as corner wrt the angleDeg threshold
|
||||
*/
|
||||
template <class TriMeshType>
|
||||
static void LaplacianReprojectBorder(PolyMeshType &poly_m,
|
||||
TriMeshType &tri_mesh,
|
||||
int nstep=100,
|
||||
ScalarType Damp=0.5,
|
||||
ScalarType angleDeg=100)
|
||||
{
|
||||
typedef typename TriMeshType::FaceType FaceType;
|
||||
|
||||
//first select corners
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexClearS(poly_m);
|
||||
|
||||
//update topology
|
||||
vcg::tri::UpdateTopology<PolyMeshType>::FaceFace(poly_m);
|
||||
|
||||
//update border vertices
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexBorderFromFaceAdj(poly_m);
|
||||
|
||||
//select corner vertices on the border
|
||||
ScalarType angleRad=angleDeg * M_PI / 180;
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::SelectVertexCornerBorder(poly_m,angleRad);
|
||||
|
||||
for (int s=0;s<nstep;s++)
|
||||
{
|
||||
std::vector<CoordType> AvVert;
|
||||
LaplacianPos(poly_m,AvVert);
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
if (!poly_m.vert[i].IsB())continue;
|
||||
if (poly_m.vert[i].IsS())continue;
|
||||
poly_m.vert[i].P()=poly_m.vert[i].P()*Damp+
|
||||
AvVert[i]*(1-Damp);
|
||||
}
|
||||
|
||||
//then reproject on border
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
if (!poly_m.vert[i].IsB())continue;
|
||||
if (poly_m.vert[i].IsS())continue;
|
||||
|
||||
CoordType testPos=poly_m.vert[i].P();
|
||||
ScalarType minD=std::numeric_limits<ScalarType>::max();
|
||||
CoordType closPos;
|
||||
for (size_t j=0;j<tri_mesh.face.size();j++)
|
||||
for (size_t k=0;k<3;k++)
|
||||
{
|
||||
if (!tri_mesh.face[j].IsB(k))continue;
|
||||
|
||||
CoordType P0,P1;
|
||||
P0.Import(tri_mesh.face[j].cP0(k));
|
||||
P1.Import(tri_mesh.face[j].cP1(k));
|
||||
vcg::Segment3<ScalarType> Seg(P0,P1);
|
||||
ScalarType testD;
|
||||
CoordType closTest;
|
||||
vcg::SegmentPointDistance(Seg,testPos,closTest,testD);
|
||||
if (testD>minD)continue;
|
||||
minD=testD;
|
||||
closPos=closTest;
|
||||
}
|
||||
poly_m.vert[i].P()=closPos;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*! \brief This function smooth the borders of the polygonal mesh and reproject back to its border
|
||||
*/
|
||||
static void LaplacianReprojectBorder(PolyMeshType &poly_m,
|
||||
int nstep=100,
|
||||
ScalarType Damp=0.5)
|
||||
{
|
||||
//transform into triangular
|
||||
TempMesh GuideSurf;
|
||||
vcg::tri::PolygonSupport<TempMesh,PolyMeshType>::ImportFromPolyMesh(GuideSurf,poly_m);
|
||||
vcg::tri::UpdateBounding<TempMesh>::Box(GuideSurf);
|
||||
vcg::tri::UpdateNormal<TempMesh>::PerVertexNormalizedPerFace(GuideSurf);
|
||||
vcg::tri::UpdateTopology<TempMesh>::FaceFace(GuideSurf);
|
||||
vcg::tri::UpdateFlags<TempMesh>::FaceBorderFromFF(GuideSurf);
|
||||
|
||||
LaplacianReprojectBorder<TempMesh>(poly_m,GuideSurf,nstep,Damp);
|
||||
}
|
||||
|
||||
/*! \brief This function performs the reprojection of the polygonal mesh onto a triangular one passed as input parameter
|
||||
*/
|
||||
template <class TriMeshType>
|
||||
static void LaplacianReproject(PolyMeshType &poly_m,
|
||||
TriMeshType &tri_mesh,
|
||||
bool fixIrr=false,
|
||||
int nstep=100,
|
||||
ScalarType Damp=0.5)
|
||||
{
|
||||
typedef typename TriMeshType::FaceType FaceType;
|
||||
typedef vcg::GridStaticPtr<FaceType, ScalarType> TriMeshGrid;
|
||||
TriMeshGrid grid;
|
||||
|
||||
//initialize the grid
|
||||
grid.Set(tri_mesh.face.begin(),tri_mesh.face.end());
|
||||
|
||||
ScalarType MaxD=tri_mesh.bbox.Diag();
|
||||
|
||||
if (fixIrr)
|
||||
poly_m.NumIrregular(true);
|
||||
for (int s=0;s<nstep;s++)
|
||||
{
|
||||
std::vector<CoordType> AvVert;
|
||||
LaplacianPos(poly_m,AvVert);
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
if (poly_m.vert[i].IsB())continue;
|
||||
if (fixIrr && (poly_m.vert[i].IsS()))continue;
|
||||
poly_m.vert[i].P()=poly_m.vert[i].P()*Damp+
|
||||
AvVert[i]*(1-Damp);
|
||||
}
|
||||
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
CoordType testPos=poly_m.vert[i].P();
|
||||
CoordType closestPt;
|
||||
ScalarType minDist;
|
||||
FaceType *f=NULL;
|
||||
CoordType norm,ip;
|
||||
f=vcg::tri::GetClosestFaceBase(tri_mesh,grid,testPos,MaxD,minDist,closestPt,norm,ip);
|
||||
poly_m.vert[i].P()=poly_m.vert[i].P()*Damp+
|
||||
closestPt*(1-Damp);
|
||||
poly_m.vert[i].N()=norm;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*! \brief This function performs the polygon regularization as in "Statics Aware Grid Shells"
|
||||
* followed by a reprojection step on the triangle mesh passed as parameter
|
||||
*/
|
||||
template <class TriMeshType>
|
||||
static void SmoothReprojectPCA(PolyMeshType &poly_m,
|
||||
TriMeshType &tri_mesh,
|
||||
int relaxStep=100,
|
||||
bool fixIrr=false,
|
||||
ScalarType Damp=0.5)
|
||||
{
|
||||
vcg::tri::UpdateTopology<PolyMeshType>::FaceFace(poly_m);
|
||||
|
||||
//UpdateBorderVertexFromPFFAdj(poly_m);
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexBorderFromFaceAdj(poly_m);
|
||||
|
||||
typedef typename TriMeshType::FaceType FaceType;
|
||||
typedef vcg::GridStaticPtr<FaceType, typename TriMeshType::ScalarType> TriMeshGrid;
|
||||
TriMeshGrid grid;
|
||||
|
||||
//initialize the grid
|
||||
grid.Set(tri_mesh.face.begin(),tri_mesh.face.end());
|
||||
|
||||
ScalarType MaxD=tri_mesh.bbox.Diag();
|
||||
|
||||
// //update quality as area
|
||||
// for (size_t i=0;i<poly_m.face.size();i++)
|
||||
// poly_m.face[i].Q()=vcg::PolyArea(poly_m.face[i]);
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
typename TriMeshType::CoordType testPos;
|
||||
testPos.Import(poly_m.vert[i].P());
|
||||
typename TriMeshType::CoordType closestPt;
|
||||
typename TriMeshType::ScalarType minDist;
|
||||
typename TriMeshType::FaceType *f=NULL;
|
||||
typename TriMeshType::CoordType norm,ip;
|
||||
f=vcg::tri::GetClosestFaceBase(tri_mesh,grid,testPos,MaxD,minDist,closestPt,norm,ip);
|
||||
poly_m.vert[i].N().Import(norm);
|
||||
}
|
||||
|
||||
for(int k=0;k<relaxStep;k++)
|
||||
{
|
||||
//smooth PCA step
|
||||
SmoothPCA(poly_m,1,Damp,fixIrr);
|
||||
//reprojection step
|
||||
//laplacian smooth step
|
||||
//Laplacian(poly_m,Damp,1);
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
typename TriMeshType::CoordType testPos;
|
||||
testPos.Import(poly_m.vert[i].P());
|
||||
typename TriMeshType::CoordType closestPt;
|
||||
typename TriMeshType::ScalarType minDist;
|
||||
FaceType *f=NULL;
|
||||
typename TriMeshType::CoordType norm,ip;
|
||||
f=vcg::tri::GetClosestFaceBase(tri_mesh,grid,testPos,MaxD,minDist,closestPt,norm,ip);
|
||||
poly_m.vert[i].P().Import(testPos*Damp+closestPt*(1-Damp));
|
||||
poly_m.vert[i].N().Import(norm);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*! \brief This function performs the polygon regularization as in "Statics Aware Grid Shells"
|
||||
* followed by a reprojection step on the original mesh
|
||||
*/
|
||||
static void SmoothReprojectPCA(PolyMeshType &poly_m,
|
||||
int relaxStep=100,
|
||||
bool fixIrr=false,
|
||||
ScalarType Damp=0.5)
|
||||
{
|
||||
//transform into triangular
|
||||
TempMesh GuideSurf;
|
||||
vcg::tri::PolygonSupport<TempMesh,PolyMeshType>::ImportFromPolyMesh(GuideSurf,poly_m);
|
||||
vcg::tri::UpdateBounding<TempMesh>::Box(GuideSurf);
|
||||
vcg::tri::UpdateNormal<TempMesh>::PerVertexNormalizedPerFace(GuideSurf);
|
||||
vcg::tri::UpdateTopology<TempMesh>::FaceFace(GuideSurf);
|
||||
vcg::tri::UpdateFlags<TempMesh>::FaceBorderFromFF(GuideSurf);
|
||||
|
||||
//optimize it
|
||||
vcg::PolygonalAlgorithm<PolyMeshType>::SmoothReprojectPCA<TempMesh>(poly_m,GuideSurf,relaxStep,fixIrr,Damp);
|
||||
}
|
||||
|
||||
/*! \brief This function return average edge size
|
||||
*/
|
||||
static ScalarType AverageEdge(PolyMeshType &poly_m)
|
||||
{
|
||||
ScalarType AvL=0;
|
||||
size_t numE=0;
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
int NumV=poly_m.face[i].VN();
|
||||
for (size_t j=0;j<NumV;j++)
|
||||
{
|
||||
CoordType pos0=poly_m.face[i].V(j)->P();
|
||||
CoordType pos1=poly_m.face[i].V((j+1)%NumV)->P();
|
||||
AvL+=(pos0-pos1).Norm();
|
||||
numE++;
|
||||
}
|
||||
}
|
||||
AvL/=numE;
|
||||
return AvL;
|
||||
}
|
||||
|
||||
|
||||
/*! \brief This function remove valence 2 faces from the mesh
|
||||
*/
|
||||
static void RemoveValence2Faces(PolyMeshType &poly_m)
|
||||
{
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
if (poly_m.face[i].VN()>=3)continue;
|
||||
vcg::tri::Allocator<PolyMeshType>::DeleteFace(poly_m,poly_m.face[i]);
|
||||
}
|
||||
|
||||
//then remove unreferenced vertices
|
||||
vcg::tri::Clean<PolyMeshType>::RemoveUnreferencedVertex(poly_m);
|
||||
vcg::tri::Allocator<PolyMeshType>::CompactEveryVector(poly_m);
|
||||
|
||||
}
|
||||
|
||||
/*! \brief This function remove valence 2 vertices on the border by considering the degree threshold
|
||||
* bacause there could be eventually some corner that should be preserved
|
||||
*/
|
||||
static void RemoveValence2BorderVertices(PolyMeshType &poly_m,
|
||||
ScalarType corner_degree=25)
|
||||
{
|
||||
//update topology
|
||||
vcg::tri::UpdateTopology<PolyMeshType>::FaceFace(poly_m);
|
||||
|
||||
//update border vertices
|
||||
//UpdateBorderVertexFromPFFAdj(poly_m);
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexBorderFromFaceAdj(poly_m);
|
||||
|
||||
vcg::tri::UpdateFlags<PolyMeshType>::VertexClearS(poly_m);
|
||||
|
||||
//select corners
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
if (poly_m.face[i].IsD())continue;
|
||||
|
||||
//get vertices of the face
|
||||
int NumV=poly_m.face[i].VN();
|
||||
|
||||
for (size_t j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v0=poly_m.face[i].V((j+NumV-1)%NumV);
|
||||
VertexType *v1=poly_m.face[i].V(j);
|
||||
VertexType *v2=poly_m.face[i].V((j+1)%NumV);
|
||||
//must be 3 borders
|
||||
if ((!v0->IsB())||(!v1->IsB())||(!v2->IsB()))continue;
|
||||
CoordType dir0=(v0->P()-v1->P());
|
||||
CoordType dir1=(v2->P()-v1->P());
|
||||
dir0.Normalize();
|
||||
dir1.Normalize();
|
||||
ScalarType testDot=(dir0*dir1);
|
||||
if (testDot>(-cos(corner_degree* (M_PI / 180.0))))
|
||||
v1->SetS();
|
||||
}
|
||||
}
|
||||
|
||||
typename PolyMeshType::template PerVertexAttributeHandle<size_t> valenceVertH =
|
||||
vcg::tri::Allocator<PolyMeshType>:: template GetPerVertexAttribute<size_t> (poly_m);
|
||||
|
||||
//initialize to zero
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
valenceVertH[i]=0;
|
||||
|
||||
//then sum up the valence
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
for (int j=0;j<poly_m.face[i].VN();j++)
|
||||
valenceVertH[poly_m.face[i].V(j)]++;
|
||||
|
||||
//then re-elaborate the faces
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
if (poly_m.face[i].IsD())continue;
|
||||
|
||||
//get vertices of the face
|
||||
int NumV=poly_m.face[i].VN();
|
||||
|
||||
std::vector<VertexType*> FaceV;
|
||||
for (size_t j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v=poly_m.face[i].V(j);
|
||||
assert(!v->IsD());
|
||||
if ((!v->IsS()) && (v->IsB()) && (valenceVertH[v]==1)) continue;
|
||||
FaceV.push_back(v);
|
||||
}
|
||||
|
||||
//then deallocate face
|
||||
if (FaceV.size()==NumV)continue;
|
||||
|
||||
//otherwise deallocate and set new vertices
|
||||
poly_m.face[i].Dealloc();
|
||||
poly_m.face[i].Alloc(FaceV.size());
|
||||
for (size_t j=0;j<FaceV.size();j++)
|
||||
poly_m.face[i].V(j)=FaceV[j];
|
||||
}
|
||||
|
||||
//then remove unreferenced vertices
|
||||
vcg::tri::Clean<PolyMeshType>::RemoveUnreferencedVertex(poly_m);
|
||||
vcg::tri::Allocator<PolyMeshType>::CompactEveryVector(poly_m);
|
||||
|
||||
vcg::tri::Allocator<PolyMeshType>::DeletePerVertexAttribute(poly_m,valenceVertH);
|
||||
}
|
||||
|
||||
/*! \brief This function collapse small edges which are on the boundary of the mesh
|
||||
* this is sometimes useful to remove small edges coming out from a quadrangulation which is not
|
||||
* aligned to boundaries
|
||||
*/
|
||||
static void CollapseBorderSmallEdges(PolyMeshType &poly_m,const ScalarType perc_average=0.3)
|
||||
{
|
||||
//compute the average edge
|
||||
ScalarType AvEdge=AverageEdge(poly_m);
|
||||
ScalarType minLimit=AvEdge*perc_average;
|
||||
|
||||
while(CollapseBorderSmallEdgesStep(poly_m,minLimit)){};
|
||||
|
||||
RemoveValence2Faces(poly_m);
|
||||
|
||||
RemoveValence2BorderVertices(poly_m);
|
||||
}
|
||||
|
||||
/*! \brief This function use a local global approach to flatten polygonal faces
|
||||
* the approach is similar to "Shape-Up: Shaping Discrete Geometry with Projections"
|
||||
*/
|
||||
static ScalarType FlattenFaces(PolyMeshType &poly_m, size_t steps=100,bool OnlySFaces=false)
|
||||
{
|
||||
ScalarType MaxDispl=0;
|
||||
for (size_t s=0;s<steps;s++)
|
||||
{
|
||||
std::vector<std::vector<CoordType> > VertPos(poly_m.vert.size());
|
||||
|
||||
for (size_t i=0;i<poly_m.face.size();i++)
|
||||
{
|
||||
if (poly_m.face[i].IsD())continue;
|
||||
|
||||
if (OnlySFaces && (!poly_m.face[i].IsS()))continue;
|
||||
//get vertices of the face
|
||||
int NumV=poly_m.face[i].VN();
|
||||
if (NumV<=3)continue;
|
||||
|
||||
//save vertice's positions
|
||||
std::vector<CoordType> FacePos;
|
||||
for (int j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v=poly_m.face[i].V(j);
|
||||
assert(!v->IsD());
|
||||
FacePos.push_back(v->P());
|
||||
}
|
||||
|
||||
//then fit the plane
|
||||
vcg::Plane3<ScalarType> FitPl;
|
||||
vcg::FitPlaneToPointSet(FacePos,FitPl);
|
||||
|
||||
//project each point onto fitting plane
|
||||
for (int j=0;j<NumV;j++)
|
||||
{
|
||||
VertexType *v=poly_m.face[i].V(j);
|
||||
int IndexV=vcg::tri::Index(poly_m,v);
|
||||
CoordType ProjP=FitPl.Projection(v->P());
|
||||
VertPos[IndexV].push_back(ProjP);
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t i=0;i<poly_m.vert.size();i++)
|
||||
{
|
||||
CoordType AvgPos(0,0,0);
|
||||
|
||||
for (size_t j=0;j<VertPos[i].size();j++)
|
||||
AvgPos+=VertPos[i][j];
|
||||
|
||||
if (VertPos[i].size()==0)continue;
|
||||
|
||||
AvgPos/=(ScalarType)VertPos[i].size();
|
||||
|
||||
MaxDispl=std::max(MaxDispl,(poly_m.vert[i].P()-AvgPos).Norm());
|
||||
poly_m.vert[i].P()=AvgPos;
|
||||
}
|
||||
}
|
||||
return MaxDispl;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}//end namespace vcg
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue