coustyflowmap.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
#ifndef BIOPROCESSING_WATERSHED_COUSTYFLOWMAP
#define BIOPROCESSING_WATERSHED_COUSTYFLOWMAP
 
//--- bioprocessing ----------------------------------------------------------
#include <bioprocessing/graph/pointvertex.h>            // bio::PointVertexRef
//--- aims -------------------------------------------------------------------
#include <aims/vector/vector.h>                                      // Point*
//--- cartodata --------------------------------------------------------------
#include <cartodata/volume/volume.h>                       // carto::VolumeRef
//--- cartobase --------------------------------------------------------------
#include <cartobase/smart/rcptr.h>                            // carto::rc_ptr
#include <cartobase/smart/refwrapper.h>            // carto::reference_wrapper
//--- std --------------------------------------------------------------------
#include <map>                                                     // std::map
#include <limits>                                       // std::numeric_limits
#include <utility>                                                // std::pair
//----------------------------------------------------------------------------
 
namespace bio {
  template <typename V, typename L> class CoustyFlowMap;
  template <typename V, typename L> class CoustyFlowMapRef;
 
  //==========================================================================
  //   FLOW MAP
  //==========================================================================
  template <typename V, typename L>
  class CoustyFlowMap: public std::map<V,L>, public carto::RCObject
  {
  };
 
  //==========================================================================
  //   FLOW MAP: POINT VERTEX SPECIALIZATION
  //==========================================================================
  template <typename L>
  class CoustyFlowMap<PointVertexRef<Point4dl>,L>
  {
    //--- typedef ------------------------------------------------------------
  public:
    typedef PointVertexRef<Point4dl>     Vertex;       
 
    //--- constructor --------------------------------------------------------
  public:
    CoustyFlowMap(): _volume(), _minima() {}
    ~CoustyFlowMap() {}
 
    //--- iterator -----------------------------------------------------------
  public:
    class const_iterator;  
    class iterator;        
    const_iterator begin() const { return const_iterator(_volume,false); }
    const_iterator end() const { return const_iterator(_volume,true); }
    iterator begin() { return iterator(_volume,false); }
    iterator end() { return iterator(_volume,true); }
 
    //--- interface ----------------------------------------------------------
  public:
    template <typename Iterator>
    void init( Iterator b, Iterator e )
    {
      int j = 0;
      Iterator i;
      for( i = b; i != e; ++i )
      {
        const typename Iterator::Point & p = i->point();
        _volume( p[0], p[1], p[2], p[3] ) = labelNone();
      }
    }
    L labelNone() const
    {
      return std::numeric_limits<L>::max();
    }
    L labelMinus() const
    {
      if( std::numeric_limits<L>::min() < 0 )
        return -1;
      else
        return std::numeric_limits<L>::max() - 1;
    }
    L label( Vertex v ) const
    {
      const typename Vertex::Point & p = v.point();
      return _volume( p[0], p[1], p[2], p[3] );
    }
    void setLabel( Vertex v, L lab )
    {
      const typename Vertex::Point & p = v.point();
      _volume( p[0], p[1], p[2], p[3] ) = lab;
    }
    void setMinimum( Vertex v )
    {
      const typename Vertex::Point & p = v.point();
      _minima( p[0], p[1], p[2], p[3] ) = 1;
    }
    carto::VolumeRef<L> volume()
    {
      return _volume;
    }
    size_t size() const { return (size_t) _volume.getSizeX() *
                                 (size_t) _volume.getSizeY() *
                                 (size_t) _volume.getSizeZ() *
                                 (size_t) _volume.getSizeT(); }
    carto::VolumeRef<L> getMinima()
    {
      return _minima;
    }
 
    //--- volume -------------------------------------------------------------
  public:
    void setVolume( carto::VolumeRef<L> in )
    {
      _volume = in;
      _minima->reallocate( in.getSizeX(), in.getSizeY(), in.getSizeZ(), in.getSizeT() );
    }
    void setDimensions( int sx = 1, int sy = 1, int sz = 1, int st = 1 )
    {
      _volume->reallocate( sx, sy, sz, st );
      _minima->reallocate( sx, sy, sz, st );
    }
    void setHeader( const carto::PropertySet & h )
    {
      _volume->copyHeaderFrom( h );
      _minima->copyHeaderFrom( h );
    }
 
    //--- members ------------------------------------------------------------
  protected:
    carto::VolumeRef<L> _volume;
    carto::VolumeRef<L> _minima;
  };
 
 
  //==========================================================================
  //   FLOW MAP POINT: ITERATORS
  //==========================================================================
 
  template <typename L>
  class CoustyFlowMap<PointVertexRef<Point4dl>,L>::const_iterator
  {
  public:
    typedef CoustyFlowMap<PointVertexRef<Point4dl>,L>        Owner;
    typedef typename Owner::Vertex                          Vertex;
    typedef std::pair<Vertex,carto::reference_wrapper<L> >  IterType;
 
  protected:
    L & noneref() { return *( (L*) this ); }
    const_iterator( carto::VolumeRef<L> in, bool end = false ):
      _current(Vertex(),carto::wrap::ref(noneref())),
      _volume(in),
      _dimensions(in.getSizeX(),in.getSizeY(),in.getSizeZ(),in.getSizeT())
    {
      if( end )
        toEnd();
      else
        toBegin();
    }
  public:
    const_iterator(): _current(Vertex(),carto::wrap::ref(noneref())) {}
    const_iterator( const const_iterator & other ): _current(other._current) {}
    const_iterator( const iterator & other ): _current(other._current) {}
 
 
    const_iterator & operator=( const const_iterator & other )
    {
      _current = other._current;
      _dimensions = other._dimensions;
      _volume = other._volume;
      return *this;
    }
    const_iterator & operator=( const iterator & other )
    {
      _current = other._current;
      _dimensions = other._dimensions;
      _volume = other._volume;
      return *this;
    }
    const_iterator & operator++()
    {
      if( _current.first.point()[0] < _dimensions[0]-1 )
        ++( _current.first.point()[0] );
      else
      {
        _current.first.point()[0] = 0;
        if( _current.first.point()[1] < _dimensions[1]-1 )
          ++( _current.first.point()[1] );
        else
        {
          _current.first.point()[1] = 0;
          if( _current.first.point()[2] < _dimensions[2]-1 )
            ++( _current.first.point()[2] );
          else
          {
            _current.first.point()[2] = 0;
            if( _current.first.point()[3] < _dimensions[3]-1 )
              ++( _current.first.point()[3] );
            else
              toEnd();
          }
        }
      }
      computeLabel();
      return *this;
    }
    const_iterator   operator++(int)
    {
      const_iterator prev = *this;
      ++(*this);
      return prev;
    }
    const IterType & operator*() const { return _current; }
    const IterType * operator->() const { return &_current; }
    bool operator==( const const_iterator & other ) const
    {
      return other._current.first == _current.first;
    }
    bool operator==( const iterator & other ) const { return other == *this; }
    bool operator!=( const const_iterator & other ) const { return !( other == *this ); }
    bool operator!=( const iterator & other ) const { return !( other == *this ); }
 
  protected:
    void toBegin() { _current.first = Vertex(Point4dl(0,0,0,0)); computeLabel(); }
    void toEnd() { _current.first = Vertex(_dimensions); computeLabel(); }
    void computeLabel()
    {
      if( _current.first.point() != _dimensions )
        _current.second = carto::wrap::ref(
          _volume( _current.first.point()[0], _current.first.point()[1],
                   _current.first.point()[2], _current.first.point()[3] ) );
      else
        _current.second = carto::wrap::ref(noneref());
    }
    IterType             _current;
    Point4dl             _dimensions;
    carto::VolumeRef<L>  _volume;
 
    friend class CoustyFlowMap<Vertex, L>;
  };
 
  template <typename L>
  class CoustyFlowMap<PointVertexRef<Point4dl>,L>::iterator:
    public CoustyFlowMap<PointVertexRef<Point4dl>,L>::const_iterator
  {
  protected:
    iterator( carto::VolumeRef<L> in, bool end = false ): const_iterator(in,end) {}
  public:
    iterator(): const_iterator() {}
    iterator( const iterator & other ): const_iterator(other) {}
 
    typedef CoustyFlowMap<PointVertexRef<Point4dl>, L> Owner;
    typedef typename Owner::Vertex Vertex;
    typedef std::pair<Vertex,carto::reference_wrapper<L> > IterType;
 
    iterator & operator=( const iterator & other ) { const_iterator::operator=(other); }
    iterator & operator++() { const_iterator::operator++(); return *this; }
    iterator   operator++(int)
    {
      iterator prev = *this;
      ++(*this);
      return prev;
    }
    IterType & operator*() { return this->_current; }
    IterType * operator->() { return &(this->_current); }
 
    friend class CoustyFlowMap<Vertex,L>;
  };
 
  //==========================================================================
  //   FLOW MAP REF
  //==========================================================================
  template <typename V, typename L>
  class CoustyFlowMapRef: public carto::rc_ptr<CoustyFlowMap<V,L> >
  {
  };
 
  //==========================================================================
  //   FLOW MAP POINT REF
  //==========================================================================
  template <typename L>
  class CoustyFlowMapRef<PointVertexRef<Point4dl>,L>:
    public carto::rc_ptr<CoustyFlowMap<PointVertexRef<Point4dl>,L> >
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef carto::rc_ptr<CoustyFlowMap<PointVertexRef<Point4dl>,L> >  Base;
    typedef CoustyFlowMap<PointVertexRef<Point4dl>,L>                  Pointed;
  public:
    typedef typename Pointed::Vertex     Vertex;
 
    //--- constructor --------------------------------------------------------
  public:
    CoustyFlowMapRef(): Base( new Pointed() ) {}
    ~CoustyFlowMapRef() {}
 
    //--- iterator -----------------------------------------------------------
  public:
    typedef typename Pointed::const_iterator const_iterator;
    typedef typename Pointed::iterator iterator;
    const_iterator begin() const { return (*this)->begin(); }
    const_iterator end() const { return (*this)->end(); }
    iterator begin() { return (*this)->begin(); }
    iterator end() { return (*this)->end(); }
 
    //--- interface ----------------------------------------------------------
  public:
    template <typename Iterator>
    void init( Iterator b, Iterator e ) { return (*this)->init(b,e); }
    L labelNone() const { return (*this)->labelNone(); }
    L labelMinus() const { return (*this)->labelMinus(); }
    L label( Vertex v ) const { return (*this)->label(v); }
    void setLabel( Vertex v, L lab ) { return (*this)->setLabel(v,lab); }
    void setMinimum( Vertex v ) { return (*this)->setMinimum(v); }
    carto::VolumeRef<L> volume() { return (*this)->volume(); }
    size_t size() const { return (*this)->size(); }
    carto::VolumeRef<L> getMinima() { return (*this)->getMinima(); }
    // void setSeeds( aims::BucketMap<Void> & seeds ) { return (*this)->setSeeds(seeds); }
 
 
    //--- volume -------------------------------------------------------------
  public:
    void setVolume( carto::VolumeRef<L> in )
    { return (*this)->setVolume(in); }
    void setDimensions( int sx = 1, int sy = 1, int sz = 1, int st = 1 )
    { return (*this)->setDimensions(sx,sy,sz,st); }
    void setHeader( const carto::PropertySet & h )
    { return (*this)->setHeader(h); }
  };
 
} // namespace bio
 
#endif // BIOPROCESSING_WATERSHED_COUSTYFLOWMAP