IntegralInvariantVolumeEstimator.h

 
#pragma once
 
#if defined(IntegralInvariantVolumeEstimator_RECURSES)
#error Recursive header files inclusion detected in IntegralInvariantVolumeEstimator.h
#else // defined(IntegralInvariantVolumeEstimator_RECURSES)
 
#define IntegralInvariantVolumeEstimator_RECURSES
 
#if !defined IntegralInvariantVolumeEstimator_h
 
#define IntegralInvariantVolumeEstimator_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
 
#include "DGtal/kernel/BasicPointFunctors.h"
#include "DGtal/kernel/CPointPredicate.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/geometry/surfaces/estimation/IIGeometricFunctors.h"
#include "DGtal/shapes/EuclideanShapesDecorator.h"
 
#include "DGtal/shapes/implicit/ImplicitBall.h"
 
 
namespace DGtal
{
 
// template class IntegralInvariantVolumeEstimator
template <typename TKSpace, typename TPointPredicate, typename TVolumeFunctor>
class IntegralInvariantVolumeEstimator
{
public:
  typedef IntegralInvariantVolumeEstimator< TKSpace, TPointPredicate, TVolumeFunctor> Self;
  typedef TKSpace KSpace;
  typedef TPointPredicate PointPredicate;
  typedef TVolumeFunctor VolumeFunctor;
 
  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 typename VolumeFunctor::Quantity Quantity;
  typedef int Value;
 
  typedef functors::PointFunctorFromPointPredicateAndDomain< PointPredicate, Domain, unsigned int > ShapePointFunctor;
  typedef FunctorOnCells< ShapePointFunctor, KSpace > ShapeSpelFunctor;
 
 
  typedef functors::ConstValueCell<Value, Spel> KernelSpelFunctor;
  typedef ImplicitBall<Space> KernelSupport;
  typedef EuclideanShapesCSG< 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 > ));
  BOOST_CONCEPT_ASSERT (( concepts::CUnaryFunctor< VolumeFunctor, Component, Quantity > ));
  BOOST_STATIC_ASSERT (( concepts::ConceptUtils::SameType< typename Convolver::Quantity, 
                                                 typename VolumeFunctor::Argument >::value ));
 
 
  // ----------------------- Standard services ------------------------------
public:
 
  IntegralInvariantVolumeEstimator( VolumeFunctor fct = VolumeFunctor() );
 
  IntegralInvariantVolumeEstimator ( ConstAlias< KSpace > K, 
                                     ConstAlias< PointPredicate > aPointPredicate,
                                     VolumeFunctor fct = VolumeFunctor() );
 
  ~IntegralInvariantVolumeEstimator();
 
  IntegralInvariantVolumeEstimator ( 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:
 
  VolumeFunctor myFct;            
  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 IntegralInvariantVolumeEstimator
 
  template <typename TKSpace, typename TPointPredicate, typename TVolumeFunctor>
  std::ostream&
  operator<< ( std::ostream & out, 
               const IntegralInvariantVolumeEstimator<TKSpace, TPointPredicate, TVolumeFunctor> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/IntegralInvariantVolumeEstimator.ih"
 
//                                                                           //
 
#endif // !defined IntegralInvariantVolumeEstimator_h
 
#undef IntegralInvariantVolumeEstimator_RECURSES
#endif // else defined(IntegralInvariantVolumeEstimator_RECURSES)