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( const ImageAdapter & other ) = default;
 
    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)