BasicPointPredicates.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.
template <typename TPoint, bool boolCst>
inline
bool
DGtal::ConstantPointPredicate<TPoint,boolCst>
::operator()( const Point & p ) const
{
  return boolCst;
}
//------------------------------------------------------------------------------
template <typename TPoint>
inline
DGtal::IsLowerPointPredicate<TPoint>
::IsLowerPointPredicate( const Point & upperBound )
  : myUpperBound( upperBound )
{}
//------------------------------------------------------------------------------
template <typename TPoint>
inline
bool
DGtal::IsLowerPointPredicate<TPoint>
::operator()( const Point & p ) const
{
  return p.isLower( myUpperBound );
}

//------------------------------------------------------------------------------
template <typename TPoint>
inline
DGtal::IsUpperPointPredicate<TPoint>
::IsUpperPointPredicate( const Point & lowerBound )
  : myLowerBound( lowerBound )
{}
//------------------------------------------------------------------------------
template <typename TPoint>
inline
bool
DGtal::IsUpperPointPredicate<TPoint>
::operator()( const Point & p ) const
{
  return p.isUpper( myLowerBound );
}

//------------------------------------------------------------------------------
template <typename TPoint>
inline
DGtal::IsWithinPointPredicate<TPoint>
::IsWithinPointPredicate( const Point & lowerBound,
        const Point & upperBound )
  : myLowerBound( lowerBound ), myUpperBound( upperBound )
{}
//------------------------------------------------------------------------------
template <typename TPoint>
inline
bool
DGtal::IsWithinPointPredicate<TPoint>
::operator()( const Point & p ) const
{
  return p.isUpper( myLowerBound )
    && p.isLower( myUpperBound );
}

//------------------------------------------------------------------------------
template <typename TPointPredicate>
inline
DGtal::NotPointPredicate<TPointPredicate>
::NotPointPredicate( const PointPredicate & pred )
  : myPred( pred )
{
}
//------------------------------------------------------------------------------
template <typename TPointPredicate>
inline
bool
DGtal::NotPointPredicate<TPointPredicate>
::operator()( const Point & p ) const
{
  return ! myPred( p );
}
//------------------------------------------------------------------------------
template <typename TPointPredicate>
inline
DGtal::EqualPointPredicate<TPointPredicate>
::EqualPointPredicate( const Point & aPoint )
  : myPoint( aPoint )
{
}
//------------------------------------------------------------------------------
template <typename TPointPredicate>
inline
bool
DGtal::EqualPointPredicate<TPointPredicate>
::operator()( const Point & p ) const
{
  return (myPoint == p);
}
//------------------------------------------------------------------------------
template <typename TPointPredicate1, typename TPointPredicate2, typename TBinaryFunctor>
inline
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>
::BinaryPointPredicate( const PointPredicate1 & pred1,
      const PointPredicate2 & pred2,
      const TBinaryFunctor & boolFunctor )
  : myPred1( &pred1 ), myPred2( &pred2 ), myBoolFunctor( &boolFunctor )
{
}
//------------------------------------------------------------------------------
template <typename TPointPredicate1, typename TPointPredicate2, typename TBinaryFunctor>
inline
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>
::BinaryPointPredicate( const BinaryPointPredicate& other )
  : myPred1( other.pred1 ), myPred2( other.pred2 ), myBoolFunctor( other.boolFunctor )
{
}
//------------------------------------------------------------------------------
template <typename TPointPredicate1, typename TPointPredicate2, typename TBinaryFunctor>
inline
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>&
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>
::operator=( const BinaryPointPredicate& other )
{
  if (this != &other)
    {
      myPred1 = other.myPred1; 
      myPred2 = other.myPred2; 
      myBoolFunctor = other.myBoolFunctor; 
    }
    return *this; 
}
//------------------------------------------------------------------------------
template <typename TPointPredicate1, typename TPointPredicate2, typename TBinaryFunctor>
inline
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>
::~BinaryPointPredicate()
{
}
//------------------------------------------------------------------------------
template <typename TPointPredicate1, typename TPointPredicate2, typename TBinaryFunctor>
inline
bool 
DGtal::BinaryPointPredicate<TPointPredicate1,TPointPredicate2,TBinaryFunctor>
::operator()( const Point & p ) const
{
  return myBoolFunctor->operator()( myPred1->operator()( p ), 
                                    myPred2->operator()( p ) );
}

//------------------------------------------------------------------------------
template <typename TPointFunctor, typename TPredicate>
inline
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>
::PointFunctorPredicate( const PointFunctor & aFun,
      const Predicate & aPred)
  : myFun( &aFun ), myPred( &aPred )
{
}
//------------------------------------------------------------------------------
template <typename TPointFunctor, typename TPredicate>
inline
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>
::PointFunctorPredicate( const PointFunctorPredicate& other )
  : myFun( other.myFun), myPred( other.myPred )
{
}
//------------------------------------------------------------------------------
template <typename TPointFunctor, typename TPredicate>
inline
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>&
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>
::operator=( const PointFunctorPredicate& other )
{
  if (this != &other)
    {
      myFun = other.myFun; 
      myPred = other.myPred; 
    }
    return *this;
}
//------------------------------------------------------------------------------
template <typename TPointFunctor, typename TPredicate>
inline
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>
::~PointFunctorPredicate()
{
}
//------------------------------------------------------------------------------
template <typename TPointFunctor, typename TPredicate>
inline
bool 
DGtal::PointFunctorPredicate<TPointFunctor, TPredicate>
::operator()( const Point & p ) const
{
  return myPred->operator()( myFun->operator()( p ) );
}
//                                                                           //