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)