From d15745b12826fb64efb8b14d09dd934156d3b4c2 Mon Sep 17 00:00:00 2001 From: cignoni Date: Sun, 25 Oct 2015 23:24:23 +0000 Subject: [PATCH] Corrected missing template and typename keyword and added function to just select the points --- vcg/complex/algorithms/point_outlier.h | 178 +++++++++++++------------ 1 file changed, 96 insertions(+), 82 deletions(-) diff --git a/vcg/complex/algorithms/point_outlier.h b/vcg/complex/algorithms/point_outlier.h index 1667ee1e..81178c19 100644 --- a/vcg/complex/algorithms/point_outlier.h +++ b/vcg/complex/algorithms/point_outlier.h @@ -21,7 +21,7 @@ * * ****************************************************************************/ #ifndef VCG_TRI_OUTLIERS__H -#define VCG_TRI_OUTLIERS_H +#define VCG_TRI_OUTLIERS__H #include @@ -37,92 +37,106 @@ class OutlierRemoval { public: - typedef typename MeshType::ScalarType ScalarType; - typedef typename vcg::KdTree KdTreeType; - typedef typename vcg::KdTree::PriorityQueue PriorityQueue; - + typedef typename MeshType::ScalarType ScalarType; + typedef typename vcg::KdTree KdTreeType; + typedef typename vcg::KdTree::PriorityQueue PriorityQueue; + + + /** + Compute an outlier probability value for each vertex of the mesh using the approch + in the paper "LoOP: Local Outlier Probabilities". The outlier probability is stored in the + vertex attribute "outlierScore". It use the input kdtree to find the kNearest of each vertex. + + "LoOP: local outlier probabilities" by Hans-Peter Kriegel et al. + Proceedings of the 18th ACM conference on Information and knowledge management + */ + static void ComputeLoOPScore(MeshType& mesh, KdTreeType& kdTree, int kNearest) + { + vcg::tri::RequireCompactness(mesh); + typename MeshType::template PerVertexAttributeHandle outlierScore = tri::Allocator:: template GetPerVertexAttribute(mesh, std::string("outlierScore")); + typename MeshType::template PerVertexAttributeHandle sigma = tri::Allocator:: template GetPerVertexAttribute(mesh, std::string("sigma")); + typename MeshType::template PerVertexAttributeHandle plof = tri::Allocator:: template GetPerVertexAttribute(mesh, std::string("plof")); - /** - Compute an outlier probability value for each vertex of the mesh using the approch - in the paper "LoOP: Local Outlier Probabilities". The outlier probability is stored in the - vertex attribute "outlierScore". It use the input kdtree to find the kNearest of each vertex. - - "LoOP: local outlier probabilities" by Hans-Peter Kriegel et al. - Proceedings of the 18th ACM conference on Information and knowledge management - */ - static void ComputeLoOPScore(MeshType& mesh, KdTreeType& kdTree, int kNearest) - { - vcg::tri::RequireCompactness(mesh); - CMesh::PerVertexAttributeHandle outlierScore = vcg::tri::Allocator::GetPerVertexAttribute(mesh, std::string("outlierScore")); - CMesh::PerVertexAttributeHandle sigma = vcg::tri::Allocator::GetPerVertexAttribute(mesh, std::string("sigma")); - CMesh::PerVertexAttributeHandle plof = vcg::tri::Allocator::GetPerVertexAttribute(mesh, std::string("plof")); - #pragma omp parallel for schedule(dynamic, 10) - for (int i = 0; i < mesh.vert.size(); i++) - { - PriorityQueue queue; - kdTree.doQueryK(mesh.vert[i].cP(), kNearest, queue); - ScalarType sum = 0; - for (int j = 0; j < queue.getNofElements(); j++) - sum += queue.getWeight(j); - sum /= (queue.getNofElements()); - sigma[i] = sqrt(sum); - } + for (int i = 0; i < mesh.vert.size(); i++) + { + PriorityQueue queue; + kdTree.doQueryK(mesh.vert[i].cP(), kNearest, queue); + ScalarType sum = 0; + for (int j = 0; j < queue.getNofElements(); j++) + sum += queue.getWeight(j); + sum /= (queue.getNofElements()); + sigma[i] = sqrt(sum); + } + + float mean = 0; +#pragma omp parallel for reduction(+: mean) schedule(dynamic, 10) + for (int i = 0; i < mesh.vert.size(); i++) + { + PriorityQueue queue; + kdTree.doQueryK(mesh.vert[i].cP(), kNearest, queue); + ScalarType sum = 0; + for (int j = 0; j < queue.getNofElements(); j++) + sum += sigma[queue.getIndex(j)]; + sum /= (queue.getNofElements()); + plof[i] = sigma[i] / sum - 1.0f; + mean += plof[i] * plof[i]; + } + + mean /= mesh.vert.size(); + mean = sqrt(mean); - float mean = 0; -#pragma omp parallel for reduction(+: mean) schedule(dynamic, 10) - for (int i = 0; i < mesh.vert.size(); i++) - { - PriorityQueue queue; - kdTree.doQueryK(mesh.vert[i].cP(), kNearest, queue); - ScalarType sum = 0; - for (int j = 0; j < queue.getNofElements(); j++) - sum += sigma[queue.getIndex(j)]; - sum /= (queue.getNofElements()); - plof[i] = sigma[i] / sum - 1.0f; - mean += plof[i] * plof[i]; - } - - mean /= mesh.vert.size(); - mean = sqrt(mean); - #pragma omp parallel for schedule(dynamic, 10) - for (int i = 0; i < mesh.vert.size(); i++) - { - ScalarType value = plof[i] / (mean * sqrt(2.0f)); - double dem = 1.0 + 0.278393 * value; - dem += 0.230389 * value * value; - dem += 0.000972 * value * value * value; - dem += 0.078108 * value * value * value * value; - ScalarType op = max(0.0, 1.0 - 1.0 / dem); - outlierScore[i] = op; - } + for (int i = 0; i < mesh.vert.size(); i++) + { + ScalarType value = plof[i] / (mean * sqrt(2.0f)); + double dem = 1.0 + 0.278393 * value; + dem += 0.230389 * value * value; + dem += 0.000972 * value * value * value; + dem += 0.078108 * value * value * value * value; + ScalarType op = max(0.0, 1.0 - 1.0 / dem); + outlierScore[i] = op; + } - vcg::tri::Allocator::DeletePerVertexAttribute(mesh, std::string("sigma")); - vcg::tri::Allocator::DeletePerVertexAttribute(mesh, std::string("plof")); - }; - - - /** - Delete all the vertex of the mesh with an outlier probability above the input threshold [0.0, 1.0]. - */ - static int DeleteLoOPOutliers(MeshType& mesh, KdTreeType& kdTree, int kNearest, float threshold) - { - ComputeLoOPScore(mesh, kdTree, kNearest); - int count = 0; - CMesh::PerVertexAttributeHandle outlierScore = vcg::tri::Allocator::GetPerVertexAttribute(mesh, std::string("outlierScore")); - for (int i = 0; i < mesh.vert.size(); i++) - { - if (outlierScore[i] > threshold) - { - vcg::tri::Allocator::DeleteVertex(mesh, mesh.vert[i]); - count++; - } - } - vcg::tri::Allocator::CompactVertexVector(mesh); - vcg::tri::Allocator::DeletePerVertexAttribute(mesh, std::string("outlierScore")); - return count; - }; + tri::Allocator::DeletePerVertexAttribute(mesh, std::string("sigma")); + tri::Allocator::DeletePerVertexAttribute(mesh, std::string("plof")); + }; + + /** + Select all the vertex of the mesh with an outlier probability above the input threshold [0.0, 1.0]. + */ + static int SelectLoOPOutliers(MeshType& mesh, KdTreeType& kdTree, int kNearest, float threshold) + { + ComputeLoOPScore(mesh, kdTree, kNearest); + int count = 0; + typename MeshType:: template PerVertexAttributeHandle outlierScore = tri::Allocator::template GetPerVertexAttribute(mesh, std::string("outlierScore")); + for (int i = 0; i < mesh.vert.size(); i++) + { + if (outlierScore[i] > threshold) + { + mesh.vert[i].SetS(); + count++; + } + } + return count; + } + + + + /** + Delete all the vertex of the mesh with an outlier probability above the input threshold [0.0, 1.0]. + */ + static int DeleteLoOPOutliers(MeshType& m, KdTreeType& kdTree, int kNearest, float threshold) + { + SelectLoOPOutliers(m,kdTree,kNearest,threshold); + int ovn = m.vn; + + for(typename MeshType::VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi) + if((*vi).IsS() ) tri::Allocator::DeleteVertex(m,*vi); + tri::Allocator::CompactVertexVector(m); + tri::Allocator::DeletePerVertexAttribute(m, std::string("outlierScore")); + return m.vn - ovn; + } }; } // end namespace tri