ImageHelper.h

 
#pragma once
 
#if defined(ImageHelper_RECURSES)
#error Recursive header files inclusion detected in ImageHelper.h
#else // defined(ImageHelper_RECURSES)
#define ImageHelper_RECURSES
 
#if !defined ImageHelper_h
#define ImageHelper_h
 
// Inclusions
#include <iostream>
#include <algorithm>
#include <functional>
 
#include "DGtal/base/Common.h"
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/CConstSinglePassRange.h"
#include "DGtal/kernel/BasicPointPredicates.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/images/CConstImage.h"
#include "DGtal/images/ConstImageAdapter.h"
#include "DGtal/images/CImage.h"
#include "DGtal/base/CQuantity.h"
#include "DGtal/images/ImageContainerBySTLMap.h"
#include "DGtal/images/SetValueIterator.h"
#include "DGtal/kernel/sets/DigitalSetFromMap.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/base/ConstAlias.h"
 
 
namespace DGtal
{
 
 
  template<typename I, typename O, typename P>
  void setFromPointsRangeAndPredicate(const I& itb, const I& ite, const O& ito, const P& aPred); 
 
  template<typename I, typename O, typename F>
  void setFromPointsRangeAndFunctor(const I& itb, const I& ite, 
                                    const O& ito, const F& aFunctor, 
                                    const typename F::Value& aThreshold = 0); 
 
  template<typename I, typename O>
  void setFromImage(const I& aImg, 
                    const O& ito, 
                    const typename I::Value& aThreshold = 0); 
 
  template<typename I, typename O>
  void setFromImage(const I& aImg, 
                    const O& ito, 
                    const typename I::Value& low,
                    const typename I::Value& up); 
 
 
  template<typename It, typename Im>
  void imageFromRangeAndValue(const It& itb, const It& ite, Im& aImg, 
                              const typename Im::Value& aValue = 0); 
 
  template<typename R, typename I>
  void imageFromRangeAndValue(const R& aRange, I& aImg, 
                              const typename I::Value& aValue = 0); 
 
  template<typename I, typename F>
  void imageFromFunctor(I& aImg, const F& aFun); 
 
  template<typename I1, typename I2>
  void imageFromImage(I1& aImg1, const I2& aImg2); 
 
  template<typename I, typename S>
  bool insertAndSetValue(I& aImg, S& aSet, 
                         const typename I::Point& aPoint, 
                         const typename I::Value& aValue ); 
 
  template<typename I, typename S>
  bool insertAndAlwaysSetValue(I& aImg, S& aSet, 
                               const typename I::Point& aPoint, 
                               const typename I::Value& aValue ); 
 
  template<typename I, typename S>
  bool findAndGetValue(const I& aImg, const S& aSet, 
                       const typename I::Point& aPoint, 
                       typename I::Value& aValue ); 
 
 
 
 
  template<typename Image, typename PointPredicate, typename TValue=DGtal::int32_t>
  class ImageToConstantFunctor
  {
  public:
 
    typedef typename Image::Point Point;
    typedef TValue Value;
    
    BOOST_CONCEPT_ASSERT(( concepts::CConstImage<Image> ));
    BOOST_CONCEPT_ASSERT(( concepts::CPointPredicate<PointPredicate> ));
    BOOST_CONCEPT_ASSERT(( concepts::CQuantity<Value> ));
    
    /*BOOST_CONCEPT_USAGE(ImageToConstantFunctor)
    {
        Point p1;
        typename PointPredicate::Point p2;
        ConceptUtils::sameType( p1, p2 );
    }*/
    
    ImageToConstantFunctor( ConstAlias< Image > anImage,
                            ConstAlias< PointPredicate > aPointPred,
                            Value aVal = NumberTraits< Value >::ONE,
                            bool reverseValues = false )
      : myImage(&anImage),
        myPointPred(&aPointPred),
        myVal(aVal),
        reverse(reverseValues)
    {}
    
    Value operator()( const Point &aPoint ) const
    {
      if ((myImage->domain().isInside(aPoint)))
      {
          if( reverse )
          {
              if( !myPointPred->operator()(aPoint) )
              {
                  return myVal;
              }
              else
              {
                  return NumberTraits<Value>::ZERO;
              }
          }
          else
          {
              if( myPointPred->operator()(aPoint) )
              {
                  return myVal;
              }
              else
              {
                  return NumberTraits<Value>::ZERO;
              }
          }
      }
      else
      {
        return NumberTraits<Value>::ZERO;
      }
    }
 
    private:
    
    const Image *myImage;
    
    const PointPredicate *myPointPred;
 
    Value myVal;
 
    bool reverse;
  };
 
 
 
 
 
} // namespace DGtal
 
// Includes inline functions
#include "DGtal/images/ImageHelper.ih"
//                                                                           //
 
#endif // !defined ImageHelper_h
 
#undef ImageHelper_RECURSES
#endif // else defined(ImageHelper_RECURSES)