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

Update ref and user man

This commit is contained in:
Simon Giraudot 2017-01-09 14:27:03 +01:00
parent 821b26d4e4
commit d43fe019fe
17 changed files with 636 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Classification/doc/Classification/Classification.txt
View File

@ -15,18 +15,18 @@ This component implements a generalization of the algorithm described in \cgalCi
- some analysis is performed on the input data set
- attributes are computed based on this analysis
- a set of classification types (for example: ground, building, vegetation) is defined by the user
- attributes are given weights and each pair of attribute/type is assigned a relationship. This can either be done by hand or using training (see \ref Classification_training)
- classification is computed item-wise by minimizing an energy defined as the sum of the values taken by attributes on input items (which depend on the attribute/type relationship)
- attributes are given weights and each pair of attribute and type is assigned a relationship. This can either be done by hand or using training (see \ref Classification_training)
- classification is computed itemwise by minimizing an energy defined as the sum of the values taken by attributes on input items (which depend on the attribute/type relationship)
- additional regularization can be used by smoothing either locally or globally through an Alpha Expansion approach.
This package is designed to be easily extended by the users: more specifically, attributes and types can be defined by users to handle any data they need to classify (although \cgal provides a predefined framework for common urban scenes).
Currently, \cgal provides data structures to handle classification of point sets.
\cgalFigureBegin{Classification_Organization,organization.png}
Organization of the package.
\cgalFigureEnd
This package is designed to be easily extended by users: more specifically, attributes and types can be defined by users to handle any data they need to classify (although \cgal provides a predefined framework for common urban scenes).
Currently, \cgal provides data structures to handle classification of point sets.
\section Classification_structures Data Structures
\subsection Classification_analysis Analysis
@ -39,7 +39,7 @@ Organization of the package.
- [Local_eigen_analysis](@ref CGAL::Classification::Local_eigen_analysis) precomputes covariance matrices on local neighborhoods of points and stores the associated eigenvectors and eigenvalues
- [Planimetric_grid](@ref CGAL::Classification::Planimetric_grid) is a 2D grid used for digital terrain modeling.
The following code snippet shows how to instantiate such data structures from an input PLY point set (the full example is given at the end of the manual). The class `CGAL::Classifier` that handles classification is also instanciated (see \ref Classification_classifier).
The following code snippet shows how to instantiate such data structures from an input PLY point set (the full example is given at the end of the manual). The class `CGAL::Classifier` that handles classification is also instantiated (see \ref Classification_classifier).
\snippet Classification/example_classifier.cpp Analysis
@ -56,7 +56,7 @@ Attributes are accessed through `Handle` objects, `CGAL::Classification::Attribu
- [Vertical_dispersion](@ref CGAL::Classification::Attribute::Vertical_dispersion) computes how noisy the point set is on a local Z-cylinder
- [Verticality](@ref CGAL::Classification::Attribute::Verticality) compares the local normal vector to the vertical vector.
For more details about how these different attributes can help identifying one classification type or the other, please refer to their associated reference manual pages. In addition, \cgal also provides attributes solely based on the local eigen values \cgalCite{cgal:mbrsh-raofw-11}. Such attributes are more theoretical and harder to relate to a specific use case, but they can help differenciating some classification types:
For more details about how these different attributes can help to identify one classification type or the other, please refer to their associated reference manual pages. In addition, \cgal also provides attributes solely based on the local eigen values \cgalCite{cgal:mbrsh-raofw-11}. Such attributes are more theoretical and harder to relate to a specific use case, but they can help to differentiate some classification types:
- [Anisotropy](@ref CGAL::Classification::Attribute::Anisotropy)
- [Eigentropy](@ref CGAL::Classification::Attribute::Eigentropy)
@ -86,7 +86,7 @@ A classification type represents how an item should be classified, for example:
- [NEUTRAL](@ref CGAL::Classification::Attribute::NEUTRAL): the type is not affected by the attribute
- [PENALIZING](@ref CGAL::Classification::Attribute::PENALIZING): the type is favored by low values of the attribute
Let \f$x=(x_i)_{i=1..N_c}\f$ be a potential classification result with \f$N_c\f$ the number of input items and \f$x_i\f$ the class of the \f$i^{th}\f$ item (for example: vegetation, ground, etc.). Let \f$a_j(i)\f$ be the raw value of the \f$j^{th}\f$ attribute at the \f$i^{th}\f$ item and \f$w_j\f$ be the weight of this attribute. We define the normalized value of the \f$j^{th}\f$ attribute at the \f$i^{th}\f$ item as follows:
Let \f$x=(x_i)_{i=1..N_c}\f$ be a potential classification result with \f$N_c\f$ the number of input items and \f$x_i\f$ the class of the \f$i^{th}\f$ item (for example: vegetation, ground, etc.). Let \f$a_j(i)\f$ be the raw value of the \f$j^{th}\f$ attribute at the \f$i^{th}\f$ item and \f$w_j\f$ be the weight of this attribute. We define the normalized value \f$A_j(x_i) \in [0:1]\f$ of the \f$j^{th}\f$ attribute at the \f$i^{th}\f$ item as follows:
\f{eqnarray*}{
A_j(x_i) = & (1 - \min(\max(0,\frac{a_j(i)}{w_j}), 1)) & \mbox{if } a_j \mbox{ favors } x_i \\
@ -229,7 +229,7 @@ The example \ref Classification_example_training shows how to set inliers and ru
\section Classification_examples Examples
\subsection Classification_example_simple Simple classification
\subsection Classification_example_general General classification
The following example:

38
Classification/doc/Classification/PackageDescription.txt
View File

@ -39,15 +39,15 @@
## Classification ##
- `CGAL::Classifier<Range, ItemMap>`
- `CGAL::Point_set_classifier<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classifier<ItemRange, ItemMap>`
- `CGAL::Point_set_classifier<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
## Data Structures ##
- `CGAL::Classification::Point_set_neighborhood<Kernel, Range, PointMap>`
- `CGAL::Classification::Local_eigen_analysis<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Planimetric_grid<Kernel, Range, PointMap>`
- `CGAL::Classification::Point_set_neighborhood<Geom_traits, PointRange, PointMap>`
- `CGAL::Classification::Local_eigen_analysis<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Planimetric_grid<Geom_traits, PointRange, PointMap>`
## Classification Type ##
@ -61,20 +61,20 @@
## Predefined Attributes ##
- `CGAL::Classification::Attribute::Anisotropy<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Distance_to_plane<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Echo_scatter<Kernel, Range, PointMap, EchoMap>`
- `CGAL::Classification::Attribute::Eigentropy<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Elevation<Kernel, Range, PointMap>`
- `CGAL::Classification::Attribute::Hsv<Kernel, Range, ColorMap>`
- `CGAL::Classification::Attribute::Linearity<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Omnivariance<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Planarity<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Sphericity<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Sum_eigenvalues<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Surface_variation<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Vertical_dispersion<Kernel, Range, PointMap>`
- `CGAL::Classification::Attribute::Verticality<Kernel, Range, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Anisotropy<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Distance_to_plane<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Echo_scatter<Geom_traits, PointRange, PointMap, EchoMap>`
- `CGAL::Classification::Attribute::Eigentropy<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Elevation<Geom_traits, PointRange, PointMap>`
- `CGAL::Classification::Attribute::Hsv<Geom_traits, PointRange, ColorMap>`
- `CGAL::Classification::Attribute::Linearity<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Omnivariance<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Planarity<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Sphericity<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Sum_eigenvalues<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Surface_variation<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
- `CGAL::Classification::Attribute::Vertical_dispersion<Geom_traits, PointRange, PointMap>`
- `CGAL::Classification::Attribute::Verticality<Geom_traits, PointRange, PointMap, DiagonalizeTraits>`
*/

1
Classification/doc/Classification/dependencies
View File

@ -4,3 +4,4 @@ STL_Extension
Algebraic_foundations
Circulator
Stream_support
Solver_interface

24
Classification/include/CGAL/Classification/Attribute/Distance_to_plane.h
View File

@ -33,26 +33,26 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on local distance to a fitted plane.
Characterizing a level of non-planarity can help identify noisy
parts of the input such as vegetation. This attribute computes the
distance of a point to a locally fitted plane.
%Attribute based on local distance to a fitted
plane. Characterizing a level of non-planarity can help to
identify noisy parts of the input such as vegetation. This
attribute computes the distance of a point to a locally fitted
plane.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Distance_to_plane : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> distance_to_plane_attribute;
@ -65,7 +65,7 @@ public:
\param point_map property map to access the input points.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Distance_to_plane (const Range& input,
Distance_to_plane (const PointRange& input,
PointMap point_map,
const Local_eigen_analysis& eigen)
{

25
Classification/include/CGAL/Classification/Attribute/Echo_scatter.h
View File

@ -13,26 +13,25 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on echo scatter.
%Attribute based on echo scatter. The number of returns (echo
number) is a useful information provided by most LIDAR sensors. It
can help to identify trees.
The number of returns (echo number) is a useful information
provided by most LIDAR sensors. It can help identify trees.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam EchoMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `PointRange` and value type
is `std::size_t`.
*/
template <typename Kernel, typename Range, typename PointMap, typename EchoMap>
template <typename Geom_traits, typename PointRange, typename PointMap, typename EchoMap>
class Echo_scatter : public Attribute_base
{
public:
typedef Classification::Planimetric_grid<Kernel, Range, PointMap> Grid;
typedef Classification::Planimetric_grid<Geom_traits, PointRange, PointMap> Grid;
private:
typedef Classification::Image<float> Image_float;
@ -48,7 +47,7 @@ public:
\param grid_resolution resolution of the planimetric grid.
\param radius_neighbors radius of local neighborhoods.
*/
Echo_scatter (const Range& input,
Echo_scatter (const PointRange& input,
EchoMap echo_map,
Grid& grid,
const double grid_resolution,

194
Classification/include/CGAL/Classification/Attribute/Eigen.h
View File

@ -33,39 +33,37 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Linearity is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Linearity is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
\frac{\lambda_1 - \lambda_2}{\lambda_1}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Linearity : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Linearity (const Range& input,
Linearity (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -94,39 +92,37 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Planarity is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Planarity is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
\frac{\lambda_2 - \lambda_3}{\lambda_1}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Planarity : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Planarity (const Range& input,
Planarity (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -154,39 +150,37 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Sphericity is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Sphericity is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
\frac{\lambda_3}{\lambda_1}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Sphericity : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Sphericity (const Range& input,
Sphericity (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -213,39 +207,37 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Omnivariance is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Omnivariance is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
(\lambda_1 \times \lambda_2 \times \lambda_3)^{\frac{1}{3}}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Omnivariance : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Omnivariance (const Range& input,
Omnivariance (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -269,39 +261,37 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Anisotropy is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Anisotropy is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
\frac{\lambda_1 - \lambda_3}{\lambda_1}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Anisotropy : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Anisotropy (const Range& input,
Anisotropy (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -328,39 +318,37 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Eigentropy is defined, for the 3 eigenvalues \f$\lambda_1 \ge
\lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. Eigentropy is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
\f[
- \sum_{i=1}^3 \lambda_i \times \log{\lambda_i}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Eigentropy : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Eigentropy (const Range& input,
Eigentropy (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -391,39 +379,38 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
The sum of the eigenvalues is defined, for the 3 eigenvalues
\f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance matrix of a
local neighborhood. The sum of the eigenvalues is defined, for the
3 eigenvalues \f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge 0\f$,
as:
\f[
\lambda_1 + \lambda_2 + \lambda_3
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Sum_eigenvalues : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Sum_eigenvalues (const Range& input,
Sum_eigenvalues (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);
@ -445,39 +432,38 @@ public:
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on the eigenvalues of the covariance matrix
of a local neighborhood.
Surface variation is defined, for the 3 eigenvalues \f$\lambda_1
\ge \lambda_2 \ge \lambda_3 \ge 0\f$, as:
%Attribute based on the eigenvalues of the covariance
matrix of a local neighborhood. Surface variation is defined, for
the 3 eigenvalues \f$\lambda_1 \ge \lambda_2 \ge \lambda_3 \ge
0\f$, as:
\f[
\frac{\lambda_3}{\lambda_1 + \lambda_2 + \lambda_3}
\f]
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Surface_variation : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> attrib;
public:
/*!
\brief Constructs the attribute.
Constructs the attribute.
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Surface_variation (const Range& input,
Surface_variation (const PointRange& input,
Local_eigen_analysis& eigen)
{
this->set_weight(1.);

31
Classification/include/CGAL/Classification/Attribute/Elevation.h
View File

@ -35,29 +35,26 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on local elevation.
%Attribute based on local elevation. The local position of the
ground can be computed for urban scenes. This attribute computes
the distance to the local estimation of the ground. It is useful
to discriminate the ground from horizontal roofs.
The local position of the ground can be computed for urban
scenes. This attribute computes the distance to the local
estimation of the ground.
It is useful to discriminate the ground from horizontal roofs.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
*/
template <typename Kernel, typename Range, typename PointMap>
template <typename Geom_traits, typename PointRange, typename PointMap>
class Elevation : public Attribute_base
{
typedef typename Kernel::Iso_cuboid_3 Iso_cuboid_3;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid_3;
typedef Image<float> Image_float;
typedef Planimetric_grid<Kernel, Range, PointMap> Grid;
typedef Planimetric_grid<Geom_traits, PointRange, PointMap> Grid;
std::vector<double> elevation_attribute;
@ -69,10 +66,10 @@ public:
\param point_map property map to access the input points.
\param grid precomputed `Planimetric_grid`.
\param grid_resolution resolution of the planimetric grid.
\param radius_dtm radius for digital terrain modeling (must be bigger than the size of a building).
\param radius_dtm radius for digital terrain modeling (should be
larger than the width and length of the largest building).
*/
Elevation (const Range& input,
Elevation (const PointRange& input,
PointMap point_map,
const Grid& grid,
const double grid_resolution,

39
Classification/include/CGAL/Classification/Attribute/Hsv.h
View File

@ -33,29 +33,40 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on HSV colorimetric information.
%Attribute based on HSV colorimetric information. If the input
point cloud has colorimetric information, it can be used for
classification purposes. This attribute is based on a Gaussian
probabilistic model on one of the three HSV channels (hue,
saturation or value). It computes the probability of the color of
the input point to match this specific color channel defined by a
mean and a standard deviation.
If the input point cloud has colorimetric information, it can be
used for classification purposes. This attribute is based on a
Gaussian probabilistic model on one of the three HSV channels
(hue, saturation or value).
The HSV channels are defined this way:
It computes the probability of the color of the input point to
match this specific color channel defined by a mean and a standard
deviation.
- Hue ranges from 0 to 360 and measures the general "tint" of the
color (green, blue, pink, etc.)
- Saturation ranges from 0 to 100 and measures the "strength" of the
color (0 is gray and 100 is the fully saturated color)
- Value ranges from 0 to 100 and measures the "brightness" of the
color (0 is black and 100 is the fully bright color)
For example, such an attribute using the channel 0 (hue) with a
mean of 90 (which corresponds to a green hue) can help identify
mean of 90 (which corresponds to a green hue) can help to identify
trees.
\note The user only needs to provide a map to standard (and more common)
RGB colors, the conversion to HSV is done internally.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam ColorMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
type is the value type of the iterator of `PointRange` and value type
is `CGAL::Classification::RGB_Color`.
*/
template <typename Kernel, typename Range, typename ColorMap>
template <typename Geom_traits, typename PointRange, typename ColorMap>
class Hsv : public Attribute_base
{
typedef typename Classification::RGB_Color RGB_Color;
@ -77,7 +88,7 @@ public:
\param mean mean value of the specified channel.
\param sd standard deviation of the specified channel.
*/
Hsv (const Range& input,
Hsv (const PointRange& input,
ColorMap color_map,
std::size_t channel,
double mean, double sd)

21
Classification/include/CGAL/Classification/Attribute/Vertical_dispersion.h
View File

@ -34,27 +34,26 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on local vertical dispersion of points.
Urban scenes can often be decomposed as a set of 2D regions with
%Attribute based on local vertical dispersion of points. Urban
scenes can often be decomposed as a set of 2D regions with
different heights. While these heights are usually piecewise
constant or piecewise linear, on some specific parts of the scene
such as vegetation, they can become extremely unstable. This
attribute quantifies the vertical dispersion of the points on a
local Z-cylinder around the points.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
*/
template <typename Kernel, typename Range, typename PointMap>
template <typename Geom_traits, typename PointRange, typename PointMap>
class Vertical_dispersion : public Attribute_base
{
typedef Classification::Image<float> Image_float;
typedef Classification::Planimetric_grid<Kernel, Range, PointMap> Grid;
typedef Classification::Planimetric_grid<Geom_traits, PointRange, PointMap> Grid;
std::vector<double> vertical_dispersion;
public:
@ -67,7 +66,7 @@ public:
\param grid_resolution resolution of the planimetric grid.
\param radius_neighbors radius of local neighborhoods.
*/
Vertical_dispersion (const Range& input,
Vertical_dispersion (const PointRange& input,
PointMap point_map,
const Grid& grid,
const double grid_resolution,
@ -83,7 +82,7 @@ public:
Dispersion(i,j)=0;
std::size_t square = (std::size_t)(0.5 * radius_neighbors / grid_resolution) + 1;
typename Kernel::Vector_3 verti (0., 0., 1.);
typename Geom_traits::Vector_3 verti (0., 0., 1.);
for (std::size_t j = 0; j < grid.height(); j++){
for (std::size_t i = 0; i < grid.width(); i++){

38
Classification/include/CGAL/Classification/Attribute/Verticality.h
View File

@ -33,26 +33,26 @@ namespace Attribute {
/*!
\ingroup PkgClassificationAttributes
\brief Attribute based on local verticality.
%Attribute based on local verticality. The orientation of the
local tangent plane of the considered point can be useful to
discriminate facades from the ground. This attribute can use
normal vectors if available or eigen analysis that estimates
tangent planes from local neighborhoods.
The orientation of the best fitting plane of a local neighborhood
of the considered point can be useful to discriminate facades from
the ground.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Verticality : public Attribute_base
{
typedef Classification::Local_eigen_analysis<Kernel, Range,
typedef Classification::Local_eigen_analysis<Geom_traits, PointRange,
PointMap, DiagonalizeTraits> Local_eigen_analysis;
std::vector<double> verticality_attribute;
@ -63,15 +63,15 @@ public:
\param input input range.
\param eigen class with precomputed eigenvectors and eigenvalues.
*/
Verticality (const Range& input,
Verticality (const PointRange& input,
const Local_eigen_analysis& eigen)
{
this->set_weight(1.);
typename Kernel::Vector_3 vertical (0., 0., 1.);
typename Geom_traits::Vector_3 vertical (0., 0., 1.);
for (std::size_t i = 0; i < input.size(); i++)
{
typename Kernel::Vector_3 normal = eigen.normal_vector(i);
typename Geom_traits::Vector_3 normal = eigen.normal_vector(i);
normal = normal / CGAL::sqrt (normal * normal);
verticality_attribute.push_back (1. - CGAL::abs(normal * vertical));
}
@ -84,21 +84,21 @@ public:
\brief Constructs the attribute using provided normals of points.
\tparam VectorMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Vector_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Vector_3`.
\param input input range.
\param normal_map property map to access the normal vectors of the input points.
*/
template <typename VectorMap>
Verticality (const Range& input,
Verticality (const PointRange& input,
VectorMap normal_map)
{
this->set_weight(1.);
typename Kernel::Vector_3 vertical (0., 0., 1.);
typename Geom_traits::Vector_3 vertical (0., 0., 1.);
for (std::size_t i = 0; i < input.size(); i++)
{
typename Kernel::Vector_3 normal = get(normal_map, *(input.begin()+i));
typename Geom_traits::Vector_3 normal = get(normal_map, *(input.begin()+i));
normal = normal / CGAL::sqrt (normal * normal);
verticality_attribute.push_back (1. - std::fabs(normal * vertical));
}

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

@ -107,7 +107,7 @@ public:
/*!
\ingroup PkgClassification
\brief Handle to an `Attribute_base`.
\brief %Handle to an `Attribute_base`.
\cgalModels Handle
*/

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

@ -20,23 +20,23 @@ namespace Classification {
eigenvalues of the covariance matrices of all points of a point
set using a local neighborhood.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type is
`RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel, typename Range, typename PointMap,
template <typename Geom_traits, typename PointRange, typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Local_eigen_analysis
{
public:
typedef typename Kernel::Point_3 Point;
typedef typename Kernel::Vector_3 Vector;
typedef typename Kernel::Plane_3 Plane;
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<double, 3> Eigenvalues; ///< Eigenvalues (sorted in ascending order)
@ -68,7 +68,7 @@ public:
\param neighbor_query object used to access neighborhoods of points.
*/
template <typename NeighborQuery>
Local_eigen_analysis (const Range& input,
Local_eigen_analysis (const PointRange& input,
PointMap point_map,
const NeighborQuery& neighbor_query)
{

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

@ -19,20 +19,20 @@ namespace Classification {
projection along the Z-axis lies within this cell. The mapping
from each point to the cell it lies in is also stored.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type is
`RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
*/
template <typename Kernel, typename Range, typename PointMap>
template <typename Geom_traits, typename PointRange, typename PointMap>
class Planimetric_grid
{
public:
typedef typename Kernel::Point_3 Point_3;
typedef typename Kernel::Iso_cuboid_3 Iso_cuboid_3;
typedef typename Geom_traits::Point_3 Point_3;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid_3;
private:
typedef Image<std::vector<std::size_t> > Image_indices;
@ -56,7 +56,7 @@ public:
\param bbox bounding box of the input range.
\param grid_resolution resolution of the planimetric grid.
*/
Planimetric_grid (const Range& input,
Planimetric_grid (const PointRange& input,
PointMap point_map,
const Iso_cuboid_3& bbox,
const double grid_resolution)

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

@ -22,8 +22,8 @@ namespace Classification {
\ingroup PkgClassificationDataStructures
\brief Class that precomputes spatial searching structures for an
input point set and gives easy access to local neighborhoods of
points.
input point set and gives access to the local neighborhood of a
point as a set of indices.
It allows the user to generate models of `NeighborQuery` based on
a fixed range neighborhood or on a fixed K number of neighbors. In
@ -31,22 +31,22 @@ namespace Classification {
simplified version of the point set to allow for neighbor queries
at a higher scale.
\tparam Kernel is a model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam Geom_traits is a model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type is
`RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
*/
template <typename Kernel, typename Range, typename PointMap>
template <typename Geom_traits, typename PointRange, typename PointMap>
class Point_set_neighborhood
{
typedef typename Kernel::FT FT;
typedef typename Kernel::Point_3 Point;
typedef typename Geom_traits::FT FT;
typedef typename Geom_traits::Point_3 Point;
class My_point_property_map{
const Range* input;
const PointRange* input;
PointMap point_map;
public:
@ -55,14 +55,14 @@ class Point_set_neighborhood
typedef std::size_t key_type;
typedef boost::lvalue_property_map_tag category;
My_point_property_map () { }
My_point_property_map (const Range *input, PointMap point_map)
My_point_property_map (const PointRange *input, PointMap point_map)
: input (input), point_map (point_map) { }
reference operator[] (key_type k) const { return get(point_map, *(input->begin()+k)); }
friend inline reference get (const My_point_property_map& ppmap, key_type i)
{ return ppmap[i]; }
};
typedef Search_traits_3<Kernel> SearchTraits_3;
typedef Search_traits_3<Geom_traits> SearchTraits_3;
typedef Search_traits_adapter <std::size_t, My_point_property_map, SearchTraits_3> Search_traits;
typedef Sliding_midpoint<Search_traits> Splitter;
typedef Distance_adapter<std::size_t, My_point_property_map, Euclidean_distance<SearchTraits_3> > Distance;
@ -102,9 +102,10 @@ public:
/// \cond SKIP_IN_MANUAL
template <typename OutputIterator>
void operator() (const value_type& query, OutputIterator output) const
OutputIterator operator() (const value_type& query, OutputIterator output) const
{
neighborhood.k_neighbors (query, k, output);
return output;
}
/// \endcond
};
@ -134,9 +135,10 @@ public:
/// \cond SKIP_IN_MANUAL
template <typename OutputIterator>
void operator() (const value_type& query, OutputIterator output) const
OutputIterator operator() (const value_type& query, OutputIterator output) const
{
neighborhood.range_neighbors (query, radius, output);
return output;
}
/// \endcond
};
@ -154,7 +156,7 @@ public:
\param input input range.
\param point_map property map to access the input points.
*/
Point_set_neighborhood (const Range& input,
Point_set_neighborhood (const PointRange& input,
PointMap point_map)
: m_tree (NULL)
{
@ -179,7 +181,7 @@ public:
\param point_map property map to access the input points.
\param voxel_size size of the cells of the 3D grid used for simplification.
*/
Point_set_neighborhood (const Range& input,
Point_set_neighborhood (const PointRange& input,
PointMap point_map,
double voxel_size)
: m_tree (NULL)

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

@ -77,7 +77,7 @@ public:
/*!
\ingroup PkgClassification
\brief Handle to a classification `Type`.
\brief %Handle to a classification `Type`.
\cgalModels Handle
*/

586
Classification/include/CGAL/Classifier.h
View File

@ -62,43 +62,41 @@ namespace CGAL {
classification types.
This class implements the core of the classification algorithm
\cgalCite{cgal:lm-clscm-12}. It uses a data set as input and assignes
each input item to a classification type among a set of user
defined classification types.
To achieve this classification algorithm, a set of local geometric
attributes are used, such as planarity, elevation or vertical
dispersion. In addition, the user must define a set of classification
types such as building, ground or vegetation.
\cgalCite{cgal:lm-clscm-12}. It uses a data set as input and assigns
each input item to a classification type among a set of user defined
classification types. To achieve this classification, a set of local
geometric attributes are used, such as planarity, elevation or
vertical dispersion. In addition, the user must define a set of
classification types such as building, ground or vegetation.
Each pair of attribute and type must be assigned an
[Attribute::Effect](@ref CGAL::Classification::Attribute::Effect) (for
example, vegetation has a low planarity and a high vertical
dispersion) and each attribute must be assigned a weight. These
parameters can be set up by hand or by automatic training, provided a
small user defined set of inlier is given for each classification
small user-defined set of inlier is given for each classification
type.
\tparam Range range of items, model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam ItemRange model of `ConstRange`. Its iterator type is
`RandomAccessIterator`.
\tparam ItemMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type is
type is the value type of the iterator of `ItemRange` and value type is
the type of the items that are classified.
*/
template <typename Range,
template <typename ItemRange,
typename ItemMap>
class Classifier
{
public:
/// \cond SKIP_IN_MANUAL
typedef typename ItemMap::value_type Item;
typedef typename Classification::Type_handle Type_handle;
typedef typename Classification::Attribute_handle Attribute_handle;
/// \cond SKIP_IN_MANUAL
typedef typename ItemMap::value_type Item;
#ifdef CGAL_DO_NOT_USE_BOYKOV_KOLMOGOROV_MAXFLOW_SOFTWARE
typedef internal::Alpha_expansion_graph_cut_boost Alpha_expansion;
#else
@ -107,7 +105,7 @@ public:
protected:
const Range& m_input;
const ItemRange& m_input;
ItemMap m_item_map;
std::vector<std::size_t> m_assigned_type;
@ -135,7 +133,7 @@ public:
\param item_map property map to access the input items.
*/
Classifier (const Range& input,
Classifier (const ItemRange& input,
ItemMap item_map)
: m_input (input), m_item_map (item_map)
{
@ -147,6 +145,195 @@ public:
virtual ~Classifier() { }
/// \endcond
/// \name Attributes
/// @{
/*!
\brief Adds an attribute.
\tparam Attribute type of the attribute, inherited from
`Classification::Attribute_base`.
\tparam T types of the parameters of the attribute's constructor.
\param t parameters of the attribute's constructor.
\return a handle to the newly added attribute.
*/
#if (!defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES) && !defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)) || DOXYGEN_RUNNING
template <typename Attribute, typename ... T>
Attribute_handle add_attribute (T&& ... t)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, std::forward<T>(t)...)));
return m_attributes.back();
}
#else
template <typename Attribute>
Attribute_handle add_attribute ()
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input)));
return m_attributes.back();
}
template <typename Attribute, typename T1>
Attribute_handle add_attribute (T1& t1)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2>
Attribute_handle add_attribute (T1& t1, T2& t2)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3, typename T4>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3, T4& t4)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3, t4)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3, typename T4, typename T5>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3, T4& t4, T5& t5)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3, t4, t5)));
return m_attributes.back();
}
#endif
/*!
\brief Removes an attribute.
\param attribute the handle to attribute type that must be removed.
\return `true` if the attribute was correctly removed, `false` if
its handle was not found.
*/
bool remove_attribute (Attribute_handle attribute)
{
for (std::size_t i = 0; i < m_attributes.size(); ++ i)
if (m_attributes[i] == attribute)
{
m_attributes.erase (m_attributes.begin() + i);
return true;
}
return false;
}
/*!
\brief Returns how many attributes are defined.
*/
std::size_t number_of_attributes() const
{
return m_attributes.size();
}
/*!
\brief Removes all attributes.
*/
void clear_attributes ()
{
m_attributes.clear();
}
/// \cond SKIP_IN_MANUAL
Attribute_handle get_attribute(std::size_t index)
{
return m_attributes[index];
}
/// \endcond
/// @}
/// \name Classification Types
/// @{
/*!
\brief Adds a classification type.
\param name name of the classification type.
\return a handle to the newly added classification type.
*/
Type_handle add_classification_type (const char* name)
{
Type_handle out (new Classification::Type (name));
m_types.push_back (out);
return out;
}
/*!
\brief Removes a classification type.
\param type the handle to the classification type that must be removed.
\return `true` if the classification type was correctly removed,
`false` if its handle was not found.
*/
bool remove_classification_type (Type_handle type)
{
std::size_t idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == type)
{
m_types.erase (m_types.begin() + i);
idx = i;
break;
}
if (idx == (std::size_t)(-1))
return false;
std::cerr << idx << std::endl;
for (std::size_t i = 0; i < m_assigned_type.size(); ++ i)
if (m_assigned_type[i] == (std::size_t)(-1))
continue;
else if (m_assigned_type[i] > idx)
m_assigned_type[i] --;
else if (m_assigned_type[i] == idx)
m_assigned_type[i] = (std::size_t)(-1);
for (std::size_t i = 0; i < m_training_type.size(); ++ i)
if (m_assigned_type[i] == (std::size_t)(-1))
continue;
else if (m_training_type[i] > idx)
m_training_type[i] --;
else if (m_training_type[i] == idx)
m_training_type[i] = (std::size_t)(-1);
return true;
}
/*!
\brief Returns how many classification types are defined.
*/
std::size_t number_of_classification_types () const
{
return m_types.size();
}
/// \cond SKIP_IN_MANUAL
Type_handle get_classification_type (std::size_t index)
{
return m_types[index];
}
/// \endcond
/*!
\brief Removes all classification types.
*/
void clear_classification_types ()
{
m_types.clear();
}
/// @}
/// \name Classification
/// @{
@ -271,7 +458,7 @@ public:
*/
template <typename NeighborQuery>
void run_with_graphcut (const NeighborQuery& neighbor_query,
const double& weight)
const double weight)
{
prepare_classification ();
@ -321,196 +508,6 @@ public:
/// \name Classification Types
/// @{
/*!
\brief Adds a classification type.
\param name name of the classification type.
\return a handle to the newly added classification type.
*/
Type_handle add_classification_type (const char* name)
{
Type_handle out (new Classification::Type (name));
m_types.push_back (out);
return out;
}
/*!
\brief Removes a classification type.
\param type the handle to the classification type that must be removed.
\return `true` if the classification type was correctly removed,
`false` if its handle was not found.
*/
bool remove_classification_type (Type_handle type)
{
std::size_t idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == type)
{
m_types.erase (m_types.begin() + i);
idx = i;
break;
}
if (idx == (std::size_t)(-1))
return false;
std::cerr << idx << std::endl;
for (std::size_t i = 0; i < m_assigned_type.size(); ++ i)
if (m_assigned_type[i] == (std::size_t)(-1))
continue;
else if (m_assigned_type[i] > idx)
m_assigned_type[i] --;
else if (m_assigned_type[i] == idx)
m_assigned_type[i] = (std::size_t)(-1);
for (std::size_t i = 0; i < m_training_type.size(); ++ i)
if (m_assigned_type[i] == (std::size_t)(-1))
continue;
else if (m_training_type[i] > idx)
m_training_type[i] --;
else if (m_training_type[i] == idx)
m_training_type[i] = (std::size_t)(-1);
return true;
}
/*!
\brief Returns how many classification types are defined.
*/
std::size_t number_of_classification_types () const
{
return m_types.size();
}
/// \cond SKIP_IN_MANUAL
Type_handle get_classification_type (std::size_t idx)
{
return m_types[idx];
}
/// \endcond
/*!
\brief Removes all classification types.
*/
void clear_classification_types ()
{
m_types.clear();
}
/// @}
/// \name Attributes
/// @{
/*!
\brief Adds an attribute.
\tparam Attribute type of the attribute, inherited from
`Classification::Attribute_base`.
\tparam T types of the parameters of the attribute's constructor.
\param t parameters of the attribute's constructor.
\return a handle to the newly added attribute.
*/
#if (!defined(CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES) && !defined(CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE)) || DOXYGEN_RUNNING
template <typename Attribute, typename ... T>
Attribute_handle add_attribute (T&& ... t)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, std::forward<T>(t)...)));
return m_attributes.back();
}
#else
template <typename Attribute>
Attribute_handle add_attribute ()
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input)));
return m_attributes.back();
}
template <typename Attribute, typename T1>
Attribute_handle add_attribute (T1& t1)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2>
Attribute_handle add_attribute (T1& t1, T2& t2)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3, typename T4>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3, T4& t4)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3, t4)));
return m_attributes.back();
}
template <typename Attribute, typename T1, typename T2, typename T3, typename T4, typename T5>
Attribute_handle add_attribute (T1& t1, T2& t2, T3& t3, T4& t4, T5& t5)
{
m_attributes.push_back (Attribute_handle (new Attribute(m_input, t1, t2, t3, t4, t5)));
return m_attributes.back();
}
#endif
/*!
\brief Removes an attribute.
\param attribute the handle to attribute type that must be removed.
\return `true` if the attribute was correctly removed, `false` if
its handle was not found.
*/
bool remove_attribute (Attribute_handle attribute)
{
for (std::size_t i = 0; i < m_attributes.size(); ++ i)
if (m_attributes[i] == attribute)
{
m_attributes.erase (m_attributes.begin() + i);
return true;
}
return false;
}
/*!
\brief Returns how many attributes are defined.
*/
std::size_t number_of_attributes() const
{
return m_attributes.size();
}
/*!
\brief Removes all attributes.
*/
void clear_attributes ()
{
m_attributes.clear();
}
/// \cond SKIP_IN_MANUAL
Attribute_handle get_attribute(std::size_t idx)
{
return m_attributes[idx];
}
/// \endcond
/// @}
/// \name Output
/// @{
@ -574,18 +571,101 @@ public:
/// \name Training
/// @{
/*!
\brief Adds the item at position `index` as an inlier of
`class_type` for the training algorithm.
\note This inlier is only used for training. There is no guarantee
that the item at position `index` will be classified as `class_type`
after calling `run()`, `run_with_local_smoothing()` or
`run_with_graphcut()`.
\return `true` if the inlier was correctly added, `false`
otherwise (if `class_type` was not found).
*/
bool set_inlier (Type_handle class_type, std::size_t index)
{
std::size_t type_idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == class_type)
{
type_idx = i;
break;
}
if (type_idx == (std::size_t)(-1))
return false;
if (m_training_type.empty())
reset_inlier_sets();
m_training_type[index] = type_idx;
return true;
}
/*!
\brief Adds the items at positions `indices` as inliers of
`class_type` for the training algorithm.
\note These inliers are only used for training. There is no
guarantee that the items at positions `indices` will be classified
as `class_type` after calling `run()`,
`run_with_local_smoothing()` or `run_with_graphcut()`.
\tparam IndexRange range of `std::size_t`, model of `ConstRange`.
*/
template <class IndexRange>
bool set_inliers (Type_handle class_type,
IndexRange indices)
{
std::size_t type_idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == class_type)
{
type_idx = i;
break;
}
if (type_idx == (std::size_t)(-1))
return false;
if (m_training_type.empty())
reset_inlier_sets();
for (typename IndexRange::const_iterator it = indices.begin();
it != indices.end(); ++ it)
m_training_type[*it] = type_idx;
return true;
}
/*!
\brief Resets inlier sets used for training.
*/
void reset_inlier_sets()
{
std::vector<std::size_t>(m_input.size(), (std::size_t)(-1)).swap (m_training_type);
}
/*!
\brief Runs the training algorithm.
All the `Classification::Type` and `Classification::Attribute`
necessary for the classification should have been added before
running this function.
necessary for classification should have been added before running
this function. Each classification type must have ben given a small set
of user-defined inliers to provide the training algorithm with a
ground truth (see `set_inlier()` and `set_inliers()`).
Each classification type must be given a small set of user-defined
inliers to provide the training algorithm with a ground truth.
This methods estimates the set of attribute weights and of
[effects](@ref Classification::Attribute::Effect) that make the
classifier succeed in correctly classifying the sets of inliers
given by the user. These parameters are directly modified within
the `Classification::Attribute_base` and `Classification::Type`
objects. After training, the user can call `run()`,
`run_with_local_smoothing()` or `run_with_graphcut()` to compute
the classification using the estimated parameters.
\param nb_tests number of tests to perform. Higher values may
provide the user with better results at the cost of higher
provide the user with better results at the cost of a higher
computation time. Using a value of at least 10 times the number of
attributes is advised.
@ -796,81 +876,6 @@ public:
}
/*!
\brief Resets inlier sets used for training.
*/
void reset_inlier_sets()
{
std::vector<std::size_t>(m_input.size(), (std::size_t)(-1)).swap (m_training_type);
}
/*!
\brief Adds the item at position `idx` as an inlier of
`class_type` for the training algorithm.
\note This inlier is only used for training. There is no guarantee
that the item at position `idx` will be classified as `class_type`
after calling `run()`, `run_with_local_smoothing()` or
`run_with_graphcut()`.
\return `true` if the inlier was correctly added, `false`
otherwise (if `class_type` was not found).
*/
bool set_inlier (Type_handle class_type, std::size_t idx)
{
std::size_t type_idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == class_type)
{
type_idx = i;
break;
}
if (type_idx == (std::size_t)(-1))
return false;
if (m_training_type.empty())
reset_inlier_sets();
m_training_type[idx] = type_idx;
return true;
}
/*!
\brief Adds the items at positions `indices` as inliers of
`class_type` for the training algorithm.
\note These inliers are only used for training. There is no
guarantee that the items at positions `indices` will be classified
as `class_type` after calling `run()`,
`run_with_local_smoothing()` or `run_with_graphcut()`.
\tparam IndexRange range of `std::size_t`, model of `ConstRange`.
*/
template <class IndexRange>
bool set_inliers (Type_handle class_type,
IndexRange indices)
{
std::size_t type_idx = (std::size_t)(-1);
for (std::size_t i = 0; i < m_types.size(); ++ i)
if (m_types[i] == class_type)
{
type_idx = i;
break;
}
if (type_idx == (std::size_t)(-1))
return false;
if (m_training_type.empty())
reset_inlier_sets();
for (typename IndexRange::const_iterator it = indices.begin();
it != indices.end(); ++ it)
m_training_type[*it] = type_idx;
return true;
}
/// @}
@ -904,6 +909,8 @@ public:
protected:
/// \cond SKIP_IN_MANUAL
double classification_value (const std::size_t& class_type,
const std::size_t& pt_index) const
{
@ -1057,6 +1064,7 @@ protected:
return false;
}
/// \endcond
};

148
Classification/include/CGAL/Point_set_classifier.h
View File

@ -58,73 +58,74 @@ namespace CGAL {
set of generic attributes. Attributes can be generated at multiple
scales to increase the reliability of the classification.
\tparam Kernel model of \cgal Kernel.
\tparam Range range of items, model of `ConstRange`. Its iterator type
is `RandomAccessIterator`.
\tparam Geom_traits model of \cgal Kernel.
\tparam PointRange model of `ConstRange`. Its iterator type is
`RandomAccessIterator`.
\tparam PointMap model of `ReadablePropertyMap` whose key
type is the value type of the iterator of `Range` and value type
is `Point_3<Kernel>`.
type is the value type of the iterator of `PointRange` and value type
is `Geom_traits::Point_3`.
\tparam DiagonalizeTraits model of `DiagonalizeTraits` used
for matrix diagonalization.
*/
template <typename Kernel,
typename Range,
template <typename Geom_traits,
typename PointRange,
typename PointMap,
typename DiagonalizeTraits = CGAL::Default_diagonalize_traits<double,3> >
class Point_set_classifier : public Classifier<Range, PointMap>
class Point_set_classifier : public Classifier<PointRange, PointMap>
{
public:
typedef typename Kernel::Iso_cuboid_3 Iso_cuboid_3;
typedef typename Geom_traits::Iso_cuboid_3 Iso_cuboid_3;
typedef Classifier<Range, PointMap> Base;
typedef typename Range::const_iterator Iterator;
/// \cond SKIP_IN_MANUAL
typedef Classifier<PointRange, PointMap> Base;
typedef typename PointRange::const_iterator Iterator;
using Base::m_input;
using Base::m_item_map;
/// \endcond
typedef Classification::Planimetric_grid
<Kernel, Range, PointMap> Planimetric_grid;
<Geom_traits, PointRange, PointMap> Planimetric_grid;
typedef Classification::Point_set_neighborhood
<Kernel, Range, PointMap> Neighborhood;
<Geom_traits, PointRange, PointMap> Neighborhood;
typedef Classification::Local_eigen_analysis
<Kernel, Range, PointMap, DiagonalizeTraits> Local_eigen_analysis;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Local_eigen_analysis;
/// \cond SKIP_IN_MANUAL
typedef Classification::Attribute_handle Attribute_handle;
typedef Classification::Type Type;
typedef Classification::Type_handle Type_handle;
/// \cond SKIP_IN_MANUAL
typedef typename Kernel::Point_3 Point;
typedef typename Geom_traits::Point_3 Point;
typedef Classification::Attribute::Anisotropy
<Kernel, Range, PointMap, DiagonalizeTraits> Anisotropy;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Anisotropy;
typedef Classification::Attribute::Distance_to_plane
<Kernel, Range, PointMap, DiagonalizeTraits> Distance_to_plane;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Distance_to_plane;
typedef Classification::Attribute::Eigentropy
<Kernel, Range, PointMap, DiagonalizeTraits> Eigentropy;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Eigentropy;
typedef Classification::Attribute::Elevation
<Kernel, Range, PointMap> Elevation;
<Geom_traits, PointRange, PointMap> Elevation;
typedef Classification::Attribute::Linearity
<Kernel, Range, PointMap, DiagonalizeTraits> Linearity;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Linearity;
typedef Classification::Attribute::Omnivariance
<Kernel, Range, PointMap, DiagonalizeTraits> Omnivariance;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Omnivariance;
typedef Classification::Attribute::Planarity
<Kernel, Range, PointMap, DiagonalizeTraits> Planarity;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Planarity;
typedef Classification::Attribute::Sphericity
<Kernel, Range, PointMap, DiagonalizeTraits> Sphericity;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Sphericity;
typedef Classification::Attribute::Sum_eigenvalues
<Kernel, Range, PointMap, DiagonalizeTraits> Sum_eigen;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Sum_eigen;
typedef Classification::Attribute::Surface_variation
<Kernel, Range, PointMap, DiagonalizeTraits> Surface_variation;
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Surface_variation;
typedef Classification::Attribute::Vertical_dispersion
<Kernel, Range, PointMap> Dispersion;
<Geom_traits, PointRange, PointMap> Dispersion;
typedef Classification::Attribute::Verticality
<Kernel, Range, PointMap, DiagonalizeTraits> Verticality;
/// \endcond
<Geom_traits, PointRange, PointMap, DiagonalizeTraits> Verticality;
typedef typename Classification::RGB_Color RGB_Color;
/// \endcond
private:
struct Scale
@ -135,7 +136,7 @@ private:
double voxel_size;
std::vector<Attribute_handle> attributes;
Scale (const Range& input, PointMap point_map,
Scale (const PointRange& input, PointMap point_map,
const Iso_cuboid_3& bbox, double voxel_size)
: voxel_size (voxel_size)
{
@ -199,7 +200,7 @@ public:
\param point_map property map to access the input points.
*/
Point_set_classifier(const Range& input, PointMap point_map) : Base (input, point_map)
Point_set_classifier(const PointRange& input, PointMap point_map) : Base (input, point_map)
{
m_bbox = CGAL::bounding_box
(boost::make_transform_iterator (m_input.begin(), CGAL::Property_map_to_unary_function<PointMap>(m_item_map)),
@ -222,8 +223,8 @@ public:
/*!
\brief Generate all possible attributes from an input range.
The smallest scale is automatically estimated and the data
structures needed (`Neighborhood`, `Planimetric_grid` and
The size of the smallest scale is automatically estimated and the
data structures needed (`Neighborhood`, `Planimetric_grid` and
`Local_eigen_analysis`) are computed at `nb_scales` recursively
larger scales. At each scale, the following attributes are
generated:
@ -238,13 +239,13 @@ public:
- `CGAL::Classification::Attribute::Sphericity`
- `CGAL::Classification::Attribute::Sum_eigenvalues`
- `CGAL::Classification::Attribute::Surface_variation`
- `CGAL::Classification::Attribute::Vertical_dispersion`
- `CGAL::Classification::Attribute::Vertical_dispersion` based on eigenvalues
If normal vectors are provided (if `VectorMap` is different from
`CGAL::Default`), the following attribute is generated at each
scale:
- `CGAL::Classification::Attribute::Vertical_dispersion`
- `CGAL::Classification::Attribute::Vertical_dispersion` based on normal vectors
If colors are provided (if `ColorMap` is different from
`CGAL::Default`), the following attributes are generated at each
@ -268,9 +269,15 @@ public:
- `CGAL::Classification::Attribute::Echo_scatter`
\tparam VectorMap model of `ReadablePropertyMap` with value type `Vector_3<Kernel>`.
\tparam ColorMap model of `ReadablePropertyMap` with value type `CGAL::Classification::RGB_Color`.
\tparam EchoMap model of `ReadablePropertyMap` with value type `std::size_t`.
\tparam VectorMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`Geom_traits::Vector_3`.
\tparam ColorMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`CGAL::Classification::RGB_Color`.
\tparam EchoMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`std::size_t`.
\param nb_scales number of scales to compute.
\param normal_map property map to access the normal vectors of the input points (if any).
\param color_map property map to access the colors of the input points (if any).
@ -284,7 +291,7 @@ public:
ColorMap color_map = ColorMap(),
EchoMap echo_map = EchoMap())
{
typedef typename Default::Get<VectorMap, typename Kernel::Vector_3 >::type
typedef typename Default::Get<VectorMap, typename Geom_traits::Vector_3 >::type
Vmap;
typedef typename Default::Get<ColorMap, RGB_Color >::type
Cmap;
@ -328,21 +335,34 @@ public:
*/
const Local_eigen_analysis& eigen(std::size_t scale = 0) const { return *(m_scales[scale]->eigen); }
/*!
\brief Returns the grid resolution at scale `scale`.
\brief Returns the number of scales that were computed.
*/
std::size_t number_of_scales() const { return m_scales.size(); }
/*!
\brief Returns the grid resolution at scale `scale`. This
resolution is the length and width of a cell of the
`Planimetric_grid` defined at this scale.
\note `generate_attributes()` must have been called before calling
this method.
*/
double grid_resolution(std::size_t scale = 0) const { return m_scales[scale]->grid_resolution(); }
/*!
\brief Returns the radius used for neighborhood queries at scale `scale`.
\brief Returns the radius used for neighborhood queries at scale
`scale`. This radius is the smallest radius that is relevant from
a geometric point of view at this scale (that is to say that
encloses a few cells of `Planimetric_grid`).
\note `generate_attributes()` must have been called before calling
this method.
*/
double 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`.
\brief Returns the radius used for digital terrain modeling at
scale `scale`. This radius represents the minimum size of a
building at this scale.
\note `generate_attributes()` must have been called before calling
this method.
@ -421,7 +441,7 @@ public:
std::cerr << "Normal based attributes computed in " << t.time() << " second(s)" << std::endl;
}
void generate_normal_based_attributes(const CGAL::Default_property_map<Iterator, typename Kernel::Vector_3>&)
void generate_normal_based_attributes(const CGAL::Default_property_map<Iterator, typename Geom_traits::Vector_3>&)
{
CGAL::Timer t; t.start();
generate_multiscale_attribute_variant_0<Verticality> ();
@ -431,7 +451,7 @@ public:
void generate_color_based_attributes(ColorMap color_map)
{
typedef Classification::Attribute::Hsv<Kernel, Range, ColorMap> Hsv;
typedef Classification::Attribute::Hsv<Geom_traits, PointRange, ColorMap> Hsv;
CGAL::Timer t; t.start();
for (std::size_t i = 0; i <= 8; ++ i)
{
@ -459,7 +479,7 @@ public:
template <typename EchoMap>
void generate_echo_based_attributes(EchoMap echo_map)
{
typedef Classification::Attribute::Echo_scatter<Kernel, Range, PointMap, EchoMap> Echo_scatter;
typedef Classification::Attribute::Echo_scatter<Geom_traits, PointRange, PointMap, EchoMap> Echo_scatter;
CGAL::Timer t; t.start();
for (std::size_t i = 0; i < m_scales.size(); ++ i)
{
@ -510,9 +530,9 @@ public:
This allows to easily save and recover a specific classification
configuration, that is to say:
- The computed scales
- The size of the smallest scale
- The attributes and their respective weights
- The classification types and the effect the attributes have on them
- The classification types and the effects of the attributes on them
The output file is written in an XML format that is readable by
the `load_configuration()` method.
@ -582,9 +602,15 @@ public:
The input file should be in the XML format written by the
`save_configuration()` method.
\tparam VectorMap model of `ReadablePropertyMap` with value type `Vector_3<Kernel>`.
\tparam ColorMap model of `ReadablePropertyMap` with value type `CGAL::Classification::RGB_Color`.
\tparam EchoMap model of `ReadablePropertyMap` with value type `std::size_t`.
\tparam VectorMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`Geom_traits::Vector_3`.
\tparam ColorMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`CGAL::Classification::RGB_Color`.
\tparam EchoMap model of `ReadablePropertyMap` whose key type is
the value type of the iterator of `PointRange` and value type is
`std::size_t`.
\param input input stream.
\param normal_map property map to access the normal vectors of the input points (if any).
\param color_map property map to access the colors of the input points (if any).
@ -598,7 +624,7 @@ public:
ColorMap color_map = ColorMap(),
EchoMap echo_map = EchoMap())
{
typedef typename Default::Get<VectorMap, typename Kernel::Vector_3 >::type
typedef typename Default::Get<VectorMap, typename Geom_traits::Vector_3 >::type
Vmap;
typedef typename Default::Get<ColorMap, RGB_Color >::type
Cmap;
@ -615,11 +641,11 @@ public:
/*!
\brief Writes a classification in a colored and labeled PLY format
in the stream `output`.
\brief Writes the classified point set in a colored and labeled
PLY format in the stream `output`.
The input point set is written in a PLY format with the addition
of several PLY properties:
The input points are written in a PLY format with the addition of
the following PLY properties:
- a property `label` that indicates which classification type is
assigned to the point. The types are indexed from 0 to N (the
@ -773,8 +799,8 @@ private:
ColorMap color_map,
EchoMap echo_map)
{
typedef Classification::Attribute::Echo_scatter<Kernel, Range, PointMap, EchoMap> Echo_scatter;
typedef Classification::Attribute::Hsv<Kernel, Range, ColorMap> Hsv;
typedef Classification::Attribute::Echo_scatter<Geom_traits, PointRange, PointMap, EchoMap> Echo_scatter;
typedef Classification::Attribute::Hsv<Geom_traits, PointRange, ColorMap> Hsv;
clear();
@ -842,7 +868,7 @@ private:
else if (id == "verticality")
{
if (boost::is_convertible<VectorMap,
typename CGAL::Default_property_map<Iterator, typename Kernel::Vector_3> >::value)
typename CGAL::Default_property_map<Iterator, typename Geom_traits::Vector_3> >::value)
this->template add_attribute<Verticality>(*(m_scales[scale]->eigen));
else
this->template add_attribute<Verticality>(normal_map);