borderiterator.h

Go to the documentation of this file.

#ifndef AIMSDATA_BORDER_BORDERITERATOR_H
#define AIMSDATA_BORDER_BORDERITERATOR_H


#include <aims/vector/vector.h>                                      // Point*
#include <cartodata/volume/volume.h>                              // VolumeRef
#include <iostream>

namespace aims
{
  //==========================================================================
  // BORDER ITERATOR
  //==========================================================================
  template <typename T>
  class BorderIterator
  {
  public:
    BorderIterator( carto::VolumeRef<T> in, bool inside = false,
                    const Point4dl & size = Point4dl( -1, -1, -1, -1 ) ):
      _volume(in),
      _inside(inside),
      _sizeinf(size),
      _sizesup(size)
    {
      if( !inside )
      {
        std::vector<int> borders = _volume.getBorders();
        if( size[0] < 0 )
        {
          _sizeinf[0] = borders[0];
          _sizesup[0] = borders[1];
        }
        if( size[1] < 0 )
        {
          _sizeinf[1] = borders[2];
          _sizesup[1] = borders[3];
        }
        if( size[2] < 0 )
        {
          _sizeinf[2] = borders[4];
          _sizesup[2] = borders[5];
        }
        if( size[3] < 0 )
        {
          _sizeinf[3] = borders[6];
          _sizesup[3] = borders[7];
        }
      }
    }
    BorderIterator( carto::VolumeRef<T> in, bool inside,
                    const Point4dl & sizeinf,
                    const Point4dl & sizesup ):
      _volume(in),
      _inside(inside),
      _sizeinf(sizeinf),
      _sizesup(sizesup)
    {
      if( !inside )
      {
        std::vector<int> borders = _volume.getBorders();
        if( _sizeinf[0] < 0 )
          _sizeinf[0] = borders[0];
        if( _sizesup[0] < 0 )
          _sizesup[0] = borders[1];

        if( _sizeinf[1] < 0 )
          _sizeinf[1] = borders[2];
        if( _sizesup[1] < 0 )
          _sizesup[1] = borders[3];

        if( _sizeinf[2] < 0 )
          _sizeinf[2] = borders[4];
        if( _sizesup[1] < 0 )
          _sizesup[2] = borders[5];

        if( _sizeinf[3] < 0 )
          _sizeinf[3] = borders[6];
        if( _sizesup[1] < 0 )
          _sizesup[3] = borders[7];
      }
    }

    BorderIterator():
      _volume( (carto::Volume<T>*)0 ),
      _inside(false),
      _sizeinf(),
      _sizesup()
    {}

  public:
    class iterator;

    class const_iterator
    {
      //--- constructors -----------------------------------------------------
    public:
      const_iterator();
      const_iterator( const const_iterator & other );
      const_iterator( const iterator & other );
    protected:
      const_iterator( BorderIterator<T> & b, bool end = false );
      const_iterator( BorderIterator<T> & b, const Point4dl & current );

      //--- operators --------------------------------------------------------
    public:
      const_iterator & operator=( const const_iterator & other );
      const_iterator & operator=( const iterator & other );
      const_iterator & operator++();
      const_iterator   operator++(int);
      const T & operator*() const;
      const T * operator->() const;
      bool operator==( const const_iterator & other ) const;
      bool operator==( const iterator & other ) const;
      bool operator!=( const const_iterator & other ) const;
      bool operator!=( const iterator & other ) const;

      //--- member method ----------------------------------------------------
      Point4dl coordinate() const { return _current; }
      carto::VolumeRef<T> volume() { return _border._volume; }

      //--- members ----------------------------------------------------------
    protected:
      BorderIterator<T>     _border;
      Point4dl              _current;

      //--- helpers ----------------------------------------------------------
    protected:
      bool isBorder( const Point4dl & p ) const;
      bool isNonBorderImage( const Point4dl & p ) const;
      Point4dl reset( const Point4dl & p,
                      const Point4dl & move ) const;
      Point4dl nextMove( const Point4dl & move ) const;
      Point4dl computeNext( const Point4dl & p ) const;
      Point4dl end() const;
      long jumpX() const;

      //--- friends ----------------------------------------------------------
      friend class BorderIterator<T>;
      friend class iterator;
    };

    class iterator: public const_iterator
    {
      //--- constructors -----------------------------------------------------
    public:
      iterator();
      iterator( const iterator & other );
    protected:
      iterator( BorderIterator<T> & b, bool end = false );
      iterator( BorderIterator<T> & b, const Point4dl & current );

      //--- operators --------------------------------------------------------
    public:
      iterator & operator=( const iterator & other );
      iterator & operator++();
      iterator   operator++(int);
      T & operator*();
      T * operator->();

      //--- friends ----------------------------------------------------------
      friend class BorderIterator<T>;
    };

  public:
    iterator        begin()       { return iterator(*this); }
    iterator        end()         { return iterator(*this,true); }
    const_iterator  begin() const { return const_iterator(*this); }
    const_iterator  end()   const { return const_iterator(*this,true); }

    bool operator==( const BorderIterator<T> & other ) const
    {
      return  ( _inside == other._inside ) &&
              ( _sizeinf == other._sizeinf ) &&
              ( _sizesup == other._sizesup ) &&
              ( _volume.get()== other._volume.get() );
    }

  protected:
    carto::VolumeRef<T>   _volume;
    bool                  _inside;
    Point4dl              _sizeinf;
    Point4dl              _sizesup;

    friend class const_iterator;
    friend class iterator;
  };

  //--- const_iterator -------------------------------------------------------
  template <typename T>
  BorderIterator<T>::const_iterator::const_iterator():
    _border(),
    _current()
  {}

  template <typename T>
  BorderIterator<T>::const_iterator::const_iterator( BorderIterator<T> & b, bool end ):
    _border(b),
    _current( (end ? this->end() : Point4dl(0,0,0,0) ) )
  {
    if( !_border._inside && !end )
    {
      const Point4dl & start = _border._sizeinf;
      _current = Point4dl( -start[0], -start[1], -start[2], -start[3] );
      if( !isBorder(_current) )
        _current = computeNext( _current );
    }
  }

  template <typename T>
  BorderIterator<T>::const_iterator::const_iterator( BorderIterator<T> & b,
                                             const Point4dl & current ):
    _border(b),
    _current(current)
  {}

  template <typename T>
  BorderIterator<T>::const_iterator::const_iterator(
    const typename BorderIterator<T>::const_iterator & other ):
    _border(other._border),
    _current(other._current)
  {}

  template <typename T>
  BorderIterator<T>::const_iterator::const_iterator(
    const typename BorderIterator<T>::iterator & other ):
    _border(other._border),
    _current(other._current)
  {}

  template <typename T>
  typename BorderIterator<T>::const_iterator & BorderIterator<T>::const_iterator::operator=(
    const typename BorderIterator<T>::const_iterator & other )
  {
    _border = other._border;
    _current = other._current;
    return *this;
  }

  template <typename T>
  typename BorderIterator<T>::const_iterator & BorderIterator<T>::const_iterator::operator=(
    const typename BorderIterator<T>::iterator & other )
  {
    _border = other._border;
    _current = other._current;
    return *this;
  }

  template <typename T>
  const T & BorderIterator<T>::const_iterator::operator*() const
  {
    return _border._volume( _current[0], _current[1], _current[2], _current[3] );
  }

  template <typename T>
  const T * BorderIterator<T>::const_iterator::operator->() const
  {
    return &( _border._volume( _current[0], _current[1], _current[2], _current[3] ) );
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::operator==( const const_iterator & other ) const
  {
    return (_border == other._border) && (_current == other._current);
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::operator==( const iterator & other ) const
  {
    return (_border == other._border) && (_current == other._current);
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::operator!=( const const_iterator & other ) const
  {
    return !(*this == other);
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::operator!=( const iterator & other ) const
  {
    return !(*this == other);
  }

  template <typename T>
  Point4dl BorderIterator<T>::const_iterator::end() const
  {
    return Point4dl( std::numeric_limits<long>::max(),
                     std::numeric_limits<long>::max(),
                     std::numeric_limits<long>::max(),
                     std::numeric_limits<long>::max() );
  }

  template <typename T>
  long BorderIterator<T>::const_iterator::jumpX() const
  {
    if( _border._inside )
      return _border._volume.getSizeX() - _border._sizesup[0];
    else
      return _border._volume.getSizeX();
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::isBorder( const Point4dl & p ) const
  {
    if( _border._inside )
    {
      // outside allocated volume
      if( ( p[0] < 0 ) || ( p[0] >= _border._volume.getSizeX() ) ||
          ( p[1] < 0 ) || ( p[1] >= _border._volume.getSizeY() ) ||
          ( p[2] < 0 ) || ( p[2] >= _border._volume.getSizeZ() ) ||
          ( p[3] < 0 ) || ( p[3] >= _border._volume.getSizeT() ) )
        return false;
      // inside borders
      else if( ( p[0] < _border._sizeinf[0] ) ||
               ( p[0] >= _border._volume.getSizeX() - _border._sizesup[0] + 1 ) ||
               ( p[1] < _border._sizeinf[1] ) ||
               ( p[1] >= _border._volume.getSizeY() - _border._sizesup[1] + 1 ) ||
               ( p[2] < _border._sizeinf[2] ) ||
               ( p[2] >= _border._volume.getSizeZ() - _border._sizesup[2] + 1 ) ||
               ( p[3] < _border._sizeinf[3] ) ||
               ( p[3] >= _border._volume.getSizeT() - _border._sizesup[3] + 1 ) )
        return true;
      // inside non-border volume
      else
        return false;
    }
    else
    {
      // outside allocated volume
      if( ( p[0] < -_border._sizeinf[0] ) ||
          ( p[0] >= _border._volume.getSizeX() + _border._sizesup[0] ) ||
          ( p[1] < -_border._sizeinf[1] ) ||
          ( p[1] >= _border._volume.getSizeY() + _border._sizesup[1] ) ||
          ( p[2] < -_border._sizeinf[2] ) ||
          ( p[2] >= _border._volume.getSizeZ() + _border._sizesup[2] ) ||
          ( p[3] < -_border._sizeinf[3] ) ||
          ( p[3] >= _border._volume.getSizeT() + _border._sizesup[3] ) )
        return false;
      // inside border
      else if( ( p[0] < 0 ) || ( p[0] >= _border._volume.getSizeX() ) ||
               ( p[1] < 0 ) || ( p[1] >= _border._volume.getSizeY() ) ||
               ( p[2] < 0 ) || ( p[2] >= _border._volume.getSizeZ() ) ||
               ( p[3] < 0 ) || ( p[3] >= _border._volume.getSizeT() ) )
        return true;
      // inside non-border volume
      else
        return false;
    }
  }

  template <typename T>
  bool BorderIterator<T>::const_iterator::isNonBorderImage( const Point4dl & p ) const
  {
    if( _border._inside )
    {
      return( _border._sizeinf[0] <= p[0] && p[0] < _border._volume.getSizeX() - _border._sizesup[0] &&
              _border._sizeinf[1] <= p[1] && p[1] < _border._volume.getSizeY() - _border._sizesup[1] &&
              _border._sizeinf[2] <= p[2] && p[2] < _border._volume.getSizeZ() - _border._sizesup[2] &&
              _border._sizeinf[3] <= p[3] && p[3] < _border._volume.getSizeT() - _border._sizesup[3] );
    }
    else
    {
      return( 0 <= p[0] && p[0] < _border._volume.getSizeX() &&
              0 <= p[1] && p[1] < _border._volume.getSizeY() &&
              0 <= p[2] && p[2] < _border._volume.getSizeZ() &&
              0 <= p[3] && p[3] < _border._volume.getSizeT() );
    }
  }

  template <typename T>
  Point4dl BorderIterator<T>::const_iterator::reset(
    const Point4dl & p, const Point4dl & move ) const
  {
    Point4dl newp = p;

    if( _border._inside )
    {
      if( move[0] > 0 )
        newp[0] = 0;
      else if( move[1] > 0 )
        newp[1] = 0;
      else if( move[2] > 0 )
        newp[2] = 0;
      else if( move[3] > 0 )
        newp[3] = 0;
    }
    else
    {
      if( move[0] > 0 )
        newp[0] = -_border._sizeinf[0];
      else if( move[1] > 0 )
        newp[1] = -_border._sizeinf[1];
      else if( move[2] > 0 )
        newp[2] = -_border._sizeinf[2];
      else if( move[3] > 0 )
        newp[3] = -_border._sizeinf[3];
    }

    return newp;
  }

  template <typename T>
  Point4dl BorderIterator<T>::const_iterator::nextMove(
    const Point4dl & move ) const
  {
    if( move[0] > 0 )
      return Point4dl(0,1,0,0);
    else if( move[1] > 0 )
      return Point4dl(0,0,1,0);
    else if( move[2] > 0 )
      return Point4dl(0,0,0,1);
    else if( move[3] > 0 )
      return Point4dl(0,0,0,0);

    // error
    return move;
  }

  template <typename T>
  Point4dl BorderIterator<T>::const_iterator::computeNext(
    const Point4dl & current ) const
  {
    Point4dl move( 1, 0, 0, 0 );
    Point4dl next = current + move;
    while( !isBorder(next) && next != end() )
    {
      // if next is inside: jump inside image
      if( isNonBorderImage( next ) ) {
        next[0] = jumpX();
        move = Point4dl( 1, 0, 0, 0 );
      }
      // else: reset studied dim at line begin, and change dim
      else
      {
        next = reset( next, move );
        move = nextMove( move );
        if( move == Point4dl(0, 0, 0, 0) )
          next = end();
        else
          next = next + move;
      }
    }

    return next;
  }

  template <typename T>
  typename BorderIterator<T>::const_iterator & BorderIterator<T>::const_iterator::operator++()
  {
    _current = computeNext( _current );
    return *this;
  }

  template <typename T>
  typename BorderIterator<T>::const_iterator BorderIterator<T>::const_iterator::operator++(int)
  {
    typename BorderIterator<T>::const_iterator prev = *this;
    _current = computeNext( _current );
    return prev;
  }

  //--- iterator -------------------------------------------------------------
  template <typename T>
  BorderIterator<T>::iterator::iterator():
    const_iterator()
  {}

  template <typename T>
  BorderIterator<T>::iterator::iterator( BorderIterator<T> & b, bool end ):
    const_iterator(b,end)
  {}

  template <typename T>
  BorderIterator<T>::iterator::iterator( BorderIterator<T> & b, const Point4dl & current ):
    const_iterator(b, current)
  {}

  template <typename T>
  BorderIterator<T>::iterator::iterator(
    const typename BorderIterator<T>::iterator & other ):
    const_iterator(other)
  {}

  template <typename T>
  typename BorderIterator<T>::iterator & BorderIterator<T>::iterator::operator=(
    const typename BorderIterator<T>::iterator & other )
  {
    const_iterator::operator=( other );
    return *this;
  }

  template <typename T>
  T & BorderIterator<T>::iterator::operator*()
  {
    return const_iterator::_border._volume(
      const_iterator::_current[0],
      const_iterator::_current[1],
      const_iterator::_current[2],
      const_iterator::_current[3] );
  }

  template <typename T>
  T * BorderIterator<T>::iterator::operator->()
  {
    return &( const_iterator::_border._volume(
      const_iterator::_current[0],
      const_iterator::_current[1],
      const_iterator::_current[2],
      const_iterator::_current[3] ) );
  }

  template <typename T>
  typename BorderIterator<T>::iterator & BorderIterator<T>::iterator::operator++()
  {
    const_iterator::_current = const_iterator::computeNext(
      const_iterator::_current );
    return *this;
  }

  template <typename T>
  typename BorderIterator<T>::iterator BorderIterator<T>::iterator::operator++(int)
  {
    typename BorderIterator<T>::iterator prev = *this;
    const_iterator::_current = const_iterator::computeNext(
      const_iterator::_current );
    return prev;
  }

} // namespace aims

#endif // AIMSDATA_BORDER_BORDERITERATOR_H