ConstImageAdapter.h

 
#pragma once
 
#if defined(ConstImageAdapter_RECURSES)
#error Recursive header files inclusion detected in ConstImageAdapter.h
#else // defined(ConstImageAdapter_RECURSES)
#define ConstImageAdapter_RECURSES
 
#if !defined ConstImageAdapter_h
#define ConstImageAdapter_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"
 
namespace DGtal
{
// Template class ConstImageAdapter
template <typename TImageContainer,
          typename TNewDomain,
          typename TFunctorD,
          typename TNewValue, typename TFunctorV>
class ConstImageAdapter
{
 
    // ----------------------- Types ------------------------------
 
public:
    typedef ConstImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV> Self;
 
    BOOST_CONCEPT_ASSERT(( concepts::CConstImage<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> ));
 
    typedef TImageContainer ImageContainer;
 
    typedef DefaultConstImageRange<Self> ConstRange;
 
    // ----------------------- Standard services ------------------------------
 
public:
 
    ConstImageAdapter(
                      ConstAlias<ImageContainer> anImage,
                      ConstAlias<Domain> aDomain,
                      ConstAlias<TFunctorD> aFD,
                      ConstAlias<TFunctorV> aFV
      ) :
            myImagePtr(&anImage), mySubDomainPtr(&aDomain), myFD(&aFD), myFV(&aFV)
    {
      defaultValue = 0;
#ifdef DEBUG_VERBOSE
        trace.warning() << "ConstImageAdapter Ctor fromRef " << std::endl;
#endif
    }
 
    ConstImageAdapter( const ConstImageAdapter & other ) = default;
 
    ConstImageAdapter & operator= ( const ConstImageAdapter & other )
    {
#ifdef DEBUG_VERBOSE
        trace.warning() << "ConstImageAdapter assignment " << std::endl;
#endif
        if (&other != this)
        {
            myImagePtr = other.myImagePtr;
            mySubDomainPtr = other.mySubDomainPtr;
            myFD = other.myFD;
            myFV = other.myFV;
            defaultValue = other.defaultValue;
        }
        return *this;
    }
 
 
    ~ConstImageAdapter() {}
 
    // ----------------------- Interface --------------------------------------
public:
 
 
    const Domain & domain() const
    {
      return (*mySubDomainPtr);
    }
 
    ConstRange constRange() const
    {
        return ConstRange( *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 selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const
    {
        return (myImagePtr->isValid() );
    }
 
 
    std::string className() const;
 
 
    const ImageContainer * getPointer() const
    {
        return myImagePtr;
    }
    
    void setDefaultValue ( Value aValue )
    {
      defaultValue = aValue;
    }
    
    Value getDefaultValue () const
    {
      return defaultValue;
    }
 
    // ------------------------- Protected Datas ------------------------------
private:
    ConstImageAdapter() {
#ifdef DEBUG_VERBOSE
        trace.warning() << "ConstImageAdapter Ctor default " << std::endl;
#endif
    }
 
    // ------------------------- Private Datas --------------------------------
protected:
 
    const ImageContainer * myImagePtr;
 
    const Domain *mySubDomainPtr;
 
    const TFunctorD* myFD;
 
    const TFunctorV* myFV;
    
    Value defaultValue;
 
private:
 
 
    // ------------------------- Internals ------------------------------------
private:
 
}; // end of class ConstImageAdapter
 
 
template <typename TImageContainer, typename TNewDomain, typename TFunctorD, typename TNewValue, typename TFunctorV>
std::ostream&
operator<< ( std::ostream & out, const ConstImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/ConstImageAdapter.ih"
 
//                                                                           //
 
#endif // !defined ConstImageAdapter_h
 
#undef ConstImageAdapter_RECURSES
#endif // else defined(ConstImageAdapter_RECURSES)