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

Merge branch 'devel' of github.com:cnr-isti-vclab/vcglib into devel

This commit is contained in:
Luigi Malomo 2021-11-17 18:21:47 +01:00
parent 8bc75c8c4d ad562ed9f1
commit 3fbbf0e94f
23 changed files with 180 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
apps/sample/trimesh_attribute_saving/trimesh_attribute_saving.cpp
View File

@ -45,7 +45,7 @@ class MyMesh : public vcg::tri::TriMesh< std::vector<MyVertex>, std::vector<MyFa
int main()
{
MyMesh m;
Torus<MyMesh>(m, 3.0f, 1.0f);
vcg::tri::Torus<MyMesh>(m, 3.0f, 1.0f);
//! [Adding a few attributes]
// add a per-vertex attribute with type float named "GaussianCurvature"
MyMesh::PerVertexAttributeHandle<float>

2
apps/sample/trimesh_hole/trimesh_hole.cpp
View File

@ -229,7 +229,7 @@ int main(int argc,char ** argv){
{
f1=f2;
f2++;
TriSplit<MyMesh,CenterPointBarycenter<MyMesh> >::Apply(vf[i],&(*f1),&(*f2),&(*vertp),CenterPointBarycenter<MyMesh>() );
vcg::tri::TriSplit<MyMesh,vcg::tri::CenterPointBarycenter<MyMesh> >::Apply(vf[i],&(*f1),&(*f2),&(*vertp),vcg::tri::CenterPointBarycenter<MyMesh>() );
f1->SetS();
f2->SetS();
for(int itr=0;itr<3;itr++)

6
apps/sample/trimesh_intersection_mesh/trimesh_intersection_mesh.cpp
View File

@ -70,7 +70,7 @@ int main(int ,char **)
tri::UpdateSelection<MyMesh>::FaceDilate(m1);
tri::Clean<MyMesh>::SelectIntersectingFaces(m2,m1);
tri::UpdateSelection<MyMesh>::FaceDilate(m2);
IsotropicRemeshing<MyMesh>::Params params;
vcg::tri::IsotropicRemeshing<MyMesh>::Params params;
float len = (tri::Stat<MyMesh>::ComputeFaceEdgeLengthAverage(m1,true) + tri::Stat<MyMesh>::ComputeFaceEdgeLengthAverage(m1,true));
params.SetTargetLen(len*0.8f);
@ -78,8 +78,8 @@ int main(int ,char **)
params.iter=1; // just one iteration to avoid overtessellating.
params.selectedOnly=true;
printf(" Input mesh %8i v %8i f\n",m1.VN(),m1.FN());
IsotropicRemeshing<MyMesh>::Do(m1, params);
IsotropicRemeshing<MyMesh>::Do(m2, params);
vcg::tri::IsotropicRemeshing<MyMesh>::Do(m1, params);
vcg::tri::IsotropicRemeshing<MyMesh>::Do(m2, params);
printf(" Input mesh %8i v %8i f\n",m1.VN(),m1.FN());
}
tri::Clean<MyMesh>::SelectIntersectingFaces(m1,m2);

6
apps/sample/trimesh_remeshing/trimesh_remeshing.cpp
View File

@ -75,7 +75,7 @@ int main( int argc, char **argv )
// Mesh cleaning
tri::Clean<MyMesh>::RemoveUnreferencedVertex(original);
Allocator<MyMesh>::CompactEveryVector(original);
vcg::tri::Allocator<MyMesh>::CompactEveryVector(original);
tri::UpdateNormal<MyMesh>::PerVertexNormalizedPerFaceNormalized(original);
@ -90,7 +90,7 @@ int main( int argc, char **argv )
float maxSurfDist = maxSurfDistPerc*(original.bbox.Diag()/100.f);
printf("Length Thr: %8.3f ~ %4.2f %% on %5.3f\n",lengthThr,targetLenPerc,original.bbox.Diag());
IsotropicRemeshing<MyMesh>::Params params;
vcg::tri::IsotropicRemeshing<MyMesh>::Params params;
params.SetTargetLen(lengthThr);
params.SetFeatureAngleDeg(creaseAngle);
params.iter=iterNum;
@ -111,7 +111,7 @@ int main( int argc, char **argv )
printf(" Input mesh %8i v %8i f\n",toremesh.VN(),toremesh.FN());
IsotropicRemeshing<MyMesh>::Do(toremesh, original, params);
vcg::tri::IsotropicRemeshing<MyMesh>::Do(toremesh, original, params);
vcg::tri::io::ExporterPLY<MyMesh>::Save(toremesh, "remesh.ply");
printf("Output mesh %8i v %8i f\n",toremesh.VN(),toremesh.FN());

4
apps/sample/trimesh_texture_clean/trimesh_texture_clean.cpp
View File

@ -52,8 +52,8 @@ int main(int ,char ** )
// generate a simple 2D grid
Grid(m,20,20,1,1);
// assign it a simple planar parametrization
tri:UpdateTexture<MyMesh>::WedgeTexFromPlane(m,Point3f(1.0f,0,0),Point3f(0,1.0f,0),true);
// assign it a simple planar parametrization
tri::UpdateTexture<MyMesh>::WedgeTexFromPlane(m,Point3f(1.0f,0,0),Point3f(0,1.0f,0),true);
tri::io::ExporterOBJ<MyMesh>::Save(m,"grid_0.obj",mask);
// randomly perturb a few coord textures introducing fake seams

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++)

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

@ -474,9 +474,9 @@ bool TagFaceEdgeSelWithPolyLine(MeshType &poly,bool markFlag=true)
{
CoordType p0=f->P0(i);
CoordType p1=f->P1(i);
if (p0>p1) std::swap(p0,p1);
if(edgeToPolyVertMap[make_pair(p0,p1)]) printf("Found an already used Edge %lu - %lu %lu!!!\n", tri::Index(base,f->V0(i)),tri::Index(base,f->V1(i)),tri::Index(poly,&*vi));
edgeToPolyVertMap[make_pair(p0,p1)]=&*vi;
if (p0>p1) std::swap(p0,p1);
if(edgeToPolyVertMap[std::make_pair(p0,p1)]) printf("Found an already used Edge %lu - %lu %lu!!!\n", tri::Index(base,f->V0(i)),tri::Index(base,f->V1(i)),tri::Index(poly,&*vi));
edgeToPolyVertMap[std::make_pair(p0,p1)]=&*vi;
}
}
}
@ -1136,7 +1136,7 @@ public:
CoordType p0 = ep.V()->P();
CoordType p1 = ep.VFlip()->P();
if (p0>p1) std::swap(p0,p1);
VertexPointer vp=edgeToPolyVertMap[make_pair(p0,p1)];
VertexPointer vp=edgeToPolyVertMap[std::make_pair(p0,p1)];
return vp!=0;
}
};
@ -1152,7 +1152,7 @@ public:
CoordType p0 = ep.V()->P();
CoordType p1 = ep.VFlip()->P();
if (p0>p1) std::swap(p0,p1);
VertexPointer vp=edgeToPolyVertMap[make_pair(p0,p1)];
VertexPointer vp=edgeToPolyVertMap[std::make_pair(p0,p1)];
assert(vp);
nv.P()=vp->P();
return;

4
vcg/complex/algorithms/implicit_smooth.h
View File

@ -260,7 +260,7 @@ public:
//add the entries for mass matrix
if (SParam.useMassMatrix)
MeshToMatrix<MeshType>::MassMatrixEntry(mesh,IndexM,ValuesM,!SParam.SmoothQ);
vcg::tri::MeshToMatrix<MeshType>::MassMatrixEntry(mesh,IndexM,ValuesM,!SParam.SmoothQ);
//then add entries for lagrange mult due to barycentric constraints
for (size_t i=0;i<SParam.ConstrainedF.size();i++)
@ -313,7 +313,7 @@ public:
//get the entries for laplacian matrix
std::vector<std::pair<int,int> > IndexL;
std::vector<ScalarType> ValuesL;
MeshToMatrix<MeshType>::GetLaplacianMatrix(mesh,IndexL,ValuesL,SParam.useCotWeight,SParam.lapWeight,!SParam.SmoothQ);
vcg::tri::MeshToMatrix<MeshType>::GetLaplacianMatrix(mesh,IndexL,ValuesL,SParam.useCotWeight,SParam.lapWeight,!SParam.SmoothQ);
//initialize sparse laplacian matrix
if (!SParam.SmoothQ)

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>

4
vcg/complex/algorithms/update/halfedge_indexed.h
View File

@ -214,9 +214,9 @@ namespace vcg
for(typename MeshType::EdgeIterator ei1 = m.edge.begin(); ei1 != m.edge.end(); ++ei1 )
{
vector<HEdgePointer> hedges = HalfEdgeTopology<MeshType>::get_incident_hedges((*ei1).V(0));
std::vector<HEdgePointer> hedges = HalfEdgeTopology<MeshType>::get_incident_hedges((*ei1).V(0));
for(typename vector<HEdgePointer>::iterator hi = hedges.begin(); hi != hedges.end(); ++hi)
for(typename std::vector<HEdgePointer>::iterator hi = hedges.begin(); hi != hedges.end(); ++hi)
{
if((*hi)->HOp()->HVp() == (*ei1).V(1))
{

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)

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

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

6
wrap/gcache/cache.h
View File

@ -26,7 +26,7 @@ typedef unsigned __int64 uint64_t;
#include "provider.h"
using namespace std;
//using namespace std;
/* this cache system enforce the rule that the items in a cache are always in all the cache below */
/* two mechanism to remove tokens from the cache:
1) set token count to something low
@ -169,7 +169,7 @@ protected:
if(unload() || load()) {
new_data.testAndSetOrdered(0, 1); //if not changed, set as changed
input->check_queue.open(); //we signal ourselves to check again
cout << "loaded or unloaded\n";
std::cout << "loaded or unloaded\n";
}
input->check_queue.leave();
}
@ -212,7 +212,7 @@ protected:
} else { //last item is locked need to reorder stack
remove = this->heap.popMin();
this->heap.push(remove);
cout << "Reordering stack something (what?)\n";
std::cout << "Reordering stack something (what?)\n";
return true;
}
}

2
wrap/gcache/controller.h
View File

@ -140,7 +140,7 @@ class Controller {
void resume() {
assert(!stopped);
assert(paused);
cout << "Resume" << endl;
std::cout << "Resume" << std::endl;
//unlock and open all doors
for(unsigned int i = 0; i < caches.size(); i++) {

2
wrap/gui/frustum.h
View File

@ -59,7 +59,7 @@ Adding copyright.
#include <vcg/space/line3.h>
#include <iostream>
using namespace std;
//using namespace std;
namespace vcg {

10
wrap/gui/trackmode.cpp
View File

@ -82,7 +82,7 @@ void SphereMode::Apply (Trackball * tb, Point3f new_point)
// Figure out how much to rotate around that axis.
// float phi = Distance (hitNew, hitOld) / tb->radius;
// float phi = vcg::Angle(hitNew - center,hitOld - center)*(Distance(hitNew,center)/tb->radius);
float phi = max(vcg::Angle(hitNew - center,hitOld - center),(Distance(hitNew,hitOld)/tb->radius)) ;
float phi = std::max(vcg::Angle(hitNew - center,hitOld - center),(Distance(hitNew,hitOld)/tb->radius)) ;
tb->track.rot = Quaternionf (-phi, axis) * tb->last_track.rot;
}
@ -128,12 +128,12 @@ void ZMode::Draw(Trackball * tb){
// Scale mode implementation.
void ScaleMode::Apply (Trackball * tb, float WheelNotch)
{
tb->track.sca *= pow (1.2f, -WheelNotch);
tb->track.sca *= std::pow (1.2f, -WheelNotch);
}
void ScaleMode::Apply (Trackball * tb, Point3f new_point)
{
tb->track.sca = tb->last_track.sca * pow (3.0f, -(getDeltaY(tb,new_point)));
tb->track.sca = tb->last_track.sca * std::pow (3.0f, -(getDeltaY(tb,new_point)));
}
void ScaleMode::Draw(Trackball * tb){
@ -787,7 +787,7 @@ void NavigatorWasdMode::Animate(unsigned int msec, Trackball * tb){
float vel = current_speed_h.Norm();
if (vel<topSpeedH*0.05) {
// stopped: decrease step heigth to zero
step_current*=pow(dumping,sec);
step_current*=std::pow(dumping,sec);
if (step_current<step_height*0.06) { step_current=0; step_x=0.0f;}
} else {
// running: rise step heigth
@ -797,7 +797,7 @@ void NavigatorWasdMode::Animate(unsigned int msec, Trackball * tb){
if (step_current<step_current_min) step_current=step_current_min;
}
current_speed*=pow(dumping,sec);
current_speed*=std::pow(dumping,sec);
if (current_speed.Norm()<topSpeedH*0.005) current_speed.SetZero(); // full stop
tb->track.tra[1]+=step_last;

2
wrap/gui/trackutils.h
View File

@ -35,7 +35,7 @@
#include <wrap/gl/space.h>
#include <vector>
#include <iostream>
using namespace std;
//using namespace std;
namespace vcg {