VoronoiCovarianceMeasure.h

 
#pragma once

 
#if defined(VoronoiCovarianceMeasure_RECURSES)
#error Recursive header files inclusion detected in VoronoiCovarianceMeasure.h
#else // defined(VoronoiCovarianceMeasure_RECURSES)
#define VoronoiCovarianceMeasure_RECURSES
 
#if !defined VoronoiCovarianceMeasure_h
#define VoronoiCovarianceMeasure_h

// Inclusions
#include <cmath>
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/math/BasicMathFunctions.h"
#include "DGtal/kernel/BasicPointPredicates.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/math/linalg/SimpleMatrix.h"
#include "DGtal/kernel/Point2ScalarFunctors.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/geometry/volumes/distance/VoronoiMap.h"
#include "DGtal/geometry/tools/SpatialCubicalSubdivision.h"
 
namespace DGtal
{

  // template class VoronoiCovarianceMeasure
  template <typename TSpace, typename TSeparableMetric>
  class VoronoiCovarianceMeasure
  {
    BOOST_CONCEPT_ASSERT(( concepts::CSpace< TSpace > ));
    BOOST_CONCEPT_ASSERT(( concepts::CSeparableMetric<TSeparableMetric> ));
 
  public:
    typedef TSpace Space;                         
    typedef TSeparableMetric Metric;              
    typedef typename Space::Point Point;          
    typedef typename Space::Size Size;            
    typedef typename Space::Integer Integer;      
    typedef DGtal::HyperRectDomain<Space> Domain; 
    typedef DGtal::ImageContainerBySTLVector<Domain,bool> CharacteristicSet; 
    typedef DGtal::SpatialCubicalSubdivision<Space> ProximityStructure; 

    struct CharacteristicSetPredicate {
      typedef CharacteristicSetPredicate Self;
      typedef typename Space::Point Point;          
      CharacteristicSetPredicate() : ptrSet( 0 ) {}
      CharacteristicSetPredicate( ConstAlias<CharacteristicSet> aSet) : ptrSet( &aSet ) {}
      CharacteristicSetPredicate( const Self& other ) : ptrSet( other.ptrSet ) {}
      Self& operator=( const Self& other ) { ptrSet = other.ptrSet; return *this; }
      bool operator()( const Point& p ) const
      { 
        ASSERT( ptrSet != 0 );
        return (*ptrSet)( p );
      }
      bool operator()( const Point& p ) const {…}
    private:
      const CharacteristicSet* ptrSet;
    };
    struct CharacteristicSetPredicate {…};
    typedef DGtal::functors::NotPointPredicate<CharacteristicSetPredicate> NotPredicate; 
    typedef DGtal::VoronoiMap<Space, NotPredicate, Metric > Voronoi; 
 
    typedef double Scalar;                                    
    typedef DGtal::SimpleMatrix< Scalar,
                                 Space::dimension, 
                                 Space::dimension > MatrixNN; 
    typedef typename MatrixNN::RowVector VectorN;             
    typedef std::vector<Point> PointContainer;                
    typedef std::map<Point,MatrixNN> Point2MatrixNN;          
 
    // ----------------------- Standard services ------------------------------
  public:

    VoronoiCovarianceMeasure( double _R, double _r, Metric aMetric = Metric(), bool verbose = false );

    ~VoronoiCovarianceMeasure();

    Scalar R() const;
    Scalar r() const;
 
    void clean();

    template <typename PointInputIterator>
    void init( PointInputIterator itb, PointInputIterator ite );

    const Domain& domain() const;

    const Voronoi& voronoiMap() const;

    const Point2MatrixNN& vcmMap() const;

    template <typename Point2ScalarFunction>
    MatrixNN measure( Point2ScalarFunction chi_r, Point p ) const;
 
    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:

    double myBigR;  
    double mySmallR;  
    Metric myMetric;
    bool myVerbose;
    Domain myDomain;
    CharacteristicSet* myCharSet;
    Voronoi* myVoronoi;
    Point2MatrixNN myVCM;
    ProximityStructure* myProximityStructure;
 
    // ------------------------- Hidden services ------------------------------
  protected:

    VoronoiCovarianceMeasure();
 
  private:

    VoronoiCovarianceMeasure ( const VoronoiCovarianceMeasure & other );

    VoronoiCovarianceMeasure & operator= ( const VoronoiCovarianceMeasure & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class VoronoiCovarianceMeasure
  class VoronoiCovarianceMeasure {…};
 

  template <typename TSpace, typename TSeparableMetric>
  std::ostream&
  operator<< ( std::ostream & out, 
               const VoronoiCovarianceMeasure<TSpace, TSeparableMetric> & object );
 
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/geometry/volumes/estimation/VoronoiCovarianceMeasure.ih"
 
//                                                                           //
 
#endif // !defined VoronoiCovarianceMeasure_h
 
#undef VoronoiCovarianceMeasure_RECURSES
#endif // else defined(VoronoiCovarianceMeasure_RECURSES)