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)