manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

removing using namespace std from header files

This commit is contained in:
alemuntoni 2021-11-17 17:39:01 +01:00
parent 6b44e8e23e
commit 8de019c1e3
10 changed files with 150 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vcg/complex/algorithms/create/platonic.h
View File

@ -1125,7 +1125,7 @@ struct _SphUsedTypes : public UsedTypes< Use<_SphVertex> ::AsVertexType,
class _SphVertex : public Vertex<_SphUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags >{};
class _SphFace : public Face< _SphUsedTypes, face::VertexRef, face::Normal3f, face::BitFlags, face::FFAdj > {};
class _SphMesh : public tri::TriMesh< vector<_SphVertex>, vector<_SphFace> > {};
class _SphMesh : public tri::TriMesh< std::vector<_SphVertex>, std::vector<_SphFace> > {};
template <class MeshType>

2
vcg/complex/algorithms/create/plymc/simplemeshprovider.h
View File

@ -147,7 +147,7 @@ public:
bool openALN (const char* alnName)
{
vector<RangeMap> rmaps;
std::vector<RangeMap> rmaps;
ALNParser::ParseALN(rmaps, alnName);
for(size_t i=0; i<rmaps.size(); i++)

16
vcg/complex/algorithms/isotropic_remeshing.h
View File

@ -429,7 +429,7 @@ private:
for(auto vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
if(!(*vi).IsD())
{
vector<FaceType*> ff;
std::vector<FaceType*> ff;
face::VFExtendedStarVF(&*vi, 2, ff);
ScalarType tot = 0.f;
@ -906,8 +906,8 @@ private:
p1.FlipV();
vector<int> vi0, vi1;
vector<FaceType*> ff0, ff1;
std::vector<int> vi0, vi1;
std::vector<FaceType*> ff0, ff1;
face::VFStarVF<FaceType>(p0.V(), ff0, vi0);
face::VFStarVF<FaceType>(p1.V(), ff1, vi1);
@ -956,7 +956,7 @@ private:
Point3<ScalarType> collapseNV, collapsedNV0, collapsedNV1;
collapseNV = (p.V()->P() - p.VFlip()->P()).normalized();
vector<VertexType*> vv;
std::vector<VertexType*> vv;
face::VVStarVF<FaceType>(p.V(), vv);
for(VertexType *v: vv)
@ -1052,9 +1052,9 @@ private:
* \ | / \|/ +0 \ / -1
* v3 v3 v3
*/
static bool chooseBestCrossCollapse(PosType &p, VertexPair& bp, vector<FaceType*> &ff)
static bool chooseBestCrossCollapse(PosType &p, VertexPair& bp, std::vector<FaceType*> &ff)
{
vector<VertexType*> vv0, vv1, vv2, vv3;
std::vector<VertexType*> vv0, vv1, vv2, vv3;
VertexType *v0, *v1, *v2, *v3;
v0 = p.F()->V1(p.VInd());
@ -1175,8 +1175,8 @@ private:
PosType pi(&*fi, i);
if(!pi.V()->IsB())
{
vector<FaceType*> ff;
vector<int> vi;
std::vector<FaceType*> ff;
std::vector<int> vi;
face::VFStarVF<FaceType>(pi.V(), ff, vi);
//if cross need to check what creases you have and decide where to collapse accordingly

25
vcg/complex/algorithms/overlap_estimation.h
View File

@ -32,9 +32,6 @@
#include <qdatetime.h>
using namespace std;
using namespace vcg;
/** \brief This class provides a strategy to estimate the overlap percentage of two range maps/point clouds.
*
* This class can be used, for exemple, into an automatic alignment process to check the quality of the
@ -56,9 +53,9 @@ template<class MESH_TYPE> class OverlapEstimation
typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::VertexPointer VertexPointer;
typedef typename MeshType::VertexIterator VertexIterator;
typedef typename vector<VertexPointer>::iterator VertexPointerIterator;
typedef GridStaticPtr<VertexType, ScalarType > MeshGrid;
typedef tri::EmptyTMark<MeshType> MarkerVertex;
typedef typename std::vector<VertexPointer>::iterator VertexPointerIterator;
typedef vcg::GridStaticPtr<VertexType, ScalarType > MeshGrid;
typedef vcg::tri::EmptyTMark<MeshType> MarkerVertex;
private:
/** Private simple class needed to perform sampling of pointers to vertexes. */
@ -70,7 +67,7 @@ template<class MESH_TYPE> class OverlapEstimation
VertexPointerSampler(){ m = new MeshType(); m->Tr.SetIdentity(); m->sfn=0; }
~VertexPointerSampler(){ if(m) delete m; }
vector<VertexType*> sampleVec;
std::vector<VertexType*> sampleVec;
void AddVert(VertexType &p){ sampleVec.push_back(&p); } //this function is the only we really need
void AddFace(const FaceType &f, const CoordType &p){}
@ -110,7 +107,7 @@ template<class MESH_TYPE> class OverlapEstimation
private:
MeshType* mFix; /** Pointer to mesh \c mFix. */
MeshType* mMov; /** Pointer to mesh \c mMov. */
vector<vector<int> >* normBuckets; //structure to hold normals bucketing. Needed for normal equalized sampling during consensus
std::vector<std::vector<int> >* normBuckets; //structure to hold normals bucketing. Needed for normal equalized sampling during consensus
MeshGrid* gridFix; //variable to manage uniform grid
MarkerVertex markerFunctorFix; //variable to manage uniform grid
@ -182,7 +179,7 @@ template<class MESH_TYPE> class OverlapEstimation
//if no buckets are provided get a vector of vertex pointers sampled uniformly
//else, get a vector of vertex pointers sampled in a normal equalized manner; used as query points
vector<VertexPointer> queryVert;
std::vector<VertexPointer> queryVert;
if(param.normalEqualization){
assert(normBuckets);
for(unsigned int i=0; i<mMov->vert.size(); i++) queryVert.push_back(&(mMov->vert[i]));//do a copy of pointers to vertexes
@ -249,7 +246,7 @@ template<class MESH_TYPE> class OverlapEstimation
* @param vert Destination vector.
* @param sampleNum Requested number of vertexes.
*/
void SampleVertUniform(MESH_TYPE& m, vector<typename MESH_TYPE::VertexPointer>& vert, int sampleNum)
void SampleVertUniform(MESH_TYPE& m, std::vector<typename MESH_TYPE::VertexPointer>& vert, int sampleNum)
{
VertexPointerSampler sampler;
tri::SurfaceSampling<MeshType, VertexPointerSampler>::VertexUniform(m, sampler, sampleNum);
@ -258,12 +255,12 @@ template<class MESH_TYPE> class OverlapEstimation
/** Buckets normals of the vertexes contained in \c vert .
* \return A vector of vectors containing indexes to \c vert .
*/
vector<vector<int> >* BucketVertexNormal(typename MESH_TYPE::VertContainer& vert, int bucketDim = 30)
std::vector<std::vector<int> >* BucketVertexNormal(typename MESH_TYPE::VertContainer& vert, int bucketDim = 30)
{
static vector<Point3f> NV;
if(NV.size()==0) GenNormal<float>::Uniform(bucketDim,NV);
vector<vector<int> >* BKT = new vector<vector<int> >(NV.size()); //NV size is greater then bucketDim, so don't change this!
std::vector<std::vector<int> >* BKT = new std::vector<std::vector<int> >(NV.size()); //NV size is greater then bucketDim, so don't change this!
int ind;
for(int i=0;i<vert.size();++i){
@ -281,7 +278,7 @@ template<class MESH_TYPE> class OverlapEstimation
{
assert(normBuckets);
// vettore di contatori per sapere quanti punti ho gia' preso per ogni bucket
vector<int> BKTpos(normBuckets->size(),0);
std::vector<int> BKTpos(normBuckets->size(),0);
if(SampleNum >= int(vert.size())) SampleNum= int(vert.size()-1);
@ -289,7 +286,7 @@ template<class MESH_TYPE> class OverlapEstimation
for(int i=0;i<SampleNum;){
ind=LocRnd(normBuckets->size()); // Scelgo un Bucket
int &CURpos = BKTpos[ind];
vector<int> &CUR = (*normBuckets)[ind];
std::vector<int> &CUR = (*normBuckets)[ind];
if(CURpos<int(CUR.size())){
swap(CUR[CURpos], CUR[ CURpos + LocRnd((*normBuckets)[ind].size()-CURpos)]);

2
vcg/complex/algorithms/pointcloud_normal.h
View File

@ -62,7 +62,7 @@ public:
// tree.setMaxNofNeighbors(nn);
const ScalarType maxDistSquared = maxDist*maxDist;
int cnt=0;
int step = max(m.vn, int(m.vn / 100));
int step = std::max(m.vn, int(m.vn / 100));
typename KdTree<ScalarType>::PriorityQueue nq;
for (VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
{

10
vcg/complex/algorithms/smooth.h
View File

@ -1417,7 +1417,7 @@ A(...) (2-2nm) =
// move vertex
vp->P() = ct;
vector<FacePointer> faces2 = HalfEdgeTopology<MeshType>::get_incident_faces(vp);
std::vector<FacePointer> faces2 = HalfEdgeTopology<MeshType>::get_incident_faces(vp);
// estimate normal
typename MeshType::CoordType avgn(0, 0, 0);
@ -1425,7 +1425,7 @@ A(...) (2-2nm) =
for (unsigned int i = 0; i < faces2.size(); i++)
if (faces2[i])
{
vector<VertexPointer> vertices = HalfEdgeTopology<MeshType>::getVertices(faces2[i]);
std::vector<VertexPointer> vertices = HalfEdgeTopology<MeshType>::getVertices(faces2[i]);
assert(vertices.size() == 4);
@ -1444,9 +1444,9 @@ A(...) (2-2nm) =
typename MeshTypeTri::FaceType *f = 0;
typename MeshTypeTri::FaceType *fr = 0;
vector<typename MeshTypeTri::CoordType> closests;
vector<typename MeshTypeTri::ScalarType> minDists;
vector<typename MeshTypeTri::FaceType *> faces;
std::vector<typename MeshTypeTri::CoordType> closests;
std::vector<typename MeshTypeTri::ScalarType> minDists;
std::vector<typename MeshTypeTri::FaceType *> faces;
ray.SetDirection(-raydir);
f = vcg::tri::DoRay<MeshTypeTri, GRID>(gridmesh, grid, ray, diag / 4.0, t);

3
vcg/complex/algorithms/update/fitmaps.h
View File

@ -42,9 +42,6 @@
#include <vcg/complex/algorithms/smooth.h>
using namespace Eigen;
namespace vcg { namespace tri {
template<class MeshType>

226
vcg/complex/algorithms/update/halfedge_topology.h
View File

@ -25,10 +25,6 @@
#include <vcg/connectors/halfedge_pos.h>
using namespace std;
using namespace vcg::hedge;
using namespace vcg::tri;
namespace vcg
{
namespace tri
@ -123,7 +119,7 @@ namespace vcg
HEdgePointer hp;
vector<VertexPointer> vps = getVertices(fp);
std::vector<VertexPointer> vps = getVertices(fp);
assert(vps.size()==4);
@ -138,7 +134,7 @@ namespace vcg
while(hp->HVp() != vp)
hp= hp->HNp();
vector<HEdgePointer> hps = getHEdges(fp,hp);
std::vector<HEdgePointer> hps = getHEdges(fp,hp);
assert(vp == hps[0]->HVp());
@ -195,10 +191,10 @@ namespace vcg
if(b[j])
{
if(HasHE)
Allocator<MeshType>::DeleteEdge(m, *(hps[i]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge(m, *(hps[i]->HEp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[i]->HOp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[i+1]->HOp()) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[i]->HOp()) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[i+1]->HOp()) );
hps[i+1]->HVp()->VHp() = NULL;
@ -218,17 +214,17 @@ namespace vcg
}
Allocator<MeshType>::DeleteFace(m, *(fp) );
Allocator<MeshType>::DeleteVertex(m, *(opposite_vertex) );
vcg::tri::Allocator<MeshType>::DeleteFace(m, *(fp) );
vcg::tri::Allocator<MeshType>::DeleteVertex(m, *(opposite_vertex) );
if(HasHE)
{
Allocator<MeshType>::DeleteEdge(m, *(hps[1]->HEp()) );
Allocator<MeshType>::DeleteEdge(m, *(hps[3]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge(m, *(hps[1]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge(m, *(hps[3]->HEp()) );
}
Allocator<MeshType>::DeleteHEdge(m, *(hps[0]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[1]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[2]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[3]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[0]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[1]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[2]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hps[3]) );
return vp;
@ -288,17 +284,17 @@ namespace vcg
fp1->FHp() = hp->HNp();
Allocator<MeshType>::DeleteVertex(m, *vp);
vcg::tri::Allocator<MeshType>::DeleteVertex(m, *vp);
if(MeshType::HEdgeType::HasHEAdjacency())
{
Allocator<MeshType>::DeleteEdge(m, *(hp->HEp()) );
Allocator<MeshType>::DeleteEdge(m, *(hp->HPp()->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge(m, *(hp->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge(m, *(hp->HPp()->HEp()) );
}
Allocator<MeshType>::DeleteHEdge(m, *hp );
Allocator<MeshType>::DeleteHEdge(m, *(hp->HOp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()->HOp()) );
Allocator<MeshType>::DeleteFace(m, *fp2 );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *hp );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hp->HOp()) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()) );
vcg::tri::Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()->HOp()) );
vcg::tri::Allocator<MeshType>::DeleteFace(m, *fp2 );
return fp1;
@ -335,13 +331,13 @@ namespace vcg
bool HasHE = MeshType::HEdgeType::HasHEAdjacency();
bool HasEH = MeshType::EdgeType::HasEHAdjacency();
vector<HEdgePointer> ext_hedges;
std::vector<HEdgePointer> ext_hedges;
vector<HEdgePointer> int_hedges = getHEdges(fp);
std::vector<HEdgePointer> int_hedges = getHEdges(fp);
Allocator<MeshType>::DeleteFace( m, *(fp) );
vcg::tri::Allocator<MeshType>::DeleteFace( m, *(fp) );
for(typename vector<HEdgePointer>::iterator hi = int_hedges.begin(); hi != int_hedges.end();++hi)
for(typename std::vector<HEdgePointer>::iterator hi = int_hedges.begin(); hi != int_hedges.end();++hi)
{
if((*hi)->HOp()->HFp() != fp)
@ -349,15 +345,15 @@ namespace vcg
else if(vertex_valence((*hi)->HVp()) == 1)
{
Allocator<MeshType>::DeleteVertex( m, *((*hi)->HVp()) );
vcg::tri::Allocator<MeshType>::DeleteVertex( m, *((*hi)->HVp()) );
if(HasHE)
Allocator<MeshType>::DeleteEdge( m, *((*hi)->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge( m, *((*hi)->HEp()) );
}
}
for(typename vector<HEdgePointer>::iterator hi = int_hedges.begin(); hi != int_hedges.end();++hi)
Allocator<MeshType>::DeleteHEdge( m, *(*hi) );
for(typename std::vector<HEdgePointer>::iterator hi = int_hedges.begin(); hi != int_hedges.end();++hi)
vcg::tri::Allocator<MeshType>::DeleteHEdge( m, *(*hi) );
assert(ext_hedges.size() == 2);
@ -369,7 +365,7 @@ namespace vcg
if(HasHE)
{
Allocator<MeshType>::DeleteEdge( m, *(ext_hedges[1]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge( m, *(ext_hedges[1]->HEp()) );
ext_hedges[1]->HEp() = ext_hedges[0]->HEp();
@ -390,11 +386,11 @@ namespace vcg
if(HasHE)
{
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[0]->HEp()) );
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[1]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[0]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[1]->HEp()) );
}
Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[0]) );
Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[1]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[0]) );
vcg::tri::Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[1]) );
return NULL;
}
@ -434,9 +430,9 @@ namespace vcg
assert(!has_doublet_quad(fp1));
assert(!has_doublet_quad(fp2));
vector<FacePointer> fps;
typedef vector<HEdgePointer> hedge_vect;
vector<hedge_vect> hps;
std::vector<FacePointer> fps;
typedef std::vector<HEdgePointer> hedge_vect;
std::vector<hedge_vect> hps;
fps.push_back(fp1);
fps.push_back(fp2);
@ -510,12 +506,12 @@ namespace vcg
assert(MeshType::VertexType::HasVHAdjacency());
assert( vp->VHp() );
Pos<MeshType> p(vp->VHp(), true);
vcg::hedge::Pos<MeshType> p(vp->VHp(), true);
HEdgePointer hep = p.HE();
typedef vector<HEdgePointer> hedge_vect;
vector<hedge_vect> hedges;
typedef std::vector<HEdgePointer> hedge_vect;
std::vector<hedge_vect> hedges;
do
{
@ -621,10 +617,10 @@ namespace vcg
vp1->VHp() = hopp->HNp();
if(HasHEAdjacency(m))
Allocator<MeshType>::DeleteEdge(m,*(hp->HEp()));
Allocator<MeshType>::DeleteHEdge(m,*hp);
Allocator<MeshType>::DeleteHEdge(m,*hopp);
Allocator<MeshType>::DeleteVertex(m,*vp);
vcg::tri::Allocator<MeshType>::DeleteEdge(m,*(hp->HEp()));
vcg::tri::Allocator<MeshType>::DeleteHEdge(m,*hp);
vcg::tri::Allocator<MeshType>::DeleteHEdge(m,*hopp);
vcg::tri::Allocator<MeshType>::DeleteVertex(m,*vp);
return vp1;
@ -638,7 +634,7 @@ namespace vcg
*
* \return Pointer to the new face if it has been inserted, NULL otherwise
*/
static FacePointer add_face(MeshType &m, vector<VertexPointer> &vps)
static FacePointer add_face(MeshType &m, std::vector<VertexPointer> &vps)
{
assert(MeshType::VertexType::HasVHAdjacency());
@ -657,13 +653,13 @@ namespace vcg
assert( count(vps.begin(), vps.end(), vps[i]) == 1 );
}
vector<HEdgePointer> hps;
std::vector<HEdgePointer> hps;
while(hps.size() < size)
if( !can_add_hedge(vps, hps) )
return NULL;
vector<bool> non_manifold_vertices(size, false);
std::vector<bool> non_manifold_vertices(size, false);
return add_face_unsafe( m,vps, hps, non_manifold_vertices);
@ -707,12 +703,12 @@ namespace vcg
*
* \return Pointer to the new face
*/
static FacePointer add_face_unsafe(MeshType &m, vector<VertexPointer> &vps)
static FacePointer add_face_unsafe(MeshType &m, std::vector<VertexPointer> &vps)
{
unsigned int size = vps.size();
vector<HEdgePointer> hps;
vector<bool> non_manifold_vertices;
std::vector<HEdgePointer> hps;
std::vector<bool> non_manifold_vertices;
while(hps.size() < size)
{
@ -736,7 +732,7 @@ namespace vcg
*
* \return Pointer to the new face
*/
static FacePointer add_face_unsafe(MeshType &m, vector<VertexPointer> &vps, vector<HEdgePointer> &hps, vector<bool> &non_manifold_vertices)
static FacePointer add_face_unsafe(MeshType &m, std::vector<VertexPointer> &vps, std::vector<HEdgePointer> &hps, std::vector<bool> &non_manifold_vertices)
{
assert(MeshType::VertexType::HasVHAdjacency());
@ -767,7 +763,7 @@ namespace vcg
FacePointer fp;
FaceIterator fi = Allocator<MeshType>::AddFaces(m,1);
FaceIterator fi = vcg::tri::Allocator<MeshType>::AddFaces(m,1);
(*fi).Alloc( size );
fp = &(*fi);
@ -780,12 +776,12 @@ namespace vcg
if(HasEH || HasHE)
{
ei = Allocator<MeshType>::AddEdges(m,edge_n);
ei = vcg::tri::Allocator<MeshType>::AddEdges(m,edge_n);
for(EdgeIterator ei1 = ei; ei1 != m.edge.end(); ++ei1)
(*ei1).SetD();
}
typename Allocator<MeshType>::template PointerUpdater<HEdgePointer> pu;
typename vcg::tri::Allocator<MeshType>::template PointerUpdater<HEdgePointer> pu;
if(m.hedge.empty())
pu.oldBase = 0;
@ -795,7 +791,7 @@ namespace vcg
pu.oldEnd = &m.hedge.back()+1;
}
hi = Allocator<MeshType>::AddHEdges(m,2*edge_n);
hi = vcg::tri::Allocator<MeshType>::AddHEdges(m,2*edge_n);
pu.newBase = &*(m.hedge.begin());
pu.newEnd = &m.hedge.back()+1;
@ -809,7 +805,7 @@ namespace vcg
// update hedge pointers (if needed)
if( pu.NeedUpdate() )
for(typename vector<HEdgePointer>::iterator hpsi = hps.begin(); hpsi != hps.end(); ++hpsi)
for(typename std::vector<HEdgePointer>::iterator hpsi = hps.begin(); hpsi != hps.end(); ++hpsi)
{
if((*hpsi))
pu.Update(*hpsi);
@ -848,7 +844,7 @@ namespace vcg
}
}
vector<HEdgePointer> hps1;
std::vector<HEdgePointer> hps1;
for(unsigned int i = 0; i < size; i++)
{
@ -911,7 +907,7 @@ namespace vcg
// after face insertion vertex will become non-manifold
if(non_manifold_vertices[next])
{
Pos<MeshType> p(vps[next]->VHp(), true);
vcg::hedge::Pos<MeshType> p(vps[next]->VHp(), true);
while(p.F())
{
@ -965,7 +961,7 @@ namespace vcg
static void remove_face_unsafe (MeshType &m, FacePointer fp)
{
vector<HEdgePointer> hps = getHEdges(fp);
std::vector<HEdgePointer> hps = getHEdges(fp);
int size = hps.size();
@ -991,11 +987,11 @@ namespace vcg
}
else
{
Allocator<MeshType>::DeleteHEdge( m, *hps[i] );
Allocator<MeshType>::DeleteHEdge( m, *(hps[i]->HOp()) );
vcg::tri::Allocator<MeshType>::DeleteHEdge( m, *hps[i] );
vcg::tri::Allocator<MeshType>::DeleteHEdge( m, *(hps[i]->HOp()) );
if(MeshType::HEdgeType::HasHEAdjacency())
Allocator<MeshType>::DeleteEdge( m, *(hps[i]->HEp()) );
vcg::tri::Allocator<MeshType>::DeleteEdge( m, *(hps[i]->HEp()) );
if( !hps[(i+size-1)%size]->HOp()->HFp() )
{
@ -1021,7 +1017,7 @@ namespace vcg
{
bool manifold = true;
Pos<MeshType> p(hps[i]->HVp()->VHp(), true);
vcg::hedge::Pos<MeshType> p(hps[i]->HVp()->VHp(), true);
p.HE()->SetV();
@ -1051,7 +1047,7 @@ namespace vcg
}
Allocator<MeshType>::DeleteFace(m,*fp);
vcg::tri::Allocator<MeshType>::DeleteFace(m,*fp);
}
@ -1065,7 +1061,7 @@ namespace vcg
* \retval true if hedge can be inserted
* \retval false otherwise
*/
static bool can_add_hedge( vector<VertexPointer> &vps, vector<HEdgePointer> &hps )
static bool can_add_hedge( std::vector<VertexPointer> &vps, std::vector<HEdgePointer> &hps )
{
unsigned int i = hps.size();
@ -1087,7 +1083,7 @@ namespace vcg
unsigned int size = vps.size();
Pos<MeshType> p(he, false);
vcg::hedge::Pos<MeshType> p(he, false);
he->SetV();
@ -1155,11 +1151,11 @@ namespace vcg
assert(fp);
assert(!fp->IsD());
Pos<MeshType> p(fp->FHp(), true);
vcg::hedge::Pos<MeshType> p(fp->FHp(), true);
do
{
vector<FacePointer> incident_faces = get_incident_faces( p.V() );
std::vector<FacePointer> incident_faces = get_incident_faces( p.V() );
unsigned int size = incident_faces.size();
@ -1197,11 +1193,11 @@ namespace vcg
assert(hp->HFp()->VN() == 4);
assert(!hp->IsD());
vector<FacePointer> faces;
std::vector<FacePointer> faces;
HEdgePointer hopp = hp->HNp()->HNp();
vector<FacePointer> faces1 = get_incident_faces(hp->HVp(), hp);
vector<FacePointer> faces2 = get_incident_faces(hp->HNp()->HNp()->HVp(), hopp);
std::vector<FacePointer> faces1 = get_incident_faces(hp->HVp(), hp);
std::vector<FacePointer> faces2 = get_incident_faces(hp->HNp()->HNp()->HVp(), hopp);
faces.assign(faces1.begin()+1, faces1.end());
faces.assign(faces2.begin()+1, faces2.end());
@ -1236,11 +1232,11 @@ namespace vcg
// Second check
set<VertexPointer> set1;
set<VertexPointer> set2;
std::set<VertexPointer> set1;
std::set<VertexPointer> set2;
vector<VertexPointer> vect1 = getVertices(hp->HVp());
vector<VertexPointer> vect2 = getVertices(hp->HNp()->HNp()->HVp());
std::vector<VertexPointer> vect1 = getVertices(hp->HVp());
std::vector<VertexPointer> vect2 = getVertices(hp->HNp()->HNp()->HVp());
set1.insert(vect1.begin(), vect1.end());
set2.insert(vect2.begin(), vect2.end());
@ -1249,9 +1245,9 @@ namespace vcg
if(vect2.size() < size)
size = vect2.size();
vector<VertexPointer> intersection(size);
std::vector<VertexPointer> intersection(size);
typename vector<VertexPointer>::iterator it;
typename std::vector<VertexPointer>::iterator it;
it = set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), intersection.begin());
size = it- intersection.begin();
@ -1278,7 +1274,7 @@ namespace vcg
assert(vp);
assert(!vp->IsD());
set<HEdgePointer> set1;
std::set<HEdgePointer> set1;
for(HEdgeIterator hi = m.hedge.begin(); hi != m.hedge.end(); ++hi)
{
if(!(*hi).IsD() && (*hi).HVp() == vp)
@ -1286,9 +1282,9 @@ namespace vcg
}
vector<HEdgePointer> vect2 = get_incident_hedges(vp);
std::vector<HEdgePointer> vect2 = get_incident_hedges(vp);
set<HEdgePointer> set2;
std::set<HEdgePointer> set2;
set2.insert(vect2.begin(), vect2.end());
return !equal(set1.begin(), set1.end(), set2.begin());
@ -1308,7 +1304,7 @@ namespace vcg
assert(vp);
assert(!vp->IsD());
vector<FacePointer> faces = get_incident_faces(vp);
std::vector<FacePointer> faces = get_incident_faces(vp);
unsigned int size = faces.size();
int null_count = 0;
@ -1350,19 +1346,19 @@ namespace vcg
*
* \return Vector containing vertices
*/
static vector<VertexPointer> getVertices(VertexPointer vp)
static std::vector<VertexPointer> getVertices(VertexPointer vp)
{
assert(vp);
assert(!vp->IsD());
HEdgePointer hp = vp->VHp();
vector<VertexPointer> ret;
std::vector<VertexPointer> ret;
if( !hp )
return ret;
Pos<MeshType> p(hp);
vcg::hedge::Pos<MeshType> p(hp);
do
{
@ -1392,18 +1388,18 @@ namespace vcg
*
* \return Set containing faces
*/
static set<FacePointer> getFaces(VertexPointer vp)
static std::set<FacePointer> getFaces(VertexPointer vp)
{
assert(vp);
assert(!vp->IsD());
set<FacePointer> ret;
std::set<FacePointer> ret;
vector<VertexPointer> vertices = getVertices(vp);
std::vector<VertexPointer> vertices = getVertices(vp);
for(typename vector<VertexPointer>::iterator vi = vertices.begin(); vi!= vertices.end(); ++vi)
for(typename std::vector<VertexPointer>::iterator vi = vertices.begin(); vi!= vertices.end(); ++vi)
{
vector<FacePointer> incident_faces = get_incident_faces(*vi);
std::vector<FacePointer> incident_faces = get_incident_faces(*vi);
ret.insert(incident_faces.begin(), incident_faces.end());
}
@ -1426,7 +1422,7 @@ namespace vcg
assert(fp->FHp());
assert(!fp->IsD());
Pos<MeshType> p( fp->FHp() );
vcg::hedge::Pos<MeshType> p( fp->FHp() );
do
{
@ -1450,7 +1446,7 @@ namespace vcg
*
* \return Vector containing the incident vertices
*/
static vector<VertexPointer> getVertices(FacePointer fp, HEdgePointer starting_he = NULL)
static std::vector<VertexPointer> getVertices(FacePointer fp, HEdgePointer starting_he = NULL)
{
assert(fp);
assert(!fp->IsD());
@ -1460,9 +1456,9 @@ namespace vcg
assert( starting_he->HFp() == fp );
Pos<MeshType> p( starting_he, true );
vcg::hedge::Pos<MeshType> p( starting_he, true );
vector<VertexPointer> ret;
std::vector<VertexPointer> ret;
do
@ -1491,7 +1487,7 @@ namespace vcg
*
* \return Vector containing the incident hedges
*/
static vector<HEdgePointer> getHEdges(FacePointer fp, HEdgePointer starting_he = NULL)
static std::vector<HEdgePointer> getHEdges(FacePointer fp, HEdgePointer starting_he = NULL)
{
assert(fp);
assert(!fp->IsD());
@ -1501,9 +1497,9 @@ namespace vcg
else
starting_he = fp->FHp();
Pos<MeshType> p( starting_he, true );
vcg::hedge::Pos<MeshType> p( starting_he, true );
vector<HEdgePointer> ret;
std::vector<HEdgePointer> ret;
do
{
@ -1530,7 +1526,7 @@ namespace vcg
*
* \return Vector containing the incident faces
*/
static vector<FacePointer> get_incident_faces(VertexPointer vp, HEdgePointer starting_he = NULL)
static std::vector<FacePointer> get_incident_faces(VertexPointer vp, HEdgePointer starting_he = NULL)
{
assert(vp);
assert(!vp->IsD());
@ -1540,12 +1536,12 @@ namespace vcg
else
starting_he = vp->VHp();
vector<FacePointer> ret;
std::vector<FacePointer> ret;
if(!starting_he)
return ret;
Pos<MeshType> p( starting_he, true );
vcg::hedge::Pos<MeshType> p( starting_he, true );
do
{
@ -1561,14 +1557,14 @@ namespace vcg
}
static vector<FacePointer> get_adjacent_faces(FacePointer fp)
static std::vector<FacePointer> get_adjacent_faces(FacePointer fp)
{
assert(fp);
assert(!fp->IsD());
vector<FacePointer> ret;
std::vector<FacePointer> ret;
Pos<MeshType> p( fp->FHp() );
vcg::hedge::Pos<MeshType> p( fp->FHp() );
assert(p.F() == fp);
do
@ -1594,7 +1590,7 @@ namespace vcg
*
* \return Vector containing the incident hedges
*/
static vector<HEdgePointer> get_incident_hedges(VertexPointer vp, HEdgePointer starting_he = NULL)
static std::vector<HEdgePointer> get_incident_hedges(VertexPointer vp, HEdgePointer starting_he = NULL)
{
assert(vp);
assert(!vp->IsD());
@ -1604,12 +1600,12 @@ namespace vcg
else
starting_he = vp->VHp();
vector<HEdgePointer> ret;
std::vector<HEdgePointer> ret;
if(!starting_he)
return ret;
Pos<MeshType> p( starting_he, true );
vcg::hedge::Pos<MeshType> p( starting_he, true );
do
{
@ -1647,15 +1643,15 @@ namespace vcg
*
* \return Vector containing the hedges
*/
static vector<HEdgePointer> find_doublet_hedges_quad(FacePointer fp)
static std::vector<HEdgePointer> find_doublet_hedges_quad(FacePointer fp)
{
assert(fp);
assert(fp->FHp());
assert(!fp->IsD());
vector<HEdgePointer> ret;
std::vector<HEdgePointer> ret;
Pos<MeshType> p( fp->FHp(), true );
vcg::hedge::Pos<MeshType> p( fp->FHp(), true );
do
{
@ -1690,7 +1686,7 @@ namespace vcg
if( !(vp->VHp()) )
return true;
Pos<MeshType> p( vp->VHp() );
vcg::hedge::Pos<MeshType> p( vp->VHp() );
do
{
@ -1722,7 +1718,7 @@ namespace vcg
int ret = 0;
Pos<MeshType> p( vp->VHp() );
vcg::hedge::Pos<MeshType> p( vp->VHp() );
do
{
@ -1752,7 +1748,7 @@ namespace vcg
assert(old_vp != new_vp);
assert(!old_vp->IsD());
Pos<MeshType> p(old_vp->VHp(),true);
vcg::hedge::Pos<MeshType> p(old_vp->VHp(),true);
p.HE()->SetV();

20
vcg/complex/algorithms/voronoi_processing.h
View File

@ -432,7 +432,7 @@ static void ConvertVoronoiDiagramToMesh(MeshType &m,
for(size_t i=0;i<seedVec.size();++i)
{
VertexPointer curSeed=seedVec[i];
vector<CoordType> pt;
std::vector<CoordType> pt;
for(size_t j=0;j<innerCornerVec.size();++j)
for(int qq=0;qq<3;qq++)
if(sources[innerCornerVec[j]->V(qq)] == curSeed)
@ -457,12 +457,12 @@ static void ConvertVoronoiDiagramToMesh(MeshType &m,
CoordType nZ = pl.Direction();
CoordType nX = (pt[0]-curSeed->P()).Normalize();
CoordType nY = (nX^nZ).Normalize();
vector<std::pair<float,int> > angleVec(pt.size());
std::vector<std::pair<float,int> > angleVec(pt.size());
for(size_t j=0;j<pt.size();++j)
{
CoordType p = (pt[j]-curSeed->P()).Normalize();
float angle = 180.0f+math::ToDeg(atan2(p*nY,p*nX));
angleVec[j] = make_pair(angle,j);
angleVec[j] = std::make_pair(angle,j);
}
std::sort(angleVec.begin(),angleVec.end());
// Now build another piece of mesh.
@ -1230,8 +1230,8 @@ static int RestrictedVoronoiRelaxing(MeshType &m, std::vector<CoordType> &seedPo
sumVec[seedInd].second+=vi->cP()*area[vi];
}
vector<CoordType> newseedVec;
vector<bool> newfixedVec;
std::vector<CoordType> newseedVec;
std::vector<bool> newfixedVec;
for(size_t i=0;i<seedPosVec.size();++i)
{
@ -1406,7 +1406,7 @@ static std::pair<genericType, genericType> ordered_pair(const genericType &a, co
///
///
static void GenerateMidPointMap(MeshType &m,
map<std::pair<VertexPointer,VertexPointer>, VertexPointer > &midMap)
std::map<std::pair<VertexPointer,VertexPointer>, VertexPointer > &midMap)
{
PerVertexPointerHandle sources = tri::Allocator<MeshType>:: template GetPerVertexAttribute<VertexPointer> (m,"sources");
@ -1601,10 +1601,10 @@ static void ConvertDelaunayTriangulationToMesh(MeshType &m,
for(size_t i=0;i<seedVec.size();++i)
tri::Allocator<MeshType>::AddVertex(outMesh, seedVec[i]->P(),Color4b::White);
map<std::pair<VertexPointer,VertexPointer>, int > midMapInd;
std::map<std::pair<VertexPointer,VertexPointer>, int > midMapInd;
// Given a pair of sources gives the index of the mid vertex
map<std::pair<VertexPointer,VertexPointer>, VertexPointer > midMapPt;
std::map<std::pair<VertexPointer,VertexPointer>, VertexPointer > midMapPt;
if(refineFlag)
{
GenerateMidPointMap(m, midMapPt);
@ -1658,7 +1658,7 @@ static void PreprocessForVoronoi(MeshType &m, ScalarType radius,
for(int i=0;i<maxSubDiv;++i)
{
vpp.lcb(0,StrFormat("Subdividing %i vn %i",i,m.vn));
bool ret = tri::Refine<MeshType, MidPointType >(m,mid,min(edgeLen*2.0f,radius/vpp.refinementRatio));
bool ret = tri::Refine<MeshType, MidPointType >(m,mid,std::min(edgeLen*2.0f,radius/vpp.refinementRatio));
if(!ret) break;
}
tri::Allocator<MeshType>::CompactEveryVector(m);
@ -1715,7 +1715,7 @@ static void RelaxRefineTriangulationSpring(MeshType &m, MeshType &delaMesh, int
std::vector<float> avgLenVec(delaMesh.vn,0);
for(int i=0;i<delaMesh.vn;++i)
{
vector<VertexPointer> starVec;
std::vector<VertexPointer> starVec;
face::VVStarVF<FaceType>(&delaMesh.vert[i],starVec);
for(size_t j=0;j<starVec.size();++j)

2
vcg/complex/algorithms/voronoi_volume_sampling.h
View File

@ -286,7 +286,7 @@ ScalarType DistanceFromVoronoiSurfaceEdge(const CoordType &p_point, const CoordT
vcg::IntersectionPlanePlane(pl01,plSurf,surfLine);
vcg::LinePointDistance(surfLine,p_point,closestPt, surfLineDist);
return min(voroLineDist,surfLineDist);
return std::min(voroLineDist,surfLineDist);
}