exampleFunctorHolder.cpp

Go to the documentation of this file.

 
// Inclusions
#include <iostream>
#include <numeric>
#include <iterator>
#include <utility>
 
#include "DGtal/base/FunctorHolder.h"
#include "DGtal/kernel/PointVector.h"
 
#include "DGtal/base/Common.h"
#include "DGtal/helpers/StdDefs.h"
#include "ConfigExamples.h"
#include "DGtal/io/readers/PGMReader.h"
#include "DGtal/io/readers/GenericReader.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/kernel/BasicPointPredicates.h"
 
 
inline double signed_dist_to_unit_circle(DGtal::PointVector<2, double> const& pt)
{
  return pt.norm() - 1.;
}
 
template <typename Point>
inline
typename Point::Component
templated_signed_dist_to_unit_circle(Point const& pt)
{
  return pt.norm() - typename Point::Component(1);
}
 
template <typename Point>
struct SignedDistToCircle
{
  using Real = typename Point::Component;
 
  Point center;
  Real  radius;
 
  SignedDistToCircle(Point const& pt, Real r)
    : center(pt), radius(r)
  {}
 
  inline
  Real operator() (Point const& pt) const
    {
      return (pt - center).norm() - radius;
    }
};
 
template <typename T>
struct Binarizer
{
  T threshold;
  explicit Binarizer(T v) : threshold(v) {}
  Binarizer& operator= (Binarizer const&) = delete; // This is not a model of boost::Assignable
  bool operator() (T v) const { return v <= threshold; }
};
 
template <typename T>
inline
decltype(DGtal::functors::holdFunctor(Binarizer<T>(128))) // Deduced return type
get_trivial_binarizer()
{
  return DGtal::functors::holdFunctor( Binarizer<T>(128) );
}
 
template <typename Iterator>
auto get_mean_binarizer_from_range(Iterator first, Iterator last) // auto as return type
     -> decltype(DGtal::functors::holdFunctor(Binarizer<decltype(*first / std::distance(first, last))>(0)))
     // with trailing return type specification using ->
{
  using value_type = typename std::iterator_traits<Iterator>::value_type;
  auto const mean = std::accumulate(first, last, value_type(0));
  auto const size = std::distance(first, last);
  return DGtal::functors::holdFunctor(Binarizer<decltype(mean / size)>(mean / size));
}
 
template <typename Image>
auto get_mean_binarizer_from_an_image(std::string const& file_name)
    -> decltype(get_mean_binarizer_from_range(
          std::declval<Image>().begin(), std::declval<Image>().end() ))
{
  Image const image = DGtal::GenericReader<Image>::import(file_name);
  return get_mean_binarizer_from_range(image.begin(), image.end());
}
 
#if __cplusplus >= 201402L
template <typename Iterator>
auto get_mean_binarizer_from_range_cpp14(Iterator first, Iterator last)
{
  using value_type = typename std::iterator_traits<Iterator>::value_type;
  auto const mean = std::accumulate(first, last, value_type(0));
  auto const size = std::distance(first, last);
  return DGtal::functors::holdFunctor(Binarizer<decltype(mean / size)>(mean / size));
}
#endif
 
template <typename T>
inline
Binarizer<T> makeBinarizer( T const& v ) // T auto-deduced from the parameter v
{
  return Binarizer<T>(v);
}
 
#if 0
template <
  typename PointFunctor,
  typename Predicate
>
DGtal::functors::PointFunctorPredicate<PointFunctor, Predicate>
makePointFunctorPredicate_Example(
    DGtal::ConstAlias<PointFunctor> aFun,
    DGtal::ConstAlias<Predicate> aPred)
{
  return DGtal::functors::PointFunctorPredicate<PointFunctor, Predicate>( aFun, aPred );
}
#endif
 
template <
  typename PointFunctor,
  typename Predicate
>
DGtal::functors::PointFunctorPredicate<PointFunctor, Predicate>
makePointFunctorPredicate_Example( PointFunctor const& aFun, Predicate const& aPred )
{
  return DGtal::functors::PointFunctorPredicate<PointFunctor, Predicate>( aFun, aPred );
}
 
template <
  typename PointFunctor,
  typename Predicate
>
DGtal::functors::PointFunctorPredicate<
  typename std::decay<PointFunctor>::type,
  typename std::decay<Predicate>::type
>
makePointFunctorPredicate_Example2( PointFunctor && aFun, Predicate && aPred )
{
  return DGtal::functors::PointFunctorPredicate<
      typename std::decay<PointFunctor>::type,
      typename std::decay<Predicate>::type
  >(
    std::forward<PointFunctor>(aFun),
    std::forward<Predicate>(aPred)
  );
}
 
int main()
{
 
  // Holding a function
 
  {
    std::cout << "Holding a function" << std::endl;
    auto fn = DGtal::functors::holdFunctor( signed_dist_to_unit_circle );
    using Point = DGtal::PointVector<2, double>;
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a templated function" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    auto fn = DGtal::functors::holdFunctor( templated_signed_dist_to_unit_circle<Point> );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a function through a lambda" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    auto fn = DGtal::functors::holdFunctor( [] (Point const& pt) { return signed_dist_to_unit_circle(pt); } );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a templated function through a lambda" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    auto fn = DGtal::functors::holdFunctor( [] (Point const& pt) { return templated_signed_dist_to_unit_circle(pt); } );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
#if __cplusplus >= 201402L
  {
    std::cout << "Holding a templated function through a C++14 lambda" << std::endl;
    auto fn = DGtal::functors::holdFunctor( [] (auto const& pt) { return templated_signed_dist_to_unit_circle(pt); } );
    using Point = DGtal::PointVector<2, double>;
    std::cout << fn( Point(1, 1) ) << std::endl; // <- template parameter is resolved to Point
  }
#endif
 
  // Holding a functor
 
  {
    std::cout << "Holding a functor by (lvalue) reference" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    SignedDistToCircle<Point> dist(Point(0, 1), 2);
    auto fn = DGtal::functors::holdFunctor( dist );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a functor by rvalue reference" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    auto fn = DGtal::functors::holdFunctor( SignedDistToCircle<Point>( Point(0, 1), 2 ) );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a functor by moving it" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    SignedDistToCircle<Point> dist(Point(0, 1), 2);
    auto fn = DGtal::functors::holdFunctor( std::move(dist) );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  // Holding a lambda
 
  {
    std::cout << "Holding a lambda" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    Point center(0, 1);
    double radius = 2;
 
    auto fn = DGtal::functors::holdFunctor(
        [&center, &radius] (Point const& pt) {
            return (pt - center).norm() - radius;
        }
    );
    std::cout << fn( Point(1, 1) ) << std::endl;
  }
 
  {
    std::cout << "Holding a non-unary lambda" << std::endl;
    using Point = DGtal::PointVector<2, double>;
 
    auto dist = [] (Point const& pt, Point const& center, double radius)
      {
        return (pt - center).norm() - radius;
      };
 
    auto fn = DGtal::functors::holdFunctor( dist );
 
    std::cout << fn( Point(1, 1), Point(0, 1), 2 ) << std::endl;
  }
 
  // Copying
 
  {
    std::cout << "Copying a functor held by lvalue reference" << std::endl;
    using Point = DGtal::PointVector<2, double>;
    SignedDistToCircle<Point> dist(Point(0, 1), 2);
    auto fn = DGtal::functors::holdFunctor( dist );
    auto fn2 = fn;
 
    std::cout << fn( Point(1, 1) ) << std::endl;  // Output: -1
    std::cout << fn2( Point(1, 1) ) << std::endl; // Output: -1
 
    dist.radius = 3; // fn and fn2 both refer to the same functor dist.
 
    std::cout << fn( Point(1, 1) ) << std::endl;  // Output: -2
    std::cout << fn2( Point(1, 1) ) << std::endl; // Output: -2
  }
 
  {
    std::cout << "Copying a lambda held by rvalue reference" << std::endl;
    int init_cnt = 0;
    auto fn = DGtal::functors::holdFunctor( [init_cnt] () mutable { return ++init_cnt; } );
    std::cout << fn() << std::endl;  // Output: 1
    auto fn2 = fn;
    std::cout << fn2() << std::endl; // Output: 2
    std::cout << fn() << std::endl;  // Output: 3
  }
 
  // Type of FunctorHolder
 
  {
    std::cout << "Storing a FunctorHolder" << std::endl;
 
    using Point = DGtal::PointVector<2, double>;
    auto fn = DGtal::functors::holdFunctor( SignedDistToCircle<Point>( Point(0, 1), 2 ) );
  }
 
  {
    std::cout << "Passing a FunctorHolder" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = DGtal::functors::holdFunctor( [] (Image::Value v) { return v <= 135; } );
    DGtal::functors::PointFunctorPredicate<Image, decltype(binarizer)> predicate(image, binarizer);
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
 
  {
    std::cout << "Returning a functor" << std::endl;
    auto binarizer = get_trivial_binarizer<int>();
    std::cout << "binarizer(120) = " << binarizer(120) << std::endl;
  }
 
  {
    std::cout << "Returning a functor using trailing return syntax" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = get_mean_binarizer_from_range(image.begin(), image.end());
    DGtal::functors::PointFunctorPredicate<Image, decltype(binarizer)> predicate(image, binarizer);
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
 
  {
    std::cout << "Returning a functor using trailing return syntax and declval" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    std::string filename =  examplesPath + "samples/contourS.pgm";
 
    auto binarizer = get_mean_binarizer_from_an_image<Image>(filename);
 
    std::cout << "binarizer(120) = " << binarizer(120) << std::endl;
  }
 
  #if __cplusplus >= 201402L
  {
    std::cout << "Returning a functor using auto in C++14" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = get_mean_binarizer_from_range_cpp14(image.begin(), image.end());
    DGtal::functors::PointFunctorPredicate<Image, decltype(binarizer)> predicate(image, binarizer);
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
  #endif
 
  {
    std::cout << "Usage of Binarizer factory" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = DGtal::functors::holdFunctor( makeBinarizer(135) );
    DGtal::functors::PointFunctorPredicate<Image, decltype(binarizer)> predicate(image, binarizer);
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
 
 
  #if __cplusplus >= 201703L
  {
    std::cout << "Binarizer factory using deduction guides of C++17" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = DGtal::functors::holdFunctor( Binarizer(135) ); // Binarizer template parameter is not specified.
    DGtal::functors::PointFunctorPredicate<Image, decltype(binarizer)> predicate(image, binarizer);
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
  #endif
 
  {
    std::cout << "Usage of PointFunctorPredicate factory" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = DGtal::functors::holdFunctor( makeBinarizer(135) );
    auto predicate = makePointFunctorPredicate_Example( image, binarizer );
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
 
  {
    std::cout << "Usage of PointFunctorPredicate factory with perfect forwarding" << std::endl;
 
    //image import
    using Image = DGtal::ImageContainerBySTLVector< DGtal::Z2i::Domain, int>;
    using Point = Image::Point;
    std::string filename =  examplesPath + "samples/contourS.pgm";
    Image image = DGtal::PGMReader<Image>::importPGM(filename);
 
    auto binarizer = DGtal::functors::holdFunctor( makeBinarizer(135) );
    auto predicate = makePointFunctorPredicate_Example2( image, binarizer );
 
    Point const pt(50, 25);
    std::cout << "binarizer(" << image( pt ) << ") = " << predicate( pt ) << std::endl;
  }
  return 0;
}