ImageAdapter.h

#pragma once

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

#define ImageAdapter_RECURSES

#if !defined ImageAdapter_h

#define ImageAdapter_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/images/CImage.h"
#include "DGtal/kernel/domains/CDomain.h"

#include "DGtal/images/DefaultConstImageRange.h"
#include "DGtal/images/DefaultImageRange.h"

namespace DGtal
{
// Template class ImageAdapter
template <typename TImageContainer,
          typename TNewDomain,
          typename TFunctorD,
          typename TNewValue,
          typename TFunctorV,
          typename TFunctorVm1>
class ImageAdapter
{

    // ----------------------- Types ------------------------------

public:
    typedef ImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV, TFunctorVm1> Self; 

    BOOST_CONCEPT_ASSERT(( CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( CDomain<TNewDomain> ));
   
    typedef TNewDomain Domain;
    typedef typename TNewDomain::Point Point;
    typedef TNewValue Value;

    BOOST_CONCEPT_ASSERT(( CUnaryFunctor<TFunctorD, typename TImageContainer::Point, Point> ));
    BOOST_CONCEPT_ASSERT(( CUnaryFunctor<TFunctorVm1, typename TImageContainer::Value, Value> ));

    typedef TImageContainer ImageContainer;

    typedef DefaultConstImageRange<Self> ConstRange; 
    typedef DefaultImageRange<Self> Range; 

    // ----------------------- Standard services ------------------------------

public:

    ImageAdapter(ImageContainer &anImage, const Domain &aDomain, const TFunctorD &aFD, const TFunctorV &aFV, const TFunctorVm1 &aFVm1):
            myImagePtr(&anImage), mySubDomainPtr(&aDomain), myFD(&aFD), myFV(&aFV), myFVm1(&aFVm1)
    {
#ifdef DEBUG_VERBOSE
        trace.warning() << "ImageAdapter Ctor fromRef " << std::endl;
#endif
    }

    ImageAdapter & operator= ( const ImageAdapter & other )
    {
#ifdef DEBUG_VERBOSE
        trace.warning() << "ImageAdapter assignment " << std::endl;
#endif
        if (&other != this)
        {
            myImagePtr = other.myImagePtr;
            mySubDomainPtr = other.mySubDomainPtr;
            myFD = other.myFD;
            myFV = other.myFV;
            myFVm1 = other.myFVm1;
        }
        return *this;
    }


    ~ImageAdapter() {}

    // ----------------------- Interface --------------------------------------
public:


    const Domain & domain() const
    {
        return (*mySubDomainPtr);
    }

    ConstRange constRange() const
    {
        return ConstRange( *this );
    }

    Range range()
    {
        return Range( *this );
    }



    Value operator()(const Point & aPoint) const
    {
        ASSERT(this->domain().isInside(aPoint));
        
        return myFV->operator()(myImagePtr->operator()(myFD->operator()(aPoint)));
    }



    void setValue(const Point &aPoint, const typename TImageContainer::Value &aValue)
    {
        ASSERT(this->domain().isInside(aPoint));
        
        myImagePtr->setValue(myFD->operator()(aPoint), myFVm1->operator()(aValue));
    }




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

    bool isValid() const
    {
        return (myImagePtr->isValid() );
    }


    const ImageContainer * getPointer() const
    {
        return myImagePtr;
    }

    // ------------------------- Protected Datas ------------------------------
private:
    ImageAdapter() {
#ifdef DEBUG_VERBOSE
        trace.warning() << "ImageAdapter Ctor default " << std::endl;
#endif
    }
    
    // ------------------------- Private Datas --------------------------------
protected:

    ImageContainer * myImagePtr;
    
    const Domain *mySubDomainPtr;
    
    const TFunctorD* myFD;

    const TFunctorV* myFV;
    
    const TFunctorVm1* myFVm1;


private:


    // ------------------------- Internals ------------------------------------
private:

}; // end of class ImageAdapter


template <typename TImageContainer, typename TNewDomain, typename TFunctorD, typename TNewValue, typename TFunctorV, typename TFunctorVm1>
std::ostream&
operator<< ( std::ostream & out, const ImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV, TFunctorVm1> & object );

} // namespace DGtal


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

//                                                                           //

#endif // !defined ImageAdapter_h

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