BasicPointPredicates.h

 
#pragma once
 
#if defined(BasicPointPredicates_RECURSES)
#error Recursive header files inclusion detected in BasicPointPredicates.h
#else // defined(BasicPointPredicates_RECURSES)
#define BasicPointPredicates_RECURSES
 
#if !defined BasicPointPredicates_h
#define BasicPointPredicates_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/BasicBoolFunctors.h"
#include "DGtal/base/CPredicate.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/kernel/CPointPredicate.h"
 
// @since 0.8 In DGtal::functors
namespace DGtal {
  namespace functors {
 
  // template class ConstantPointPredicate
  template <typename TPoint, bool boolCst>
  struct ConstantPointPredicate
  {
    typedef TPoint Point;
 
    bool operator()( const Point & p ) const;
 
  }; // end of class ConstantPointPredicates
 
  // template class TruePointPredicate
  template <typename TPoint>
  struct TruePointPredicate : public ConstantPointPredicate<TPoint,true>
  {
  };
 
  // template class FalsePointPredicate
  template <typename TPoint>
  struct FalsePointPredicate : public ConstantPointPredicate<TPoint,false>
  {
  };
 
  // template class IsLowerPointPredicate
  template <typename TPoint>
  struct IsLowerPointPredicate
  {
    typedef TPoint Point;
 
    IsLowerPointPredicate( const Point & upperBound );
 
    bool operator()( const Point & p ) const;
 
    Point myUpperBound;
  };
 
  // template class IsUpperPointPredicate
  template <typename TPoint>
  struct IsUpperPointPredicate
  {
    typedef TPoint Point;
 
    IsUpperPointPredicate( const Point & lowerBound );
 
    bool operator()( const Point & p ) const;
 
    Point myLowerBound;
  };
 
  // template class IsWithinPointPredicate
  template <typename TPoint>
  struct IsWithinPointPredicate
  {
    typedef TPoint Point;
 
    IsWithinPointPredicate( const Point & lowerBound,
          const Point & upperBound );
 
    bool operator()( const Point & p ) const;
 
    Point myLowerBound;
    Point myUpperBound;
  };
 
  // template class NotPointPredicate
  template <typename TPointPredicate>
  struct NotPointPredicate
  {
    typedef TPointPredicate PointPredicate;
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate<PointPredicate> ));
    typedef typename PointPredicate::Point Point;
 
    NotPointPredicate( ConstAlias<PointPredicate> pred );
 
    bool operator()( const Point & p ) const;
 
    const PointPredicate* myPred;
  };
 
  // template class EqualPointPredicate
  template <typename TPoint>
  struct EqualPointPredicate
  {
    typedef TPoint Point;
 
    EqualPointPredicate( const Point & aPoint );
 
    bool operator()( const Point & p ) const;
 
    Point myPoint;
  };
 
  // template class BinaryPointPredicate
  template <typename TPointPredicate1, typename TPointPredicate2,
      typename TBinaryFunctor = BoolFunctor2 >
  struct BinaryPointPredicate
  {
    typedef TPointPredicate1 PointPredicate1;
    typedef TPointPredicate2 PointPredicate2;
    typedef typename PointPredicate1::Point Point;
    typedef typename PointPredicate2::Point Point2;
 
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate1 > ));
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate2 > ));
    BOOST_CONCEPT_ASSERT (( boost::BinaryFunction< TBinaryFunctor, bool, bool, bool > ));
    BOOST_STATIC_ASSERT (( boost::is_same< Point, Point2 >::value ));
 
    BinaryPointPredicate( ConstAlias<PointPredicate1> pred1, ConstAlias<PointPredicate2> pred2, ConstAlias<TBinaryFunctor> boolFunctor );
 
    bool operator()( const Point & p ) const;
 
    const PointPredicate1* myPred1;
    const PointPredicate2* myPred2;
    const TBinaryFunctor* myBoolFunctor;
  };
 
  template <typename TPointPredicate1, typename TPointPredicate2>
  struct BinaryPointPredicate<TPointPredicate1, TPointPredicate2, AndBoolFct2>
  {
    typedef TPointPredicate1 PointPredicate1;
    typedef TPointPredicate2 PointPredicate2;
    typedef typename PointPredicate1::Point Point;
    typedef typename PointPredicate2::Point Point2;
 
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate1 > ));
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate2 > ));
    BOOST_STATIC_ASSERT (( boost::is_same< Point, Point2 >::value ));
 
    BinaryPointPredicate( ConstAlias<PointPredicate1> pred1, ConstAlias<PointPredicate2> pred2, ConstAlias<AndBoolFct2> boolFunctor );
 
    bool operator()( const Point & p ) const;
 
    const PointPredicate1* myPred1;
    const PointPredicate2* myPred2;
    const AndBoolFct2* myBoolFunctor;
  };
 
  template <typename TPointPredicate1, typename TPointPredicate2>
  struct BinaryPointPredicate<TPointPredicate1, TPointPredicate2, OrBoolFct2>
  {
    typedef TPointPredicate1 PointPredicate1;
    typedef TPointPredicate2 PointPredicate2;
    typedef typename PointPredicate1::Point Point;
    typedef typename PointPredicate2::Point Point2;
 
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate1 > ));
    BOOST_CONCEPT_ASSERT (( concepts::CPointPredicate< PointPredicate2 > ));
    BOOST_STATIC_ASSERT (( boost::is_same< Point, Point2 >::value ));
 
    BinaryPointPredicate( ConstAlias<PointPredicate1> pred1, ConstAlias<PointPredicate2> pred2, ConstAlias<OrBoolFct2> boolFunctor );
 
    bool operator()( const Point & p ) const;
 
    const PointPredicate1* myPred1;
    const PointPredicate2* myPred2;
    const OrBoolFct2* myBoolFunctor;
  };
 
  // template class PointFunctorPredicate
  template <typename TPointFunctor, typename TPredicate>
  struct PointFunctorPredicate
  {
    BOOST_CONCEPT_ASSERT (( concepts::CPointFunctor< TPointFunctor > ));
    BOOST_CONCEPT_ASSERT (( concepts::CUnaryFunctor< TPredicate, typename TPointFunctor::Value, bool > ));
 
    typedef TPointFunctor PointFunctor;
    typedef TPredicate Predicate;
    typedef typename PointFunctor::Point Point;
 
    PointFunctorPredicate( ConstAlias<PointFunctor> aFun, ConstAlias<Predicate> aPred );
 
    bool operator()( const Point & p ) const;
 
    const PointFunctor* myFun;
    const Predicate* myPred;
  };
 
} // namespace functors
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/kernel/BasicPointPredicates.ih"
 
//                                                                           //
 
#endif // !defined BasicPointPredicates_h
 
#undef BasicPointPredicates_RECURSES
#endif // else defined(BasicPointPredicates_RECURSES)