Aim: This functor estimates normal vector for a collection of surfels using spherical accumulator based Hough voting. More...

#include <DGtal/geometry/surfaces/estimation/estimationFunctors/SphericalHoughNormalVectorEstimator.h>

Public Types
typedef TSurfel	Surfel
typedef TEmbedder	SCellEmbedder
typedef SCellEmbedder::RealPoint	RealPoint
typedef RealPoint	Quantity
typedef SimpleMatrix< double, 3, 3 >	Matrix

Public Member Functions
	SphericalHoughNormalVectorEstimator (ConstAlias< SCellEmbedder > anEmbedder, const double h, const double minimalAspectRatio=0.001, const unsigned int nbTrials=100, const unsigned int accumulatorSize=10, const unsigned int nbAccumulators=5)
	SphericalHoughNormalVectorEstimator ()=delete
void	pushSurfel (const Surfel &aSurf, const double aDistance)
Quantity	eval ()
void	reset ()

Private Member Functions
Matrix	randomRotation () const
Quantity	getNormal (const unsigned int i, const unsigned int j, const unsigned int k, double &aspect) const

Private Attributes
const SCellEmbedder *	myEmbedder
	Alias of the geometrical embedder.
const double	myH
	Grid step.
const double	myAspectRatio
	Minimal aspect ratio (norm of the cross-product) to consider a given triangle.
const unsigned int	myNbTrials
	Number of trials in the neignborhood.
const unsigned int	mySize
	Size of the accumulator.
const unsigned int	myNbAccumulators
	Number of randomly shifted spherical accumulators to consider.
std::vector< RealPoint >	myPoints
	vector of embedded surfels
std::vector< SphericalAccumulator< RealPoint > >	myAccumulators
	Spherical Accumulators.
std::vector< Matrix >	myRotations
	Random rotations.
std::vector< Matrix >	myInverseRotations
	Random inverse rotations.

Detailed Description

template<typename TSurfel, typename TEmbedder>
class DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >

Aim: This functor estimates normal vector for a collection of surfels using spherical accumulator based Hough voting.

Description of template class 'SphericalHoughNormalVectorEstimator'

This functors implements [16] algorithm:

we first collect the surfels using the pushSurfel method;
we select random triples of surfels and estimate the normal vectors of the associated triangles;
each normal vector is added to a spherical accumulator (see SphericalAccumulator);
the estimated normal vector is computed from normal vectors of the bin of the accumulator with maximal vote.

To avoid aliasing artefacts of the spherical accumulator, several randomly rotated accumulators are used.

Given a random triple of surfels, a threshold on the triangle aspect ratio can be specified to discard bad aspect triangles (e.g. thin ones).

This functor is a model of concepts::CLocalEstimatorFromSurfelFunctor

Template Parameters

TSurfel	type of surfels
TEmbedder	type of functors which embed surfel to \( \mathbb{R}^3\)

Definition at line 84 of file SphericalHoughNormalVectorEstimator.h.

Member Typedef Documentation

◆ Matrix

template<typename TSurfel, typename TEmbedder>

typedef SimpleMatrix<double,3,3> DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::Matrix

Definition at line 92 of file SphericalHoughNormalVectorEstimator.h.

◆ Quantity

template<typename TSurfel, typename TEmbedder>

typedef RealPoint DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::Quantity

Definition at line 91 of file SphericalHoughNormalVectorEstimator.h.

◆ RealPoint

template<typename TSurfel, typename TEmbedder>

typedef SCellEmbedder::RealPoint DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::RealPoint

Definition at line 90 of file SphericalHoughNormalVectorEstimator.h.

◆ SCellEmbedder

template<typename TSurfel, typename TEmbedder>

typedef TEmbedder DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::SCellEmbedder

Definition at line 89 of file SphericalHoughNormalVectorEstimator.h.

◆ Surfel

template<typename TSurfel, typename TEmbedder>

typedef TSurfel DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::Surfel

Definition at line 88 of file SphericalHoughNormalVectorEstimator.h.

Constructor & Destructor Documentation

◆ SphericalHoughNormalVectorEstimator() [1/2]

template<typename TSurfel, typename TEmbedder>

DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::SphericalHoughNormalVectorEstimator	(	ConstAlias< SCellEmbedder >	anEmbedder,
		const double	h,
		const double	minimalAspectRatio = 0.001,
		const unsigned int	nbTrials = 100,
		const unsigned int	accumulatorSize = 10,
		const unsigned int	nbAccumulators = 5 )

inline

Constructor.

Parameters

[in]	anEmbedder	embedder to map surfel to R^n.
[in]	h	grid step
[in]	minimalAspectRatio	the minimal aspect ratio of triangles to be considered in the accumulator (default=0.001).
[in]	nbTrials	number of random triangles in the neighborhood to consider (default=100).
[in]	accumulatorSize	size of the spherical accumulators (see SphericalAccumulator, default=10).
[in]	nbAccumulators	number of randomly rotated spherical accumulators to consider in order to avoid aliasing artefacts. (default=5)

Definition at line 104 of file SphericalHoughNormalVectorEstimator.h.

                                                                                 :
      myEmbedder(&anEmbedder),myH(h), myAspectRatio(minimalAspectRatio),
      myNbTrials( nbTrials), mySize(accumulatorSize) , myNbAccumulators(nbAccumulators)
      {
        SphericalAccumulator<RealPoint> accum(mySize);
        
        //We precompute the random rotations and accumulators
        for(auto i = 0u; i < myNbAccumulators; ++i)
        {
          Matrix m = randomRotation();
          myAccumulators.push_back( accum );
          myRotations.push_back( m );
          myInverseRotations.push_back( m.inverse() );
        }
      }

References DGtal::SimpleMatrix< TComponent, TM, TN >::inverse(), myAccumulators, myAspectRatio, myEmbedder, myH, myInverseRotations, myNbAccumulators, myNbTrials, myRotations, mySize, and randomRotation().

◆ SphericalHoughNormalVectorEstimator() [2/2]

template<typename TSurfel, typename TEmbedder>

DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::SphericalHoughNormalVectorEstimator ( )

delete

Disable default constructor.

Member Function Documentation

◆ eval()

template<typename TSurfel, typename TEmbedder>

Quantity DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::eval ( )

inline

Estimate normal vector using spherical accumulator voting.

Returns: the feature score

Definition at line 152 of file SphericalHoughNormalVectorEstimator.h.

      {
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0,
                                                        static_cast<int>(myPoints.size()) - 1 );
        double aspect;
        
        for(auto t = 0u; t < myNbTrials ; ++t)
        {
          unsigned int i,j,k;
          
          //We pick 3 distinct point indices.
          i = distribution(generator);
          j = distribution(generator);
          while ( (j = distribution(generator)) == i);
          while (( (k = distribution(generator)) == i) || (k == j) );
          
          RealPoint vector = getNormal(i,j,k,aspect);
          if ((vector.norm() > 0.00001) && (aspect > myAspectRatio))
          {
            //we have an admissible triangle, we push both normal vectors
            for(auto acc = 0u; acc < myNbAccumulators; ++acc)
            {
              RealPoint shifted = myRotations[acc]*vector;
              myAccumulators[acc].addDirection( shifted );
              myAccumulators[acc].addDirection( -shifted );
            }
          }
        }
        //We return the max bin orientation summing up all accumulators vote
        typename SphericalAccumulator<RealPoint>::Size posPhi,posTheta;
        RealPoint vote;
        for(auto acc = 0u; acc < myNbAccumulators; ++acc)
        {
          myAccumulators[acc].maxCountBin(posPhi, posTheta);
          RealPoint dir = myInverseRotations[acc]*myAccumulators[acc].representativeDirection(posPhi, posTheta).getNormalized() ;
          
          //We only consider z-oriented normals (since we pushed vector and -vector)
          if ( dir.dot(RealPoint(0,0,1)) > 0.0 )
          vote += dir;
          else
          vote += -dir;
        }
        return vote.getNormalized();
      }

References getNormal(), myAccumulators, myAspectRatio, myInverseRotations, myNbAccumulators, myNbTrials, myPoints, and myRotations.

◆ getNormal()

template<typename TSurfel, typename TEmbedder>

Quantity DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::getNormal	(	const unsigned int	i,
		const unsigned int	j,
		const unsigned int	k,
		double &	aspect ) const

inlineprivate

Computes the (unnormalized) normal vector of a triangle defined by triangle (i,j,k). The variable aspect returns the aspect ratio of the triangle.

Parameters

[in]	i	a first vertex index.
[in]	j	a second vertex index.
[in]	k	a third vertex index.
[out]	aspect	aspect ratio of the triangle.

Returns: a random rotation matrix.

Definition at line 268 of file SphericalHoughNormalVectorEstimator.h.

      {
        ASSERT( i < myPoints.size());
        ASSERT( j < myPoints.size());
        ASSERT( k < myPoints.size());
        
        const RealPoint v = myPoints[i] - myPoints[j];
        const RealPoint u = myPoints[i] - myPoints[k];
        const RealPoint w = myPoints[j] - myPoints[k];
        
        //aspect ratio
        const double a = u.norm() , b = v.norm();
        const double c = w.norm();
        const double s = (a+b+c)/2.0;
        double denom = (8.0*(s-a)*(s-b)*(s-c));
        if ( std::abs( denom ) <= std::abs( denom ) * 1e-6 )
          aspect = 0.;
        else
          aspect = a*b*c / denom;
 
        return v.crossProduct(u);
      }

References myPoints.

Referenced by eval().

◆ pushSurfel()

template<typename TSurfel, typename TEmbedder>

void DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::pushSurfel	(	const Surfel &	aSurf,
		const double	aDistance )

inline

Add the geometrical embedding of a surfel to the point list and update the normal spherical hough voting.

Parameters

aSurf	a surfel to add
aDistance	distance of aSurf to the neighborhood boundary (NOT USED HERE)

Definition at line 138 of file SphericalHoughNormalVectorEstimator.h.

      {
        BOOST_VERIFY(aDistance == aDistance);
        RealPoint p = myH * ( myEmbedder->operator()(aSurf) );
        myPoints.push_back(p);
      }

References myEmbedder, myH, and myPoints.

◆ randomRotation()

template<typename TSurfel, typename TEmbedder>

Matrix DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::randomRotation ( ) const

inlineprivate

Returns: a random rotation matrix.

Definition at line 215 of file SphericalHoughNormalVectorEstimator.h.

      {
        const double theta = (rand()+0.f)/RAND_MAX * 2* M_PI;
        const double phi = (rand()+0.f)/RAND_MAX * 2* M_PI;
        const  double psi = (rand()+0.f)/RAND_MAX * 2* M_PI;
        Matrix Rt;
        Rt.setComponent(0,0,1);
        Rt.setComponent(1,0,0);
        Rt.setComponent(2,0,0);
        Rt.setComponent(0,1,0);
        Rt.setComponent(1,1,cos(theta));
        Rt.setComponent(2,1,-sin(theta));
        Rt.setComponent(0,2,0);
        Rt.setComponent(1,2,sin(theta));
        Rt.setComponent(2,2,cos(theta));
        
        Matrix Rph;
        Rph.setComponent(0,0,cos(phi));
        Rph.setComponent(1,0,0);
        Rph.setComponent(2,0,sin(phi));
        Rph.setComponent(0,1,0);
        Rph.setComponent(1,1,1);
        Rph.setComponent(2,1,0);
        Rph.setComponent(0,2,-sin(phi));
        Rph.setComponent(1,2,0);
        Rph.setComponent(2,2,cos(phi));
        
        Matrix Rps;
        Rps.setComponent(0,0,cos(psi));
        Rps.setComponent(1,0,-sin(psi));
        Rps.setComponent(2,0,0);
        Rps.setComponent(0,1,sin(psi));
        Rps.setComponent(1,1,cos(psi));
        Rps.setComponent(2,1,0);
        Rps.setComponent(0,2,0);
        Rps.setComponent(1,2,0);
        Rps.setComponent(2,2,1);
        
        return Rt*Rph*Rps;
      }

References phi(), and DGtal::SimpleMatrix< TComponent, TM, TN >::setComponent().

Referenced by SphericalHoughNormalVectorEstimator().

◆ reset()

template<typename TSurfel, typename TEmbedder>

void DGtal::functors::SphericalHoughNormalVectorEstimator< TSurfel, TEmbedder >::reset ( )

inline

Reset the point list.

Definition at line 202 of file SphericalHoughNormalVectorEstimator.h.

      {
        myPoints.clear();
        //accumulators cleanup
        for(auto i = 0u; i < myNbAccumulators; ++i)
          myAccumulators[i].clear();
      }