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/ConstAlias.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(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CDomain<TNewDomain> ));
   
    typedef TNewDomain Domain;
    typedef typename TNewDomain::Point Point;
    typedef TNewValue Value;

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

    typedef TImageContainer ImageContainer;

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

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

public:

    ImageAdapter(
                 ImageContainer &anImage, 
                 ConstAlias<Domain>       aDomain, 
                 ConstAlias<TFunctorD>    aFD,
                 ConstAlias<TFunctorV>    aFV,
                 ConstAlias<TFunctorVm1>  aFVm1
      ) :
            myImagePtr(&anImage), mySubDomainPtr(&aDomain), myFD(&aFD), myFV(&aFV), myFVm1(&aFVm1)
    {
      defaultValue = 0;
#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;
            defaultValue = other.defaultValue;
        }
        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));
      
      typename TImageContainer::Point point = myFD->operator()(aPoint);
      if (myImagePtr->domain().isInside(point))
        return myFV->operator()(myImagePtr->operator()(point));
      else
        return defaultValue;
    }
    



    void setValue(const Point &aPoint, const  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;
    }
    
    void setDefaultValue ( Value aValue )
    {
      defaultValue = aValue;
    }
    
    Value getDefaultValue () const
    {
      return defaultValue;
    }

    // ------------------------- 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;
    
    Value defaultValue;


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)