manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/vcg/complex/algorithms/voronoi_remesher.h

796 lines
26 KiB
C++
Raw Blame History

/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004-2017 \/)\/ *
* 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_VORONOI_REMESHER_H
#define _VCGLIB_VORONOI_REMESHER_H
#include <vcg/complex/complex.h>
#include <vcg/complex/algorithms/update/topology.h>
#include <vcg/complex/algorithms/refine.h>
#include <vcg/complex/algorithms/clean.h>
#include <vcg/complex/algorithms/voronoi_processing.h>
#include <vcg/complex/algorithms/point_sampling.h>
#include <vcg/complex/algorithms/crease_cut.h>
#include <vcg/complex/algorithms/curve_on_manifold.h>
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <array>
#include <utility>
//#define DEBUG_VORO 1
//#include <QElapsedTimer>
#ifdef DEBUG_VORO
#include <wrap/io_trimesh/export.h>
#include <QString>
#endif
namespace vcg {
namespace tri {
class VoroEdgeMeshAux
{
class EmEdgeType;
class EmVertexType;
class EUsedTypes : public vcg::UsedTypes<vcg::Use<EmVertexType>::AsVertexType,
vcg::Use<EmEdgeType>::AsEdgeType> {};
class EmVertexType : public vcg::Vertex<EUsedTypes
, vcg::vertex::Coord3d
, vcg::vertex::BitFlags
, vcg::vertex::VEAdj> {};
class EmEdgeType : public vcg::Edge<EUsedTypes
, vcg::edge::VertexRef
, vcg::edge::BitFlags
, vcg::edge::EEAdj
, vcg::edge::VEAdj> {};
public:
class EdgeMeshType : public vcg::tri::TriMesh<std::vector<EmVertexType>, std::vector<EmEdgeType> >
{
public:
~EdgeMeshType()
{
this->Clear();
this->ClearAttributes();
}
};
};
template <class MeshType>
class Remesher
{
public:
typedef Remesher ThisType;
typedef MeshType Mesh;
typedef typename Mesh::ScalarType ScalarType;
typedef typename Mesh::CoordType CoordType;
typedef typename Mesh::FaceType FaceType;
typedef typename Mesh::FacePointer FacePointer;
typedef typename Mesh::VertexType VertexType;
typedef typename Mesh::VertexPointer VertexPointer;
typedef typename Mesh::FaceIterator FaceIterator;
typedef typename Mesh::VertexIterator VertexIterator;
typedef std::shared_ptr<Mesh> MeshPtr;
protected:
typedef face::Pos<FaceType> PosType;
typedef typename VoroEdgeMeshAux::EdgeMeshType EdgeMeshType;
/// \brief splitCC split the provided mesh into connected components.
/// \param mesh the inputMesh.
/// \return the vector of connected components (meshes) for the input model
/// (if the input mesh is a single connected component returns an empty vector).
///
inline static std::vector<MeshPtr> splitCC(MeshType & mesh)
{
std::vector<MeshPtr> ret;
// find the connected components
std::vector<std::pair<int, typename MeshType::FacePointer> > CCV;
Clean<MeshType>::ConnectedComponents(mesh, CCV);
if (CCV.size() == 1)
return ret;
for(size_t i=0; i<CCV.size(); ++i)
{
UpdateSelection<MeshType>::Clear(mesh);
CCV[i].second->SetS();
UpdateSelection<MeshType>::FaceConnectedFF(mesh);
ret.push_back(std::make_shared<MeshType>());
Append<MeshType, MeshType>::MeshCopy(*(ret.back()), mesh, true);
}
return ret;
}
public:
static const int VoroRelaxationStep = 30;
///
/// \brief Remesh the main function that remeshes a mesh preserving creases.
/// \param original the mesh
/// \param samplingRadius is the sampling ragius for remeshing
/// \param borderCreaseAngleDeg is the angle treshold for preserving corner points on the mesh boundary
/// \param internalCreaseAngleDeg is the angle treshold for preserving creases on the mesh surface (if this value is < 0 it is set to borderCreaseAngleDeg)
/// \return the remeshed mesh
///
static inline MeshPtr Remesh(Mesh & original, const ScalarType samplingRadius, const ScalarType borderCreaseAngleDeg = 0.0, const ScalarType internalCreaseAngleDeg = -1.0)
{
RequireFFAdjacency(original);
RequireVFAdjacency(original);
UpdateTopology<Mesh>::FaceFace(original);
UpdateFlags<Mesh>::FaceBorderFromFF(original);
UpdateFlags<Mesh>::VertexBorderFromFaceAdj(original);
if (Clean<Mesh>::CountNonManifoldEdgeFF(original) > 0)
{
std::cout << "Input mesh has non manifold edges" << std::endl;
return nullptr;
}
const ScalarType borderAngleDeg = std::max(ScalarType(0), borderCreaseAngleDeg);
const ScalarType creaseAngleDeg = internalCreaseAngleDeg < 0 ? borderAngleDeg : internalCreaseAngleDeg;
// split on creases
if (creaseAngleDeg > 0)
{
CreaseCut<Mesh>(original, vcg::math::ToRad(creaseAngleDeg));
Allocator<Mesh>::CompactEveryVector(original);
UpdateTopology<Mesh>::FaceFace(original);
UpdateFlags<Mesh>::FaceBorderFromFF(original);
UpdateFlags<Mesh>::VertexBorderFromFaceAdj(original);
}
// Mark the non manifold border vertices as visited on the input mesh
// TODO maybe optimize this
{
// extract border mesh
EdgeMeshType em;
ThisType::ExtractMeshBorders(original, em);
// get the border edge mesh and leave the non manifold vertices only
tri::Allocator<EdgeMeshType>::CompactEveryVector(em);
vcg::tri::Clean<EdgeMeshType>::SelectNonManifoldVertexOnEdgeMesh(em);
for (EdgeMeshType::VertexType & v : em.vert)
{
if (!v.IsS())
{
tri::Allocator<EdgeMeshType>::DeleteVertex(em, v);
}
}
tri::Allocator<EdgeMeshType>::CompactVertexVector(em);
// clear visited vertices
tri::UpdateFlags<Mesh>::VertexClearV(original);
if (em.vn != 0)
{
// iterate over the mesh and mark as visited all the matching vertices with the non manifold border
tri::UpdateBounding<EdgeMeshType>::Box(em);
EdgeMeshType::BoxType bbox = em.bbox;
bbox.Offset(bbox.Diag()/1000.0);
typedef SpatialHashTable<EdgeMeshType::VertexType, EdgeMeshType::ScalarType> HashVertexGrid;
HashVertexGrid HG;
HG.Set(em.vert.begin(), em.vert.end(), bbox);
typedef EdgeMeshType::CoordType Coord;
EdgeMeshType::ScalarType dist_upper_bound = bbox.Diag()/1000.0;
for (VertexType & v : original.vert)
{
EdgeMeshType::ScalarType dist;
EdgeMeshType::VertexType * nonManifoldVertex = GetClosestVertex<EdgeMeshType,HashVertexGrid>(em, HG, Coord::Construct(v.cP()), dist_upper_bound, dist);
if (nonManifoldVertex != NULL && dist == 0)
{
v.SetV();
}
}
}
}
#ifdef DEBUG_VORO
io::Exporter<Mesh>::Save(original, "creaseSplit.ply", io::Mask::IOM_VERTCOLOR);
#endif
// One CC
std::vector<MeshPtr> ccs = splitCC(original);
if (ccs.empty())
{
return RemeshOneCC(original, samplingRadius, borderAngleDeg);
}
// Multiple CCs
// std::cout << "Remeshing " << ccs.size() << " components" << std::endl;
for (size_t i=0; i<ccs.size(); i++)
{
// std::cout << "Remeshing component " << (i+1) << "/" << ccs.size() << std::endl;
ccs[i] = RemeshOneCC(*ccs[i], samplingRadius, borderAngleDeg, i);
}
MeshPtr ret = std::make_shared<Mesh>();
for (MeshPtr & mesh : ccs)
{
Append<Mesh,Mesh>::Mesh(*ret, *mesh);
}
Clean<Mesh>::RemoveDuplicateVertex(*ret, true);
return ret;
}
protected:
///
/// \brief RemeshOneCC the function that remeshes a single connected component mesh preserving its boundary (consistently for eventually adjacent meshes).
/// \param original the mesh
/// \param samplingRadius is the sampling radius for remeshing
/// \param borderCreaseAngleDeg is the angle treshold for preserving corner points on the mesh boundary
/// \return the remeshed mesh
///
static inline MeshPtr RemeshOneCC(Mesh & original, const ScalarType samplingRadius, const ScalarType borderCreaseAngleDeg = 0.0, int idx = 0)
{
// double timeBorders = 0;
// double timePoisson = 0;
// double timeRelax = 0;
// double timeSeed = 0;
// double timeSources = 0;
// double timeDelaunay = 0;
// QElapsedTimer timer;
// timer.start();
(void)idx;
RequireCompactness(original);
RequirePerFaceFlags(original);
UpdateTopology<Mesh>::FaceFace(original);
UpdateFlags<Mesh>::FaceBorderFromFF(original);
UpdateFlags<Mesh>::VertexBorderFromFaceAdj(original);
#ifdef DEBUG_VORO
io::ExporterPLY<MeshType>::Save(original, QString("cc_%1.ply").arg(idx).toStdString().c_str(), io::Mask::IOM_VERTCOLOR);
#endif
// Resample border
Mesh poissonEdgeMesh;
{
typedef typename EdgeMeshType::CoordType Coord;
EdgeMeshType em;
ThisType::ExtractMeshBorders(original, em);
Allocator<EdgeMeshType>::CompactVertexVector(em);
Allocator<EdgeMeshType>::CompactEdgeVector(em);
// split on non manifold vertices of edgemesh
vcg::tri::Clean<EdgeMeshType>::SelectNonManifoldVertexOnEdgeMesh(em);
{
// select also the visited vertices (coming from the non manifold vertices of the whole crease-cut mesh)
for (auto & v : em.vert)
{
if (v.IsV()) { v.SetS(); }
}
}
const int manifoldSplits = vcg::tri::Clean<EdgeMeshType>::SplitSelectedVertexOnEdgeMesh(em);
(void)manifoldSplits;
#ifdef DEBUG_VORO
std::cout << manifoldSplits << " non-manifold splits" << std::endl;
io::ExporterOBJ<EdgeMeshType>::Save(em, QString("edgeMesh_%1.obj").arg(idx).toStdString().c_str(), io::Mask::IOM_EDGEINDEX);
#endif
// eventually split on 'creases'
if (borderCreaseAngleDeg > 0.0)
{
// split creases
UpdateFlags<EdgeMeshType>::VertexClearS(em);
UpdateFlags<EdgeMeshType>::VertexClearV(em);
Clean<EdgeMeshType>::SelectCreaseVertexOnEdgeMesh(em, vcg::math::ToRad(borderCreaseAngleDeg));
const int splits = Clean<EdgeMeshType>::SplitSelectedVertexOnEdgeMesh(em);
(void)splits;
#ifdef DEBUG_VORO
std::cout << splits << " splits" << std::endl;
io::ExporterOBJ<EdgeMeshType>::Save(em, QString("edgeMesh_split_%1.obj").arg(idx).toStdString().c_str(), io::Mask::IOM_EDGEINDEX);
#endif
}
// Samples vector
std::vector<Coord> borderSamples;
TrivialSampler<EdgeMeshType> ps(borderSamples);
// uniform edge sampling
UpdateTopology<EdgeMeshType>::EdgeEdge(em);
SurfaceSampling<EdgeMeshType>::EdgeMeshUniform(em, ps, samplingRadius, false);
BuildMeshFromCoordVector(poissonEdgeMesh, borderSamples);
UpdateBounding<Mesh>::Box(poissonEdgeMesh);
// remove duplicate vertices
Clean<Mesh>::RemoveDuplicateVertex(poissonEdgeMesh, false);
Allocator<Mesh>::CompactVertexVector(poissonEdgeMesh);
// select all vertices (to mark them fixed)
UpdateFlags<Mesh>::VertexSetS(poissonEdgeMesh);
#ifdef DEBUG_VORO
io::ExporterPLY<MeshType>::Save(poissonEdgeMesh, QString("borderMesh_%1.ply").arg(idx).toStdString().c_str(), io::Mask::IOM_VERTCOLOR);
#endif
}
// timeBorders = timer.restart() / 1000.0;
typedef VoronoiProcessing<Mesh> Voronoi;
typedef TrivialSampler<Mesh> BaseSampler;
typedef SurfaceSampling<Mesh, BaseSampler> SurfaceSampler;
typedef SurfaceSampling<Mesh, FixSampler> SurfaceFixSampler;
// copy original mesh
Mesh baseMesh;
Append<Mesh, Mesh>::MeshCopy(baseMesh, original, false, true);
// refine to obtain a base mesh
VoronoiProcessingParameter vpp;
vpp.refinementRatio = 5.0f;
Voronoi::PreprocessForVoronoi(baseMesh, samplingRadius, vpp);
// Poisson sampling preserving border
std::vector<CoordType> seedPointVec;
std::vector<bool> seedFixedVec;
FixSampler fix_sampler(seedPointVec, seedFixedVec);
// montecarlo sampler
std::vector<CoordType> sampleVec;
BaseSampler mps(sampleVec);
// NOTE in order to make the results consistent the random sampling generator is initialized with the same value
SurfaceSampler::SamplingRandomGenerator().initialize(5489u);
// Montecarlo oversampling
Mesh montecarloMesh;
// const int poissonCount = SurfaceSampler::ComputePoissonSampleNum(original, samplingRadius)/* * 0.7*/;
int poissonCount = 0;
{
const ScalarType meshArea = Stat<Mesh>::ComputeMeshArea(original);
const ScalarType meshBoundary = Stat<Mesh>::ComputeBorderLength(original);
const double factor = math::Sqrt(3)/2;
const ScalarType areaPerSample = samplingRadius*samplingRadius * factor;
poissonCount = meshArea / areaPerSample - meshBoundary * samplingRadius * factor * 0.5; // totalArea / (r^2 * sqrt(3)/2) - (totalBoundary * r * sqrt(3)/4)
}
// std::cout << "poisson Count: " << poissonCount << std::endl;
if (poissonCount <= 0)
{
// no need for internal sampling
for (auto vi = poissonEdgeMesh.vert.begin(); vi != poissonEdgeMesh.vert.end(); vi++)
{
fix_sampler.AddVert(*vi);
}
}
else
{
// Montecarlo poisson sampling
SurfaceSampler::MontecarloPoisson(original, mps, poissonCount * 40);
BuildMeshFromCoordVector(montecarloMesh,sampleVec);
#ifdef DEBUG_VORO
io::ExporterPLY<MeshType>::Save(montecarloMesh, QString("montecarloMesh_%1.ply").arg(idx).toStdString().c_str());
#endif
// Poisson disk pruning initialized with edges
typename SurfaceFixSampler::PoissonDiskParam pp;
pp.preGenMesh = &poissonEdgeMesh;
pp.preGenFlag = true;
SurfaceFixSampler::PoissonDiskPruning(fix_sampler, montecarloMesh, samplingRadius, pp);
}
#ifdef DEBUG_VORO
Mesh poissonMesh;
BuildMeshFromCoordVector(poissonMesh,seedPointVec);
io::ExporterPLY<MeshType>::Save(poissonMesh, QString("poissonMesh_%1.ply").arg(idx).toStdString().c_str());
#endif
// timePoisson = timer.restart() / 1000.0;
// std::cout << "poisson samples " << seedPointVec.size() << std::endl;
// not enough points
if (seedPointVec.size() < 3)
{
return std::make_shared<Mesh>();
}
// restricted relaxation with fixed points
vpp.seedPerturbationProbability = 0.0f;
Voronoi::RestrictedVoronoiRelaxing(baseMesh, seedPointVec, seedFixedVec, VoroRelaxationStep, vpp);
#ifdef DEBUG_VORO
BuildMeshFromCoordVector(poissonMesh,seedPointVec);
io::ExporterPLY<MeshType>::Save(poissonMesh, QString("relaxedMesh_%1.ply").arg(idx).toStdString().c_str());
#endif
// timeRelax = timer.restart() / 1000.0;
// FAIL?
MeshPtr finalMeshPtr = std::make_shared<Mesh>();
std::vector<VertexType *> seedVertexVec;
// Voronoi::SeedToVertexConversion(baseMesh, seedPointVec, seedVertexVec, false);
ThisType::SeedToFixedBorderVertexConversion(baseMesh, samplingRadius, seedPointVec, seedFixedVec, seedVertexVec);
EuclideanDistance<Mesh> dd;
// timeSeed = timer.restart() / 1000.0;
// std::cout << "BEGIN compute vertex sources (basemesh vn:" << baseMesh.VN() << " fn:" << baseMesh.FN() << ")" << std::endl;
Voronoi::ComputePerVertexSources(baseMesh, seedVertexVec, dd);
// std::cout << "END compute vertex sources" << std::endl;
// timeSources = timer.restart() / 1000.0;
// traditional
// Voronoi::ConvertDelaunayTriangulationToMesh(baseMesh, *finalMeshPtr, seedVertexVec, false);
// border-preserving
ThisType::ConvertDelaunayTriangulationExtendedToMesh(baseMesh, *finalMeshPtr, seedVertexVec);
#ifdef DEBUG_VORO
io::ExporterPLY<MeshType>::Save(*finalMeshPtr, QString("voroMesh_%1.ply").arg(idx).toStdString().c_str());
io::ExporterPLY<MeshType>::Save(baseMesh, QString("baseMesh_%1.ply").arg(idx).toStdString().c_str(), io::Mask::IOM_VERTCOLOR);
#endif
// timeDelaunay = timer.elapsed() / 1000.0;
// std::cout << "border: " << timeBorders << std::endl
// << "poisson: " << timePoisson << std::endl
// << "relax: " << timeRelax << std::endl
// << "seed: " << timeSeed << std::endl
// << "sources: " << timeSources << std::endl
// << "delaunay: " << timeDelaunay << std::endl;
return finalMeshPtr;
}
static inline void ExtractMeshBorders(Mesh & mesh, EdgeMeshType & sides)
{
RequireFFAdjacency(mesh);
// clean the edge mesh containing the borders
sides.Clear();
// gather into separate vertices lists
std::vector<std::vector<VertexType *> > edges;
for (auto fi = mesh.face.begin(); fi != mesh.face.end(); fi++)
{
for (int e=0; e<fi->VN(); e++)
{
if (vcg::face::IsBorder(*fi, e))
{
std::vector<VertexType *> tmp;
tmp.push_back(fi->V(e));
tmp.push_back(fi->V((e+1)%fi->VN()));
edges.push_back(tmp);
}
}
}
// convert to edge mesh
for (auto & e : edges)
{
assert(e.size() >= 2);
std::vector<typename EdgeMeshType::VertexType *> newVtx;
// insert new vertices and store their pointer
auto vi = Allocator<EdgeMeshType>::AddVertices(sides, e.size());
for (const auto & v : e)
{
vi->ImportData(*v);
newVtx.push_back(&(*vi++));
}
auto ei = Allocator<EdgeMeshType>::AddEdges(sides, e.size() - 1);
for (int i=0; i<static_cast<int>(e.size() - 1); i++)
{
ei->V(0) = newVtx[i];
ei->V(1) = newVtx[i+1];
ei++;
}
}
Clean<EdgeMeshType>::RemoveDuplicateVertex(sides);
}
static void SeedToFixedBorderVertexConversion(MeshType & m,
const ScalarType samplingRadius,
const std::vector<CoordType> & seedPVec,
const std::vector<bool> & seedFixed,
std::vector<VertexType *> & seedVVec)
{
typedef typename vcg::SpatialHashTable<VertexType, ScalarType> HashVertexGrid;
seedVVec.clear();
UpdateTopology<MeshType>::FaceFace(m);
UpdateFlags<MeshType>::VertexBorderFromFaceAdj(m);
typename MeshType::BoxType bbox = m.bbox;
bbox.Offset(bbox.Diag()/100.0);
// internal vertices grid
HashVertexGrid HG;
HG.Set(m.vert.begin(),m.vert.end(), bbox);
// boundary vertices grid
MeshType borderMesh;
HashVertexGrid borderHG;
{
// get border vertices and build another mesh
std::vector<CoordType> borderPts;
for (auto vit=m.vert.begin(); vit!=m.vert.end(); vit++)
{
if (!vit->IsD() && vit->IsB())
borderPts.push_back(vit->cP());
}
if (!borderPts.empty())
{
BuildMeshFromCoordVector(borderMesh,borderPts);
borderMesh.bbox = m.bbox;
borderHG.Set(borderMesh.vert.begin(), borderMesh.vert.end(), bbox);
}
}
const ScalarType dist_upper_bound=samplingRadius*4;
VertexType * vp = NULL;
for( size_t i = 0; i < seedPVec.size(); i++)
{
const CoordType & p = seedPVec[i];
const bool fixed = seedFixed[i];
if (!fixed)
{
ScalarType dist;
vp = GetClosestVertex<MeshType,HashVertexGrid>(m, HG, p, dist_upper_bound, dist);
if (vp)
{
seedVVec.push_back(vp);
}
}
else
{
vp = NULL;
ScalarType dist;
VertexType * borderVp = GetClosestVertex<MeshType,HashVertexGrid>(borderMesh, borderHG, p, dist_upper_bound, dist);
if (borderVp)
{
std::vector<ScalarType> dist;
std::vector<VertexType *> vps;
std::vector<CoordType> pts;
// vp = GetClosestVertex<MeshType,HashVertexGrid>(m, HG, borderVp->cP(), dist_upper_bound, dist);
unsigned int n = GetKClosestVertex<MeshType,HashVertexGrid>(m, HG, 16, borderVp->cP(), dist_upper_bound, vps, dist, pts);
if (n>0)
{
ScalarType d = dist[0];
seedVVec.push_back(vps[0]);
assert(dist.size() == size_t(n));
for (size_t j=1; j<dist.size(); j++)
{
if (dist[j] <= d)
{
seedVVec.push_back(vps[j]);
d = dist[j];
}
else
{
break;
}
}
}
}
}
}
}
static void ConvertDelaunayTriangulationExtendedToMesh(MeshType &m,
MeshType &outMesh,
std::vector<VertexType *> &seedVec)
{
typedef VoronoiProcessing<MeshType> Voronoi;
RequirePerVertexAttribute(m ,"sources");
RequireCompactness(m);
RequireVFAdjacency(m);
auto sources = Allocator<MeshType>::template GetPerVertexAttribute<VertexPointer> (m,"sources");
outMesh.Clear();
UpdateTopology<MeshType>::FaceFace(m);
UpdateFlags<MeshType>::FaceBorderFromFF(m);
std::map<VertexPointer, int> seedMap; // It says if a given vertex of m is a seed (and its index in seedVec)
Voronoi::BuildSeedMap(m, seedVec, seedMap);
std::vector<FacePointer> innerCornerVec, // Faces adjacent to three different regions
borderCornerVec; // Faces that are on the border and adjacent to at least two regions.
Voronoi::GetFaceCornerVec(m, sources, innerCornerVec, borderCornerVec);
// First add all the needed vertices: seeds and corners
for(size_t i=0;i<seedVec.size();++i)
{
Allocator<MeshType>::AddVertex(outMesh, seedVec[i]->P(), vcg::Color4b::White);
}
// Now just add one face for each inner corner
std::vector<std::array<VertexPointer, 3> > toAdd;
for(size_t i=0; i<innerCornerVec.size(); ++i)
{
VertexPointer s0 = sources[innerCornerVec[i]->V(0)];
VertexPointer s1 = sources[innerCornerVec[i]->V(1)];
VertexPointer s2 = sources[innerCornerVec[i]->V(2)];
assert ( (s0!=s1) && (s0!=s2) && (s1!=s2) );
VertexPointer v0 = & outMesh.vert[seedMap[s0]];
VertexPointer v1 = & outMesh.vert[seedMap[s1]];
VertexPointer v2 = & outMesh.vert[seedMap[s2]];
Allocator<MeshType>::AddFace(outMesh, v0, v1, v2);
}
// Now loop around the borders and find the missing delaunay triangles
// select border seed vertices only and pick one
UpdateFlags<Mesh>::VertexBorderFromFaceAdj(m);
UpdateFlags<Mesh>::VertexClearS(m);
UpdateFlags<Mesh>::VertexClearV(m);
std::vector<VertexPointer> borderSeeds;
for (auto & s : seedVec)
{
if (s->IsB())
{
s->SetS();
borderSeeds.emplace_back(s);
}
}
for (VertexPointer startBorderVertex : borderSeeds)
{
if (startBorderVertex->IsV())
{
continue;
}
// unvisited border seed found
// put the pos on the border
PosType pos(startBorderVertex->VFp(), startBorderVertex->VFi());
do {
pos.NextE();
} while (!pos.IsBorder() || (pos.VInd() != pos.E()));
// check all border edges between each consecutive border seeds pair
do {
std::vector<VertexPointer> edgeVoroVertices(1, sources[pos.V()]);
// among all sources found
do {
pos.NextB();
VertexPointer source = sources[pos.V()];
if (edgeVoroVertices.empty() || edgeVoroVertices.back() != source)
{
edgeVoroVertices.push_back(source);
}
} while (!pos.V()->IsS());
pos.V()->SetV();
// assert(edgeVoroVertices.size() >= 2);
if (edgeVoroVertices.size() >= 3)
{
std::vector<VertexPointer> v;
for (size_t i=0; i<edgeVoroVertices.size(); i++)
{
v.push_back(&outMesh.vert[seedMap[edgeVoroVertices[i]]]);
}
// also handles N>3 vertices holes
for (size_t i=0; i<edgeVoroVertices.size()-2; i++)
{
Allocator<MeshType>::AddFace(outMesh, v[0],v[i+1],v[i+2]);
}
// if (edgeVoroVertices.size() > 3)
// {
// std::cout << "Weird case: " << edgeVoroVertices.size() << " voroseeds on one border" << std::endl;
// }
}
// // add face if 3 different voronoi regions are crossed by the edge
// if (edgeVoroVertices.size() == 3)
// {
// VertexPointer v0 = & outMesh.vert[seedMap[edgeVoroVertices[0]]];
// VertexPointer v1 = & outMesh.vert[seedMap[edgeVoroVertices[1]]];
// VertexPointer v2 = & outMesh.vert[seedMap[edgeVoroVertices[2]]];
// Allocator<MeshType>::AddFace(outMesh, v0,v1,v2);
// }
// else
// {
// std::cout << "Weird case!! " << edgeVoroVertices.size() << " voroseeds on one border" << std::endl;
// if (edgeVoroVertices.size() == 4)
// {
// VertexPointer v0 = & outMesh.vert[seedMap[edgeVoroVertices[0]]];
// VertexPointer v1 = & outMesh.vert[seedMap[edgeVoroVertices[1]]];
// VertexPointer v2 = & outMesh.vert[seedMap[edgeVoroVertices[2]]];
// VertexPointer v3 = & outMesh.vert[seedMap[edgeVoroVertices[3]]];
// Allocator<MeshType>::AddFace(outMesh, v0,v1,v2);
// Allocator<MeshType>::AddFace(outMesh, v0,v2,v3);
// }
// }
} while ((pos.V() != startBorderVertex));
}
Clean<MeshType>::RemoveUnreferencedVertex(outMesh);
Allocator<MeshType>::CompactVertexVector(outMesh);
}
///
/// \brief The FixSampler class is used with poisson disk pruning to preserve selected vertices and
/// keep an auxiliary vector indicating wether the sample is fixed or not
///
class FixSampler
{
public:
typedef typename MeshType::CoordType CoordType;
typedef typename MeshType::VertexType VertexType;
FixSampler(std::vector<CoordType> & samples, std::vector<bool> & fixed)
: sampleVec(samples)
, fixedVec (fixed)
{
reset();
}
void reset()
{
sampleVec.clear();
fixedVec .clear();
}
void AddVert(const VertexType &p)
{
sampleVec.push_back(p.cP());
fixedVec .push_back(p.IsS());
}
private:
std::vector<CoordType> & sampleVec;
std::vector<bool> & fixedVec;
};
};
} // end namespace tri
} // end namespace vcg
#endif // _VCGLIB_VORONOI_REMESHER_H
Reference in New Issue View Git Blame Copy Permalink