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

Cleaning up sample prog

This commit is contained in:
Paolo Cignoni 2016-06-09 10:46:10 +00:00
parent ef724af624
commit 121d356fbf
5 changed files with 412 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
apps/sample/common.pri
View File

@ -1,6 +1,8 @@
DEPENDPATH += . ../../.. DEPENDPATH += . ../../..
INCLUDEPATH += . ../../.. INCLUDEPATH += . ../../..
CONFIG += console stl CONFIG += console c++11
TEMPLATE = app TEMPLATE = app
# Mac specific Config required to avoid to make application bundles # Mac specific Config required to avoid to make application bundles
CONFIG -= app_bundle CONFIG -= app_bundle
QMAKE_CXXFLAGS += -std=c++11

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

@ -98,7 +98,7 @@ void example2(){
// normally, faces with more than 4sides are split into parallelograms // normally, faces with more than 4sides are split into parallelograms
// this merges them (optional, try removing it!) // this merges them (optional, try removing it!)
vcg::tri::PolygonSupport<MyMesh,int>::MergeFlatFaces(m); vcg::tri::PolygonSupport<MyMesh,MyMesh>::MergeFlatFaces(m);
int savemask = vcg::tri::io::Mask::IOM_BITPOLYGONAL; int savemask = vcg::tri::io::Mask::IOM_BITPOLYGONAL;
vcg::tri::io::ExporterOFF<MyMesh>::Save(m,fullMeshFilename,savemask); vcg::tri::io::ExporterOFF<MyMesh>::Save(m,fullMeshFilename,savemask);

0
apps/sample/hashing_2D/test_hash2d.cpp → apps/sample/space_index_2d/test_hash2d.cpp
View File

0
apps/sample/hashing_2D/test_hash2d.pro → apps/sample/space_index_2d/test_hash2d.pro
View File

809
apps/sample/trimesh_indexing/trimesh_indexing.cpp
View File

@ -1,11 +1,13 @@
#include <iostream> #include <iostream>
#include <QTime> #include <QTime>
#ifdef _OPENMP
#include <omp.h> #include <omp.h>
#endif
#include "nanoflann.hpp" #include "nanoflann.hpp"
#include <vcg/complex/complex.h> #include <vcg/complex/complex.h>
#include <wrap/io_trimesh/import.h> #include <wrap/io_trimesh/import.h>
#include <wrap/io_trimesh/export.h> #include <wrap/io_trimesh/export.h>
@ -22,415 +24,420 @@ float queryDist = 0.0037;
float ratio = 1000.0f; float ratio = 1000.0f;
class CVertex; class CVertex;
class CFace; class CFace;
class CEdge; class CEdge;
class CUsedTypes : public vcg::UsedTypes < vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType>{}; class CUsedTypes : public vcg::UsedTypes < vcg::Use< CVertex >::AsVertexType, vcg::Use< CFace >::AsFaceType>{};
class CVertex : public vcg::Vertex < CUsedTypes, vcg::vertex::Coord3f, vcg::vertex::Normal3f, vcg::vertex::Radiusf, vcg::vertex::BitFlags, vcg::vertex::Qualityf, vcg::vertex::Color4b>{}; class CVertex : public vcg::Vertex < CUsedTypes, vcg::vertex::Coord3f, vcg::vertex::Normal3f, vcg::vertex::Radiusf, vcg::vertex::BitFlags, vcg::vertex::Qualityf, vcg::vertex::Color4b>{};
class CFace : public vcg::Face < CUsedTypes, vcg::face::VertexRef>{}; class CFace : public vcg::Face < CUsedTypes, vcg::face::VertexRef>{};
class CMesh : public vcg::tri::TriMesh < std::vector< CVertex >, std::vector< CFace > > {}; class CMesh : public vcg::tri::TriMesh < std::vector< CVertex >, std::vector< CFace > > {};
template <typename T> template <typename T>
struct PointCloud struct PointCloud
{ {
struct Point struct Point
{ {
T x,y,z; T x,y,z;
}; };
std::vector<Point> pts; std::vector<Point> pts;
inline size_t kdtree_get_point_count() const { return pts.size(); } inline size_t kdtree_get_point_count() const { return pts.size(); }
inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t size) const inline T kdtree_distance(const T *p1, const size_t idx_p2,size_t size) const
{ {
const T d0=p1[0]-pts[idx_p2].x; const T d0=p1[0]-pts[idx_p2].x;
const T d1=p1[1]-pts[idx_p2].y; const T d1=p1[1]-pts[idx_p2].y;
const T d2=p1[2]-pts[idx_p2].z; const T d2=p1[2]-pts[idx_p2].z;
return d0*d0+d1*d1+d2*d2; return d0*d0+d1*d1+d2*d2;
} }
inline T kdtree_get_pt(const size_t idx, int dim) const inline T kdtree_get_pt(const size_t idx, int dim) const
{ {
if (dim==0) return pts[idx].x; if (dim==0) return pts[idx].x;
else if (dim==1) return pts[idx].y; else if (dim==1) return pts[idx].y;
else return pts[idx].z; else return pts[idx].z;
} }
template <class BBOX> template <class BBOX>
bool kdtree_get_bbox(BBOX &bb) const { return false; } bool kdtree_get_bbox(BBOX &bb) const { return false; }
}; };
void testKDTree(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples) void testKDTree(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples)
{ {
std::cout << "==================================================="<< std::endl; std::cout << "==================================================="<< std::endl;
std::cout << "KDTree" << std::endl; std::cout << "KDTree" << std::endl;
QTime time; QTime time;
time.start(); time.start();
// Construction of the kdTree // Construction of the kdTree
vcg::ConstDataWrapper<CMesh::VertexType::CoordType> wrapperVcg(&mesh.vert[0].P(), mesh.vert.size(), size_t(mesh.vert[1].P().V()) - size_t(mesh.vert[0].P().V())); vcg::ConstDataWrapper<CMesh::VertexType::CoordType> wrapperVcg(&mesh.vert[0].P(), mesh.vert.size(), size_t(mesh.vert[1].P().V()) - size_t(mesh.vert[0].P().V()));
vcg::KdTree<CMesh::ScalarType> kdTreeVcg(wrapperVcg); vcg::KdTree<CMesh::ScalarType> kdTreeVcg(wrapperVcg);
std::cout << "Build: " << time.elapsed() << " ms" << std::endl; std::cout << "Build: " << time.elapsed() << " ms" << std::endl;
int nn=1;
// Computation of the point radius // Computation of the point radius
float mAveragePointSpacing = 0; float mAveragePointSpacing = 0;
time.restart(); time.restart();
#pragma omp parallel for reduction(+: mAveragePointSpacing) schedule(dynamic, 10) #pragma omp parallel for reduction(+: mAveragePointSpacing) schedule(dynamic, 10)
for (int i = 0; i < mesh.vert.size(); i++) for (int i = 0; i < mesh.vert.size(); i++)
{ {
vcg::KdTree<CMesh::ScalarType>::PriorityQueue queue; #ifdef #ifdef _OPENMP
kdTreeVcg.doQueryK(mesh.vert[i].cP(), 16, queue); nn =omp_get_num_threads();
float newRadius = 2.0f * sqrt(queue.getWeight(0)/ queue.getNofElements()); #endif
mesh.vert[i].R() -= newRadius; vcg::KdTree<CMesh::ScalarType>::PriorityQueue queue;
mAveragePointSpacing += newRadius; kdTreeVcg.doQueryK(mesh.vert[i].cP(), 16, queue);
} float newRadius = 2.0f * sqrt(queue.getWeight(0)/ queue.getNofElements());
mAveragePointSpacing /= mesh.vert.size(); mesh.vert[i].R() -= newRadius;
std::cout << "Average point radius (OpenMP) " << mAveragePointSpacing << std::endl; mAveragePointSpacing += newRadius;
std::cout << "Time (OpenMP): " << time.elapsed() << " ms" << std::endl; }
std::cout << "Num trhread " << nn << std::endl;
queryDist = mAveragePointSpacing * 150; mAveragePointSpacing /= mesh.vert.size();
std::cout << "Average point radius (OpenMP with" << nn << " threads) " << mAveragePointSpacing << std::endl;
// Test with the radius search std::cout << "Time (OpenMP): " << time.elapsed() << " ms" << std::endl;
std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
float avgTime = 0.0f; queryDist = mAveragePointSpacing * 150;
for (int ii = 0; ii < num_test; ii++)
{ // Test with the radius search
time.restart(); std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
std::vector<unsigned int> indeces; float avgTime = 0.0f;
std::vector<float> dists; for (int ii = 0; ii < num_test; ii++)
kdTreeVcg.doQueryDist(mesh.vert[test_indeces[ii]].cP(), queryDist, indeces, dists); {
avgTime += time.elapsed(); time.restart();
} std::vector<unsigned int> indeces;
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; std::vector<float> dists;
kdTreeVcg.doQueryDist(mesh.vert[test_indeces[ii]].cP(), queryDist, indeces, dists);
// Test with the k-nearest search avgTime += time.elapsed();
std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the k-nearest search
time.restart(); std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl;
vcg::KdTree<CMesh::ScalarType>::PriorityQueue queue; avgTime = 0.0f;
kdTreeVcg.doQueryK(mesh.vert[test_indeces[ii]].cP(), kNearest, queue); for (int ii = 0; ii < num_test * 10; ii++)
avgTime += time.elapsed(); {
} time.restart();
std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; vcg::KdTree<CMesh::ScalarType>::PriorityQueue queue;
kdTreeVcg.doQueryK(mesh.vert[test_indeces[ii]].cP(), kNearest, queue);
// Test with the closest search avgTime += time.elapsed();
std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the closest search
time.restart(); std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl;
unsigned int index; avgTime = 0.0f;
float minDist; for (int ii = 0; ii < num_test * 10; ii++)
kdTreeVcg.doQueryClosest(randomSamples[ii], index, minDist); {
avgTime += time.elapsed(); time.restart();
} unsigned int index;
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; float minDist;
} kdTreeVcg.doQueryClosest(randomSamples[ii], index, minDist);
avgTime += time.elapsed();
}
void testNanoFLANN(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f> randomSamples) std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl;
{ }
std::cout << "==================================================="<< std::endl;
std::cout << "nanoFLANN" << std::endl;
void testNanoFLANN(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f> randomSamples)
PointCloud<float> cloud; {
cloud.pts.resize(mesh.vert.size()); std::cout << "==================================================="<< std::endl;
for (size_t i=0; i < mesh.vert.size(); i++) std::cout << "nanoFLANN" << std::endl;
{
cloud.pts[i].x = mesh.vert[i].P().X(); PointCloud<float> cloud;
cloud.pts[i].y = mesh.vert[i].P().Y(); cloud.pts.resize(mesh.vert.size());
cloud.pts[i].z = mesh.vert[i].P().Z(); for (size_t i=0; i < mesh.vert.size(); i++)
} {
cloud.pts[i].x = mesh.vert[i].P().X();
typedef nanoflann::KDTreeSingleIndexAdaptor< cloud.pts[i].y = mesh.vert[i].P().Y();
nanoflann::L2_Simple_Adaptor<float, PointCloud<float> > , cloud.pts[i].z = mesh.vert[i].P().Z();
PointCloud<float>, }
3 /* dim */
> my_kd_tree_t; typedef nanoflann::KDTreeSingleIndexAdaptor<
nanoflann::L2_Simple_Adaptor<float, PointCloud<float> > ,
// Construction of the nanoFLANN KDtree PointCloud<float>,
QTime time; 3 /* dim */
time.start(); > my_kd_tree_t;
my_kd_tree_t index(3, cloud, nanoflann::KDTreeSingleIndexAdaptorParams(16) );
index.buildIndex(); // Construction of the nanoFLANN KDtree
std::cout << "Build nanoFlann: " << time.elapsed() << " ms" << std::endl; QTime time;
time.start();
// Test with the radius search my_kd_tree_t index(3, cloud, nanoflann::KDTreeSingleIndexAdaptorParams(16) );
std::cout << "Radius search (" << num_test << " tests)"<< std::endl; index.buildIndex();
float avgTime = 0.0f; std::cout << "Build nanoFlann: " << time.elapsed() << " ms" << std::endl;
std::vector<std::pair<size_t,float> > ret_matches;
nanoflann::SearchParams params; // Test with the radius search
for (int ii = 0; ii < num_test; ii++) std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
{ float avgTime = 0.0f;
time.restart(); std::vector<std::pair<size_t,float> > ret_matches;
const size_t nMatches = index.radiusSearch(mesh.vert[test_indeces[ii]].P().V(), queryDist, ret_matches, params); nanoflann::SearchParams params;
avgTime += time.elapsed(); for (int ii = 0; ii < num_test; ii++)
} {
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; time.restart();
const size_t nMatches = index.radiusSearch(mesh.vert[test_indeces[ii]].P().V(), queryDist, ret_matches, params);
// Test with the k-nearest search avgTime += time.elapsed();
std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl;
std::vector<size_t> ret_index(kNearest);
std::vector<float> out_dist_sqr(kNearest); // Test with the k-nearest search
for (int ii = 0; ii < num_test * 10; ii++) std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl;
{ avgTime = 0.0f;
time.restart(); std::vector<size_t> ret_index(kNearest);
index.knnSearch(mesh.vert[test_indeces[ii]].P().V(), kNearest, &ret_index[0], &out_dist_sqr[0]); std::vector<float> out_dist_sqr(kNearest);
avgTime += time.elapsed(); for (int ii = 0; ii < num_test * 10; ii++)
} {
std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; time.restart();
index.knnSearch(mesh.vert[test_indeces[ii]].P().V(), kNearest, &ret_index[0], &out_dist_sqr[0]);
// Test with the closest search avgTime += time.elapsed();
std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl;
std::vector<size_t> ret_index_clos(1);
std::vector<float> out_dist_sqr_clos(1); // Test with the closest search
for (int ii = 0; ii < num_test * 10; ii++) std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl;
{ avgTime = 0.0f;
time.restart(); std::vector<size_t> ret_index_clos(1);
index.knnSearch(randomSamples[ii].V(), 1, &ret_index_clos[0], &out_dist_sqr_clos[0]); std::vector<float> out_dist_sqr_clos(1);
avgTime += time.elapsed(); for (int ii = 0; ii < num_test * 10; ii++)
} {
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; time.restart();
} index.knnSearch(randomSamples[ii].V(), 1, &ret_index_clos[0], &out_dist_sqr_clos[0]);
avgTime += time.elapsed();
}
void testUniformGrid(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples) std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl;
{ }
std::cout << "==================================================="<< std::endl;
std::cout << "Uniform Grid" << std::endl;
QTime time; void testUniformGrid(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples)
time.start(); {
std::cout << "==================================================="<< std::endl;
// Construction of the uniform grid std::cout << "Uniform Grid" << std::endl;
typedef vcg::GridStaticPtr<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; QTime time;
MeshGrid uniformGrid; time.start();
uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Construction of the uniform grid
typedef vcg::GridStaticPtr<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid;
// Test with the radius search MeshGrid uniformGrid;
std::cout << "Radius search (" << num_test << " tests)"<< std::endl; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
float avgTime = 0.0f; std::cout << "Build: " << time.elapsed() << " ms" << std::endl;
for (int ii = 0; ii < num_test; ii++)
{ // Test with the radius search
time.restart(); std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; float avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test; ii++)
std::vector<float> dists; {
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points);
// Test with the k-nearest search avgTime += time.elapsed();
std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the k-nearest search
time.restart(); std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test * 10; ii++)
std::vector<float> dists; {
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points);
// Test with the Closest search avgTime += time.elapsed();
std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the Closest search
time.restart(); std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl;
float minDist; avgTime = 0.0f;
vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist); for (int ii = 0; ii < num_test * 10; ii++)
avgTime += time.elapsed(); {
} time.restart();
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; float minDist;
} vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist);
avgTime += time.elapsed();
}
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl;
void testSpatialHashing(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples) }
{
std::cout << "==================================================="<< std::endl;
std::cout << "Spatial Hashing" << std::endl;
QTime time; void testSpatialHashing(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples)
time.start(); {
std::cout << "==================================================="<< std::endl;
// Construction of the uniform grid std::cout << "Spatial Hashing" << std::endl;
typedef vcg::SpatialHashTable<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; QTime time;
MeshGrid uniformGrid; time.start();
uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Construction of the uniform grid
typedef vcg::SpatialHashTable<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid;
// Test with the radius search MeshGrid uniformGrid;
std::cout << "Radius search (" << num_test << " tests)"<< std::endl; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
float avgTime = 0.0f; std::cout << "Build: " << time.elapsed() << " ms" << std::endl;
for (int ii = 0; ii < num_test; ii++)
{ // Test with the radius search
time.restart(); std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; float avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test; ii++)
std::vector<float> dists; {
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points);
// Test with the k-nearest search avgTime += time.elapsed();
std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the k-nearest search
time.restart(); std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test * 10; ii++)
std::vector<float> dists; {
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points);
// Test with the Closest search avgTime += time.elapsed();
std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the Closest search
time.restart(); std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl;
float minDist; avgTime = 0.0f;
vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist); for (int ii = 0; ii < num_test * 10; ii++)
avgTime += time.elapsed(); {
} time.restart();
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; float minDist;
} vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist);
avgTime += time.elapsed();
}
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl;
void testPerfectSpatialHashing(CMesh& mesh, std::vector<unsigned int>& test_indeces) }
{
std::cout << "==================================================="<< std::endl;
std::cout << "Perfect Spatial Hashing" << std::endl;
QTime time; void testPerfectSpatialHashing(CMesh& mesh, std::vector<unsigned int>& test_indeces)
time.start(); {
std::cout << "==================================================="<< std::endl;
// Construction of the uniform grid std::cout << "Perfect Spatial Hashing" << std::endl;
typedef vcg::SpatialHashTable<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; QTime time;
MeshGrid uniformGrid; time.start();
uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Construction of the uniform grid
typedef vcg::SpatialHashTable<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid;
// Test with the radius search MeshGrid uniformGrid;
std::cout << "Radius search (" << num_test << " tests)"<< std::endl; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
float avgTime = 0.0f; std::cout << "Build: " << time.elapsed() << " ms" << std::endl;
for (int ii = 0; ii < num_test; ii++)
{ // Test with the radius search
time.restart(); std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; float avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test; ii++)
std::vector<float> dists; {
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl << std::endl; std::vector<float> dists;
} vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points);
avgTime += time.elapsed();
}
void testOctree(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples) std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl << std::endl;
{ }
std::cout << "==================================================="<< std::endl;
std::cout << "Octree" << std::endl;
QTime time; void testOctree(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f>& randomSamples)
time.start(); {
std::cout << "==================================================="<< std::endl;
// Construction of the uniform grid std::cout << "Octree" << std::endl;
typedef vcg::Octree<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid; QTime time;
MeshGrid uniformGrid; time.start();
uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
std::cout << "Build: " << time.elapsed() << " ms" << std::endl; // Construction of the uniform grid
typedef vcg::Octree<CMesh::VertexType, CMesh::VertexType::ScalarType> MeshGrid;
// Test with the radius search MeshGrid uniformGrid;
std::cout << "Radius search (" << num_test << " tests)"<< std::endl; uniformGrid.Set(mesh.vert.begin(), mesh.vert.end());
float avgTime = 0.0f; std::cout << "Build: " << time.elapsed() << " ms" << std::endl;
for (int ii = 0; ii < num_test; ii++)
{ // Test with the radius search
time.restart(); std::cout << "Radius search (" << num_test << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; float avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test; ii++)
std::vector<float> dists; {
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetInSphereVertex(mesh, uniformGrid, mesh.vert[test_indeces[ii]].cP(), queryDist, vertexPtr, dists, points);
// Test with the k-nearest search avgTime += time.elapsed();
std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the k-nearest search
time.restart(); std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl;
std::vector<CMesh::VertexPointer> vertexPtr; avgTime = 0.0f;
std::vector<CMesh::VertexType::CoordType> points; for (int ii = 0; ii < num_test * 10; ii++)
std::vector<float> dists; {
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points); time.restart();
avgTime += time.elapsed(); std::vector<CMesh::VertexPointer> vertexPtr;
} std::vector<CMesh::VertexType::CoordType> points;
std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; std::vector<float> dists;
vcg::tri::GetKClosestVertex(mesh, uniformGrid, kNearest, mesh.vert[test_indeces[ii]].cP(), mesh.bbox.Diag(), vertexPtr, dists, points);
// Test with the Closest search avgTime += time.elapsed();
std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; }
avgTime = 0.0f; std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl;
for (int ii = 0; ii < num_test * 10; ii++)
{ // Test with the Closest search
time.restart(); std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl;
float minDist; avgTime = 0.0f;
vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist); for (int ii = 0; ii < num_test * 10; ii++)
avgTime += time.elapsed(); {
} time.restart();
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; float minDist;
} vcg::tri::GetClosestVertex(mesh, uniformGrid, randomSamples[ii], mesh.bbox.Diag(), minDist);
avgTime += time.elapsed();
}
std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl;
}
int main( int argc, char * argv[] ) int main( int argc, char * argv[] )
{ {
if (argc < 2) if (argc < 2) {
std::cout << "Invalid arguments" << std::endl; std::cout << "Invalid arguments" << std::endl;
exit(-1);
}
CMesh mesh;
if (vcg::tri::io::Importer<CMesh>::Open(mesh, argv[1]) != 0)
std::cout << "Invalid filename" << std::endl;
CMesh mesh; std::cout << "Mesh BBox diagonal: " << mesh.bbox.Diag() << std::endl;
if (vcg::tri::io::Importer<CMesh>::Open(mesh, argv[1]) != 0) std::cout << "Max point random offset: " << mesh.bbox.Diag() / 1000.0f << std::endl << std::endl;
std::cout << "Invalid filename" << std::endl;
std::cout << "Mesh BBox diagonal: " << mesh.bbox.Diag() << std::endl; vcg::math::MarsenneTwisterRNG randGen;
std::cout << "Max point random offset: " << mesh.bbox.Diag() / 1000.0f << std::endl << std::endl; randGen.initialize(0);
std::vector<vcg::Point3f> randomSamples;
for (int i = 0; i < num_test * 10; i++)
randomSamples.push_back(vcg::math::GeneratePointOnUnitSphereUniform<float>(randGen) * randGen.generate01() * mesh.bbox.Diag() / ratio);
vcg::math::MarsenneTwisterRNG randGen; std::vector<unsigned int> test_indeces;
randGen.initialize(0); for (int i = 0; i < num_test * 10; i++)
std::vector<vcg::Point3f> randomSamples; {
for (int i = 0; i < num_test * 10; i++) int index = randGen.generate01() * (mesh.vert.size() - 1);
randomSamples.push_back(vcg::math::GeneratePointOnUnitSphereUniform<float>(randGen) * randGen.generate01() * mesh.bbox.Diag() / ratio); test_indeces.push_back(index);
randomSamples[i] += mesh.vert[i].P();
}
std::vector<unsigned int> test_indeces; testKDTree(mesh, test_indeces, randomSamples);
for (int i = 0; i < num_test * 10; i++) testNanoFLANN(mesh, test_indeces, randomSamples);
{ testUniformGrid(mesh, test_indeces, randomSamples);
int index = randGen.generate01() * (mesh.vert.size() - 1); testSpatialHashing(mesh, test_indeces, randomSamples);
test_indeces.push_back(index); testPerfectSpatialHashing(mesh, test_indeces);
randomSamples[i] += mesh.vert[i].P(); testOctree(mesh, test_indeces, randomSamples);
}
testKDTree(mesh, test_indeces, randomSamples);
testNanoFLANN(mesh, test_indeces, randomSamples);
testUniformGrid(mesh, test_indeces, randomSamples);
testSpatialHashing(mesh, test_indeces, randomSamples);
testPerfectSpatialHashing(mesh, test_indeces);
testOctree(mesh, test_indeces, randomSamples);
} }