ImageContainerBySTLVector.h

#pragma once

#if defined(ImageContainerBySTLVector_RECURSES)
#error Recursive header files inclusion detected in ImageContainerBySTLVector.h
#else // defined(ImageContainerBySTLVector_RECURSES)

#define ImageContainerBySTLVector_RECURSES

#if !defined ImageContainerBySTLVector_h

#define ImageContainerBySTLVector_h

// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/base/SimpleRandomAccessConstRangeFromPoint.h"
#include "DGtal/base/SimpleRandomAccessRangeFromPoint.h"
#include "DGtal/base/CLabel.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/kernel/NumberTraits.h"


namespace DGtal
{


  template<typename TImage>
  class DistanceFunctorFromPoint
  {

  public:

    typedef typename TImage::Point Point;
    typedef typename TImage::Difference Difference;

  public:

    DistanceFunctorFromPoint( const TImage *aImagePtr): myImagePtr(aImagePtr)
    {};

    Difference operator() ( const Point &aPoint ) const
    {
      return Difference ( myImagePtr->linearized ( aPoint ) );
    }
  private:
    const TImage *myImagePtr;

  };

  // class ImageContainerBySTLVector

  template <typename TDomain, typename TValue>

  class ImageContainerBySTLVector: public std::vector<TValue>
  {

  public:

    typedef ImageContainerBySTLVector<TDomain, TValue> Self;

    BOOST_CONCEPT_ASSERT ( ( concepts::CDomain<TDomain> ) );
    typedef TDomain Domain;
    typedef typename Domain::Point Point;
    typedef typename Domain::Vector Vector;
    typedef typename Domain::Integer Integer;
    typedef typename Domain::Size Size;
    typedef typename Domain::Dimension Dimension;
    typedef Point Vertex;

    BOOST_STATIC_CONSTANT( Dimension, dimension = Domain::Space::dimension ); 

    BOOST_STATIC_ASSERT ( ( boost::is_same< Domain,
                                            HyperRectDomain< typename Domain::Space > >::value ) );

    BOOST_CONCEPT_ASSERT ( ( concepts::CLabel<TValue> ) );
    typedef TValue Value;


  private:

    Domain myDomain;

    Vector myExtent;


  public:

    ImageContainerBySTLVector ( const Domain &aDomain );

    ImageContainerBySTLVector ( const ImageContainerBySTLVector & other );

    ImageContainerBySTLVector& operator= ( const ImageContainerBySTLVector & other );

    ~ImageContainerBySTLVector();




    Value operator() ( const Point & aPoint ) const;

    void setValue ( const Point &aPoint, const Value &aValue );

    const Domain &domain() const;


    Vector extent() const;

    void translateDomain ( const Vector& aShift );

    void selfDisplay ( std::ostream & out ) const;


    bool isValid() const;

    // ------------- realization CDrawableWithBoard2D --------------------

    std::string className() const;


    // built-in iterators
    typedef typename std::vector<Value>::iterator Iterator;
    typedef typename std::vector<Value>::const_iterator ConstIterator;
    typedef typename std::vector<Value>::reverse_iterator ReverseIterator;
    typedef typename std::vector<Value>::const_reverse_iterator ConstReverseIterator;
    typedef typename std::vector<Value>::difference_type Difference;

    typedef typename std::vector<Value>::iterator OutputIterator;
    typedef typename std::vector<Value>::reverse_iterator ReverseOutputIterator;

    typedef SimpleRandomAccessConstRangeFromPoint<ConstIterator,DistanceFunctorFromPoint<Self> > ConstRange;
    typedef SimpleRandomAccessRangeFromPoint<ConstIterator,Iterator,DistanceFunctorFromPoint<Self> > Range;

    ConstRange constRange() const;

    Range range();



    class SpanIterator
    {

      friend class ImageContainerBySTLVector<Domain, Value>;

    public:

      typedef std::bidirectional_iterator_tag iterator_category;
      typedef Value value_type;
      typedef ptrdiff_t difference_type;
      typedef Value* pointer;
      typedef Value& reference;

      SpanIterator ( const Point & p ,
                     const Dimension aDim ,
                     ImageContainerBySTLVector<Domain, Value> *aMap ) :  myMap ( aMap ), myDimension ( aDim )
      {
        myPos = aMap->linearized ( p );

        //We compute the myShift quantity
        myShift = 1;

        for ( Dimension k = 0; k < myDimension  ; k++ )
          myShift *= aMap->myExtent[k];
      }


      inline
      void setValue ( const Value aVal )
      {
        ( *myMap ) [ myPos ] = aVal;
      }

      inline
      const Value & operator*()
      {
        return ( *myMap ) [ myPos ];
      }

      inline
      bool operator== ( const SpanIterator &it ) const
      {
        return ( myPos == it.myPos );
      }

      inline
      bool operator!= ( const SpanIterator &it ) const
      {
        return ( myPos != it.myPos );
      }

      inline
      void next()
      {
        myPos += myShift;
      }

      inline
      void prev()
      {
        ASSERT ( ( long int ) myPos - myShift > 0 );
        myPos -= myShift;
      }

      inline
      SpanIterator &operator++()
      {
        this->next();
        return *this;
      }

      inline
      SpanIterator &operator++ ( int )
      {
        SpanIterator tmp = *this;
        ++*this;
        return tmp;
      }

      inline
      SpanIterator &operator--()
      {
        this->prev();
        return *this;
      }

      inline
      SpanIterator &operator-- ( int )
      {
        SpanIterator tmp = *this;
        --*this;
        return tmp;
      }

    private:
      Size myPos;

      ImageContainerBySTLVector<Domain, Value> *myMap;

      Dimension  myDimension;

      Size myShift;

    };

    void setValue ( SpanIterator &it, const Value &aValue )
    {
      it.setValue ( aValue );
    }


    SpanIterator spanBegin ( const Point &aPoint, const Dimension aDimension )
    {
      return SpanIterator ( aPoint, aDimension, this );
    }

    SpanIterator spanEnd ( const Point &aPoint, const Dimension aDimension )
    {
      Point tmp = aPoint;
      tmp[ aDimension ] = myDomain.upperBound() [ aDimension ] + 1;
      return SpanIterator ( tmp, aDimension, this );
    }

    Value getValue ( SpanIterator &it )
    {
      return ( *it );
    };




    Size linearized ( const Point &aPoint ) const;



  };

  template <typename Domain, typename V>
  inline
  std::ostream&
  operator<< ( std::ostream & out, const ImageContainerBySTLVector<Domain, V> & object )
  {
    object.selfDisplay ( out );
    return out;
  }

} // namespace DGtal


// Includes inline functions
#include "DGtal/images/ImageContainerBySTLVector.ih"

//                                                                           //

#endif // !defined ImageContainerBySTLVector_h

#undef ImageContainerBySTLVector_RECURSES
#endif // else defined(ImageContainerBySTLVector_RECURSES)