Histogram.h

 
#pragma once
 
#if defined(Histogram_RECURSES)
#error Recursive header files inclusion detected in Histogram.h
#else // defined(Histogram_RECURSES)
 
#define Histogram_RECURSES
 
#if !defined Histogram_h
 
#define Histogram_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Clone.h"
#include "DGtal/math/CBinner.h"
#include "DGtal/kernel/CEuclideanRing.h"
#include "DGtal/math/Statistic.h"
 
namespace DGtal
{
  template <typename TQuantity>
  struct RegularBinner {
    typedef TQuantity Quantity;
    typedef RegularBinner< Quantity > Self;
    typedef DGtal::uint32_t Bin;
 
    Quantity myMin; 
    Quantity myMax; 
    Bin myNb;       
    Quantity myWidth;
    RegularBinner( const Quantity & min, const Quantity & max, Bin n )
      : myMin( min ), myMax( max ), myNb( n )
    {
      ASSERT( max > min );
      ASSERT( n > 0 );
      myWidth = ( max - min ) / static_cast<Quantity>( n );
    }
 
    inline Bin size() const
    { 
      return myNb;
    }
 
    inline Bin operator()( const Quantity & q ) const
    {
      if ( q <= myMin )      return NumberTraits<Bin>::ZERO;
      else if ( q >= myMax ) return myNb - NumberTraits<Bin>::ONE;
      else return static_cast<Bin>( floor( NumberTraits<Quantity>::castToDouble( ( q - myMin ) / myWidth ) ) );
    }
  };
 
  // template class Histogram
  template < typename TQuantity,
             typename TBinner = RegularBinner< TQuantity > >
  class Histogram
  {
  public:
    BOOST_CONCEPT_ASSERT(( concepts::CEuclideanRing< TQuantity > ));
    BOOST_CONCEPT_ASSERT(( concepts::CBinner< TBinner > ));
    BOOST_STATIC_ASSERT(( boost::is_same< TQuantity, typename TBinner::Quantity >::value ));
 
    // ----------------------- public types ------------------------------
  public:
    typedef TQuantity Quantity;
    typedef TBinner Binner;
    typedef Histogram< Quantity, Binner > Self;
    typedef typename Binner::Bin Bin;
    typedef DGtal::uint64_t Size;
    typedef std::vector<Size> Container;
    typedef Container::const_iterator ConstIterator;
 
    enum Formula { SquareRoot ,
                   Sturges , 
                   Rice ,
                   Scott  };
    // ----------------------- Standard services ------------------------------
  public:
 
    ~Histogram();
 
    Histogram();
 
    void clear();
 
    void init( Clone<Binner> binner );
 
    void init( Formula formula, const Statistic<Quantity> & stat );
 
    void init( Bin nbBins, const Statistic<Quantity> & stat );
 
    void addValue( Quantity q );
 
    template <typename TInputIterator>
    void addValues( TInputIterator it, TInputIterator itE );
 
    void terminate();
 
    Bin bin( Quantity q ) const;
 
    Bin size() const;
 
    Size area() const;
 
    Size nb( Bin b ) const;
 
    Size accumulation( Bin b ) const;
 
    double pdf( Bin b ) const;
 
    double cdf( Bin b ) const;
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
    const Binner* myBinner;
    Container myHistogram;
    Container myCumulativeHistogram;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  private:
 
    Histogram ( const Histogram & other );
 
    Histogram & operator= ( const Histogram & other );
 
    // ------------------------- Internals ------------------------------------
  private:
    void prepare( Bin size );
 
 
  }; // end of class Histogram
 
 
  template <typename TQuantity, typename TBinner>
  std::ostream&
  operator<< ( std::ostream & out, const Histogram<TQuantity, TBinner> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/math/Histogram.ih"
 
//                                                                           //
 
#endif // !defined Histogram_h
 
#undef Histogram_RECURSES
#endif // else defined(Histogram_RECURSES)