functors.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Less than functors that use tolerances ---------------------------------

#include <xmscore/math/math.h>
#include <xmscore/points/pt.h>

namespace xms
{
template <typename T>
class ltPt3
{
private:
  T m_xytol; 
  T m_ztol;  

public:
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  ltPt3(T a_xytol, T a_ztol)
  : m_xytol(a_xytol)
  , m_ztol(a_ztol)
  {
  } // ltPt3::ltPt3
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  bool operator()(const Pt3<T> lhs, const Pt3<T> rhs) const
  {
    if (EQ_TOL(lhs.x, rhs.x, m_xytol))
    {
      if (EQ_TOL(lhs.y, rhs.y, m_xytol))
      {
        if (EQ_TOL(lhs.z, rhs.z, m_ztol))
        {
          return false;
        }
        else if (LT_TOL(lhs.z, rhs.z, m_ztol))
          return true;
        else
          return false;
      }
      else if (LT_TOL(lhs.y, rhs.y, m_xytol))
        return true;
      else
        return false;
    }
    else if (LT_TOL(lhs.x, rhs.x, m_xytol))
      return true;
    else
      return false;
  } // operator()
};  // ltPt3

template <typename T>
class ltPt3_2D
{
private:
  double m_xytol; 

public:
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  ltPt3_2D(T a_xytol)
  : m_xytol(a_xytol)
  {
  } // ltPt3_2D::ltPt3_2D
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  bool operator()(const Pt3<T> a_lhs, const Pt3<T> a_rhs) const
  {
    if (EQ_TOL(a_lhs.x, a_rhs.x, m_xytol))
    {
      if (EQ_TOL(a_lhs.y, a_rhs.y, m_xytol))
      {
        return false;
      }
      else if (LT_TOL(a_lhs.y, a_rhs.y, m_xytol))
        return true;
      else
        return false;
    }
    else if (LT_TOL(a_lhs.x, a_rhs.x, m_xytol))
      return true;
    else
      return false;
  } // ltPt3_2D::operator()
};  // ltPt3_2D

template <typename T>
class ltPt2
{
private:
  double m_xytol; 

public:
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  ltPt2(T a_xytol)
  : m_xytol(a_xytol)
  {
  } // ltPt2::ltPt2
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  bool operator()(const Pt2<T> a_lhs, const Pt2<T> a_rhs) const
  {
    if (EQ_TOL(a_lhs.x, a_rhs.x, m_xytol))
    {
      if (EQ_TOL(a_lhs.y, a_rhs.y, m_xytol))
      {
        return false;
      }
      else if (LT_TOL(a_lhs.y, a_rhs.y, m_xytol))
        return true;
      else
        return false;
    }
    else if (LT_TOL(a_lhs.x, a_rhs.x, m_xytol))
      return true;
    else
      return false;
  } // ltPt2::operator()
};  // ltPt2

typedef ltPt3<double> ltPt3d;       
typedef ltPt3_2D<double> ltPt3d_2D; 
typedef ltPt2<double> ltPt2d;       

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
Pt2<_T> ptTruncate(Pt2<_T> const& a_in)
{
  Pt2<_T> out;
  out.x = static_cast<int>(a_in.x);
  out.y = static_cast<int>(a_in.y);
  return out;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
Pt3<_T> ptTruncate(Pt3<_T> const& a_in)
{
  Pt3<_T> out;
  out.x = static_cast<int>(a_in.x);
  out.y = static_cast<int>(a_in.y);
  out.z = static_cast<int>(a_in.z);
  return out;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename _T>
Pt4<_T> ptTruncate(Pt4<_T> const& a_in)
{
  Pt4<_T> out;
  out.x = static_cast<int>(a_in.x);
  out.y = static_cast<int>(a_in.y);
  out.z = static_cast<int>(a_in.z);
  out.w = static_cast<int>(a_in.w);
  return out;
}

} // namespace xms