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 ( ( 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;

    static const typename Domain::Dimension dimension = Domain::dimension;

    BOOST_STATIC_ASSERT ( ( boost::is_same< Domain,
                            HyperRectDomain<SpaceND<dimension, Integer> > >::value ) );

    BOOST_CONCEPT_ASSERT ( ( CLabel<TValue> ) );
    typedef TValue Value;
    // obsolete
    // typedef SimpleConstRange<typename vector<Value>::const_iterator > ConstRange;


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 vector<Value>::iterator Iterator;
    typedef typename vector<Value>::const_iterator ConstIterator;
    typedef typename vector<Value>::reverse_iterator ReverseIterator;
    typedef typename vector<Value>::const_reverse_iterator ConstReverseIterator;
    typedef typename vector<Value>::difference_type Difference;

    typedef typename vector<Value>::iterator OutputIterator;
    typedef typename 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)