songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use floats everywhere (need for very little memory size)

This commit is contained in:
Simon Giraudot 2017-03-17 13:55:28 +01:00
parent 026a01b140
commit 17343421f5
15 changed files with 297 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Classification/include/CGAL/Classification/Evaluation.h
View File

@ -31,12 +31,12 @@ class Evaluation
{ {
mutable std::map<Label_handle, std::size_t> m_map_labels; mutable std::map<Label_handle, std::size_t> m_map_labels;
std::vector<double> m_precision; std::vector<float> m_precision;
std::vector<double> m_recall; std::vector<float> m_recall;
std::vector<double> m_iou; // intersection over union std::vector<float> m_iou; // intersection over union
double m_accuracy; float m_accuracy;
double m_mean_iou; float m_mean_iou;
double m_mean_f1; float m_mean_f1;
public: public:
@ -79,9 +79,9 @@ public:
for (std::size_t j = 0; j < labels.size(); ++ j) for (std::size_t j = 0; j < labels.size(); ++ j)
{ {
m_precision[j] = true_positives[j] / double(true_positives[j] + false_positives[j]); m_precision[j] = true_positives[j] / float(true_positives[j] + false_positives[j]);
m_recall[j] = true_positives[j] / double(true_positives[j] + false_negatives[j]); m_recall[j] = true_positives[j] / float(true_positives[j] + false_negatives[j]);
m_iou[j] = true_positives[j] / double(true_positives[j] + false_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_iou += m_iou[j];
m_mean_f1 += 2. * (m_precision[j] * m_recall[j]) m_mean_f1 += 2. * (m_precision[j] * m_recall[j])
@ -90,7 +90,7 @@ public:
m_mean_iou /= labels.size(); m_mean_iou /= labels.size();
m_mean_f1 /= 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. 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]]; return m_precision[m_map_labels[label]];
} }
@ -115,7 +115,7 @@ public:
the true positives and the false negatives. 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]]; return m_recall[m_map_labels[label]];
} }
@ -131,7 +131,7 @@ public:
\f] \f]
*/ */
double f1_score (Label_handle label) const float f1_score (Label_handle label) const
{ {
std::size_t label_idx = m_map_labels[label]; std::size_t label_idx = m_map_labels[label];
return 2. * (m_precision[label_idx] * m_recall[label_idx]) 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 the sum of the true positives, of the false positives and of the
false negatives. 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]]; return m_iou[m_map_labels[label]];
} }
@ -157,19 +157,19 @@ public:
Accuracy is the total number of true positives divided by the Accuracy is the total number of true positives divided by the
total number of provided inliers. 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 \brief Returns the mean \f$F_1\f$ score of the training over all
labels (see `f1_score()`). 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 \brief Returns the mean intersection over union of the training
over all labels (see `intersection_over_union()`). 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; }
}; };

6
Classification/include/CGAL/Classification/Feature/Distance_to_plane.h
View File

@ -48,13 +48,13 @@ namespace Feature {
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Distance_to_plane : public Feature_base class Distance_to_plane : public Feature_base
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis; PointMap, DiagonalizeTraits> Local_eigen_analysis;
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
std::vector<double> distance_to_plane_feature; std::vector<float> distance_to_plane_feature;
#else #else
const PointRange& input; const PointRange& input;
PointMap point_map; PointMap point_map;
@ -85,7 +85,7 @@ public:
} }
/// \cond SKIP_IN_MANUAL /// \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 #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
return distance_to_plane_feature[pt_index]; return distance_to_plane_feature[pt_index];

12
Classification/include/CGAL/Classification/Feature/Echo_scatter.h
View File

@ -55,7 +55,7 @@ public:
private: private:
typedef Classification::Image<float> Image_float; typedef Classification::Image<float> Image_float;
std::vector<double> echo_scatter; std::vector<float> echo_scatter;
public: public:
/*! /*!
@ -70,8 +70,8 @@ public:
Echo_scatter (const PointRange& input, Echo_scatter (const PointRange& input,
EchoMap echo_map, EchoMap echo_map,
const Grid& grid, const Grid& grid,
const double grid_resolution, const float grid_resolution,
double radius_neighbors = 1.) float radius_neighbors = 1.)
{ {
this->set_name ("echo_scatter"); this->set_name ("echo_scatter");
Image_float Scatter(grid.width(), grid.height()); 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 k = squareXmin; k <= squareXmax; k++){
for(std::size_t l = squareYmin; l <= squareYmax; l++){ 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){ if(grid.indices(k,l).size()>0){
@ -128,12 +128,12 @@ public:
for(std::size_t i = 0; i < input.size(); i++){ for(std::size_t i = 0; i < input.size(); i++){
std::size_t I= grid.x(i); std::size_t I= grid.x(i);
std::size_t J= grid.y(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 /// \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]; return echo_scatter[pt_index];
} }

40
Classification/include/CGAL/Classification/Feature/Eigen.h
View File

@ -31,7 +31,7 @@ namespace Classification {
namespace Feature { namespace Feature {
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Eigen_feature : public Feature_base class Eigen_feature : public Feature_base
{ {
protected: protected:
@ -39,7 +39,7 @@ protected:
PointMap, DiagonalizeTraits> Local_eigen_analysis; PointMap, DiagonalizeTraits> Local_eigen_analysis;
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
std::vector<double> attrib; std::vector<float> attrib;
#else #else
const Local_eigen_analysis& eigen; const Local_eigen_analysis& eigen;
#endif #endif
@ -67,8 +67,8 @@ public:
} }
#endif #endif
virtual double get_value (const Local_eigen_analysis& eigen, std::size_t i) = 0; virtual float get_value (const Local_eigen_analysis& eigen, std::size_t i) = 0;
virtual double value (std::size_t pt_index) virtual float value (std::size_t pt_index)
{ {
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
return attrib[pt_index]; return attrib[pt_index];
@ -99,7 +99,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Linearity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Linearity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -120,7 +120,7 @@ public:
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[2] < 1e-15) if (ev[2] < 1e-15)
@ -151,7 +151,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Planarity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Planarity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -172,7 +172,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[2] < 1e-15) if (ev[2] < 1e-15)
@ -204,7 +204,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Sphericity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Sphericity : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -225,7 +225,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[2] < 1e-15) if (ev[2] < 1e-15)
@ -256,7 +256,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Omnivariance : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Omnivariance : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -277,7 +277,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
return (std::pow (std::fabs(ev[0] * ev[1] * ev[2]), 0.333333333)); return (std::pow (std::fabs(ev[0] * ev[1] * ev[2]), 0.333333333));
@ -305,7 +305,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Anisotropy : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Anisotropy : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -326,7 +326,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[2] < 1e-15) if (ev[2] < 1e-15)
@ -357,7 +357,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Eigentropy : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Eigentropy : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -378,7 +378,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[0] < 1e-15 if (ev[0] < 1e-15
@ -414,7 +414,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Sum_eigenvalues : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Sum_eigenvalues : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -435,7 +435,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); return eigen.sum_of_eigenvalues(i);
} }
@ -463,7 +463,7 @@ public:
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Surface_variation : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits> class Surface_variation : public Eigen_feature<Geom_traits, PointRange, PointMap, DiagonalizeTraits>
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
@ -484,7 +484,7 @@ public:
this->init(input, eigen); this->init(input, eigen);
} }
/// \cond SKIP_IN_MANUAL /// \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); const typename Local_eigen_analysis::Eigenvalues& ev = eigen.eigenvalue(i);
if (ev[0] + ev[1] + ev[2] < 1e-15) if (ev[0] + ev[1] + ev[2] < 1e-15)

38
Classification/include/CGAL/Classification/Feature/Elevation.h
View File

@ -57,7 +57,14 @@ class Elevation : public Feature_base
typedef Image<float> Image_float; typedef Image<float> Image_float;
typedef Planimetric_grid<Geom_traits, PointRange, PointMap> Grid; typedef Planimetric_grid<Geom_traits, PointRange, PointMap> Grid;
std::vector<double> elevation_feature; #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
std::vector<float> elevation_feature;
#else
const PointRange& input;
PointMap point_map;
const Grid& grid;
Image_float dtm;
#endif
public: public:
/*! /*!
@ -73,8 +80,11 @@ public:
Elevation (const PointRange& input, Elevation (const PointRange& input,
PointMap point_map, PointMap point_map,
const Grid& grid, const Grid& grid,
const double grid_resolution, const float grid_resolution,
double radius_dtm = -1.) float radius_dtm = -1.)
#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
: input(input), point_map(point_map), grid(grid)
#endif
{ {
this->set_name ("elevation"); this->set_name ("elevation");
if (radius_dtm < 0.) if (radius_dtm < 0.)
@ -88,7 +98,7 @@ public:
{ {
if (grid.indices(i,j).empty()) if (grid.indices(i,j).empty())
continue; continue;
double mean = 0.; float mean = 0.;
for (std::size_t k = 0; k < grid.indices(i,j).size(); ++ k) 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 += get(point_map, *(input.begin()+grid.indices(i,j)[k])).z();
mean /= grid.indices(i,j).size(); mean /= grid.indices(i,j).size();
@ -106,7 +116,7 @@ public:
std::size_t squareXmin = (i < square ? 0 : i - square); std::size_t squareXmin = (i < square ? 0 : i - square);
std::size_t squareXmax = (std::min)(grid.width() - 1, i + square); std::size_t squareXmax = (std::min)(grid.width() - 1, i + square);
std::vector<double> z; std::vector<float> z;
z.reserve(squareXmax - squareXmin +1 ); z.reserve(squareXmax - squareXmin +1 );
for(std::size_t k = squareXmin; k <= squareXmax; k++) for(std::size_t k = squareXmin; k <= squareXmax; k++)
if (dem(k,j) != 0.) if (dem(k,j) != 0.)
@ -119,7 +129,11 @@ public:
} }
dem.free(); dem.free();
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
Image_float dtm(grid.width(),grid.height()); 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) 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 squareYmin = (j < square ? 0 : j - square);
std::size_t squareYmax = (std::min)(grid.height() - 1, j + square); std::size_t squareYmax = (std::min)(grid.height() - 1, j + square);
std::vector<double> z; std::vector<float> z;
z.reserve(squareYmax - squareYmin +1 ); z.reserve(squareYmax - squareYmin +1 );
for(std::size_t l = squareYmin; l <= squareYmax; l++) for(std::size_t l = squareYmin; l <= squareYmax; l++)
if (dtm_x(i,l) != 0.) if (dtm_x(i,l) != 0.)
@ -140,19 +154,27 @@ public:
} }
dtm_x.free(); dtm_x.free();
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
elevation_feature.reserve(input.size()); elevation_feature.reserve(input.size());
for (std::size_t i = 0; i < input.size(); i++){ for (std::size_t i = 0; i < input.size(); i++){
std::size_t I = grid.x(i); std::size_t I = grid.x(i);
std::size_t J = grid.y(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 /// \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]; 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 /// \endcond

10
Classification/include/CGAL/Classification/Feature/Hsv.h
View File

@ -73,13 +73,13 @@ class Hsv : public Feature_base
typedef typename Classification::HSV_Color HSV_Color; typedef typename Classification::HSV_Color HSV_Color;
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
std::vector<double> color_feature; std::vector<float> color_feature;
#else #else
const PointRange& input; const PointRange& input;
ColorMap color_map; ColorMap color_map;
std::size_t m_channel; std::size_t m_channel;
double m_mean; float m_mean;
double m_sd; float m_sd;
#endif #endif
public: public:
@ -98,7 +98,7 @@ public:
Hsv (const PointRange& input, Hsv (const PointRange& input,
ColorMap color_map, ColorMap color_map,
std::size_t channel, std::size_t channel,
double mean, double sd) float mean, float sd)
#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
: input(input), color_map(color_map), m_channel(channel), m_mean(mean), m_sd(sd) : input(input), color_map(color_map), m_channel(channel), m_mean(mean), m_sd(sd)
#endif #endif
@ -121,7 +121,7 @@ public:
} }
/// \cond SKIP_IN_MANUAL /// \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 #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
return color_feature[pt_index]; return color_feature[pt_index];

39
Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h
View File

@ -54,7 +54,13 @@ class Vertical_dispersion : public Feature_base
{ {
typedef Classification::Image<float> Image_float; typedef Classification::Image<float> Image_float;
typedef Classification::Planimetric_grid<Geom_traits, PointRange, PointMap> Grid; typedef Classification::Planimetric_grid<Geom_traits, PointRange, PointMap> Grid;
std::vector<double> vertical_dispersion;
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
std::vector<float> vertical_dispersion;
#else
const Grid& grid;
Image_float Dispersion;
#endif
public: public:
/*! /*!
@ -69,14 +75,22 @@ public:
Vertical_dispersion (const PointRange& input, Vertical_dispersion (const PointRange& input,
PointMap point_map, PointMap point_map,
const Grid& grid, const Grid& grid,
const double grid_resolution, const float grid_resolution,
double radius_neighbors = -1.) float radius_neighbors = -1.)
#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
: grid (grid)
#endif
{ {
this->set_name ("vertical_dispersion"); this->set_name ("vertical_dispersion");
if (radius_neighbors < 0.) if (radius_neighbors < 0.)
radius_neighbors = 5. * grid_resolution; radius_neighbors = 5. * grid_resolution;
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
Image_float Dispersion(grid.width(), grid.height()); 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 j = 0; j < grid.height(); j++)
for (std::size_t i = 0; i < grid.width(); i++) for (std::size_t i = 0; i < grid.width(); i++)
Dispersion(i,j)=0; Dispersion(i,j)=0;
@ -89,7 +103,7 @@ public:
if(!(grid.mask(i,j))) if(!(grid.mask(i,j)))
continue; continue;
std::vector<double> hori; std::vector<float> hori;
std::size_t squareXmin = (i < square ? 0 : i - square); std::size_t squareXmin = (i < square ? 0 : i - square);
std::size_t squareXmax = (std::min) (grid.width()-1, 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 k = squareXmin; k <= squareXmax; k++)
for(std::size_t l = squareYmin; l <= squareYmax; l++) for(std::size_t l = squareYmin; l <= squareYmax; l++)
if(CGAL::sqrt(pow((double)k-i,2)+pow((double)l-j,2)) if(CGAL::sqrt(pow((float)k-i,2)+pow((float)l-j,2))
<=(double)0.5*radius_neighbors/grid_resolution <=(float)0.5*radius_neighbors/grid_resolution
&& (grid.indices(k,l).size()>0)) && (grid.indices(k,l).size()>0))
for(std::size_t t=0; t<grid.indices(k,l).size();t++) for(std::size_t t=0; t<grid.indices(k,l).size();t++)
{ {
@ -135,18 +149,25 @@ public:
} }
} }
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
for (std::size_t i = 0; i < input.size(); i++) for (std::size_t i = 0; i < input.size(); i++)
{ {
std::size_t I= grid.x(i); std::size_t I= grid.x(i);
std::size_t J= grid.y(i); std::size_t J= grid.y(i);
vertical_dispersion.push_back((double)Dispersion(I,J)); vertical_dispersion.push_back((float)Dispersion(I,J));
} }
#endif
} }
/// \cond SKIP_IN_MANUAL /// \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 vertical_dispersion[pt_index]; return vertical_dispersion[pt_index];
#else
std::size_t I = grid.x(pt_index);
std::size_t J = grid.y(pt_index);
return ((float)Dispersion(I,J));
#endif
} }
/// \endcond /// \endcond
}; };

20
Classification/include/CGAL/Classification/Feature/Verticality.h
View File

@ -49,17 +49,15 @@ namespace Feature {
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Verticality : public Feature_base class Verticality : public Feature_base
{ {
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange, typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis; PointMap, DiagonalizeTraits> Local_eigen_analysis;
const typename Geom_traits::Vector_3 vertical; const typename Geom_traits::Vector_3 vertical;
std::vector<double> verticality_feature; std::vector<float> verticality_feature;
#ifndef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES const Local_eigen_analysis* eigen;
const Local_eigen_analysis& eigen;
#endif
public: public:
/*! /*!
@ -71,7 +69,7 @@ public:
#ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES #ifdef CGAL_CLASSIFICATION_PRECOMPUTE_FEATURES
Verticality (const PointRange& input, Verticality (const PointRange& input,
const Local_eigen_analysis& eigen) const Local_eigen_analysis& eigen)
: vertical (0., 0., 1.) : vertical (0., 0., 1.), eigen(NULL)
{ {
this->set_name ("verticality"); this->set_name ("verticality");
@ -85,7 +83,7 @@ public:
#else #else
Verticality (const PointRange&, Verticality (const PointRange&,
const Local_eigen_analysis& eigen) const Local_eigen_analysis& eigen)
: vertical (0., 0., 1.), eigen (eigen) : vertical (0., 0., 1.), eigen (&eigen)
{ {
this->set_name ("verticality"); this->set_name ("verticality");
} }
@ -103,7 +101,7 @@ public:
template <typename VectorMap> template <typename VectorMap>
Verticality (const PointRange& input, Verticality (const PointRange& input,
VectorMap normal_map) VectorMap normal_map)
: vertical (0., 0., 1.) : vertical (0., 0., 1.), eigen(NULL)
{ {
this->set_name ("verticality"); this->set_name ("verticality");
for (std::size_t i = 0; i < input.size(); i++) for (std::size_t i = 0; i < input.size(); i++)
@ -116,12 +114,12 @@ public:
/// \cond SKIP_IN_MANUAL /// \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 #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); normal = normal / CGAL::sqrt (normal * normal);
return (1. - CGAL::abs(normal * vertical)); return (1. - CGAL::abs(normal * vertical));
} }

2
Classification/include/CGAL/Classification/Feature_base.h
View File

@ -70,7 +70,7 @@ public:
position `index`. This method must be implemented by inherited position `index`. This method must be implemented by inherited
classes. classes.
*/ */
virtual double value (std::size_t index) = 0; virtual float value (std::size_t index) = 0;
}; };

82
Classification/include/CGAL/Classification/Local_eigen_analysis.h
View File

@ -56,16 +56,14 @@ namespace Classification {
for matrix diagonalization. for matrix diagonalization.
*/ */
template <typename Geom_traits, typename PointRange, typename PointMap, template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Local_eigen_analysis class Local_eigen_analysis
{ {
public: public:
typedef typename Geom_traits::Point_3 Point; typedef typename Geom_traits::Point_3 Point;
typedef typename Geom_traits::Vector_3 Vector; typedef typename Geom_traits::Vector_3 Vector;
typedef typename Geom_traits::Plane_3 Plane; typedef typename Geom_traits::Plane_3 Plane;
typedef CGAL::cpp11::array<float, 3> Eigenvalues; ///< Eigenvalues (sorted in ascending order)
typedef CGAL::cpp11::array<double, 3> Eigenvalues; ///< Eigenvalues (sorted in ascending order)
private: private:
@ -77,7 +75,7 @@ private:
const PointRange& m_input; const PointRange& m_input;
PointMap m_point_map; PointMap m_point_map;
const NeighborQuery& m_neighbor_query; const NeighborQuery& m_neighbor_query;
double& m_mean_range; float& m_mean_range;
tbb::mutex& m_mutex; tbb::mutex& m_mutex;
public: public:
@ -86,7 +84,7 @@ private:
const PointRange& input, const PointRange& input,
PointMap point_map, PointMap point_map,
const NeighborQuery& neighbor_query, const NeighborQuery& neighbor_query,
double& mean_range, float& mean_range,
tbb::mutex& mutex) tbb::mutex& mutex)
: m_eigen (eigen), m_input (input), m_point_map (point_map), : m_eigen (eigen), m_input (input), m_point_map (point_map),
m_neighbor_query (neighbor_query), m_mean_range (mean_range), m_mutex (mutex) m_neighbor_query (neighbor_query), m_mean_range (mean_range), m_mutex (mutex)
@ -115,15 +113,16 @@ private:
}; };
#endif #endif
std::vector<Eigenvalues> m_eigenvalues; typedef CGAL::cpp11::array<float, 3> float3;
std::vector<double> m_sum_eigenvalues; std::vector<float3> m_eigenvalues;
std::vector<Point> m_centroids; std::vector<float> m_sum_eigenvalues;
std::vector<Vector> m_smallest_eigenvectors; std::vector<float3> m_centroids;
std::vector<float3> m_smallest_eigenvectors;
#ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE
std::vector<Vector> m_middle_eigenvectors; std::vector<float3> m_middle_eigenvectors;
std::vector<Vector> m_largest_eigenvectors; std::vector<float3> m_largest_eigenvectors;
#endif #endif
double m_mean_range; float m_mean_range;
public: public:
@ -202,12 +201,25 @@ public:
/*! /*!
\brief Returns the estimated unoriented normal vector of the point at position `index`. \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`. \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`. \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`. \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 /// \cond SKIP_IN_MANUAL
double mean_range() const { return m_mean_range; } float mean_range() const { return m_mean_range; }
/// \endcond /// \endcond
private: private:
@ -229,21 +241,21 @@ private:
{ {
if (neighbor_points.size() == 0) if (neighbor_points.size() == 0)
{ {
Eigenvalues v = {{ 0., 0., 0. }}; Eigenvalues v = {{ 0.f, 0.f, 0.f }};
m_eigenvalues[index] = v; m_eigenvalues[index] = v;
m_centroids[index] = query; m_centroids[index] = {{ float(query.x()), float(query.y()), float(query.z()) }};
m_smallest_eigenvectors[index] = Vector (0., 0., 1.); m_smallest_eigenvectors[index] = {{ 0.f, 0.f, 1.f }};
#ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE
m_middle_eigenvectors[index] = Vector (0., 1., 0.); m_middle_eigenvectors[index] = {{ 0.f, 1.f, 0.f }};
m_largest_eigenvectors[index] = Vector (1., 0., 0.); m_largest_eigenvectors[index] = {{ 1.f, 0.f, 0.f }};
#endif #endif
return; return;
} }
Point centroid = CGAL::centroid (neighbor_points.begin(), neighbor_points.end()); 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<double, 6> covariance = {{ 0., 0., 0., 0., 0., 0. }}; CGAL::cpp11::array<float, 6> covariance = {{ 0.f, 0.f, 0.f, 0.f, 0.f, 0.f }};
for (std::size_t i = 0; i < neighbor_points.size(); ++ i) for (std::size_t i = 0; i < neighbor_points.size(); ++ i)
{ {
@ -256,25 +268,25 @@ private:
covariance[5] += d.z () * d.z (); covariance[5] += d.z () * d.z ();
} }
Eigenvalues evalues = {{ 0., 0., 0. }}; CGAL::cpp11::array<float, 3> evalues = {{ 0.f, 0.f, 0.f }};
CGAL::cpp11::array<double, 9> evectors = {{ 0., 0., 0., CGAL::cpp11::array<float, 9> evectors = {{ 0.f, 0.f, 0.f,
0., 0., 0., 0.f, 0.f, 0.f,
0., 0., 0. }}; 0.f, 0.f, 0.f }};
DiagonalizeTraits::diagonalize_selfadjoint_covariance_matrix DiagonalizeTraits::diagonalize_selfadjoint_covariance_matrix
(covariance, evalues, evectors); (covariance, evalues, evectors);
// Normalize // Normalize
double sum = evalues[0] + evalues[1] + evalues[2]; float sum = evalues[0] + evalues[1] + evalues[2];
if (sum > 0.) if (sum > 0.f)
for (std::size_t i = 0; i < 3; ++ i) for (std::size_t i = 0; i < 3; ++ i)
evalues[i] = evalues[i] / sum; evalues[i] = evalues[i] / sum;
m_sum_eigenvalues[index] = sum; m_sum_eigenvalues[index] = float(sum);
m_eigenvalues[index] = evalues; m_eigenvalues[index] = {{ float(evalues[0]), float(evalues[1]), float(evalues[2]) }};
m_smallest_eigenvectors[index] = Vector (evectors[0], evectors[1], evectors[2]); m_smallest_eigenvectors[index] = {{ float(evectors[0]), float(evectors[1]), float(evectors[2]) }};
#ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE #ifdef CGAL_CLASSIFICATION_EIGEN_FULL_STORAGE
m_middle_eigenvectors[index] = Vector (evectors[3], evectors[4], evectors[5]); m_middle_eigenvectors[index] = {{ float(evectors[3]), float(evectors[4]), float(evectors[5]) }};
m_largest_eigenvectors[index] = Vector (evectors[6], evectors[7], evectors[8]); m_largest_eigenvectors[index] = {{ float(evectors[6]), float(evectors[7]), float(evectors[8]) }};
#endif #endif
} }

4
Classification/include/CGAL/Classification/Planimetric_grid.h
View File

@ -79,7 +79,7 @@ public:
Planimetric_grid (const PointRange& input, Planimetric_grid (const PointRange& input,
PointMap point_map, PointMap point_map,
const Iso_cuboid_3& bbox, 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 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; 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_y.push_back ((std::size_t)((p.y() - bbox.ymin()) / grid_resolution));
m_grid(m_x.back(), m_y.back()).push_back (i); m_grid(m_x.back(), m_y.back()).push_back (i);
} }
std::cerr << "Grid size = " << width * height << std::endl;
} }
/*! /*!

55
Classification/include/CGAL/Classification/Point_set_feature_generator.h
View File

@ -89,7 +89,7 @@ template <typename Geom_traits,
#else #else
typename ConcurrencyTag = CGAL::Sequential_tag, typename ConcurrencyTag = CGAL::Sequential_tag,
#endif #endif
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> > typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<float,3> >
class Point_set_feature_generator class Point_set_feature_generator
{ {
@ -147,10 +147,10 @@ private:
Neighborhood* neighborhood; Neighborhood* neighborhood;
Planimetric_grid* grid; Planimetric_grid* grid;
Local_eigen_analysis* eigen; Local_eigen_analysis* eigen;
double voxel_size; float voxel_size;
Scale (const PointRange& input, PointMap point_map, 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) : voxel_size (voxel_size)
{ {
CGAL::Real_timer t; CGAL::Real_timer t;
@ -170,7 +170,7 @@ private:
t.start(); t.start();
eigen = new Local_eigen_analysis (input, point_map, neighborhood->k_neighbor_query(6)); 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) if (this->voxel_size < 0)
this->voxel_size = range; this->voxel_size = range;
t.stop(); t.stop();
@ -186,14 +186,27 @@ private:
} }
~Scale() ~Scale()
{ {
delete neighborhood; if (neighborhood != NULL)
delete grid; delete neighborhood;
if (grid != NULL)
delete grid;
delete eigen; delete eigen;
} }
double grid_resolution() const { return voxel_size; } void reduce_memory_footprint(bool delete_neighborhood)
double radius_neighbors() const { return voxel_size * 5; } {
double radius_dtm() const { return voxel_size * 100; } 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(); 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 /// \endcond
/// \name Data Structures and Parameters /// \name Data Structures and Parameters
@ -378,7 +399,7 @@ public:
\note `generate_features()` must have been called before calling \note `generate_features()` must have been called before calling
this method. 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 \brief Returns the radius used for neighborhood queries at scale
@ -389,7 +410,7 @@ public:
\note `generate_features()` must have been called before calling \note `generate_features()` must have been called before calling
this method. 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 \brief Returns the radius used for digital terrain modeling at
scale `scale`. This radius represents the minimum size of a scale `scale`. This radius represents the minimum size of a
@ -398,7 +419,7 @@ public:
\note `generate_features()` must have been called before calling \note `generate_features()` must have been called before calling
this method. 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; using Feature_adder::scale;
ColorMap color_map; ColorMap color_map;
std::size_t channel; std::size_t channel;
double mean; float mean;
double sd; float sd;
// TODO! // TODO!
Feature_adder_color (Point_set_feature_generator* generator, ColorMap color_map, std::size_t scale, 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), : Feature_adder (generator, scale), color_map (color_map),
channel (channel), mean (mean), sd (sd) { } channel (channel), mean (mean), sd (sd) { }
@ -588,11 +609,11 @@ private:
CGAL::Real_timer t; t.start(); CGAL::Real_timer t; t.start();
m_scales.reserve (nb_scales); 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)); m_scales.push_back (new Scale (m_input, m_point_map, m_bbox, voxel_size));
voxel_size = m_scales[0]->grid_resolution(); voxel_size = m_scales[0]->grid_resolution();
for (std::size_t i = 1; i < nb_scales; ++ i) for (std::size_t i = 1; i < nb_scales; ++ i)
{ {
voxel_size *= 2; voxel_size *= 2;

14
Classification/include/CGAL/Classification/Point_set_neighborhood.h
View File

@ -142,14 +142,14 @@ public:
typedef Point_set_neighborhood::Point value_type; ///< typedef Point_set_neighborhood::Point value_type; ///<
private: private:
const Point_set_neighborhood& neighborhood; const Point_set_neighborhood& neighborhood;
double radius; float radius;
public: public:
/*! /*!
\brief Constructs a range neighbor query object. \brief Constructs a range neighbor query object.
\param neighborhood point set neighborhood object. \param neighborhood point set neighborhood object.
\param radius radius of the neighbor query sphere. \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) { } : neighborhood (neighborhood), radius(radius) { }
/// \cond SKIP_IN_MANUAL /// \cond SKIP_IN_MANUAL
@ -202,7 +202,7 @@ public:
*/ */
Point_set_neighborhood (const PointRange& input, Point_set_neighborhood (const PointRange& input,
PointMap point_map, PointMap point_map,
double voxel_size) float voxel_size)
: m_tree (NULL) : m_tree (NULL)
{ {
// First, simplify // First, simplify
@ -239,7 +239,7 @@ public:
/*! /*!
\brief Returns a neighbor query object with fixed radius `radius`. \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); return Range_neighbor_query (*this, radius);
} }
@ -265,7 +265,7 @@ private:
template <typename Map> template <typename Map>
void voxelize_point_set (std::vector<std::size_t>& indices, Map point_map, void voxelize_point_set (std::vector<std::size_t>& indices, Map point_map,
double voxel_size) float voxel_size)
{ {
std::map<Point, std::vector<std::size_t> > grid; std::map<Point, std::vector<std::size_t> > grid;
@ -292,10 +292,10 @@ private:
(pts.end(), (pts.end(),
CGAL::Property_map_to_unary_function<Map>(point_map))); CGAL::Property_map_to_unary_function<Map>(point_map)));
std::size_t chosen = 0; std::size_t chosen = 0;
double min_dist = (std::numeric_limits<double>::max)(); float min_dist = (std::numeric_limits<float>::max)();
for (std::size_t i = 0; i < pts.size(); ++ i) 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) if (dist < min_dist)
{ {
min_dist = dist; min_dist = dist;

94
Classification/include/CGAL/Classification/Sum_of_weighted_features_predicate.h
View File

@ -75,7 +75,7 @@ private:
std::vector<std::size_t>& m_training_set; std::vector<std::size_t>& m_training_set;
const Sum_of_weighted_features_predicate& m_predicate; const Sum_of_weighted_features_predicate& m_predicate;
std::size_t m_label; std::size_t m_label;
double& m_confidence; float& m_confidence;
std::size_t& m_nb_okay; std::size_t& m_nb_okay;
tbb::mutex& m_mutex; tbb::mutex& m_mutex;
@ -84,7 +84,7 @@ private:
Compute_worst_score_and_confidence (std::vector<std::size_t>& training_set, Compute_worst_score_and_confidence (std::vector<std::size_t>& training_set,
const Sum_of_weighted_features_predicate& predicate, const Sum_of_weighted_features_predicate& predicate,
std::size_t label, std::size_t label,
double& confidence, float& confidence,
std::size_t& nb_okay, std::size_t& nb_okay,
tbb::mutex& mutex) tbb::mutex& mutex)
: m_training_set (training_set) : m_training_set (training_set)
@ -99,9 +99,9 @@ private:
{ {
for (std::size_t k = r.begin(); k != r.end(); ++ k) for (std::size_t k = r.begin(); k != r.end(); ++ k)
{ {
std::vector<std::pair<double, std::size_t> > values; std::vector<std::pair<float, std::size_t> > values;
std::vector<double> v; std::vector<float> v;
m_predicate.probabilities (m_training_set[k], v); m_predicate.probabilities (m_training_set[k], v);
for(std::size_t l = 0; l < v.size(); ++ l) for(std::size_t l = 0; l < v.size(); ++ l)
@ -125,7 +125,7 @@ private:
Label_set& m_labels; Label_set& m_labels;
Feature_set& m_features; Feature_set& m_features;
std::vector<double> m_weights; std::vector<float> m_weights;
std::vector<std::vector<Effect> > m_effect_table; std::vector<std::vector<Effect> > m_effect_table;
mutable std::map<Label_handle, std::size_t> m_map_labels; mutable std::map<Label_handle, std::size_t> m_map_labels;
mutable std::map<Feature_handle, std::size_t> m_map_features; mutable std::map<Feature_handle, std::size_t> m_map_features;
@ -148,12 +148,12 @@ public:
/*! /*!
\brief Sets the weight of the feature (`weight` must be positive). \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; m_weights[m_map_features[feature]] = weight;
} }
/// \cond SKIP_IN_MANUAL /// \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; m_weights[feature] = weight;
} }
@ -162,12 +162,12 @@ public:
/*! /*!
\brief Returns the weight of the feature. \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]]; return m_weights[m_map_features[feature]];
} }
/// \cond SKIP_IN_MANUAL /// \cond SKIP_IN_MANUAL
double weight (std::size_t feature) const float weight (std::size_t feature) const
{ {
return m_weights[feature]; return m_weights[feature];
} }
@ -204,7 +204,7 @@ public:
/// \endcond /// \endcond
void probabilities (std::size_t item_index, void probabilities (std::size_t item_index,
std::vector<double>& out) const std::vector<float>& out) const
{ {
out.resize (m_labels.size()); out.resize (m_labels.size());
for (std::size_t l = 0; l < m_labels.size(); ++ l) for (std::size_t l = 0; l < m_labels.size(); ++ l)
@ -317,7 +317,7 @@ public:
typename std::map<std::string, std::size_t>::iterator typename std::map<std::string, std::size_t>::iterator
found = map_n2f.find (name); found = map_n2f.find (name);
if (found != map_n2f.end()) if (found != map_n2f.end())
m_weights[found->second] = v.second.get<double>("weight"); m_weights[found->second] = v.second.get<float>("weight");
else else
{ {
if (verbose) if (verbose)
@ -394,26 +394,32 @@ public:
configuration found. configuration found.
*/ */
template <typename ConcurrencyTag> template <typename ConcurrencyTag>
double train (const std::vector<std::size_t>& ground_truth, float train (const std::vector<std::size_t>& ground_truth,
std::size_t nb_tests = 300) std::size_t nb_tests = 300)
{ {
std::vector<std::vector<std::size_t> > training_sets (m_labels.size()); std::vector<std::vector<std::size_t> > training_sets (m_labels.size());
std::size_t nb_tot = 0;
for (std::size_t i = 0; i < ground_truth.size(); ++ i) for (std::size_t i = 0; i < ground_truth.size(); ++ i)
if (ground_truth[i] != std::size_t(-1)) 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) for (std::size_t i = 0; i < m_labels.size(); ++ i)
if (training_sets.size() <= i || training_sets[i].empty()) 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::cerr << "WARNING: \"" << m_labels[i]->name() << "\" doesn't have a training set." << std::endl;
std::vector<double> best_weights (m_features.size(), 1.); std::vector<float> best_weights (m_features.size(), 1.);
struct Feature_training struct Feature_training
{ {
std::size_t i; std::size_t i;
double wmin; float wmin;
double wmax; float wmax;
double factor; float factor;
bool operator<(const Feature_training& other) const bool operator<(const Feature_training& other) const
{ {
@ -422,8 +428,8 @@ public:
}; };
std::vector<Feature_training> feature_train; std::vector<Feature_training> feature_train;
std::size_t nb_trials = 100; std::size_t nb_trials = 100;
double wmin = 1e-5, wmax = 1e5; float wmin = 1e-5, wmax = 1e5;
double factor = std::pow (wmax/wmin, 1. / (double)nb_trials); float factor = std::pow (wmax/wmin, 1. / (float)nb_trials);
for (std::size_t j = 0; j < m_features.size(); ++ j) for (std::size_t j = 0; j < m_features.size(); ++ j)
{ {
@ -431,8 +437,8 @@ public:
best_weights[j] = weight(j); best_weights[j] = weight(j);
std::size_t nb_useful = 0; std::size_t nb_useful = 0;
double min = (std::numeric_limits<double>::max)(); float min = (std::numeric_limits<float>::max)();
double max = -(std::numeric_limits<double>::max)(); float max = -(std::numeric_limits<float>::max)();
set_weight(j, wmin); set_weight(j, wmin);
for (std::size_t i = 0; i < 100; ++ i) for (std::size_t i = 0; i < 100; ++ i)
@ -475,17 +481,17 @@ public:
estimate_feature_effect(j, training_sets); 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() CGAL_CLASSIFICATION_CERR << "Trials = " << nb_tests << ", features = " << feature_train.size()
<< ", trials per feature = " << nb_trials_per_feature << std::endl; << ", trials per feature = " << nb_trials_per_feature << std::endl;
for (std::size_t i = 0; i < feature_train.size(); ++ i) for (std::size_t i = 0; i < feature_train.size(); ++ i)
feature_train[i].factor feature_train[i].factor
= std::pow (feature_train[i].wmax / feature_train[i].wmin, = 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.; float best_score = 0.;
double best_confidence = 0.; float best_confidence = 0.;
boost::tie (best_confidence, best_score) boost::tie (best_confidence, best_score)
= compute_worst_confidence_and_score<ConcurrencyTag> (0., 0., training_sets); = compute_worst_confidence_and_score<ConcurrencyTag> (0., 0., training_sets);
@ -519,7 +525,7 @@ public:
{ {
estimate_feature_effect(current_feature_changed, training_sets); 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) boost::tie (worst_confidence, worst_score)
= compute_worst_confidence_and_score<ConcurrencyTag> (best_confidence, best_score, training_sets); = compute_worst_confidence_and_score<ConcurrencyTag> (best_confidence, best_score, training_sets);
@ -585,7 +591,7 @@ public:
private: 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) if (m_effect_table[label][feature] == FAVORING)
return favored (feature, index); return favored (feature, index);
@ -595,19 +601,19 @@ private:
return ignored (feature, index); 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)); 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); 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; return 0.5;
} }
@ -621,19 +627,19 @@ private:
void estimate_feature_effect (std::size_t feature, void estimate_feature_effect (std::size_t feature,
std::vector<std::vector<std::size_t> >& training_sets) std::vector<std::vector<std::size_t> >& training_sets)
{ {
std::vector<double> mean (m_labels.size(), 0.); std::vector<float> mean (m_labels.size(), 0.);
for (std::size_t j = 0; j < m_labels.size(); ++ j) for (std::size_t j = 0; j < m_labels.size(); ++ j)
{ {
for (std::size_t k = 0; k < training_sets[j].size(); ++ k) 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] += val;
} }
mean[j] /= training_sets[j].size(); mean[j] /= training_sets[j].size();
} }
std::vector<double> sd (m_labels.size(), 0.); std::vector<float> sd (m_labels.size(), 0.);
for (std::size_t j = 0; j < m_labels.size(); ++ j) 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) 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] += (val - mean[j]) * (val - mean[j]);
} }
sd[j] = std::sqrt (sd[j] / training_sets[j].size()); sd[j] = std::sqrt (sd[j] / training_sets[j].size());
@ -655,15 +661,15 @@ private:
} }
template <typename ConcurrencyTag> template <typename ConcurrencyTag>
std::pair<double, double> compute_worst_confidence_and_score (double lower_conf, double lower_score, std::pair<float, float> compute_worst_confidence_and_score (float lower_conf, float lower_score,
std::vector<std::vector<std::size_t> >& training_sets) std::vector<std::vector<std::size_t> >& training_sets)
{ {
double worst_confidence = (std::numeric_limits<double>::max)(); float worst_confidence = (std::numeric_limits<float>::max)();
double worst_score = (std::numeric_limits<double>::max)(); float worst_score = (std::numeric_limits<float>::max)();
for (std::size_t j = 0; j < m_labels.size(); ++ j) for (std::size_t j = 0; j < m_labels.size(); ++ j)
{ {
double confidence = 0.; float confidence = 0.;
std::size_t nb_okay = 0; std::size_t nb_okay = 0;
#ifndef CGAL_LINKED_WITH_TBB #ifndef CGAL_LINKED_WITH_TBB
@ -681,9 +687,9 @@ private:
{ {
for (std::size_t k = 0; k < training_sets[j].size(); ++ k) for (std::size_t k = 0; k < training_sets[j].size(); ++ k)
{ {
std::vector<std::pair<double, std::size_t> > values; std::vector<std::pair<float, std::size_t> > values;
std::vector<double> v; std::vector<float> v;
probabilities (training_sets[j][k], v); probabilities (training_sets[j][k], v);
for(std::size_t l = 0; l < m_labels.size(); ++ l) 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()); float score = nb_okay / (float)(training_sets[j].size());
confidence /= (double)(training_sets[j].size() * m_features.size()); confidence /= (float)(training_sets[j].size() * m_features.size());
if (confidence < worst_confidence) if (confidence < worst_confidence)
worst_confidence = confidence; worst_confidence = confidence;

52
Classification/include/CGAL/Classification/classify.h
View File

@ -64,10 +64,10 @@ namespace internal {
inline void apply (std::size_t s) const inline void apply (std::size_t s) const
{ {
std::size_t nb_class_best=0; std::size_t nb_class_best=0;
std::vector<double> values; std::vector<float> values;
m_predicate.probabilities (s, values); m_predicate.probabilities (s, values);
double val_class_best = (std::numeric_limits<double>::max)(); float val_class_best = (std::numeric_limits<float>::max)();
for(std::size_t k = 0; k < m_labels.size(); ++ k) for(std::size_t k = 0; k < m_labels.size(); ++ k)
{ {
if(val_class_best > values[k]) if(val_class_best > values[k])
@ -87,14 +87,14 @@ namespace internal {
{ {
const Label_set& m_labels; const Label_set& m_labels;
const ClassificationPredicate& m_predicate; const ClassificationPredicate& m_predicate;
std::vector<std::vector<double> >& m_values; std::vector<std::vector<float> >& m_values;
public: public:
Classifier_local_smoothing_preprocessing Classifier_local_smoothing_preprocessing
(const Label_set& labels, (const Label_set& labels,
const ClassificationPredicate& predicate, const ClassificationPredicate& predicate,
std::vector<std::vector<double> >& values) std::vector<std::vector<float> >& values)
: m_labels (labels), m_predicate (predicate), m_values (values) : m_labels (labels), m_predicate (predicate), m_values (values)
{ } { }
@ -108,7 +108,7 @@ namespace internal {
inline void apply (std::size_t s) const inline void apply (std::size_t s) const
{ {
std::vector<double> values; std::vector<float> values;
m_predicate.probabilities(s, values); m_predicate.probabilities(s, values);
for(std::size_t k = 0; k < m_labels.size(); ++ k) for(std::size_t k = 0; k < m_labels.size(); ++ k)
m_values[k][s] = values[k]; m_values[k][s] = values[k];
@ -121,7 +121,7 @@ namespace internal {
const ItemRange& m_input; const ItemRange& m_input;
const ItemMap m_item_map; const ItemMap m_item_map;
const Label_set& m_labels; const Label_set& m_labels;
const std::vector<std::vector<double> >& m_values; const std::vector<std::vector<float> >& m_values;
const NeighborQuery& m_neighbor_query; const NeighborQuery& m_neighbor_query;
std::vector<std::size_t>& m_out; std::vector<std::size_t>& m_out;
@ -130,7 +130,7 @@ namespace internal {
Classifier_local_smoothing (const ItemRange& input, Classifier_local_smoothing (const ItemRange& input,
ItemMap item_map, ItemMap item_map,
const Label_set& labels, const Label_set& labels,
const std::vector<std::vector<double> >& values, const std::vector<std::vector<float> >& values,
const NeighborQuery& neighbor_query, const NeighborQuery& neighbor_query,
std::vector<std::size_t>& out) std::vector<std::size_t>& out)
: m_input (input), m_item_map (item_map), m_labels (labels), : m_input (input), m_item_map (item_map), m_labels (labels),
@ -152,13 +152,13 @@ namespace internal {
std::vector<std::size_t> neighbors; std::vector<std::size_t> neighbors;
m_neighbor_query (get (m_item_map, *(m_input.begin()+s)), std::back_inserter (neighbors)); m_neighbor_query (get (m_item_map, *(m_input.begin()+s)), std::back_inserter (neighbors));
std::vector<double> mean (m_values.size(), 0.); std::vector<float> mean (m_values.size(), 0.);
for (std::size_t n = 0; n < neighbors.size(); ++ n) for (std::size_t n = 0; n < neighbors.size(); ++ n)
for (std::size_t j = 0; j < m_values.size(); ++ j) for (std::size_t j = 0; j < m_values.size(); ++ j)
mean[j] += m_values[j][neighbors[n]]; mean[j] += m_values[j][neighbors[n]];
std::size_t nb_class_best=0; std::size_t nb_class_best=0;
double val_class_best = (std::numeric_limits<double>::max)(); float val_class_best = (std::numeric_limits<float>::max)();
for(std::size_t k = 0; k < mean.size(); ++ k) for(std::size_t k = 0; k < mean.size(); ++ k)
{ {
mean[k] /= neighbors.size(); mean[k] /= neighbors.size();
@ -184,7 +184,7 @@ namespace internal {
const Label_set& m_labels; const Label_set& m_labels;
const ClassificationPredicate& m_predicate; const ClassificationPredicate& m_predicate;
const NeighborQuery& m_neighbor_query; const NeighborQuery& m_neighbor_query;
double m_weight; float m_weight;
const std::vector<std::vector<std::size_t> >& m_indices; const std::vector<std::vector<std::size_t> >& m_indices;
const std::vector<std::pair<std::size_t, std::size_t> >& m_input_to_indices; const std::vector<std::pair<std::size_t, std::size_t> >& m_input_to_indices;
std::vector<std::size_t>& m_out; std::vector<std::size_t>& m_out;
@ -202,7 +202,7 @@ namespace internal {
const Label_set& labels, const Label_set& labels,
const ClassificationPredicate& predicate, const ClassificationPredicate& predicate,
const NeighborQuery& neighbor_query, const NeighborQuery& neighbor_query,
double weight, float weight,
const std::vector<std::vector<std::size_t> >& indices, const std::vector<std::vector<std::size_t> >& indices,
const std::vector<std::pair<std::size_t, std::size_t> >& input_to_indices, const std::vector<std::pair<std::size_t, std::size_t> >& input_to_indices,
std::vector<std::size_t>& out) std::vector<std::size_t>& out)
@ -247,13 +247,13 @@ namespace internal {
edge_weights.push_back (m_weight); edge_weights.push_back (m_weight);
} }
std::vector<double> values; std::vector<float> values;
m_predicate.probabilities(s, values); m_predicate.probabilities(s, values);
std::size_t nb_class_best = 0; std::size_t nb_class_best = 0;
double val_class_best = (std::numeric_limits<double>::max)(); float val_class_best = (std::numeric_limits<float>::max)();
for(std::size_t k = 0; k < m_labels.size(); ++ k) for(std::size_t k = 0; k < m_labels.size(); ++ k)
{ {
double value = values[k]; float value = values[k];
probability_matrix[k][j] = value; probability_matrix[k][j] = value;
if(val_class_best > value) if(val_class_best > value)
@ -321,8 +321,8 @@ namespace internal {
{ {
output.resize(input.size()); output.resize(input.size());
std::vector<std::vector<double> > values std::vector<std::vector<float> > values
(labels.size(), std::vector<double> (input.size(), -1.)); (labels.size(), std::vector<float> (input.size(), -1.));
internal::Classifier_local_smoothing_preprocessing<ClassificationPredicate> internal::Classifier_local_smoothing_preprocessing<ClassificationPredicate>
f1 (labels, predicate, values); f1 (labels, predicate, values);
internal::Classifier_local_smoothing<ItemRange, ItemMap, NeighborQuery> internal::Classifier_local_smoothing<ItemRange, ItemMap, NeighborQuery>
@ -359,7 +359,7 @@ namespace internal {
const Label_set& labels, const Label_set& labels,
const ClassificationPredicate& predicate, const ClassificationPredicate& predicate,
const NeighborQuery& neighbor_query, const NeighborQuery& neighbor_query,
const double weight, const float weight,
const std::size_t min_number_of_subdivisions, const std::size_t min_number_of_subdivisions,
std::vector<std::size_t>& output) std::vector<std::size_t>& output)
{ {
@ -367,11 +367,11 @@ namespace internal {
(boost::make_transform_iterator (input.begin(), CGAL::Property_map_to_unary_function<ItemWithBboxMap>(bbox_map)), (boost::make_transform_iterator (input.begin(), CGAL::Property_map_to_unary_function<ItemWithBboxMap>(bbox_map)),
boost::make_transform_iterator (input.end(), CGAL::Property_map_to_unary_function<ItemWithBboxMap>(bbox_map))); boost::make_transform_iterator (input.end(), CGAL::Property_map_to_unary_function<ItemWithBboxMap>(bbox_map)));
double Dx = bbox.xmax() - bbox.xmin(); float Dx = bbox.xmax() - bbox.xmin();
double Dy = bbox.ymax() - bbox.ymin(); float Dy = bbox.ymax() - bbox.ymin();
double A = Dx * Dy; float A = Dx * Dy;
double a = A / min_number_of_subdivisions; float a = A / min_number_of_subdivisions;
double l = std::sqrt(a); float l = std::sqrt(a);
std::size_t nb_x = std::size_t(Dx / l) + 1; 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_y = std::size_t((A / nb_x) / a) + 1;
std::size_t nb = nb_x * nb_y; std::size_t nb = nb_x * nb_y;
@ -382,11 +382,11 @@ namespace internal {
for (std::size_t y = 0; y < nb_y; ++ y) for (std::size_t y = 0; y < nb_y; ++ y)
{ {
bboxes.push_back bboxes.push_back
(CGAL::Bbox_3 (bbox.xmin() + Dx * (x / double(nb_x)), (CGAL::Bbox_3 (bbox.xmin() + Dx * (x / float(nb_x)),
bbox.ymin() + Dy * (y / double(nb_y)), bbox.ymin() + Dy * (y / float(nb_y)),
bbox.zmin(), bbox.zmin(),
bbox.xmin() + Dx * ((x+1) / double(nb_x)), bbox.xmin() + Dx * ((x+1) / float(nb_x)),
bbox.ymin() + Dy * ((y+1) / double(nb_y)), bbox.ymin() + Dy * ((y+1) / float(nb_y)),
bbox.zmax())); bbox.zmax()));
} }