From 17343421f596d1c7a7bad71a3b35cbc5bd7ab5e4 Mon Sep 17 00:00:00 2001 From: Simon Giraudot Date: Fri, 17 Mar 2017 13:55:28 +0100 Subject: [PATCH] Use floats everywhere (need for very little memory size) --- .../include/CGAL/Classification/Evaluation.h | 34 +++---- .../Feature/Distance_to_plane.h | 6 +- .../Classification/Feature/Echo_scatter.h | 12 +-- .../CGAL/Classification/Feature/Eigen.h | 40 ++++---- .../CGAL/Classification/Feature/Elevation.h | 44 ++++++--- .../include/CGAL/Classification/Feature/Hsv.h | 10 +- .../Feature/Vertical_dispersion.h | 41 ++++++-- .../CGAL/Classification/Feature/Verticality.h | 20 ++-- .../CGAL/Classification/Feature_base.h | 2 +- .../Classification/Local_eigen_analysis.h | 84 ++++++++++------- .../CGAL/Classification/Planimetric_grid.h | 4 +- .../Point_set_feature_generator.h | 57 +++++++---- .../Classification/Point_set_neighborhood.h | 14 +-- .../Sum_of_weighted_features_predicate.h | 94 ++++++++++--------- .../include/CGAL/Classification/classify.h | 52 +++++----- 15 files changed, 297 insertions(+), 217 deletions(-) diff --git a/Classification/include/CGAL/Classification/Evaluation.h b/Classification/include/CGAL/Classification/Evaluation.h index 7056ce92f37..e7ece6db626 100644 --- a/Classification/include/CGAL/Classification/Evaluation.h +++ b/Classification/include/CGAL/Classification/Evaluation.h @@ -31,12 +31,12 @@ class Evaluation { mutable std::map m_map_labels; - std::vector m_precision; - std::vector m_recall; - std::vector m_iou; // intersection over union - double m_accuracy; - double m_mean_iou; - double m_mean_f1; + std::vector m_precision; + std::vector m_recall; + std::vector m_iou; // intersection over union + float m_accuracy; + float m_mean_iou; + float m_mean_f1; public: @@ -79,9 +79,9 @@ public: for (std::size_t j = 0; j < labels.size(); ++ j) { - m_precision[j] = true_positives[j] / double(true_positives[j] + false_positives[j]); - m_recall[j] = true_positives[j] / double(true_positives[j] + false_negatives[j]); - m_iou[j] = true_positives[j] / double(true_positives[j] + false_positives[j] + false_negatives[j]); + m_precision[j] = true_positives[j] / float(true_positives[j] + false_positives[j]); + m_recall[j] = true_positives[j] / float(true_positives[j] + false_negatives[j]); + m_iou[j] = true_positives[j] / float(true_positives[j] + false_positives[j] + false_negatives[j]); m_mean_iou += m_iou[j]; m_mean_f1 += 2. * (m_precision[j] * m_recall[j]) @@ -90,7 +90,7 @@ public: m_mean_iou /= labels.size(); m_mean_f1 /= labels.size(); - m_accuracy = sum_true_positives / double(total); + m_accuracy = sum_true_positives / float(total); } @@ -102,7 +102,7 @@ public: the true positives and the false positives. */ - double precision (Label_handle label) const + float precision (Label_handle label) const { return m_precision[m_map_labels[label]]; } @@ -115,7 +115,7 @@ public: the true positives and the false negatives. */ - double recall (Label_handle label) const + float recall (Label_handle label) const { return m_recall[m_map_labels[label]]; } @@ -131,7 +131,7 @@ public: \f] */ - double f1_score (Label_handle label) const + float f1_score (Label_handle label) const { std::size_t label_idx = m_map_labels[label]; return 2. * (m_precision[label_idx] * m_recall[label_idx]) @@ -146,7 +146,7 @@ public: the sum of the true positives, of the false positives and of the false negatives. */ - double intersection_over_union (Label_handle label) const + float intersection_over_union (Label_handle label) const { return m_iou[m_map_labels[label]]; } @@ -157,19 +157,19 @@ public: Accuracy is the total number of true positives divided by the total number of provided inliers. */ - double accuracy() const { return m_accuracy; } + float accuracy() const { return m_accuracy; } /*! \brief Returns the mean \f$F_1\f$ score of the training over all labels (see `f1_score()`). */ - double mean_f1_score() const { return m_mean_f1; } + float mean_f1_score() const { return m_mean_f1; } /*! \brief Returns the mean intersection over union of the training over all labels (see `intersection_over_union()`). */ - double mean_intersection_over_union() const { return m_mean_iou; } + float mean_intersection_over_union() const { return m_mean_iou; } }; diff --git a/Classification/include/CGAL/Classification/Feature/Distance_to_plane.h b/Classification/include/CGAL/Classification/Feature/Distance_to_plane.h index 91721c417fd..0bb4efe573c 100644 --- a/Classification/include/CGAL/Classification/Feature/Distance_to_plane.h +++ b/Classification/include/CGAL/Classification/Feature/Distance_to_plane.h @@ -48,13 +48,13 @@ namespace Feature { for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Distance_to_plane : public Feature_base { typedef Classification::Local_eigen_analysis Local_eigen_analysis; #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES - std::vector distance_to_plane_feature; + std::vector distance_to_plane_feature; #else const PointRange& input; PointMap point_map; @@ -85,7 +85,7 @@ public: } /// \cond SKIP_IN_MANUAL - virtual double value (std::size_t pt_index) + virtual float value (std::size_t pt_index) { #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES return distance_to_plane_feature[pt_index]; diff --git a/Classification/include/CGAL/Classification/Feature/Echo_scatter.h b/Classification/include/CGAL/Classification/Feature/Echo_scatter.h index 748946c00ee..c3ccd4fb4c0 100644 --- a/Classification/include/CGAL/Classification/Feature/Echo_scatter.h +++ b/Classification/include/CGAL/Classification/Feature/Echo_scatter.h @@ -55,7 +55,7 @@ public: private: typedef Classification::Image Image_float; - std::vector echo_scatter; + std::vector echo_scatter; public: /*! @@ -70,8 +70,8 @@ public: Echo_scatter (const PointRange& input, EchoMap echo_map, const Grid& grid, - const double grid_resolution, - double radius_neighbors = 1.) + const float grid_resolution, + float radius_neighbors = 1.) { this->set_name ("echo_scatter"); Image_float Scatter(grid.width(), grid.height()); @@ -97,7 +97,7 @@ public: for(std::size_t k = squareXmin; k <= squareXmax; k++){ for(std::size_t l = squareYmin; l <= squareYmax; l++){ - if(CGAL::sqrt(pow((double)k-i,2)+pow((double)l-j,2))<=(double)0.5*radius_neighbors/grid_resolution){ + if(CGAL::sqrt(pow((float)k-i,2)+pow((float)l-j,2))<=(float)0.5*radius_neighbors/grid_resolution){ if(grid.indices(k,l).size()>0){ @@ -128,12 +128,12 @@ public: for(std::size_t i = 0; i < input.size(); i++){ std::size_t I= grid.x(i); std::size_t J= grid.y(i); - echo_scatter.push_back((double)Scatter(I,J)); + echo_scatter.push_back((float)Scatter(I,J)); } } /// \cond SKIP_IN_MANUAL - virtual double value (std::size_t pt_index) + virtual float value (std::size_t pt_index) { return echo_scatter[pt_index]; } diff --git a/Classification/include/CGAL/Classification/Feature/Eigen.h b/Classification/include/CGAL/Classification/Feature/Eigen.h index 54bccae1271..cc998f18199 100644 --- a/Classification/include/CGAL/Classification/Feature/Eigen.h +++ b/Classification/include/CGAL/Classification/Feature/Eigen.h @@ -31,7 +31,7 @@ namespace Classification { namespace Feature { template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Eigen_feature : public Feature_base { protected: @@ -39,7 +39,7 @@ protected: PointMap, DiagonalizeTraits> Local_eigen_analysis; #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES - std::vector attrib; + std::vector attrib; #else const Local_eigen_analysis& eigen; #endif @@ -67,8 +67,8 @@ public: } #endif - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) = 0; - virtual double value (std::size_t pt_index) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) = 0; + virtual float value (std::size_t pt_index) { #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES return attrib[pt_index]; @@ -99,7 +99,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Linearity : public Eigen_feature { typedef Classification::Local_eigen_analysis > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Planarity : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); if (ev[2] < 1e-15) @@ -204,7 +204,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Sphericity : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); if (ev[2] < 1e-15) @@ -256,7 +256,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Omnivariance : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); return (std::pow (std::fabs(ev[0] * ev[1] * ev[2]), 0.333333333)); @@ -305,7 +305,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Anisotropy : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); if (ev[2] < 1e-15) @@ -357,7 +357,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Eigentropy : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); if (ev[0] < 1e-15 @@ -414,7 +414,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Sum_eigenvalues : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { return eigen.sum_of_eigenvalues(i); } @@ -463,7 +463,7 @@ public: for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Surface_variation : public Eigen_feature { typedef Classification::Local_eigen_analysisinit(input, eigen); } /// \cond SKIP_IN_MANUAL - virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) + virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) { const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i); if (ev[0] + ev[1] + ev[2] < 1e-15) diff --git a/Classification/include/CGAL/Classification/Feature/Elevation.h b/Classification/include/CGAL/Classification/Feature/Elevation.h index 0645a558a2b..4297574c28a 100644 --- a/Classification/include/CGAL/Classification/Feature/Elevation.h +++ b/Classification/include/CGAL/Classification/Feature/Elevation.h @@ -56,8 +56,15 @@ class Elevation : public Feature_base typedef Image Image_float; typedef Planimetric_grid Grid; - - std::vector elevation_feature; + +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES + std::vector elevation_feature; +#else + const PointRange& input; + PointMap point_map; + const Grid& grid; + Image_float dtm; +#endif public: /*! @@ -73,8 +80,11 @@ public: Elevation (const PointRange& input, PointMap point_map, const Grid& grid, - const double grid_resolution, - double radius_dtm = -1.) + const float grid_resolution, + float radius_dtm = -1.) +#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES + : input(input), point_map(point_map), grid(grid) +#endif { this->set_name ("elevation"); if (radius_dtm < 0.) @@ -88,7 +98,7 @@ public: { if (grid.indices(i,j).empty()) continue; - double mean = 0.; + float mean = 0.; for (std::size_t k = 0; k < grid.indices(i,j).size(); ++ k) mean += get(point_map, *(input.begin()+grid.indices(i,j)[k])).z(); mean /= grid.indices(i,j).size(); @@ -106,7 +116,7 @@ public: std::size_t squareXmin = (i < square ? 0 : i - square); std::size_t squareXmax = (std::min)(grid.width() - 1, i + square); - std::vector z; + std::vector z; z.reserve(squareXmax - squareXmin +1 ); for(std::size_t k = squareXmin; k <= squareXmax; k++) if (dem(k,j) != 0.) @@ -119,7 +129,11 @@ public: } dem.free(); +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES Image_float dtm(grid.width(),grid.height()); +#else + dtm = Image_float(grid.width(),grid.height()); +#endif for (std::size_t i = 0; i < grid.width(); ++ i) { @@ -127,7 +141,7 @@ public: { std::size_t squareYmin = (j < square ? 0 : j - square); std::size_t squareYmax = (std::min)(grid.height() - 1, j + square); - std::vector z; + std::vector z; z.reserve(squareYmax - squareYmin +1 ); for(std::size_t l = squareYmin; l <= squareYmax; l++) if (dtm_x(i,l) != 0.) @@ -139,20 +153,28 @@ public: } } dtm_x.free(); - + +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES elevation_feature.reserve(input.size()); for (std::size_t i = 0; i < input.size(); i++){ std::size_t I = grid.x(i); std::size_t J = grid.y(i); - elevation_feature.push_back ((double)(get(point_map, *(input.begin()+i)).z()-dtm(I,J))); + elevation_feature.push_back ((float)(get(point_map, *(input.begin()+i)).z()-dtm(I,J))); } - +#endif + } /// \cond SKIP_IN_MANUAL - virtual double value (std::size_t pt_index) + virtual float value (std::size_t pt_index) { +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES return elevation_feature[pt_index]; +#else + std::size_t I = grid.x(pt_index); + std::size_t J = grid.y(pt_index); + return ((float)(get(point_map, *(input.begin()+pt_index)).z()-dtm(I,J))); +#endif } /// \endcond diff --git a/Classification/include/CGAL/Classification/Feature/Hsv.h b/Classification/include/CGAL/Classification/Feature/Hsv.h index 1bf33ddcb4b..27916e9bf68 100644 --- a/Classification/include/CGAL/Classification/Feature/Hsv.h +++ b/Classification/include/CGAL/Classification/Feature/Hsv.h @@ -73,13 +73,13 @@ class Hsv : public Feature_base typedef typename Classification::HSV_Color HSV_Color; #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES - std::vector color_feature; + std::vector color_feature; #else const PointRange& input; ColorMap color_map; std::size_t m_channel; - double m_mean; - double m_sd; + float m_mean; + float m_sd; #endif public: @@ -98,7 +98,7 @@ public: Hsv (const PointRange& input, ColorMap color_map, std::size_t channel, - double mean, double sd) + float mean, float sd) #ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES : input(input), color_map(color_map), m_channel(channel), m_mean(mean), m_sd(sd) #endif @@ -121,7 +121,7 @@ public: } /// \cond SKIP_IN_MANUAL - virtual double value (std::size_t pt_index) + virtual float value (std::size_t pt_index) { #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES return color_feature[pt_index]; diff --git a/Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h b/Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h index 7f4a151f28c..b2298759c31 100644 --- a/Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h +++ b/Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h @@ -54,7 +54,13 @@ class Vertical_dispersion : public Feature_base { typedef Classification::Image Image_float; typedef Classification::Planimetric_grid Grid; - std::vector vertical_dispersion; + +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES + std::vector vertical_dispersion; +#else + const Grid& grid; + Image_float Dispersion; +#endif public: /*! @@ -69,14 +75,22 @@ public: Vertical_dispersion (const PointRange& input, PointMap point_map, const Grid& grid, - const double grid_resolution, - double radius_neighbors = -1.) + const float grid_resolution, + float radius_neighbors = -1.) +#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES + : grid (grid) +#endif { this->set_name ("vertical_dispersion"); if (radius_neighbors < 0.) radius_neighbors = 5. * grid_resolution; - + +#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES Image_float Dispersion(grid.width(), grid.height()); +#else + Dispersion = Image_float(grid.width(), grid.height()); +#endif + for (std::size_t j = 0; j < grid.height(); j++) for (std::size_t i = 0; i < grid.width(); i++) Dispersion(i,j)=0; @@ -89,7 +103,7 @@ public: if(!(grid.mask(i,j))) continue; - std::vector hori; + std::vector hori; std::size_t squareXmin = (i < square ? 0 : i - square); std::size_t squareXmax = (std::min) (grid.width()-1, i + square); @@ -98,8 +112,8 @@ public: for(std::size_t k = squareXmin; k <= squareXmax; k++) for(std::size_t l = squareYmin; l <= squareYmax; l++) - if(CGAL::sqrt(pow((double)k-i,2)+pow((double)l-j,2)) - <=(double)0.5*radius_neighbors/grid_resolution + if(CGAL::sqrt(pow((float)k-i,2)+pow((float)l-j,2)) + <=(float)0.5*radius_neighbors/grid_resolution && (grid.indices(k,l).size()>0)) for(std::size_t t=0; t > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Verticality : public Feature_base { typedef Classification::Local_eigen_analysis Local_eigen_analysis; const typename Geom_traits::Vector_3 vertical; - std::vector verticality_feature; -#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES - const Local_eigen_analysis& eigen; -#endif + std::vector verticality_feature; + const Local_eigen_analysis* eigen; public: /*! @@ -71,7 +69,7 @@ public: #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES Verticality (const PointRange& input, const Local_eigen_analysis& eigen) - : vertical (0., 0., 1.) + : vertical (0., 0., 1.), eigen(NULL) { this->set_name ("verticality"); @@ -85,7 +83,7 @@ public: #else Verticality (const PointRange&, const Local_eigen_analysis& eigen) - : vertical (0., 0., 1.), eigen (eigen) + : vertical (0., 0., 1.), eigen (&eigen) { this->set_name ("verticality"); } @@ -103,7 +101,7 @@ public: template Verticality (const PointRange& input, VectorMap normal_map) - : vertical (0., 0., 1.) + : vertical (0., 0., 1.), eigen(NULL) { this->set_name ("verticality"); for (std::size_t i = 0; i < input.size(); i++) @@ -116,12 +114,12 @@ public: /// \cond SKIP_IN_MANUAL - virtual double value (std::size_t pt_index) + virtual float value (std::size_t pt_index) { #ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES - if (verticality_feature.empty()) + if (eigen != NULL) { - typename Geom_traits::Vector_3 normal = eigen.normal_vector(pt_index); + typename Geom_traits::Vector_3 normal = eigen->normal_vector(pt_index); normal = normal / CGAL::sqrt (normal * normal); return (1. - CGAL::abs(normal * vertical)); } diff --git a/Classification/include/CGAL/Classification/Feature_base.h b/Classification/include/CGAL/Classification/Feature_base.h index 65c402e4802..194f68b840c 100644 --- a/Classification/include/CGAL/Classification/Feature_base.h +++ b/Classification/include/CGAL/Classification/Feature_base.h @@ -70,7 +70,7 @@ public: position `index`. This method must be implemented by inherited classes. */ - virtual double value (std::size_t index) = 0; + virtual float value (std::size_t index) = 0; }; diff --git a/Classification/include/CGAL/Classification/Local_eigen_analysis.h b/Classification/include/CGAL/Classification/Local_eigen_analysis.h index c0156ae6103..c7c6c2537ae 100644 --- a/Classification/include/CGAL/Classification/Local_eigen_analysis.h +++ b/Classification/include/CGAL/Classification/Local_eigen_analysis.h @@ -56,17 +56,15 @@ namespace Classification { for matrix diagonalization. */ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Local_eigen_analysis { public: typedef typename Geom_traits::Point_3 Point; typedef typename Geom_traits::Vector_3 Vector; typedef typename Geom_traits::Plane_3 Plane; + typedef CGAL::cpp11::array Eigenvalues; ///< Eigenvalues (sorted in ascending order) - typedef CGAL::cpp11::array Eigenvalues; ///< Eigenvalues (sorted in ascending order) - - private: #ifdef CGAL_LINKED_WITH_TBB @@ -77,7 +75,7 @@ private: const PointRange& m_input; PointMap m_point_map; const NeighborQuery& m_neighbor_query; - double& m_mean_range; + float& m_mean_range; tbb::mutex& m_mutex; public: @@ -86,7 +84,7 @@ private: const PointRange& input, PointMap point_map, const NeighborQuery& neighbor_query, - double& mean_range, + float& mean_range, tbb::mutex& mutex) : m_eigen (eigen), m_input (input), m_point_map (point_map), m_neighbor_query (neighbor_query), m_mean_range (mean_range), m_mutex (mutex) @@ -114,16 +112,17 @@ private: }; #endif - - std::vector m_eigenvalues; - std::vector m_sum_eigenvalues; - std::vector m_centroids; - std::vector m_smallest_eigenvectors; + + typedef CGAL::cpp11::array float3; + std::vector m_eigenvalues; + std::vector m_sum_eigenvalues; + std::vector m_centroids; + std::vector m_smallest_eigenvectors; #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE - std::vector m_middle_eigenvectors; - std::vector m_largest_eigenvectors; + std::vector m_middle_eigenvectors; + std::vector m_largest_eigenvectors; #endif - double m_mean_range; + float m_mean_range; public: @@ -202,12 +201,25 @@ public: /*! \brief Returns the estimated unoriented normal vector of the point at position `index`. */ - const Vector& normal_vector (std::size_t index) const { return m_smallest_eigenvectors[index]; } + Vector normal_vector (std::size_t index) const + { + return Vector(double(m_smallest_eigenvectors[index][0]), + double(m_smallest_eigenvectors[index][1]), + double(m_smallest_eigenvectors[index][2])); + } /*! \brief Returns the estimated local tangent plane of the point at position `index`. */ - Plane plane (std::size_t index) const { return Plane (m_centroids[index], m_smallest_eigenvectors[index]); } + Plane plane (std::size_t index) const + { + return Plane (Point (double(m_centroids[index][0]), + double(m_centroids[index][1]), + double(m_centroids[index][2])), + Vector(double(m_smallest_eigenvectors[index][0]), + double(m_smallest_eigenvectors[index][1]), + double(m_smallest_eigenvectors[index][2]))); + } /*! \brief Returns the normalized eigenvalues of the point at position `index`. @@ -217,10 +229,10 @@ public: /*! \brief Returns the sum of eigenvalues of the point at position `index`. */ - const double& sum_of_eigenvalues (std::size_t index) const { return m_sum_eigenvalues[index]; } + const float& sum_of_eigenvalues (std::size_t index) const { return m_sum_eigenvalues[index]; } /// \cond SKIP_IN_MANUAL - double mean_range() const { return m_mean_range; } + float mean_range() const { return m_mean_range; } /// \endcond private: @@ -229,21 +241,21 @@ private: { if (neighbor_points.size() == 0) { - Eigenvalues v = {{ 0., 0., 0. }}; + Eigenvalues v = {{ 0.f, 0.f, 0.f }}; m_eigenvalues[index] = v; - m_centroids[index] = query; - m_smallest_eigenvectors[index] = Vector (0., 0., 1.); + m_centroids[index] = {{ float(query.x()), float(query.y()), float(query.z()) }}; + m_smallest_eigenvectors[index] = {{ 0.f, 0.f, 1.f }}; #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE - m_middle_eigenvectors[index] = Vector (0., 1., 0.); - m_largest_eigenvectors[index] = Vector (1., 0., 0.); + m_middle_eigenvectors[index] = {{ 0.f, 1.f, 0.f }}; + m_largest_eigenvectors[index] = {{ 1.f, 0.f, 0.f }}; #endif return; } Point centroid = CGAL::centroid (neighbor_points.begin(), neighbor_points.end()); - m_centroids[index] = centroid; + m_centroids[index] = {{ float(centroid.x()), float(centroid.y()), float(centroid.z()) }}; - CGAL::cpp11::array covariance = {{ 0., 0., 0., 0., 0., 0. }}; + CGAL::cpp11::array covariance = {{ 0.f, 0.f, 0.f, 0.f, 0.f, 0.f }}; for (std::size_t i = 0; i < neighbor_points.size(); ++ i) { @@ -256,25 +268,25 @@ private: covariance[5] += d.z () * d.z (); } - Eigenvalues evalues = {{ 0., 0., 0. }}; - CGAL::cpp11::array evectors = {{ 0., 0., 0., - 0., 0., 0., - 0., 0., 0. }}; + CGAL::cpp11::array evalues = {{ 0.f, 0.f, 0.f }}; + CGAL::cpp11::array evectors = {{ 0.f, 0.f, 0.f, + 0.f, 0.f, 0.f, + 0.f, 0.f, 0.f }}; DiagonalizeTraits::diagonalize_selfadjoint_covariance_matrix (covariance, evalues, evectors); // Normalize - double sum = evalues[0] + evalues[1] + evalues[2]; - if (sum > 0.) + float sum = evalues[0] + evalues[1] + evalues[2]; + if (sum > 0.f) for (std::size_t i = 0; i < 3; ++ i) evalues[i] = evalues[i] / sum; - m_sum_eigenvalues[index] = sum; - m_eigenvalues[index] = evalues; - m_smallest_eigenvectors[index] = Vector (evectors[0], evectors[1], evectors[2]); + m_sum_eigenvalues[index] = float(sum); + m_eigenvalues[index] = {{ float(evalues[0]), float(evalues[1]), float(evalues[2]) }}; + m_smallest_eigenvectors[index] = {{ float(evectors[0]), float(evectors[1]), float(evectors[2]) }}; #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE - m_middle_eigenvectors[index] = Vector (evectors[3], evectors[4], evectors[5]); - m_largest_eigenvectors[index] = Vector (evectors[6], evectors[7], evectors[8]); + m_middle_eigenvectors[index] = {{ float(evectors[3]), float(evectors[4]), float(evectors[5]) }}; + m_largest_eigenvectors[index] = {{ float(evectors[6]), float(evectors[7]), float(evectors[8]) }}; #endif } diff --git a/Classification/include/CGAL/Classification/Planimetric_grid.h b/Classification/include/CGAL/Classification/Planimetric_grid.h index 30b2020b11e..d4a2d356e07 100644 --- a/Classification/include/CGAL/Classification/Planimetric_grid.h +++ b/Classification/include/CGAL/Classification/Planimetric_grid.h @@ -79,7 +79,7 @@ public: Planimetric_grid (const PointRange& input, PointMap point_map, const Iso_cuboid_3& bbox, - const double grid_resolution) + const float grid_resolution) { std::size_t width = (std::size_t)((bbox.xmax() - bbox.xmin()) / grid_resolution) + 1; std::size_t height = (std::size_t)((bbox.ymax() - bbox.ymin()) / grid_resolution) + 1; @@ -92,7 +92,7 @@ public: m_y.push_back ((std::size_t)((p.y() - bbox.ymin()) / grid_resolution)); m_grid(m_x.back(), m_y.back()).push_back (i); } - + std::cerr << "Grid size = " << width * height << std::endl; } /*! diff --git a/Classification/include/CGAL/Classification/Point_set_feature_generator.h b/Classification/include/CGAL/Classification/Point_set_feature_generator.h index 3c016722747..d8a329e1c84 100644 --- a/Classification/include/CGAL/Classification/Point_set_feature_generator.h +++ b/Classification/include/CGAL/Classification/Point_set_feature_generator.h @@ -89,7 +89,7 @@ template > + typename DiagonalizeTraits = CGAL::Default_diagonalize_traits > class Point_set_feature_generator { @@ -147,10 +147,10 @@ private: Neighborhood* neighborhood; Planimetric_grid* grid; Local_eigen_analysis* eigen; - double voxel_size; + float voxel_size; Scale (const PointRange& input, PointMap point_map, - const Iso_cuboid_3& bbox, double voxel_size) + const Iso_cuboid_3& bbox, float voxel_size) : voxel_size (voxel_size) { CGAL::Real_timer t; @@ -170,7 +170,7 @@ private: t.start(); eigen = new Local_eigen_analysis (input, point_map, neighborhood->k_neighbor_query(6)); - double range = eigen->mean_range(); + float range = eigen->mean_range(); if (this->voxel_size < 0) this->voxel_size = range; t.stop(); @@ -186,14 +186,27 @@ private: } ~Scale() { - delete neighborhood; - delete grid; + if (neighborhood != NULL) + delete neighborhood; + if (grid != NULL) + delete grid; delete eigen; } - double grid_resolution() const { return voxel_size; } - double radius_neighbors() const { return voxel_size * 5; } - double radius_dtm() const { return voxel_size * 100; } + void reduce_memory_footprint(bool delete_neighborhood) + { + delete grid; + grid = NULL; + if (delete_neighborhood) + { + delete neighborhood; + neighborhood = NULL; + } + } + + float grid_resolution() const { return voxel_size; } + float radius_neighbors() const { return voxel_size * 5; } + float radius_dtm() const { return voxel_size * 100; } }; @@ -335,6 +348,14 @@ public: { clear(); } + + void reduce_memory_footprint() + { + for (std::size_t i = 0; i < m_scales.size(); ++ i) + { + m_scales[i]->reduce_memory_footprint(i > 0); + } + } /// \endcond /// \name Data Structures and Parameters @@ -378,7 +399,7 @@ public: \note `generate_features()` must have been called before calling this method. */ - double grid_resolution(std::size_t scale = 0) const { return m_scales[scale]->grid_resolution(); } + float grid_resolution(std::size_t scale = 0) const { return m_scales[scale]->grid_resolution(); } /*! \brief Returns the radius used for neighborhood queries at scale @@ -389,7 +410,7 @@ public: \note `generate_features()` must have been called before calling this method. */ - double radius_neighbors(std::size_t scale = 0) const { return m_scales[scale]->radius_neighbors(); } + float radius_neighbors(std::size_t scale = 0) const { return m_scales[scale]->radius_neighbors(); } /*! \brief Returns the radius used for digital terrain modeling at scale `scale`. This radius represents the minimum size of a @@ -398,7 +419,7 @@ public: \note `generate_features()` must have been called before calling this method. */ - double radius_dtm(std::size_t scale = 0) const { return m_scales[scale]->radius_dtm(); } + float radius_dtm(std::size_t scale = 0) const { return m_scales[scale]->radius_dtm(); } @@ -488,12 +509,12 @@ private: using Feature_adder::scale; ColorMap color_map; std::size_t channel; - double mean; - double sd; + float mean; + float sd; // TODO! Feature_adder_color (Point_set_feature_generator* generator, ColorMap color_map, std::size_t scale, - std::size_t channel, double mean, double sd) + std::size_t channel, float mean, float sd) : Feature_adder (generator, scale), color_map (color_map), channel (channel), mean (mean), sd (sd) { } @@ -588,11 +609,11 @@ private: CGAL::Real_timer t; t.start(); m_scales.reserve (nb_scales); - double voxel_size = - 1.; - + // float voxel_size = 0.05; // WARNING: do not keep (-1 is the right value) + float voxel_size = -1; + m_scales.push_back (new Scale (m_input, m_point_map, m_bbox, voxel_size)); voxel_size = m_scales[0]->grid_resolution(); - for (std::size_t i = 1; i < nb_scales; ++ i) { voxel_size *= 2; diff --git a/Classification/include/CGAL/Classification/Point_set_neighborhood.h b/Classification/include/CGAL/Classification/Point_set_neighborhood.h index 4cf8e96c910..74689b25eda 100644 --- a/Classification/include/CGAL/Classification/Point_set_neighborhood.h +++ b/Classification/include/CGAL/Classification/Point_set_neighborhood.h @@ -142,14 +142,14 @@ public: typedef Point_set_neighborhood::Point value_type; ///< private: const Point_set_neighborhood& neighborhood; - double radius; + float radius; public: /*! \brief Constructs a range neighbor query object. \param neighborhood point set neighborhood object. \param radius radius of the neighbor query sphere. */ - Range_neighbor_query (const Point_set_neighborhood& neighborhood, double radius) + Range_neighbor_query (const Point_set_neighborhood& neighborhood, float radius) : neighborhood (neighborhood), radius(radius) { } /// \cond SKIP_IN_MANUAL @@ -202,7 +202,7 @@ public: */ Point_set_neighborhood (const PointRange& input, PointMap point_map, - double voxel_size) + float voxel_size) : m_tree (NULL) { // First, simplify @@ -239,7 +239,7 @@ public: /*! \brief Returns a neighbor query object with fixed radius `radius`. */ - Range_neighbor_query range_neighbor_query (const double radius) const + Range_neighbor_query range_neighbor_query (const float radius) const { return Range_neighbor_query (*this, radius); } @@ -265,7 +265,7 @@ private: template void voxelize_point_set (std::vector& indices, Map point_map, - double voxel_size) + float voxel_size) { std::map > grid; @@ -292,10 +292,10 @@ private: (pts.end(), CGAL::Property_map_to_unary_function(point_map))); std::size_t chosen = 0; - double min_dist = (std::numeric_limits::max)(); + float min_dist = (std::numeric_limits::max)(); for (std::size_t i = 0; i < pts.size(); ++ i) { - double dist = CGAL::squared_distance(get(point_map, pts[i]), centroid); + float dist = CGAL::squared_distance(get(point_map, pts[i]), centroid); if (dist < min_dist) { min_dist = dist; diff --git a/Classification/include/CGAL/Classification/Sum_of_weighted_features_predicate.h b/Classification/include/CGAL/Classification/Sum_of_weighted_features_predicate.h index 2d2b700d703..1fedb809f27 100644 --- a/Classification/include/CGAL/Classification/Sum_of_weighted_features_predicate.h +++ b/Classification/include/CGAL/Classification/Sum_of_weighted_features_predicate.h @@ -75,7 +75,7 @@ private: std::vector& m_training_set; const Sum_of_weighted_features_predicate& m_predicate; std::size_t m_label; - double& m_confidence; + float& m_confidence; std::size_t& m_nb_okay; tbb::mutex& m_mutex; @@ -84,7 +84,7 @@ private: Compute_worst_score_and_confidence (std::vector& training_set, const Sum_of_weighted_features_predicate& predicate, std::size_t label, - double& confidence, + float& confidence, std::size_t& nb_okay, tbb::mutex& mutex) : m_training_set (training_set) @@ -99,9 +99,9 @@ private: { for (std::size_t k = r.begin(); k != r.end(); ++ k) { - std::vector > values; + std::vector > values; - std::vector v; + std::vector v; m_predicate.probabilities (m_training_set[k], v); for(std::size_t l = 0; l < v.size(); ++ l) @@ -125,7 +125,7 @@ private: Label_set& m_labels; Feature_set& m_features; - std::vector m_weights; + std::vector m_weights; std::vector > m_effect_table; mutable std::map m_map_labels; mutable std::map m_map_features; @@ -148,12 +148,12 @@ public: /*! \brief Sets the weight of the feature (`weight` must be positive). */ - void set_weight (Feature_handle feature, double weight) + void set_weight (Feature_handle feature, float weight) { m_weights[m_map_features[feature]] = weight; } /// \cond SKIP_IN_MANUAL - void set_weight (std::size_t feature, double weight) + void set_weight (std::size_t feature, float weight) { m_weights[feature] = weight; } @@ -162,12 +162,12 @@ public: /*! \brief Returns the weight of the feature. */ - double weight (Feature_handle feature) const + float weight (Feature_handle feature) const { return m_weights[m_map_features[feature]]; } /// \cond SKIP_IN_MANUAL - double weight (std::size_t feature) const + float weight (std::size_t feature) const { return m_weights[feature]; } @@ -204,7 +204,7 @@ public: /// \endcond void probabilities (std::size_t item_index, - std::vector& out) const + std::vector& out) const { out.resize (m_labels.size()); for (std::size_t l = 0; l < m_labels.size(); ++ l) @@ -317,7 +317,7 @@ public: typename std::map::iterator found = map_n2f.find (name); if (found != map_n2f.end()) - m_weights[found->second] = v.second.get("weight"); + m_weights[found->second] = v.second.get("weight"); else { if (verbose) @@ -394,26 +394,32 @@ public: configuration found. */ template - double train (const std::vector& ground_truth, + float train (const std::vector& ground_truth, std::size_t nb_tests = 300) { std::vector > training_sets (m_labels.size()); + std::size_t nb_tot = 0; for (std::size_t i = 0; i < ground_truth.size(); ++ i) if (ground_truth[i] != std::size_t(-1)) - training_sets[ground_truth[i]].push_back (i); + { + training_sets[ground_truth[i]].push_back (i); + ++ nb_tot; + } + CGAL_CLASSIFICATION_CERR << "Training using " << nb_tot << " inliers" << std::endl; + for (std::size_t i = 0; i < m_labels.size(); ++ i) if (training_sets.size() <= i || training_sets[i].empty()) std::cerr << "WARNING: \"" << m_labels[i]->name() << "\" doesn't have a training set." << std::endl; - std::vector best_weights (m_features.size(), 1.); + std::vector best_weights (m_features.size(), 1.); struct Feature_training { std::size_t i; - double wmin; - double wmax; - double factor; + float wmin; + float wmax; + float factor; bool operator<(const Feature_training& other) const { @@ -422,8 +428,8 @@ public: }; std::vector feature_train; std::size_t nb_trials = 100; - double wmin = 1e-5, wmax = 1e5; - double factor = std::pow (wmax/wmin, 1. / (double)nb_trials); + float wmin = 1e-5, wmax = 1e5; + float factor = std::pow (wmax/wmin, 1. / (float)nb_trials); for (std::size_t j = 0; j < m_features.size(); ++ j) { @@ -431,8 +437,8 @@ public: best_weights[j] = weight(j); std::size_t nb_useful = 0; - double min = (std::numeric_limits::max)(); - double max = -(std::numeric_limits::max)(); + float min = (std::numeric_limits::max)(); + float max = -(std::numeric_limits::max)(); set_weight(j, wmin); for (std::size_t i = 0; i < 100; ++ i) @@ -475,17 +481,17 @@ public: estimate_feature_effect(j, training_sets); } - std::size_t nb_trials_per_feature = 1 + (std::size_t)(nb_tests / (double)(feature_train.size())); + std::size_t nb_trials_per_feature = 1 + (std::size_t)(nb_tests / (float)(feature_train.size())); CGAL_CLASSIFICATION_CERR << "Trials = " << nb_tests << ", features = " << feature_train.size() << ", trials per feature = " << nb_trials_per_feature << std::endl; for (std::size_t i = 0; i < feature_train.size(); ++ i) feature_train[i].factor = std::pow (feature_train[i].wmax / feature_train[i].wmin, - 1. / (double)nb_trials_per_feature); + 1. / (float)nb_trials_per_feature); - double best_score = 0.; - double best_confidence = 0.; + float best_score = 0.; + float best_confidence = 0.; boost::tie (best_confidence, best_score) = compute_worst_confidence_and_score (0., 0., training_sets); @@ -519,7 +525,7 @@ public: { estimate_feature_effect(current_feature_changed, training_sets); - double worst_confidence = 0., worst_score = 0.; + float worst_confidence = 0., worst_score = 0.; boost::tie (worst_confidence, worst_score) = compute_worst_confidence_and_score (best_confidence, best_score, training_sets); @@ -585,7 +591,7 @@ public: private: - double value (std::size_t label, std::size_t feature, std::size_t index) const + float value (std::size_t label, std::size_t feature, std::size_t index) const { if (m_effect_table[label][feature] == FAVORING) return favored (feature, index); @@ -595,19 +601,19 @@ private: return ignored (feature, index); } - double normalized (std::size_t feature, std::size_t index) const + float normalized (std::size_t feature, std::size_t index) const { - return (std::max) (0., (std::min) (1., m_features[feature]->value(index) / m_weights[feature])); + return (std::max) (0.f, (std::min) (1.f, m_features[feature]->value(index) / m_weights[feature])); } - double favored (std::size_t feature, std::size_t index) const + float favored (std::size_t feature, std::size_t index) const { return (1. - normalized (feature, index)); } - double penalized (std::size_t feature, std::size_t index) const + float penalized (std::size_t feature, std::size_t index) const { return normalized (feature, index); } - double ignored (std::size_t, std::size_t) const + float ignored (std::size_t, std::size_t) const { return 0.5; } @@ -621,19 +627,19 @@ private: void estimate_feature_effect (std::size_t feature, std::vector >& training_sets) { - std::vector mean (m_labels.size(), 0.); + std::vector mean (m_labels.size(), 0.); for (std::size_t j = 0; j < m_labels.size(); ++ j) { for (std::size_t k = 0; k < training_sets[j].size(); ++ k) { - double val = normalized(feature, training_sets[j][k]); + float val = normalized(feature, training_sets[j][k]); mean[j] += val; } mean[j] /= training_sets[j].size(); } - std::vector sd (m_labels.size(), 0.); + std::vector sd (m_labels.size(), 0.); for (std::size_t j = 0; j < m_labels.size(); ++ j) { @@ -641,7 +647,7 @@ private: for (std::size_t k = 0; k < training_sets[j].size(); ++ k) { - double val = normalized(feature, training_sets[j][k]); + float val = normalized(feature, training_sets[j][k]); sd[j] += (val - mean[j]) * (val - mean[j]); } sd[j] = std::sqrt (sd[j] / training_sets[j].size()); @@ -655,15 +661,15 @@ private: } template - std::pair compute_worst_confidence_and_score (double lower_conf, double lower_score, + std::pair compute_worst_confidence_and_score (float lower_conf, float lower_score, std::vector >& training_sets) { - double worst_confidence = (std::numeric_limits::max)(); - double worst_score = (std::numeric_limits::max)(); + float worst_confidence = (std::numeric_limits::max)(); + float worst_score = (std::numeric_limits::max)(); for (std::size_t j = 0; j < m_labels.size(); ++ j) { - double confidence = 0.; + float confidence = 0.; std::size_t nb_okay = 0; #ifndef CGAL_LINKED_WITH_TBB @@ -681,9 +687,9 @@ private: { for (std::size_t k = 0; k < training_sets[j].size(); ++ k) { - std::vector > values; + std::vector > values; - std::vector v; + std::vector v; probabilities (training_sets[j][k], v); for(std::size_t l = 0; l < m_labels.size(); ++ l) @@ -699,8 +705,8 @@ private: } } - double score = nb_okay / (double)(training_sets[j].size()); - confidence /= (double)(training_sets[j].size() * m_features.size()); + float score = nb_okay / (float)(training_sets[j].size()); + confidence /= (float)(training_sets[j].size() * m_features.size()); if (confidence < worst_confidence) worst_confidence = confidence; diff --git a/Classification/include/CGAL/Classification/classify.h b/Classification/include/CGAL/Classification/classify.h index 05f8f796762..acf82c8f3b1 100644 --- a/Classification/include/CGAL/Classification/classify.h +++ b/Classification/include/CGAL/Classification/classify.h @@ -64,10 +64,10 @@ namespace internal { inline void apply (std::size_t s) const { std::size_t nb_class_best=0; - std::vector values; + std::vector values; m_predicate.probabilities (s, values); - double val_class_best = (std::numeric_limits::max)(); + float val_class_best = (std::numeric_limits::max)(); for(std::size_t k = 0; k < m_labels.size(); ++ k) { if(val_class_best > values[k]) @@ -87,14 +87,14 @@ namespace internal { { const Label_set& m_labels; const ClassificationPredicate& m_predicate; - std::vector >& m_values; + std::vector >& m_values; public: Classifier_local_smoothing_preprocessing (const Label_set& labels, const ClassificationPredicate& predicate, - std::vector >& values) + std::vector >& values) : m_labels (labels), m_predicate (predicate), m_values (values) { } @@ -108,7 +108,7 @@ namespace internal { inline void apply (std::size_t s) const { - std::vector values; + std::vector values; m_predicate.probabilities(s, values); for(std::size_t k = 0; k < m_labels.size(); ++ k) m_values[k][s] = values[k]; @@ -121,7 +121,7 @@ namespace internal { const ItemRange& m_input; const ItemMap m_item_map; const Label_set& m_labels; - const std::vector >& m_values; + const std::vector >& m_values; const NeighborQuery& m_neighbor_query; std::vector& m_out; @@ -130,7 +130,7 @@ namespace internal { Classifier_local_smoothing (const ItemRange& input, ItemMap item_map, const Label_set& labels, - const std::vector >& values, + const std::vector >& values, const NeighborQuery& neighbor_query, std::vector& out) : m_input (input), m_item_map (item_map), m_labels (labels), @@ -152,13 +152,13 @@ namespace internal { std::vector neighbors; m_neighbor_query (get (m_item_map, *(m_input.begin()+s)), std::back_inserter (neighbors)); - std::vector mean (m_values.size(), 0.); + std::vector mean (m_values.size(), 0.); for (std::size_t n = 0; n < neighbors.size(); ++ n) for (std::size_t j = 0; j < m_values.size(); ++ j) mean[j] += m_values[j][neighbors[n]]; std::size_t nb_class_best=0; - double val_class_best = (std::numeric_limits::max)(); + float val_class_best = (std::numeric_limits::max)(); for(std::size_t k = 0; k < mean.size(); ++ k) { mean[k] /= neighbors.size(); @@ -184,7 +184,7 @@ namespace internal { const Label_set& m_labels; const ClassificationPredicate& m_predicate; const NeighborQuery& m_neighbor_query; - double m_weight; + float m_weight; const std::vector >& m_indices; const std::vector >& m_input_to_indices; std::vector& m_out; @@ -202,7 +202,7 @@ namespace internal { const Label_set& labels, const ClassificationPredicate& predicate, const NeighborQuery& neighbor_query, - double weight, + float weight, const std::vector >& indices, const std::vector >& input_to_indices, std::vector& out) @@ -247,13 +247,13 @@ namespace internal { edge_weights.push_back (m_weight); } - std::vector values; + std::vector values; m_predicate.probabilities(s, values); std::size_t nb_class_best = 0; - double val_class_best = (std::numeric_limits::max)(); + float val_class_best = (std::numeric_limits::max)(); for(std::size_t k = 0; k < m_labels.size(); ++ k) { - double value = values[k]; + float value = values[k]; probability_matrix[k][j] = value; if(val_class_best > value) @@ -321,8 +321,8 @@ namespace internal { { output.resize(input.size()); - std::vector > values - (labels.size(), std::vector (input.size(), -1.)); + std::vector > values + (labels.size(), std::vector (input.size(), -1.)); internal::Classifier_local_smoothing_preprocessing f1 (labels, predicate, values); internal::Classifier_local_smoothing @@ -359,7 +359,7 @@ namespace internal { const Label_set& labels, const ClassificationPredicate& predicate, const NeighborQuery& neighbor_query, - const double weight, + const float weight, const std::size_t min_number_of_subdivisions, std::vector& output) { @@ -367,11 +367,11 @@ namespace internal { (boost::make_transform_iterator (input.begin(), CGAL::Property_map_to_unary_function(bbox_map)), boost::make_transform_iterator (input.end(), CGAL::Property_map_to_unary_function(bbox_map))); - double Dx = bbox.xmax() - bbox.xmin(); - double Dy = bbox.ymax() - bbox.ymin(); - double A = Dx * Dy; - double a = A / min_number_of_subdivisions; - double l = std::sqrt(a); + float Dx = bbox.xmax() - bbox.xmin(); + float Dy = bbox.ymax() - bbox.ymin(); + float A = Dx * Dy; + float a = A / min_number_of_subdivisions; + float l = std::sqrt(a); std::size_t nb_x = std::size_t(Dx / l) + 1; std::size_t nb_y = std::size_t((A / nb_x) / a) + 1; std::size_t nb = nb_x * nb_y; @@ -382,11 +382,11 @@ namespace internal { for (std::size_t y = 0; y < nb_y; ++ y) { bboxes.push_back - (CGAL::Bbox_3 (bbox.xmin() + Dx * (x / double(nb_x)), - bbox.ymin() + Dy * (y / double(nb_y)), + (CGAL::Bbox_3 (bbox.xmin() + Dx * (x / float(nb_x)), + bbox.ymin() + Dy * (y / float(nb_y)), bbox.zmin(), - bbox.xmin() + Dx * ((x+1) / double(nb_x)), - bbox.ymin() + Dy * ((y+1) / double(nb_y)), + bbox.xmin() + Dx * ((x+1) / float(nb_x)), + bbox.ymin() + Dy * ((y+1) / float(nb_y)), bbox.zmax())); }