VoronoiCovarianceMeasureOnDigitalSurface.h

 
#pragma once
 
#if defined(VoronoiCovarianceMeasureOnDigitalSurface_RECURSES)
#error Recursive header files inclusion detected in VoronoiCovarianceMeasureOnDigitalSurface.h
#else // defined(VoronoiCovarianceMeasureOnDigitalSurface_RECURSES)
 
#define VoronoiCovarianceMeasureOnDigitalSurface_RECURSES
 
#if !defined VoronoiCovarianceMeasureOnDigitalSurface_h
 
#define VoronoiCovarianceMeasureOnDigitalSurface_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedConstPtrOrConstPtr.h"
#include "DGtal/kernel/Point2ScalarFunctors.h"
#include "DGtal/math/linalg/EigenDecomposition.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
#include "DGtal/topology/DigitalSurface.h"
#include "DGtal/geometry/volumes/distance/CSeparableMetric.h"
#include "DGtal/geometry/volumes/estimation/VoronoiCovarianceMeasure.h"
 
namespace DGtal
{
 
  enum Surfel2PointEmbedding { Pointels = 0, InnerSpel = 1, OuterSpel = 2 };
 
  // template class VoronoiCovarianceMeasureOnDigitalSurface
  template <typename TDigitalSurfaceContainer, typename TSeparableMetric,
            typename TKernelFunction>
  class VoronoiCovarianceMeasureOnDigitalSurface
  {
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer< TDigitalSurfaceContainer > ));
    BOOST_CONCEPT_ASSERT(( concepts::CSeparableMetric<TSeparableMetric> ));
    // ----------------------- public types ------------------------------
  public:
    typedef TDigitalSurfaceContainer DigitalSurfaceContainer; 
    typedef TSeparableMetric                         Metric;  
    typedef TKernelFunction                  KernelFunction;  
    typedef DigitalSurface<DigitalSurfaceContainer> Surface;  
    typedef typename DigitalSurfaceContainer::KSpace KSpace;  
    typedef typename DigitalSurfaceContainer::Surfel Surfel;  
    typedef typename KSpace::SCell                    SCell;  
    typedef typename KSpace::Space                    Space;  
    typedef typename KSpace::Point                    Point;  
    typedef VoronoiCovarianceMeasure<Space,Metric>      VCM;  
    typedef typename VCM::Scalar                     Scalar;  
    typedef typename Surface::ConstIterator   ConstIterator;  
    typedef EigenDecomposition<KSpace::dimension,Scalar> LinearAlgebraTool;  
    typedef typename VCM::VectorN                   VectorN;  
    typedef typename VCM::MatrixNN                 MatrixNN;  
 
    BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor<KernelFunction, Point, Scalar> ));
 
    struct EigenStructure {
      VectorN values;   
      MatrixNN vectors; 
    };
    struct Normals {
      VectorN vcmNormal;
      VectorN trivialNormal;
    };
    typedef std::map<Point,EigenStructure> Point2EigenStructure;  
    typedef std::map<Surfel,Normals>           Surfel2Normals;    
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~VoronoiCovarianceMeasureOnDigitalSurface();
 
    VoronoiCovarianceMeasureOnDigitalSurface( ConstAlias< Surface > _surface, 
                                              Surfel2PointEmbedding _surfelEmbedding,
                                              Scalar _R, Scalar _r, 
                                              KernelFunction chi_r,
                                              Scalar t = 2.5, Metric aMetric = Metric(), 
                                              bool verbose = false );
 
    CountedConstPtrOrConstPtr< Surface > surface() const;
    Surfel2PointEmbedding surfelEmbedding() const;
    Scalar R() const;
    Scalar r() const;
 
    Scalar radiusTrivial() const;
 
    template <typename PointOutputIterator>
    PointOutputIterator getPoints( PointOutputIterator outIt, Surfel s ) const; 
 
    const Surfel2Normals& mapSurfel2Normals() const;
 
    const Point2EigenStructure& mapPoint2ChiVCM() const;
 
    bool getChiVCMEigenvalues( VectorN& values, Surfel s ) const;
 
    bool getChiVCMEigenStructure( VectorN& values, MatrixNN& vectors, Surfel s ) const;
 
    // ----------------------- Interface --------------------------------------
  public:
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
    CountedConstPtrOrConstPtr< Surface > mySurface;
    Surfel2PointEmbedding mySurfelEmbedding;
    KernelFunction myChi;
    VCM myVCM;
    Scalar myRadiusTrivial;
    Point2EigenStructure myPt2EigenStructure;
    Surfel2Normals mySurfel2Normals;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    VoronoiCovarianceMeasureOnDigitalSurface();
 
  private:
 
    VoronoiCovarianceMeasureOnDigitalSurface ( const VoronoiCovarianceMeasureOnDigitalSurface & other );
 
    VoronoiCovarianceMeasureOnDigitalSurface & operator= ( const VoronoiCovarianceMeasureOnDigitalSurface & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class VoronoiCovarianceMeasureOnDigitalSurface
 
 
  template <typename TDigitalSurfaceContainer, typename TSeparableMetric, typename TKernelFunction>
  std::ostream&
  operator<< ( std::ostream & out, 
               const VoronoiCovarianceMeasureOnDigitalSurface<TDigitalSurfaceContainer, TSeparableMetric, TKernelFunction> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/VoronoiCovarianceMeasureOnDigitalSurface.ih"
 
//                                                                           //
 
#endif // !defined VoronoiCovarianceMeasureOnDigitalSurface_h
 
#undef VoronoiCovarianceMeasureOnDigitalSurface_RECURSES
#endif // else defined(VoronoiCovarianceMeasureOnDigitalSurface_RECURSES)