pt.h

Go to the documentation of this file.

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

//----- Included files ---------------------------------------------------------

// 3. Standard Library Headers
#include <iosfwd> // fwd decl ostream
#include <stdexcept>

// 4. External Library Headers

// 5. Shared Headers
#include <xmscore/points/ptsfwd.h>

namespace xms
{
//------------------------------------------------------------------------------
// NOTES: All member functions are defined here. None are defined in .cpp files.
//        See the notes below from MSDN "Members of Class Templates".
//
// C++ member templates are supported as long as they are fully defined within
// the enclosing class. For example, the following is supported:
//
// template<typename T>
// class X
// {
// public:
//   template<typename U>
//   void mf(const U &u)
//   {
//   }
// };
//
// While the following is not:
// template<typename T>
// class X
// {
// public:
//    template<typename U>
//    void mf(const U &u);
// };
//
// template<typename T> template <typename U>
// void X<T>::mf(const U &u)
// {
// }
//------------------------------------------------------------------------------

//----- Forward declarations ---------------------------------------------------

// Moved to ptsfwd.h so that you can include just that file instead.
// template <class T> class Pt2;
// template <class T> class Pt3;
// template <class T> class Pt4;

//----- Typedefs ---------------------------------------------------------------

// Moved to ptsfwd.h so that you can include just that file instead.
// typedef Pt2<int>    Pt2i;
// typedef Pt2<float>  Pt2f;
// typedef Pt2<double> Pt2d;
//
// typedef Pt3<int>    Pt3i;
// typedef Pt3<float>  Pt3f;
// typedef Pt3<double> Pt3d;
//
// typedef Pt4<int>    Pt4i;
// typedef Pt4<float>  Pt4f;
// typedef Pt4<double> Pt4d;

//----- Classes / Structs ------------------------------------------------------

template <class T>
class Pt2
{
  //  friend std::ostream& operator<<(std::ostream&, const Pt2&);
public:
  // Member variables

  T x; 
  T y; 

  // Constructors

  Pt2()
  : x((T)0)
  , y((T)0)
  {
  } 
  Pt2(T a_x, T a_y)
  : x(a_x)
  , y(a_y)
  {
  }
  explicit Pt2(const T& a)
  : x(a)
  , y(a)
  {
  }
  // (single arg ctors should be explicit)

  // copy constructor
  Pt2(const Pt2& a)
  : x(a.x)
  , y(a.y)
  {
  } 

  // constructors for conversions (all explicit)
  template <class U>
  explicit Pt2(const Pt2<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  {
  }
  template <class U>
  explicit Pt2(const Pt3<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  {
  }
  template <class U>
  explicit Pt2(const Pt4<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  {
  }

  // Destructor

  ~Pt2() {} 

  template <class U>
  inline const Pt2& operator=(const U& a)
  {
    x = (T)a;
    y = (T)a;
    return *this;
  }
  template <class U>
  inline const Pt2& operator=(const Pt2<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    return *this;
  }
  template <class U>
  inline const Pt2& operator=(const Pt3<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    return *this;
  }
  template <class U>
  inline const Pt2& operator=(const Pt4<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    return *this;
  }

  // Logical operators

  template <class U>
  inline bool operator==(const U& a) const
  {
    return (x == a && y == a);
  }
  template <class U>
  inline bool operator==(const Pt2<U>& a) const
  {
    return (x == a.x && y == a.y);
  }
  template <class U>
  inline bool operator==(const Pt3<U>& a) const
  {
    return (x == a.x && y == a.y);
  }
  template <class U>
  inline bool operator==(const Pt4<U>& a) const
  {
    return (x == a.x && y == a.y);
  }

  template <class U>
  inline bool operator!=(const U& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt2<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt3<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt4<U>& a) const
  {
    return !(*this == a);
  }

  template <class U>
  inline bool operator<(const U& a) const
  {
    if (x < a)
      return 1;
    else if (x > a)
      return 0;
    else
    {
      if (y < a)
        return 1;
      else
        return 0;
    }
  }
  template <class U>
  inline bool operator<(const Pt2<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else
        return 0;
    }
  }
  template <class U>
  inline bool operator<(const Pt3<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else
        return 0;
    }
  }
  template <class U>
  inline bool operator<(const Pt4<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else
        return 0;
    }
  }

  template <class U>
  inline bool operator<=(const U& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt2<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt3<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt4<U>& a) const
  {
    return (*this < a || *this == a);
  }

  template <class U>
  inline bool operator>(const U& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt2<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt3<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt4<U>& a) const
  {
    return !(*this <= a);
  }

  template <class U>
  inline bool operator>=(const U& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt2<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt3<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt4<U>& a) const
  {
    return (*this > a || *this == a);
  }

  // Arithmetic operators

  template <class U>
  inline Pt2 operator+(const U& a) const // Pt2 + int (etc)
  {
    return Pt2((T)(x + a), (T)(y + a));
  }
  template <class U>
  inline Pt2 operator+(const Pt2<U>& a) const // Pt2 + Pt2
  {
    return Pt2((T)(x + a.x), (T)(y + a.y));
  }
  template <class U>
  inline Pt2 operator+(const Pt3<U>& a) const // Pt2 + Pt3
  {
    return Pt2((T)(x + a.x), (T)(y + a.y));
  }
  template <class U>
  inline Pt2 operator+(const Pt4<U>& a) const // Pt2 + Pt4
  {
    return Pt2((T)(x + a.x), (T)(y + a.y));
  }

  template <class U>
  inline Pt2 operator-(const U& a) const // Pt2 - int (etc)
  {
    return Pt2((T)(x - a), (T)(y - a));
  }
  template <class U>
  inline Pt2 operator-(const Pt2<U>& a) const // Pt2 - Pt2
  {
    return Pt2((T)(x - a.x), (T)(y - a.y));
  }
  template <class U>
  inline Pt2 operator-(const Pt3<U>& a) const // Pt2 - Pt3
  {
    return Pt2((T)(x - a.x), (T)(y - a.y));
  }
  template <class U>
  inline Pt2 operator-(const Pt4<U>& a) const // Pt2 - Pt4
  {
    return Pt2((T)(x - a.x), (T)(y - a.y));
  }

  inline Pt2 operator-() const // -Pt2
  {
    return Pt2((T)(-x), (T)(-y));
  }

  template <class U>
  inline Pt2 operator*(const U& a) const // Pt2 * int (etc)
  {
    return Pt2((T)(x * a), (T)(y * a));
  }
  template <class U>
  inline Pt2 operator*(const Pt2<U>& a) const // Pt2 * Pt2
  {
    return Pt2((T)(x * a.x), (T)(y * a.y));
  }
  template <class U>
  inline Pt2 operator*(const Pt3<U>& a) const // Pt2 * Pt3
  {
    return Pt2((T)(x * a.x), (T)(y * a.y));
  }
  template <class U>
  inline Pt2 operator*(const Pt4<U>& a) const // Pt2 * Pt4
  {
    return Pt2((T)(x * a.x), (T)(y * a.y));
  }

  template <class U>
  inline Pt2 operator/(const U& a) const // Pt2 / int (etc)
  {
    return Pt2((T)(x / a), (T)(y / a));
  }
  template <class U>
  inline Pt2 operator/(const Pt2<U>& a) const // Pt2 / Pt2
  {
    return Pt2((T)(x / a.x), (T)(y / a.y));
  }
  template <class U>
  inline Pt2 operator/(const Pt3<U>& a) const // Pt2 / Pt3
  {
    return Pt2((T)(x / a.x), (T)(y / a.y));
  }
  template <class U>
  inline Pt2 operator/(const Pt4<U>& a) const // Pt2 / Pt4
  {
    return Pt2((T)(x / a.x), (T)(y / a.y));
  }

  template <class U>
  inline void operator+=(const U& a) // Pt2 += int (etc)
  {
    x = (T)(x + a);
    y = (T)(y + a);
  }
  template <class U>
  inline void operator+=(const Pt2<U>& a) // Pt2 += Pt2
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
  }
  template <class U>
  inline void operator+=(const Pt3<U>& a) // Pt2 += Pt3
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
  }
  template <class U>
  inline void operator+=(const Pt4<U>& a) // Pt2 += Pt4
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
  }

  template <class U>
  inline void operator-=(const U& a) // Pt2 -= int (etc)
  {
    x = (T)(x - a);
    y = (T)(y - a);
  }
  template <class U>
  inline void operator-=(const Pt2<U>& a) // Pt2 -= Pt2
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
  }
  template <class U>
  inline void operator-=(const Pt3<U>& a) // Pt2 -= Pt3
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
  }
  template <class U>
  inline void operator-=(const Pt4<U>& a) // Pt2 -= Pt4
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
  }

  template <class U>
  inline void operator*=(const U& a) // Pt2 *= int (etc)
  {
    x = (T)(x * a);
    y = (T)(y * a);
  }
  template <class U>
  inline void operator*=(const Pt2<U>& a) // Pt2 *= Pt2
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
  }
  template <class U>
  inline void operator*=(const Pt3<U>& a) // Pt2 *= Pt3
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
  }
  template <class U>
  inline void operator*=(const Pt4<U>& a) // Pt2 *= Pt4
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
  }

  template <class U>
  inline void operator/=(const U& a) // Pt2 /= int (etc)
  {
    x = (T)(x / a);
    y = (T)(y / a);
  }
  template <class U>
  inline void operator/=(const Pt2<U>& a) // Pt2 /= Pt2
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
  }
  template <class U>
  inline void operator/=(const Pt3<U>& a) // Pt2 /= Pt3
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
  }
  template <class U>
  inline void operator/=(const Pt4<U>& a) // Pt2 /= Pt4
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
  }

  // Other stuff

  void Set(T a_x, T a_y)
  {
    x = a_x;
    y = a_y;
  }
  void Set(T a)
  {
    x = a;
    y = a;
  }

  T operator[](unsigned int a) const { return *(&x + a); }
  T& operator[](unsigned int a) { return *(&x + a); }

  const T& at(unsigned int a) const
  {
    switch (a)
    {
    case 0:
      return x;
    case 1:
      return y;
    default:
      throw std::out_of_range("Pt2<T>::at(): error out of range");
    }
  }
  T& at(unsigned int a) // non-const version
  {
    // Use the const version. See Effective C++ 3rd Edition Item 3.
    return const_cast<T&>(static_cast<const Pt2<T>&>(*this).at(a));
  }

  template <typename Archive>
  void serialize(Archive& archive, const unsigned int version)
  {
    (void)version; // For doxygen which couldn't handle commenting it out.
    archive& x;
    archive& y;
  }

}; // Pt2

template <class T>
class Pt3
{
  //  friend std::ostream& operator<<(std::ostream&, const Pt3&);
public:
  // Member variables

  T x; 
  T y; 
  T z; 

  // Constructors

  Pt3()
  : x((T)0)
  , y((T)0)
  , z((T)0)
  {
  } 
  Pt3(T a_x, T a_y, T a_z)
  : x(a_x)
  , y(a_y)
  , z(a_z)
  {
  }
  Pt3(T a_x, T a_y)
  : x(a_x)
  , y(a_y)
  , z(0.0)
  {
  }
  explicit Pt3(T a)
  : x(a)
  , y(a)
  , z(a)
  {
  }
  // (single arg ctors should be explicit)

  Pt3(const Pt3& a)
  : x(a.x)
  , y(a.y)
  , z(a.z)
  {
  }

  // constructors for conversions (all explicit)
  template <class U>
  explicit Pt3(const Pt2<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z(0)
  {
  }
  template <class U>
  explicit Pt3(const Pt3<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z((T)a.z)
  {
  }
  template <class U>
  explicit Pt3(const Pt4<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z((T)a.z)
  {
  }

  ~Pt3() {} 

  template <class U>
  inline const Pt3& operator=(const U& a)
  {
    x = (T)a;
    y = (T)a;
    z = (T)a;
    return *this;
  }
  template <class U>
  inline const Pt3& operator=(const Pt2<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    return *this;
  }
  template <class U>
  inline const Pt3& operator=(const Pt3<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    z = (T)a.z;
    return *this;
  }
  template <class U>
  inline const Pt3& operator=(const Pt4<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    z = (T)a.z;
    return *this;
  }

  // Logical operators

  template <class U>
  inline bool operator==(const U& a) const
  {
    return (x == a && y == a && z == a);
  }
  template <class U>
  inline bool operator==(const Pt2<U>& a) const
  {
    return (x == a.x && y == a.y);
  }
  template <class U>
  inline bool operator==(const Pt3<U>& a) const
  {
    return (x == a.x && y == a.y && z == a.z);
  }
  template <class U>
  inline bool operator==(const Pt4<U>& a) const
  {
    return (x == a.x && y == a.y && z == a.z);
  }

  template <class U>
  inline bool operator!=(const U& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt2<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt3<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt4<U>& a) const
  {
    return !(*this == a);
  }

  template <class U>
  inline bool operator<(const U& a) const
  {
    if (x < a)
      return 1;
    else if (x > a)
      return 0;
    else
    {
      if (y < a)
        return 1;
      else if (y > a)
        return 0;
      else
      {
        if (z < a)
          return 1;
        else
          return 0;
      }
    }
  }
  template <class U>
  inline bool operator<(const Pt2<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else
        return 0;
    }
  }
  template <class U>
  inline bool operator<(const Pt3<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else if (y > a.y)
        return 0;
      else
      {
        if (z < a.z)
          return 1;
        else
          return 0;
      }
    }
  }
  template <class U>
  inline bool operator<(const Pt4<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else if (y > a.y)
        return 0;
      else
      {
        if (z < a.z)
          return 1;
        else
          return 0;
      }
    }
  }

  template <class U>
  inline bool operator<=(const U& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt2<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt3<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt4<U>& a) const
  {
    return (*this < a || *this == a);
  }

  template <class U>
  inline bool operator>(const U& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt2<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt3<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt4<U>& a) const
  {
    return !(*this <= a);
  }

  template <class U>
  inline bool operator>=(const U& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt2<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt3<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt4<U>& a) const
  {
    return (*this > a || *this == a);
  }

  // Arithmetic operators

  template <class U>
  inline Pt3 operator+(const U& a) const // Pt3 + int (etc)
  {
    return Pt3((T)(x + a), (T)(y + a), (T)(z + a));
  }
  template <class U>
  inline Pt3 operator+(const Pt2<U>& a) const // Pt3 + Pt2
  {
    return Pt3((T)(x + a.x), (T)(y + a.y), z);
  }
  template <class U>
  inline Pt3 operator+(const Pt3<U>& a) const // Pt3 + Pt3
  {
    return Pt3((T)(x + a.x), (T)(y + a.y), (T)(z + a.z));
  }
  template <class U>
  inline Pt3 operator+(const Pt4<U>& a) const // Pt3 + Pt4
  {
    return Pt3((T)(x + a.x), (T)(y + a.y), (T)(z + a.z));
  }

  template <class U>
  inline Pt3 operator-(const U& a) const // Pt3 - int (etc)
  {
    return Pt3((T)(x - a), (T)(y - a), (T)(z - a));
  }
  template <class U>
  inline Pt3 operator-(const Pt2<U>& a) const // Pt3 - Pt2
  {
    return Pt3((T)(x - a.x), (T)(y - a.y), z);
  }
  template <class U>
  inline Pt3 operator-(const Pt3<U>& a) const // Pt3 - Pt3
  {
    return Pt3((T)(x - a.x), (T)(y - a.y), (T)(z - a.z));
  }
  template <class U>
  inline Pt3 operator-(const Pt4<U>& a) const // Pt3 - Pt4
  {
    return Pt3((T)(x - a.x), (T)(y - a.y), (T)(z - a.z));
  }

  inline Pt3 operator-() const // -Pt3
  {
    return Pt3((T)(-x), (T)(-y), (T)(-z));
  }

  template <class U>
  inline Pt3 operator*(const U& a) const // Pt3 * int (etc)
  {
    return Pt3((T)(x * a), (T)(y * a), (T)(z * a));
  }
  template <class U>
  inline Pt3 operator*(const Pt2<U>& a) const // Pt3 * Pt2
  {
    return Pt3((T)(x * a.x), (T)(y * a.y), z);
  }
  template <class U>
  inline Pt3 operator*(const Pt3<U>& a) const // Pt3 * Pt3
  {
    return Pt3((T)(x * a.x), (T)(y * a.y), (T)(z * a.z));
  }
  template <class U>
  inline Pt3 operator*(const Pt4<U>& a) const // Pt3 * Pt4
  {
    return Pt3((T)(x * a.x), (T)(y * a.y), (T)(z * a.z));
  }

  template <class U>
  inline Pt3 operator/(const U& a) const // Pt3 / int (etc)
  {
    return Pt3((T)(x / a), (T)(y / a), (T)(z / a));
  }
  template <class U>
  inline Pt3 operator/(const Pt2<U>& a) const // Pt3 / Pt2
  {
    return Pt3((T)(x / a.x), (T)(y / a.y), z);
  }
  template <class U>
  inline Pt3 operator/(const Pt3<U>& a) const // Pt3 / Pt3
  {
    return Pt3((T)(x / a.x), (T)(y / a.y), (T)(z / a.z));
  }
  template <class U>
  inline Pt3 operator/(const Pt4<U>& a) const // Pt3 / Pt4
  {
    return Pt3((T)(x / a.x), (T)(y / a.y), (T)(z / a.z));
  }

  template <class U>
  inline void operator+=(const U& a) // Pt3 += int (etc)
  {
    x = (T)(x + a);
    y = (T)(y + a);
    z = (T)(z + a);
  }
  template <class U>
  inline void operator+=(const Pt2<U>& a) // Pt3 += Pt2
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
  }
  template <class U>
  inline void operator+=(const Pt3<U>& a) // Pt3 += Pt3
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
    z = (T)(z + a.z);
  }
  template <class U>
  inline void operator+=(const Pt4<U>& a) // Pt3 += Pt4
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
    z = (T)(z + a.z);
  }

  template <class U>
  inline void operator-=(const U& a) // Pt3 -= int (etc)
  {
    x = (T)(x - a);
    y = (T)(y - a);
    z = (T)(z - a);
  }
  template <class U>
  inline void operator-=(const Pt2<U>& a) // Pt3 -= Pt2
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
  }
  template <class U>
  inline void operator-=(const Pt3<U>& a) // Pt3 -= Pt3
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
    z = (T)(z - a.z);
  }
  template <class U>
  inline void operator-=(const Pt4<U>& a) // Pt3 -= Pt4
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
    z = (T)(z - a.z);
  }

  template <class U>
  inline void operator*=(const U& a) // Pt3 *= int (etc)
  {
    x = (T)(x * a);
    y = (T)(y * a);
    z = (T)(z * a);
  }
  template <class U>
  inline void operator*=(const Pt2<U>& a) // Pt3 *= Pt2
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
  }
  template <class U>
  inline void operator*=(const Pt3<U>& a) // Pt3 *= Pt3
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
    z = (T)(z * a.z);
  }
  template <class U>
  inline void operator*=(const Pt4<U>& a) // Pt3 *= Pt4
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
    z = (T)(z * a.z);
  }

  template <class U>
  inline void operator/=(const U& a) // Pt3 /= int (etc)
  {
    x = (T)(x / a);
    y = (T)(y / a);
    z = (T)(z / a);
  }
  template <class U>
  inline void operator/=(const Pt2<U>& a) // Pt3 /= Pt2
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
  }
  template <class U>
  inline void operator/=(const Pt3<U>& a) // Pt3 /= Pt3
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
    z = (T)(z / a.z);
  }
  template <class U>
  inline void operator/=(const Pt4<U>& a) // Pt3 /= Pt4
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
    z = (T)(z / a.z);
  }

  // Other stuff

  void Set(T a_x, T a_y, T a_z)
  {
    x = a_x;
    y = a_y;
    z = a_z;
  }
  void Set(T a)
  {
    x = a;
    y = a;
    z = a;
  }

  T operator[](unsigned int a) const { return *(&x + a); }
  T& operator[](unsigned int a) { return *(&x + a); }

  const T& at(unsigned int a) const
  {
    switch (a)
    {
    case 0:
      return x;
    case 1:
      return y;
    case 2:
      return z;
    default:
      throw std::out_of_range("Pt3<T>::at(): error out of range");
    }
  }
  T& at(unsigned int a) // non-const version
  {
    // Use the const version. See Effective C++ 3rd Edition Item 3.
    return const_cast<T&>(static_cast<const Pt3<T>&>(*this).at(a));
  }

  // Typedefs

  typedef T value_type; 

  template <typename Archive>
  void serialize(Archive& archive, const unsigned int version)
  {
    (void)version; // For doxygen which couldn't handle commenting it out.
    archive& x;
    archive& y;
    archive& z;
  }

}; // Pt3

template <class T>
inline Pt3<T> operator*(int a, const Pt3<T>& pt)
{
  return (pt * a);
}

template <class T>
inline Pt3<T> operator*(float a, const Pt3<T>& pt)
{
  return (pt * a);
}

template <class T>
inline Pt3<T> operator*(double a, const Pt3<T>& pt)
{
  return (pt * a);
}

template <class T>
class Pt4
{
  // friend std::ostream& operator<<(std::ostream&, const Pt4&);
public:
  // Member variables

  T x; 
  T y; 
  T z; 
  T w; 

  // Constructors

  Pt4()
  : x((T)0)
  , y((T)0)
  , z((T)0)
  , w((T)0)
  {
  } 
  Pt4(T a_x, T a_y, T a_z, T a_w)
  : x(a_x)
  , y(a_y)
  , z(a_z)
  , w(a_w)
  {
  }
  explicit Pt4(T a)
  : x(a)
  , y(a)
  , z(a)
  , w(a)
  {
  }
  // (single arg ctors should be explicit)

  Pt4(const Pt4& a)
  : x(a.x)
  , y(a.y)
  , z(a.z)
  , w(a.w)
  {
  }

  // constructors for conversions (all explicit)
  template <class U>
  explicit Pt4(const Pt2<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z((T)0)
  , w((T)0)
  {
  }
  template <class U>
  explicit Pt4(const Pt3<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z((T)a.z)
  , w((T)0)
  {
  }
  template <class U>
  explicit Pt4(const Pt4<U>& a)
  : x((T)a.x)
  , y((T)a.y)
  , z((T)a.z)
  , w((T)a.w)
  {
  }

  ~Pt4() {} 

  template <class U>
  inline const Pt4& operator=(const U& a)
  {
    x = (T)a;
    y = (T)a;
    z = (T)a;
    w = (T)a;
    return *this;
  }
  template <class U>
  inline const Pt4& operator=(const Pt2<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    return *this;
  }
  template <class U>
  inline const Pt4& operator=(const Pt3<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    z = (T)a.z;
    return *this;
  }
  template <class U>
  inline const Pt4& operator=(const Pt4<U>& a)
  {
    x = (T)a.x;
    y = (T)a.y;
    z = (T)a.z;
    w = (T)a.w;
    return *this;
  }

  // Logical operators

  template <class U>
  inline bool operator==(const U& a) const
  {
    return (x == a && y == a && z == a && w == a);
  }
  template <class U>
  inline bool operator==(const Pt2<U>& a) const
  {
    return (x == a.x && y == a.y);
  }
  template <class U>
  inline bool operator==(const Pt3<U>& a) const
  {
    return (x == a.x && y == a.y && z == a.z);
  }
  template <class U>
  inline bool operator==(const Pt4<U>& a) const
  {
    return (x == a.x && y == a.y && z == a.z && w == a.w);
  }

  template <class U>
  inline bool operator!=(const U& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt2<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt3<U>& a) const
  {
    return !(*this == a);
  }
  template <class U>
  inline bool operator!=(const Pt4<U>& a) const
  {
    return !(*this == a);
  }

  template <class U>
  inline bool operator<(const U& a) const
  {
    if (x < a)
      return 1;
    else if (x > a)
      return 0;
    else
    {
      if (y < a)
        return 1;
      else if (y > a)
        return 0;
      else
      {
        if (z < a)
          return 1;
        else if (z < a)
          return 0;
        else
        {
          if (w < a)
            return 1;
          else
            return 0;
        }
      }
    }
  }
  template <class U>
  inline bool operator<(const Pt2<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else
        return 0;
    }
  }
  template <class U>
  inline bool operator<(const Pt3<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else if (y > a.y)
        return 0;
      else
      {
        if (z < a.z)
          return 1;
        else
          return 0;
      }
    }
  }
  template <class U>
  inline bool operator<(const Pt4<U>& a) const
  {
    if (x < a.x)
      return 1;
    else if (x > a.x)
      return 0;
    else
    {
      if (y < a.y)
        return 1;
      else if (y > a.y)
        return 0;
      else
      {
        if (z < a.z)
          return 1;
        else if (z < a.z)
          return 0;
        else
        {
          if (w < a.w)
            return 1;
          else
            return 0;
        }
      }
    }
  }

  template <class U>
  inline bool operator<=(const U& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt2<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt3<U>& a) const
  {
    return (*this < a || *this == a);
  }
  template <class U>
  inline bool operator<=(const Pt4<U>& a) const
  {
    return (*this < a || *this == a);
  }

  template <class U>
  inline bool operator>(const U& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt2<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt3<U>& a) const
  {
    return !(*this <= a);
  }
  template <class U>
  inline bool operator>(const Pt4<U>& a) const
  {
    return !(*this <= a);
  }

  template <class U>
  inline bool operator>=(const U& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt2<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt3<U>& a) const
  {
    return (*this > a || *this == a);
  }
  template <class U>
  inline bool operator>=(const Pt4<U>& a) const
  {
    return (*this > a || *this == a);
  }

  // Arithmetic operators

  template <class U>
  inline Pt4 operator+(const U& a) const // Pt4 + int (etc)
  {
    return Pt4((T)(x + a), (T)(y + a), (T)(z + a), (T)(w + a));
  }
  template <class U>
  inline Pt4 operator+(const Pt2<U>& a) const // Pt4 + Pt2
  {
    return Pt4((T)(x + a.x), (T)(y + a.y), z, w);
  }
  template <class U>
  inline Pt4 operator+(const Pt3<U>& a) const // Pt4 + Pt3
  {
    return Pt4((T)(x + a.x), (T)(y + a.y), (T)(z + a.z), w);
  }
  template <class U>
  inline Pt4 operator+(const Pt4<U>& a) const // Pt4 + Pt4
  {
    return Pt4((T)(x + a.x), (T)(y + a.y), (T)(z + a.z), (T)(w + a.w));
  }

  template <class U>
  inline Pt4 operator-(const U& a) const // Pt4 - int (etc)
  {
    return Pt4((T)(x - a), (T)(y - a), (T)(z - a), (T)(w - a));
  }
  template <class U>
  inline Pt4 operator-(const Pt2<U>& a) const // Pt4 - Pt2
  {
    return Pt4((T)(x - a.x), (T)(y - a.y), z, w);
  }
  template <class U>
  inline Pt4 operator-(const Pt3<U>& a) const // Pt4 - Pt3
  {
    return Pt4((T)(x - a.x), (T)(y - a.y), (T)(z - a.z), w);
  }
  template <class U>
  inline Pt4 operator-(const Pt4<U>& a) const // Pt4 - Pt4
  {
    return Pt4((T)(x - a.x), (T)(y - a.y), (T)(z - a.z), (T)(w - a.w));
  }

  inline Pt4 operator-() const // -Pt4
  {
    return Pt4((T)(-x), (T)(-y), (T)(-z), (T)(-w));
  }

  template <class U>
  inline Pt4 operator*(const U& a) const // Pt4 * int (etc)
  {
    return Pt4((T)(x * a), (T)(y * a), (T)(z * a), (T)(w * a));
  }
  template <class U>
  inline Pt4 operator*(const Pt2<U>& a) const // Pt4 * Pt2
  {
    return Pt4((T)(x * a.x), (T)(y * a.y), z, w);
  }
  template <class U>
  inline Pt4 operator*(const Pt3<U>& a) const // Pt4 * Pt3
  {
    return Pt4((T)(x * a.x), (T)(y * a.y), (T)(z * a.z), w);
  }
  template <class U>
  inline Pt4 operator*(const Pt4<U>& a) const // Pt4 * Pt4
  {
    return Pt4((T)(x * a.x), (T)(y * a.y), (T)(z * a.z), (T)(w * a.w));
  }

  template <class U>
  inline Pt4 operator/(const U& a) const // Pt4 / int (etc)
  {
    return Pt4((T)(x / a), (T)(y / a), (T)(z / a), (T)(w / a));
  }
  template <class U>
  inline Pt4 operator/(const Pt2<U>& a) const // Pt4 / Pt2
  {
    return Pt4((T)(x / a.x), (T)(y / a.y), z, w);
  }
  template <class U>
  inline Pt4 operator/(const Pt3<U>& a) const // Pt4 / Pt3
  {
    return Pt4((T)(x / a.x), (T)(y / a.y), (T)(z / a.z), w);
  }
  template <class U>
  inline Pt4 operator/(const Pt4<U>& a) const // Pt4 / Pt4
  {
    return Pt4((T)(x / a.x), (T)(y / a.y), (T)(z / a.z), (T)(w / a.w));
  }

  template <class U>
  inline void operator+=(const U& a) // Pt4 += int (etc)
  {
    x = (T)(x + a);
    y = (T)(y + a);
    z = (T)(z + a);
    w = (T)(w + a);
  }
  template <class U>
  inline void operator+=(const Pt2<U>& a) // Pt4 += Pt2
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
  }
  template <class U>
  inline void operator+=(const Pt3<U>& a) // Pt4 += Pt3
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
    z = (T)(z + a.z);
  }
  template <class U>
  inline void operator+=(const Pt4<U>& a) // Pt4 += Pt4
  {
    x = (T)(x + a.x);
    y = (T)(y + a.y);
    z = (T)(z + a.z);
    w = (T)(w + a.w);
  }

  template <class U>
  inline void operator-=(const U& a) // Pt4 -= int (etc)
  {
    x = (T)(x - a);
    y = (T)(y - a);
    z = (T)(z - a);
    w = (T)(w - a);
  }
  template <class U>
  inline void operator-=(const Pt2<U>& a) // Pt4 -= Pt2
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
  }
  template <class U>
  inline void operator-=(const Pt3<U>& a) // Pt4 -= Pt3
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
    z = (T)(z - a.z);
  }
  template <class U>
  inline void operator-=(const Pt4<U>& a) // Pt4 -= Pt4
  {
    x = (T)(x - a.x);
    y = (T)(y - a.y);
    z = (T)(z - a.z);
    w = (T)(w - a.w);
  }

  template <class U>
  inline void operator*=(const U& a) // Pt4 *= int (etc)
  {
    x = (T)(x * a);
    y = (T)(y * a);
    z = (T)(z * a);
    w = (T)(w * a);
  }
  template <class U>
  inline void operator*=(const Pt2<U>& a) // Pt4 *= Pt2
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
  }
  template <class U>
  inline void operator*=(const Pt3<U>& a) // Pt4 *= Pt3
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
    z = (T)(z * a.z);
  }
  template <class U>
  inline void operator*=(const Pt4<U>& a) // Pt4 *= Pt4
  {
    x = (T)(x * a.x);
    y = (T)(y * a.y);
    z = (T)(z * a.z);
    w = (T)(w * a.w);
  }

  template <class U>
  inline void operator/=(const U& a) // Pt4 /= int (etc)
  {
    x = (T)(x / a);
    y = (T)(y / a);
    z = (T)(z / a);
    w = (T)(w / a);
  }
  template <class U>
  inline void operator/=(const Pt2<U>& a) // Pt4 /= Pt2
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
  }
  template <class U>
  inline void operator/=(const Pt3<U>& a) // Pt4 /= Pt3
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
    z = (T)(z / a.z);
  }
  template <class U>
  inline void operator/=(const Pt4<U>& a) // Pt4 /= Pt4
  {
    x = (T)(x / a.x);
    y = (T)(y / a.y);
    z = (T)(z / a.z);
    w = (T)(w / a.w);
  }

  // Other stuff

  void Set(T a_x, T a_y, T a_z, T a_w)
  {
    x = a_x;
    y = a_y;
    z = a_z;
    w = a_w;
  }
  void Set(T a)
  {
    x = a;
    y = a;
    z = a;
    w = a;
  }

  T operator[](unsigned int a) const { return *(&x + a); }
  T& operator[](unsigned int a) { return *(&x + a); }

  const T& at(unsigned int a) const
  {
    switch (a)
    {
    case 0:
      return x;
    case 1:
      return y;
    case 2:
      return z;
    case 3:
      return w;
    default:
      throw std::out_of_range("Pt4<T>::at(): error out of range");
    }
  }
  T& at(unsigned int a) // non-const version
  {
    // Use the const version. See Effective C++ 3rd Edition Item 3.
    return const_cast<T&>(static_cast<const Pt4<T>&>(*this).at(a));
  }

  template <typename Archive>
  void serialize(Archive& archive, const unsigned int version)
  {
    (void)version; // For doxygen which couldn't handle commenting it out.
    archive& x;
    archive& y;
    archive& z;
    archive& w;
  }

}; // Pt4

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <class _From, class _To>
_To& Pt3Convert(const _From& a_from, _To& a_to)
{
  a_to.x = static_cast<const typename _To::value_type>(a_from.x);
  a_to.y = static_cast<const typename _To::value_type>(a_from.y);
  a_to.z = static_cast<const typename _To::value_type>(a_from.z);
  return a_to;
}; // PtConvert

// Stream I/O

//
// This code ported by GMS from "The Standard C++ Library" by Nicolai M.
// Josuttis
//

//------------------------------------------------------------------------------
// Pt2<T>

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& strm,
                                                     const Pt2<T>& a_pt)
{
  // string stream
  // - with same format
  // - without special field width
  std::basic_ostringstream<charT, traits> s;
  s.copyfmt(strm);
  s.width(0);

  // fill string stream
  s << a_pt.x << "," << a_pt.y;

  // print string stream
  strm << s.str();

  return strm;
} // operator<< for Pt2<T>
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_istream<charT, traits>& operator>>(std::basic_istream<charT, traits>& strm,
                                                     Pt2<T>& a_pt)
{
  T x, y;

  // read x
  strm >> x;

  // if available
  // - read ',' and y value
  if (strm.peek() == ',')
  {
    strm.ignore();
    strm >> y;
  }
  else
  {
    y = static_cast<T>(0);
  }

  if (strm)
  {
    a_pt = Pt2<T>(x, y);
  }

  return strm;
} // operator>> for Pt2<T>

//------------------------------------------------------------------------------
// Pt3<T>

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& strm,
                                                     const Pt3<T>& a_pt)
{
  // string stream
  // - with same format
  // - without special field width
  std::basic_ostringstream<charT, traits> s;
  s.copyfmt(strm);
  s.width(0);

  // fill string stream
  s << a_pt.x << "," << a_pt.y << "," << a_pt.z;

  // print string stream
  strm << s.str();

  return strm;
} // operator<< for Pt3<T>
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_istream<charT, traits>& operator>>(std::basic_istream<charT, traits>& strm,
                                                     Pt3<T>& a_pt)
{
  T x, y, z;

  // read x
  strm >> x;

  // if available
  // - read ',' and y and z values
  if (strm.peek() == ',')
  {
    strm.ignore();
    strm >> y;
    if (strm.peek() == ',')
    {
      strm.ignore();
      strm >> z;
    }
    else
    {
      z = static_cast<T>(0);
    }
  }
  else
  {
    y = static_cast<T>(0);
    z = static_cast<T>(0);
  }

  if (strm)
  {
    a_pt = Pt3<T>(x, y, z);
  }

  return strm;
} // operator>> for Pt3<T>

//------------------------------------------------------------------------------
// Pt4<T>

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& strm,
                                                     const Pt4<T>& a_pt)
{
  // string stream
  // - with same format
  // - without special field width
  std::basic_ostringstream<charT, traits> s;
  s.copyfmt(strm);
  s.width(0);

  // fill string stream
  s << a_pt.x << "," << a_pt.y << "," << a_pt.z << "," << a_pt.w;

  // print string stream
  strm << s.str();

  return strm;
} // operator<< for Pt4<T>
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T, typename charT, typename traits>
inline std::basic_istream<charT, traits>& operator>>(std::basic_istream<charT, traits>& strm,
                                                     Pt4<T>& a_pt)
{
  T x, y, z, w;

  // read x
  strm >> x;

  // if available
  // - read ',' and y and z values
  if (strm.peek() == ',')
  {
    strm.ignore();
    strm >> y;
    if (strm.peek() == ',')
    {
      strm.ignore();
      strm >> z;
      if (strm.peek() == ',')
      {
        strm.ignore();
        strm >> w;
      }
      else
      {
        w = static_cast<T>(0);
      }
    }
    else
    {
      z = static_cast<T>(0);
      w = static_cast<T>(0);
    }
  }
  else
  {
    y = static_cast<T>(0);
    z = static_cast<T>(0);
    w = static_cast<T>(0);
  }

  if (strm)
  {
    a_pt = Pt4<T>(x, y, z, w);
  }

  return strm;
} // operator>> for Pt4<T>

} // namespace xms