SphericalAccumulator.h

 
#pragma once
 
#if defined(SphericalAccumulator_RECURSES)
#error Recursive header files inclusion detected in SphericalAccumulator.h
#else // defined(SphericalAccumulator_RECURSES)
#define SphericalAccumulator_RECURSES
 
#if !defined SphericalAccumulator_h
#define SphericalAccumulator_h
 
// Inclusions
#include <iostream>
#include <algorithm>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/NumberTraits.h"
 
namespace DGtal
{
 
  // template class SphericalAccumulator
  template <typename TVector>
  class SphericalAccumulator
  {
    // ----------------------- Standard services ------------------------------
  public:
 
    typedef TVector Vector;
 
    typedef DGtal::int32_t Quantity;
 
    typedef size_t Size;
 
    typedef std::vector<Quantity>::const_iterator  ConstIterator;
 
    typedef PointVector<3,double>  RealVector;
 
    BOOST_STATIC_ASSERT( Vector::dimension == 3);
 
    SphericalAccumulator(const Size aNphi);
 
    ~SphericalAccumulator();
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void addDirection(const Vector &aDir);
 
    void binCoordinates(const Vector &aDir,
                        Size &posPhi,
                        Size &posTheta) const;
 
    Quantity count( const Size &posPhi,
                    const Size &posTheta) const;
 
 
    Vector representativeDirection(const Size &posPhi,
                                   const Size &posTheta) const;
 
    Vector representativeDirection(ConstIterator &it) const;
 
 
    Quantity samples() const;
 
    Quantity binNumber() const { return myBinNumber;}
 
 
    void maxCountBin(Size &posPhi, Size &posTheta) const;
 
    void clear();
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    std::string className() const
    {
      return "SphericalAccumulator";
    }
 
 
    bool isValidBin(const Size &posPhi,
                    const Size &posTheta) const;
 
 
    void getBinGeometry(const Size &posPhi,
                        const Size &posTheta,
                        RealVector &a,
                        RealVector &b,
                        RealVector &c,
                        RealVector &d) const;
 
    RealVector getBinDirection(const Size &posPhi,
                               const Size &posTheta) const;
 
    // ------------------------- Iterators ------------------------------
 
    ConstIterator begin() const
    {
      return myAccumulator.begin();
    }
 
    ConstIterator end() const
    {
      return myAccumulator.end();
    }
 
 
    void binCoordinates(ConstIterator &aDir,
                        Size &posPhi,
                        Size &posTheta) const;
 
    
    SphericalAccumulator ( const SphericalAccumulator & other )
    {
      myNphi = other.myNphi;
      myNtheta = other.myNtheta;
      myAccumulator = other.myAccumulator;
      myAccumulatorDir = other.myAccumulatorDir;
      myTotal = other.myTotal;
      myBinNumber = other.myBinNumber;
      myMaxBinPhi = other.myMaxBinPhi;
      myMaxBinTheta = other.myMaxBinTheta;
    }
 
    SphericalAccumulator & operator= ( const SphericalAccumulator & other )
    {
      if (this!=other)
      {
        myNphi = other.myNphi;
        myNtheta = other.myNtheta;
        myAccumulator = other.myAccumulator;
        myAccumulatorDir = other.myAccumulatorDir;
        myTotal = other.myTotal;
        myBinNumber = other.myBinNumber;
        myMaxBinPhi = other.myMaxBinPhi;
        myMaxBinTheta = other.myMaxBinTheta; 
      }
      return *this;
    }
    
 
    
    // ------------------------- Private Datas --------------------------------
  private:
 
    Size myNphi;
 
    Size myNtheta;
 
    std::vector<Quantity> myAccumulator;
 
    std::vector<Vector> myAccumulatorDir;
 
    Quantity myTotal;
 
    Quantity myBinNumber;
 
    Size myMaxBinPhi;
 
    Size myMaxBinTheta;
 
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    SphericalAccumulator();
 
  private:
 
        // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class SphericalAccumulator
 
 
  template <typename T>
  std::ostream&
  operator<< ( std::ostream & out, const SphericalAccumulator<T> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/tools//SphericalAccumulator.ih"
 
//                                                                           //
 
#endif // !defined SphericalAccumulator_h
 
#undef SphericalAccumulator_RECURSES
#endif // else defined(SphericalAccumulator_RECURSES)