volumegraph.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_GRAPH_VOLUMEGRAPH
#define BIOPROCESSING_GRAPH_VOLUMEGRAPH
 
//--- bioprocessing ----------------------------------------------------------
#include <bioprocessing/graph/edgeweightedgraph.h>         // bio::EWBaseGraph
#include <bioprocessing/graph/setedge.h>                    // bio::SetEdgeRef
#include <bioprocessing/graph/pointvertex.h>            // bio::PointVertexRef
//--- aims -------------------------------------------------------------------
#include <aims/connectivity/structuring_element.h> // aims::StructuringElement
#include <aims/math/mathelem.h>                              // aims::MathUtil
#include <aims/vector/vector.h>                                      // Point*
//--- cartodata --------------------------------------------------------------
#include <cartodata/volume/volume.h>                       // carto::VolumeRef
//----------------------------------------------------------------------------
 
namespace bio {
  template <typename T, typename P> class VolumeGraph;
  template <typename T, typename P> class VolumeGraphRef;
 
  namespace {
    // default weight function for volume graphs
    template <typename T>
    T weightMin( const T & a, const T & b )
    {
      return ( a < b ? a : b );
    }
  }
 
//============================================================================
// VOLUME GRAPH: DECLARATION
//============================================================================
  template <typename T, typename P>
  class VolumeGraph: public EWBaseGraph< SetEdgeRef< PointVertexRef< P > >, T >
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef VolumeGraph<T,P>                                    This;     
    typedef EWBaseGraph< SetEdgeRef< PointVertexRef< P > >, T > Base;     
    typedef BaseGraph<SetEdgeRef< PointVertexRef< P > > >       BaseBase; 
  public:
    typedef T                             Type;   
    typedef P                             Point;  
    typedef typename Base::Edge           Edge;   
    typedef typename Base::Vertex         Vertex; 
    typedef typename Base::Weight         Weight; 
    typedef VolumeGraphRef<T,P>           Graph;  
    typedef VolumeGraphRef<T,P>           Ref;    
    typedef carto::VolumeRef<Type>        Volume; 
 
    //--- constructor --------------------------------------------------------
  public:
    VolumeGraph( int sx = 1, int sy = 1, int sz = 1, int st = 1,
                 const aims::strel::Connectivity & conn
                  = aims::strel::Connectivity6XYZ() );
    VolumeGraph( const Volume & in,
                 const aims::strel::Connectivity & conn
                  = aims::strel::Connectivity6XYZ() );
    virtual ~VolumeGraph() {}
 
    //--- iterators ----------------------------------------------------------
  public:
    class vertex_const_iterator;  
    class vertex_iterator;        
    class edge_iterator;          
    class edge_const_iterator;    
    vertex_const_iterator beginVertex() const { return vertex_const_iterator(_vol,false); }
    vertex_const_iterator endVertex() const { return vertex_const_iterator(_vol,true); }
    vertex_iterator       beginVertex() { return vertex_iterator(_vol,false); }
    vertex_iterator       endVertex() { return vertex_iterator(_vol,true); }
    edge_const_iterator   beginEdge( const Vertex & v ) const
      { return edge_const_iterator(_vol,false,v,_conn.begin(),_conn.end()); }

    edge_const_iterator   endEdge( const Vertex & v ) const
      { return edge_const_iterator(_vol,true,v,_conn.begin(),_conn.end()); }

    edge_iterator         beginEdge( const Vertex & v )
      { return edge_iterator(_vol,false,v,_conn.begin(),_conn.end()); }

    edge_iterator         endEdge( const Vertex & v)
      { return edge_iterator(_vol,true,v,_conn.begin(),_conn.end()); }
    // Iterator on all edges (not yet defined)
    edge_const_iterator   beginEdge() const;
    // Iterator on all edges (not yet defined)
    edge_const_iterator   endEdge() const;
    // Iterator on all edges (not yet defined)
    edge_iterator         beginEdge();
    // Iterator on all edges (not yet defined)
    edge_iterator         endEdge();
 
    //--- implementation -----------------------------------------------------
  public:
    void insert( Vertex v )                         { throw; } //< not defined
    void insert( Edge e )                           { throw; } //< not defined
    bool contains( const Vertex & v ) const;
    bool contains( const Edge & e ) const;
    bool empty() const;
    void clear();
    void insert( Edge e, Weight w = (Weight)0 )      { throw; } // not defined
    Weight weight( const Edge & e );
    Weight weight( const Edge & e ) const;
 
    //--- template implementation --------------------------------------------
  public:
    bool isAdjacent( const Vertex & x, const Vertex & y ) const
      { return BaseBase::isAdjacent(*this,x,y); }

    bool isLinked( const Vertex & x, const Vertex & y ) const
      { return BaseBase::isLinked(*this,x,y); }

    bool isSubGraph( const Graph & g ) const
      { return BaseBase::isSubGraph(*this,g); }

    bool isConnectedComponent( const Graph & g ) const
      { return BaseBase::isConnectedComponent(*this,g); }

    bool isAdjacentTo( const Vertex & v, const Graph & g ) const
      { return BaseBase::isAdjacentTo(*this,v,g); }
    bool isAdjacentFrom( const Vertex & v, const Graph & g ) const
      { return BaseBase::isAdjacentFrom(*this,v,g); }

    Graph getConnectedComponent( Vertex & v )
      { return BaseBase::getConnectedComponent(*this,v); }

    Weight Fm( const Vertex & v ) const
      { return Base::Fm(*this,v); }

    template <typename Set>
    static Set getComplement( const Set & s, const Set & e )
      { return BaseBase::getComplement(s,e); }
 
    //--- volume methods -----------------------------------------------------
  public:
    static Type notPresentValue();
    static Type presentValue();
    void setDimensions( int sx = 1, int sy = 1, int sz = 1, int st = 1 );
    void setDimensions( const Point & dim );
    void setHeader( float vx = 1., float vy = 1., float vz = 1., float vt = 1. );
    void setHeader( const Point4df & vs );
    void setWeightMethod( Weight (*weight)( const Type &, const Type & ) );
    template <typename M>
    void mask( const carto::VolumeRef<M> & mask );
          T & access( const Point & p );
    const T & access( const Point & p ) const;
    bool inside( const Point & p ) const;
 
    //--- members ------------------------------------------------------------
  protected:
    Volume _vol;
    Weight (*_weight)( const Type &, const Type & );
    aims::StructuringElement _conn;
  };
 
//============================================================================
// VOLUME GRAPH: DEFINITION
//============================================================================
 
  template <typename T, typename P>
  VolumeGraph<T,P>::VolumeGraph( int sx, int sy, int sz, int st,
                                 const aims::strel::Connectivity & conn ):
    _vol(sx,sy,sz,st),
    _conn(conn),
    _weight(&weightMin)
  {}
 
  template <typename T, typename P>
  VolumeGraph<T,P>::VolumeGraph( const Volume & in,
                                 const aims::strel::Connectivity & conn ):
    _vol(in),
    _conn(conn),
    _weight(&weightMin)
  {}
 
  template <typename T, typename P>
  bool VolumeGraph<T,P>::contains( const Vertex & v ) const
  {
    if( !inside( v.point() ) )
      return false;
    return access( v.point() ) != notPresentValue();
  }
 
 
  template <typename T, typename P>
  bool VolumeGraph<T,P>::contains( const Edge & e ) const
  {
    if( !inside( e.x().point() ) || !inside( e.y().point() ) )
      return false;
    return ( access( e.x().point() ) != notPresentValue() ) &&
           ( access( e.y().point() ) != notPresentValue() );
  }
 
  template <typename T, typename P>
  bool VolumeGraph<T,P>::empty() const
  {
    int x, y, z, t;
    for( t=0; t<_vol.getSizeT(); ++t )
      for( z=0; z<_vol.getSizeZ(); ++z )
        for( y=0; y<_vol.getSizeY(); ++y )
          for( x=0; x<_vol.getSizeX(); ++x )
            if( _vol( x, y, z, t ) != notPresentValue() )
              return false;
    return true;
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::clear()
  {
    int x, y, z, t;
    for( t=0; t<_vol.getSizeT(); ++t )
      for( z=0; z<_vol.getSizeZ(); ++z )
        for( y=0; y<_vol.getSizeY(); ++y )
          for( x=0; x<_vol.getSizeX(); ++x )
            _vol( x, y, z, t ) = notPresentValue();
  }
 
  template <typename T, typename P>
  typename VolumeGraph<T,P>::Weight VolumeGraph<T,P>::weight( const Edge & e )
  {
    T x, y;
    x = access( e.x().point() );
    y = access( e.y().point() );
    return _weight( x, y );
  }
 
  template <typename T, typename P>
  typename VolumeGraph<T,P>::Weight VolumeGraph<T,P>::weight( const Edge & e ) const
  {
    T x, y;
    x = access( e.x().point() );
    y = access( e.y().point() );
    return _weight( x, y );
  }
 
  template <typename T, typename P>
  T VolumeGraph<T,P>::notPresentValue()
  {
    return std::numeric_limits<T>::min();
  }
 
  template <typename T, typename P>
  T VolumeGraph<T,P>::presentValue()
  {
    return std::numeric_limits<T>::max();
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::setDimensions( int sx, int sy, int sz, int st )
  {
    _vol->reallocate(sx,sy,sz,st);
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::setDimensions( const Point & dim )
  {
    Point4d dim4(1,1,1,1);
    for( int i = 0; i < dim.size(); ++i )
      dim4[i] = dim[i];
    setDimensions( dim4[0], dim4[1], dim4[2], dim4[3] );
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::setHeader( float vx, float vy, float vz, float vt )
  {
    std::vector<float> vs(4,1.0);
    vs[0] = vx;
    vs[1] = vy;
    vs[2] = vz;
    vs[3] = vt;
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::setHeader( const Point4df & vs )
  {
    setHeader( vs[0], vs[1], vs[2], vs[3] );
  }
 
  template <typename T, typename P>
  void VolumeGraph<T,P>::setWeightMethod( Weight (*weight)( const Type &, const Type & ) )
  {
    _weight = weight;
  }
 
  template <typename T, typename P>
  template <typename M>
  void VolumeGraph<T,P>::mask( const carto::VolumeRef<M> & mask )
  {
    ASSERT( ( mask.getSizeX() == _vol.getSizeX() ) &&
            ( mask.getSizeY() == _vol.getSizeY() ) &&
            ( mask.getSizeZ() == _vol.getSizeZ() ) &&
            ( mask.getSizeT() == _vol.getSizeT() ) );
    int x, y, z, t;
    for( t=0; t<_vol.getSizeT(); ++t )
      for( z=0; z<_vol.getSizeZ(); ++z )
        for( y=0; y<_vol.getSizeY(); ++y )
          for( x=0; x<_vol.getSizeX(); ++x )
            if( !mask(x,y,z,t) )
              _vol( x, y, z, t ) = notPresentValue();
  }
 
  template <typename T, typename P>
  T & VolumeGraph<T,P>::access( const Point & p )
  {
    Point4d p4(0,0,0,0);
    for( int i = 0; i < p.size(); ++i )
      p4[i] = p[i];
    return _vol( p4[0], p4[1], p4[2], p4[3] );
  }
 
  template <typename T, typename P>
  const T & VolumeGraph<T,P>::access( const Point & p ) const
  {
    Point4d p4(0,0,0,0);
    for( int i = 0; i < p.size(); ++i )
      p4[i] = p[i];
    return _vol( p4[0], p4[1], p4[2], p4[3] );
  }
 
  template <typename T, typename P>
  bool VolumeGraph<T,P>::inside( const Point & p ) const
  {
    Point4d dim4(1,1,1,1);
    dim4[0] = _vol.getSizeX();
    dim4[1] = _vol.getSizeY();
    dim4[2] = _vol.getSizeZ();
    dim4[3] = _vol.getSizeT();
    for( int i = 0; i < p.size(); ++i )
      if( p[1] < 0 || p[1] >= dim4[i] )
        return false;
  }
 
//============================================================================
// VOLUME GRAPH: VERTEX ITERATORS
//============================================================================

  template <typename T, typename P>
  class VolumeGraph<T,P>::vertex_const_iterator
  {
  protected:
    typedef vertex_const_iterator                  This;
    typedef vertex_iterator                        NonConstThis;
    typedef VolumeGraph<T,P>                       Owner;
  public:
    typedef typename Owner::Edge                   Edge;
    typedef typename Owner::Vertex                 Vertex;
    typedef typename Owner::Volume                 Volume;
    typedef typename Owner::Point                  Point;
  protected:
    vertex_const_iterator( const Volume & vol, bool end ):
      _vol(vol),
      _cur(0,0,0,0),
      _vtx(Vertex::none()),
      _dim(vol.getSizeX(),vol.getSizeY(), vol.getSizeZ(), vol.getSizeT())
    {
      if( end )
        toEnd();
      else
        if( ( _cur != _dim ) && ( _vol(_cur[0],_cur[1],_cur[2],_cur[3]) == notPresentValue() ) )
          ++(*this);
      setVertex();
    }
  public:
    vertex_const_iterator():
      _vol((carto::Volume<T>*)0),
      _cur(0,0,0,0),
      _dim(0,0,0,0),
      _vtx(Vertex::none())
    {}
    vertex_const_iterator( const This & o ):
      _vol(o._vol),
      _cur(o._cur),
      _dim(o._dim),
      _vtx(o._vtx)
    {}
    vertex_const_iterator( const NonConstThis & o ):
      _vol(o._vol),
      _cur(o._cur),
      _dim(o._dim),
      _vtx(o._vtx)
    {}
    ~vertex_const_iterator() {}
    This & operator=( const This & o )
    {
      _vol = o._vol;
      _cur = o._cur;
      _dim = o._dim;
      _vtx = o._vtx;
      return *this;
    }
    This & operator=( const NonConstThis & o )
    {
      _vol = o._vol;
      _cur = o._cur;
      _dim = o._dim;
      _vtx = o._vtx;
      return *this;
    }
    This & operator++()
    {
      if( _cur[0] < _dim[0]-1 )
        ++( _cur[0] );
      else
      {
        _cur[0] = 0;
        if( _cur[1] < _dim[1]-1 )
          ++( _cur[1] );
        else
        {
          _cur[1] = 0;
          if( _cur[2] < _dim[2]-1 )
            ++( _cur[2] );
          else
          {
            _cur[2] = 0;
            if( _cur[3] < _dim[3]-1 )
              ++( _cur[3] );
            else
              toEnd();
          }
        }
      }
 
      if( ( _cur != _dim ) && ( _vol(_cur[0],_cur[1],_cur[2],_cur[3]) == notPresentValue() ) )
        return ++(*this);
      setVertex();
      return *this;
    }
    This   operator++(int)
    {
      This prev = *this;
      ++(*this);
      return prev;
    }
    bool   operator==( const This & o ) const { return _cur == o._cur; }
    bool   operator!=( const This & o ) const { return _cur != o._cur; }
    bool   operator==( const NonConstThis & o ) const { return _cur == o._cur; }
    bool   operator!=( const NonConstThis & o ) const { return _cur != o._cur; }
    const Vertex & operator*() const { return _vtx; }
    const Vertex * operator->() const { return &_vtx; }
 
  protected:
    void toEnd()
    {
      _cur = _dim;
    }
    void setVertex()
    {
      Point p;
      for( int i = 0; i < p.size(); ++i )
        p[i] = _cur[i];
      _vtx = Vertex(p);
    }
    Volume    _vol;
    Point4d   _cur;
    Point4d   _dim;
    Vertex    _vtx;
    friend class VolumeGraph<T,P>;
  };

  template <typename T, typename P>
  class VolumeGraph<T,P>::vertex_iterator: public VolumeGraph<T,P>::vertex_const_iterator
  {
  protected:
    typedef vertex_iterator                        This;
    typedef VolumeGraph<T,P>                       Owner;
    typedef typename Owner::vertex_const_iterator  Base;
  public:
    typedef typename Owner::Edge                   Edge;
    typedef typename Owner::Vertex                 Vertex;
    typedef typename Owner::Volume                 Volume;
    typedef typename Owner::Point                  Point;
  protected:
    vertex_iterator( const Volume & in, bool end = false ): Base(in,end) {}
  public:
    vertex_iterator(): Base() {}
    vertex_iterator( const This & other ): Base(other) {}
 
    This & operator=( const This & other ) { Base::operator=(other); }
    This & operator++() { Base::operator++(); return *this; }
    This   operator++(int)
    {
      This prev = *this;
      ++(*this);
      return prev;
    }
    Vertex & operator*() { return this->_vtx; }
    Vertex * operator->() { return &(this->_vtx); }
 
    friend class VolumeGraph<T,P>;
  };
 
 
//============================================================================
// VOLUME GRAPH: EDGE ITERATORS
//============================================================================
  template <typename T, typename P>
  class VolumeGraph<T,P>::edge_const_iterator
  {
  protected:
    typedef edge_const_iterator                    This;
    typedef edge_iterator                          NonConstThis;
    typedef VolumeGraph<T,P>                       Owner;
  public:
    typedef typename Owner::Edge                   Edge;
    typedef typename Owner::Vertex                 Vertex;
    typedef typename Owner::Volume                 Volume;
    typedef typename Owner::Point                  Point;
  protected:
    typedef typename aims::StructuringElement::const_iterator  ConnIt;
    typedef vertex_const_iterator                  VertexIt;
    edge_const_iterator( const Volume & vol,
                         bool end,
                         const Vertex & v,
                         ConnIt b, ConnIt e ):
      _vol(vol),
      _cur(0,0,0,0),
      _nbr(0,0,0,0),
      _dim( vol.getSizeX(), vol.getSizeY(), vol.getSizeZ(), vol.getSizeT() ),
      _vtxbeg(),
      _vtxend(),
      _conbeg(b),
      _concur(b),
      _conend(e),
      _edg(Edge::none()),
      _vtx(v)
    {
      copy( _vtx.point(), _cur );
      if( end ) toEnd();
      else      toNext();
      setEdge();
    }
    edge_const_iterator( const Volume & vol,
                           bool end,
                           VertexIt vb, VertexIt ve,
                           ConnIt b, ConnIt e ):
      _vol(vol),
      _cur(0,0,0,0),
      _nbr(0,0,0,0),
      _dim( vol.getSizeX(), vol.getSizeY(), vol.getSizeZ(), vol.getSizeT() ),
      _vtxbeg(vb),
      _vtxend(ve),
      _conbeg(b),
      _concur(b),
      _conend(e),
      _edg(Edge::none()),
      _vtx(Vertex::none())
    {
      copy( vb->point(), _cur );
      if( end ) toEnd();
      else      toNext();
      setEdge();
    }
  public:
    edge_const_iterator():
      _vol((carto::Volume<T>*)0),
      _cur(0,0,0,0),
      _nbr(0,0,0,0),
      _dim(0,0,0,0),
      _vtxbeg(),
      _vtxend(),
      _conbeg(),
      _concur(),
      _conend(),
      _edg(Edge::none()),
      _vtx(Vertex::none())
    {}
    edge_const_iterator( const This & o ):
      _vol(o._vol),
      _cur(o._cur),
      _nbr(o._nbr),
      _dim(o._dim),
      _vtxbeg(o._vtxbeg),
      _vtxend(o._vtxend),
      _conbeg(o._conbeg),
      _concur(o._concur),
      _conend(o._conend),
      _edg(o._edg),
      _vtx(o._vtx)
    {}
    edge_const_iterator( const NonConstThis & o ):
      _vol(o._vol),
      _cur(o._cur),
      _nbr(o._nbr),
      _dim(o._dim),
      _vtxbeg(o._vtxbeg),
      _vtxend(o._vtxend),
      _conbeg(o._conbeg),
      _concur(o._concur),
      _conend(o._conend),
      _edg(o._edg),
      _vtx(o._vtx)
    {}
    ~edge_const_iterator() {}
    This & operator=( const This & o )
    {
      _vol = o._vol;
      _cur = o._cur;
      _nbr = o._nbr;
      _dim = o._dim;
      _vtxbeg = o._vtxbeg;
      _vtxend = o._vtxend;
      _conbeg = o._conbeg;
      _concur = o._concur;
      _conend = o._conend;
      _edg = o._edg;
      _vtx = o._vtx;
      return *this;
    }
    This & operator=( const NonConstThis & o )
    {
      _vol = o._vol;
      _cur = o._cur;
      _nbr = o._nbr;
      _dim = o._dim;
      _vtxbeg = o._vtxbeg;
      _vtxend = o._vtxend;
      _conbeg = o._conbeg;
      _concur = o._concur;
      _conend = o._conend;
      _edg = o._edg;
      _vtx = o._vtx;
      return *this;
    }
    This & operator++()
    {
      toNext();
      setEdge();
      return *this;
    }
    This   operator++(int)
    {
      This prev = *this;
      ++(*this);
      return prev;
    }
    bool   operator==( const This & o ) const { return _edg == o._edg; }
    bool   operator!=( const This & o ) const { return _edg != o._edg; }
    bool   operator==( const NonConstThis & o ) const { return _edg == o._edg; }
    bool   operator!=( const NonConstThis & o ) const { return _edg != o._edg; }
    const Edge & operator*() const { return _edg; }
    const Edge * operator->() const { return &_edg; }
 
  protected:
    void toEnd()
    {
      _cur = Point4d(0,0,0,0);
      _nbr = _dim;
    }
    void toNext()
    {
      if( _concur == _conend ) {
        if( _vtx != Vertex::none() )
          return toEnd();
        else {
          if( _vtxbeg == _vtxend )
            return toEnd();
          else {
            _concur = _conbeg;
            ++_vtxbeg;
            copy( _vtxbeg->point(), _cur );
          }
        }
      }
      Point4d move(0,0,0,0);
      copy( *_concur, move );
      _nbr = _cur + move;
      ++_concur;
      if( !inside() )
        toNext();
      if( _nbr == _cur )
        toNext();
    }
    void setEdge()
    {
      Point p1, p2;
      copy(_cur,p1);
      copy(_nbr,p2);
      _edg = Edge( Vertex(p1), Vertex(p2) );
    }
    template <typename P1, typename P2>
    void copy( const P1 & p1, P2 & p2 )
    {
      int size = ( p1.size() > p2.size() ? p2.size() : p1.size() );
      for( int i = 0; i < size; ++i )
        p2[i] = p1[i];
    }
    bool inside()
    {
      for( int i = 0; i<4; ++i )
        if( _nbr[i] < 0 || _nbr[i] >= _dim[i] )
          return false;
      return true;
    }
 
    Volume    _vol;
    Point4d   _cur;
    Point4d   _nbr;
    Point4d   _dim;
    VertexIt  _vtxbeg;
    VertexIt  _vtxend;
    ConnIt    _conbeg;
    ConnIt    _concur;
    ConnIt    _conend;
    Edge      _edg;
    Vertex    _vtx;
 
    friend class VolumeGraph<T,P>;
  };

  template <typename T, typename P>
  class VolumeGraph<T,P>::edge_iterator: public VolumeGraph<T,P>::edge_const_iterator
  {
  protected:
    typedef VolumeGraph<T,P>                       Owner;
    typedef typename Owner::edge_const_iterator    Base;
    typedef typename Owner::edge_iterator          This;
  public:
    typedef typename Owner::Edge                   Edge;
    typedef typename Owner::Vertex                 Vertex;
    typedef typename Owner::Volume                 Volume;
    typedef typename Owner::Point                  Point;
  protected:
    typedef typename aims::StructuringElement::const_iterator  ConnIt;
    typedef vertex_iterator                        VertexIt;
    edge_iterator( const Volume & vol,
                   bool end,
                   const Vertex & v,
                   ConnIt b, ConnIt e ):
      Base(vol,end,v,b,e)
    {}
    edge_iterator( const Volume & vol,
                   bool end,
                   VertexIt vb, VertexIt ve,
                   ConnIt b, ConnIt e ):
      Base(vol,end,vb,ve,b,e)
    {}
  public:
    edge_iterator(): Base() {}
    edge_iterator( const This & other ): Base(other) {}
 
    This & operator=( const This & other ) { Base::operator=(other); }
    This & operator++() { Base::operator++(); return *this; }
    This   operator++(int)
    {
      This prev = *this;
      ++(*this);
      return prev;
    }
    Edge & operator*() { return this->_edg; }
    Edge * operator->() { return &(this->_edg); }
 
    friend class VolumeGraph<T,P>;
  };
 
//============================================================================
// VOLUME GRAPH REF
//============================================================================
  template <typename T, typename P>
  class VolumeGraphRef: public EWBaseGraphRef< SetEdgeRef< PointVertexRef< P > >, T>
  {
    //--- typedef ------------------------------------------------------------
  protected:
    typedef VolumeGraphRef<T,P>    This;
    typedef EWBaseGraphRef< SetEdgeRef< PointVertexRef< P > >, T>     Base;
    typedef VolumeGraph<T,P>       Pointed;
  public:
    typedef typename Pointed::Type           Type;
    typedef typename Pointed::Point          Point;
    typedef typename Pointed::Vertex         Vertex;
    typedef typename Pointed::Edge           Edge;
    typedef typename Pointed::Weight         Weight;
    typedef typename Pointed::Graph          Graph;
 
    //--- constructor --------------------------------------------------------
  public:
    VolumeGraphRef( int sx = 1, int sy = 1, int sz = 1, int st = 1 ):
      Base( new Pointed( sx, sy, sz, st ) ) {}

    VolumeGraphRef( carto::VolumeRef<T> volume,
                    const aims::strel::Connectivity & conn
                      = aims::strel::Connectivity6XYZ() ):
      Base( new Pointed( volume, conn ) )
    {}

    VolumeGraphRef( Pointed * e ): Base(e) {}
    VolumeGraphRef( const Base & other ): Base(other) {}
    virtual ~VolumeGraphRef() {}
 
    //--- none factory -------------------------------------------------------
  public:
    static Graph none() { return This( (Pointed*)0 ); }
 
    //--- iterator -----------------------------------------------------------
  public:
    typedef typename Pointed::vertex_const_iterator    vertex_const_iterator;
    typedef typename Pointed::vertex_iterator          vertex_iterator;
    typedef typename Pointed::edge_const_iterator      edge_const_iterator;
    typedef typename Pointed::edge_iterator            edge_iterator;
    vertex_const_iterator beginVertex() const { return ((Pointed*)(this->get()))->beginVertex(); }
    vertex_const_iterator endVertex() const { return ((Pointed*)(this->get()))->endVertex(); }
    vertex_iterator       beginVertex() { return ((Pointed*)(this->get()))->beginVertex(); }
    vertex_iterator       endVertex() { return ((Pointed*)(this->get()))->endVertex(); }
    edge_const_iterator   beginEdge( const Vertex & v ) const { return ((Pointed*)(this->get()))->beginEdge(v); }
    edge_const_iterator   endEdge( const Vertex & v ) const { return ((Pointed*)(this->get()))->endEdge(v); }
    edge_iterator         beginEdge( const Vertex & v ) { return ((Pointed*)(this->get()))->beginEdge(v); }
    edge_iterator         endEdge( const Vertex & v) { return ((Pointed*)(this->get()))->endEdge(v); }
    // edge_const_iterator   beginEdge() const { return ((Pointed*)(this->get()))->beginEdge(); }
    // edge_const_iterator   endEdge() const { return ((Pointed*)(this->get()))->endEdge(); }
    // edge_iterator         beginEdge() { return ((Pointed*)(this->get()))->beginEdge(); }
    // edge_iterator         endEdge() { return ((Pointed*)(this->get()))->endEdge(); }
 
    //--- template implementation --------------------------------------------
  public:
    bool isAdjacent( const Vertex & x, const Vertex & y ) const { return ((Pointed*)(this->get()))->isAdjacent(x,y); }
    bool isLinked( const Vertex & x, const Vertex & y ) const { return ((Pointed*)(this->get()))->isLinked(x,y); }
    bool isSubGraph( const Graph & g ) const { return ((Pointed*)(this->get()))->isSubGraph(g); }
    bool isConnectedComponent( const Graph & g ) const { return ((Pointed*)(this->get()))->isConnectedComponent(g); }
    bool isAdjacentTo( const Vertex & v, const Graph & g ) const { return ((Pointed*)(this->get()))->isAdjacentTo(v,g); }
    bool isAdjacentFrom( const Vertex & v, const Graph & g ) const { return ((Pointed*)(this->get()))->isAdjacentFrom(v,g); }
    Graph getConnectedComponent( Vertex & v ) { return ((Pointed*)(this->get()))->getConnectedComponent(v); }
    template <typename Set>
    static Set getComplement( const Set & s, const Set & e ) { return Pointed::getComplement(s,e); }
 
    //--- volume methods -----------------------------------------------------
  public:
    static Type notPresentValue() { return Pointed::notPresentValue(); }
    static Type presentValue() { return Pointed::presentValue(); }
    void setDimensions( int sx = 1, int sy = 1, int sz = 1, int st = 1 ) { return ((Pointed*)(this->get()))->setDimensions(sx,sy,sz,st); }
    void setDimensions( const Point & dim ) { return ((Pointed*)(this->get()))->setDimensions(dim); }
    void setHeader( float vx = 1., float vy = 1., float vz = 1., float vt = 1. ) { return ((Pointed*)(this->get()))->setHeader(vx,vy,vz,vt); }
    void setHeader( const Point4df & vs ) { return ((Pointed*)(this->get()))->setHeader(vs); }
    void setWeightMethod( Weight (*weight)( const Type &, const Type & ) ) { return ((Pointed*)(this->get()))->setWeightMethod(weight); }
    template <typename M>
    void mask( const carto::VolumeRef<M> & mask ) { return ((Pointed*)(this->get()))->mask(mask); }
          T & access( const Point & p ) { return ((Pointed*)(this->get()))->access(p); }
    const T & access( const Point & p ) const { return ((Pointed*)(this->get()))->access(p); }
    bool inside( const Point & p ) const { return ((Pointed*)(this->get()))->inside(p); }
  };
 
} // namespace bio
 
#endif // BIOPROCESSING_GRAPH_VOLUMEGRAPH