IntegralInvariantNormalVectorEstimator.h

 
#pragma once
 
#if defined(IntegralInvariantNormalVectorEstimator_RECURSES)
#error Recursive header files inclusion detected in IntegralInvariantNormalVectorEstimator.h
#else // defined(IntegralInvariantNormalVectorEstimator_RECURSES)
#define IntegralInvariantNormalVectorEstimator_RECURSES
 
#if !defined IntegralInvariantNormalVectorEstimator_h
#define IntegralInvariantNormalVectorEstimator_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
 
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/BasicPointFunctors.h"
#include "DGtal/topology/CCellFunctor.h"
#include "DGtal/topology/CCellularGridSpaceND.h"
#include "DGtal/geometry/surfaces/FunctorOnCells.h"
 
#include "DGtal/shapes/GaussDigitizer.h"
#include "DGtal/shapes/Shapes.h"
 
#include "DGtal/geometry/surfaces/DigitalSurfaceConvolver.h"
#include "DGtal/shapes/EuclideanShapesDecorator.h"
 
#include "DGtal/shapes/implicit/ImplicitBall.h"
 
 
namespace DGtal
{
 
namespace deprecated
{
 
// template class IntegralInvariantNormalVectorEstimator
template <typename TKSpace, typename TPointPredicate>
class IntegralInvariantNormalVectorEstimator
{
public:
  typedef IntegralInvariantNormalVectorEstimator< TKSpace, TPointPredicate> Self;
  typedef TKSpace KSpace;
  typedef TPointPredicate PointPredicate;
 
  BOOST_CONCEPT_ASSERT (( concepts::CCellularGridSpaceND< KSpace > ));
  BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate > ));
 
  typedef typename KSpace::Space Space;
  typedef HyperRectDomain<Space> Domain;
  typedef typename Space::Point Point;
  typedef typename Space::RealPoint RealPoint;
  typedef typename Space::RealVector RealVector;
  typedef typename DigitalSetSelector<Domain,  BIG_DS + HIGH_VAR_DS>::Type DigitalSet;
  typedef typename KSpace::SCell Spel;
  typedef typename KSpace::Surfel Surfel;
  typedef typename KSpace::SurfelSet SurfelSet;
  typedef typename SurfelSet::const_iterator ConstIteratorKernel;
 
  typedef RealVector Quantity;
  typedef int Value;
 
  typedef PointFunctorFromPointPredicateAndDomain< PointPredicate, Domain, unsigned int > ShapePointFunctor;
  typedef FunctorOnCells< ShapePointFunctor, KSpace > ShapeSpelFunctor;
 
 
  typedef functors::ConstValueCell<Value, Spel> KernelSpelFunctor;
  typedef ImplicitBall<Space> KernelSupport;
  typedef EuclideanShapesMinus< KernelSupport, KernelSupport > EuclideanMinus;
  typedef GaussDigitizer< Space, KernelSupport > DigitalShapeKernel;
  typedef GaussDigitizer< Space, EuclideanMinus > DigitalShape;
 
  typedef DigitalSurfaceConvolver<ShapeSpelFunctor, KernelSpelFunctor, 
                                  KSpace, DigitalShapeKernel> Convolver;
  typedef typename Convolver::PairIterators PairIterators;
  typedef typename Convolver::CovarianceMatrix Matrix;
  typedef typename Matrix::Component Component;
  typedef double Scalar;
  BOOST_CONCEPT_ASSERT (( concepts::CCellFunctor< ShapeSpelFunctor > ));
 
  struct CovarianceMatrix2NormalDirectionFunctor {
    typedef Matrix Argument;
    typedef Quantity Value;
    typedef CovarianceMatrix2NormalDirectionFunctor Self;
    CovarianceMatrix2NormalDirectionFunctor() {}
    CovarianceMatrix2NormalDirectionFunctor( const Self& /* other */ ) {}
    Self& operator=( const Self& /* other */ ) { return *this; }
    Value operator()( const Argument& arg ) const
    {
      EigenDecomposition<Space::dimension, Component>
        ::getEigenDecomposition( arg, eigenVectors, eigenValues );
      return eigenVectors.column( 0 ); // normal vector is associated to smallest eigenvalue.      
    }
    mutable Matrix eigenVectors;
    mutable RealVector eigenValues;
  };
 
  // ----------------------- Standard services ------------------------------
public:
 
  IntegralInvariantNormalVectorEstimator();
 
  IntegralInvariantNormalVectorEstimator ( ConstAlias< KSpace > K, 
                                           ConstAlias< PointPredicate > aPointPredicate );
 
  ~IntegralInvariantNormalVectorEstimator();
 
  IntegralInvariantNormalVectorEstimator ( const Self& other );
 
  Self& operator= ( const Self& other );
 
  void clear();
 
  // ----------------------- Interface --------------------------------------
public:
 
  Scalar h() const;
 
  void attach( ConstAlias< KSpace > K, 
               ConstAlias<PointPredicate> aPointPredicate );
 
  void setParams( const double dRadius );
  
  template <typename SurfelConstIterator>
  void init( const double _h, SurfelConstIterator itb, SurfelConstIterator ite );
 
  template< typename SurfelConstIterator >
  Quantity eval ( SurfelConstIterator it ) const;
 
 
  template <typename OutputIterator, typename SurfelConstIterator>
  OutputIterator eval( SurfelConstIterator itb,
                       SurfelConstIterator ite,
                       OutputIterator result ) const;
 
  void selfDisplay ( std::ostream & out ) const;
 
  bool isValid() const;
 
  // ------------------------- Private Datas --------------------------------
private:
 
  const KernelSpelFunctor myKernelFunctor;  
  std::vector< PairIterators > myKernels;   
  std::vector< DigitalSet * > myKernelsSet; 
  CountedPtr<KernelSupport>      myKernel;      
  CountedPtr<DigitalShapeKernel> myDigKernel;   
  CountedConstPtrOrConstPtr<PointPredicate> myPointPredicate; 
  CountedPtr<Domain>             myShapeDomain; 
  CountedPtr<ShapePointFunctor>  myShapePointFunctor; 
  CountedPtr<ShapeSpelFunctor>   myShapeSpelFunctor;  
  CountedPtr<Convolver>          myConvolver;   
  Scalar myH;                               
  Scalar myRadius;                          
 
private:
 
 
}; // end of class IntegralInvariantNormalVectorEstimator
 
} // namespace deprecated
 
  template <typename TKSpace, typename TPointPredicate>
  std::ostream&
  operator<< ( std::ostream & out, 
               const DGtal::deprecated::IntegralInvariantNormalVectorEstimator<TKSpace, TPointPredicate> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/IntegralInvariantNormalVectorEstimator.ih"
 
//                                                                           //
 
#endif // !defined IntegralInvariantNormalVectorEstimator_h
 
#undef IntegralInvariantNormalVectorEstimator_RECURSES
#endif // else defined(IntegralInvariantNormalVectorEstimator_RECURSES)