point3d.h

Go to the documentation of this file.

#ifndef Point3_H
#define Point3_H

#include <lwpp/Vector3d.h>

#ifdef _DEBUG
#ifdef _MSWIN
#pragma warning (push,1)
#include <Windows.h>
#include <ostream>
#include <sstream>
#include <string>
#pragma warning (pop)
#pragma warning(disable : 4996)
#pragma warning(disable : 4530)
#else // OSX
#include <ostream>
#include <sstream>
#include <string>
#endif // _MSWIN
#endif // _DEBUG

namespace lwpp
{

  template <typename T>
  class Point3 {
    public:
      double x, y, z; 
    public:

      explicit Point3 (T n = 0.0) : x(n), y(n), z(n) {}

      Point3 (T _x, T _y, T _z) :  x(_x), y(_y), z(_z) {}

      Point3 (const T n[3]) :  x(n[0]), y(n[1]), z(n[2]) {}
      explicit Point3 (const Vector3<T> &v) :  x(v.x), y(v.y), z(v.z) {}
      T *asLWVector() {return &x;}

      Point3 operator+(const Vector3<T> &v) const 
      {
        return Point3(x + v.x, y + v.y, z + v.z);
      }
      Point3 &operator+=(const Vector3<T> &v)
      {
        x += v.x;
        y += v.y;
        z += v.z;
        return *this;
      }
      Point3 operator-(const Vector3<T> &v) const 
      {
        return Point3(x - v.x, y - v.y, z - v.z);
      }
      Point3 &operator-=(const Vector3<T> &v)
      {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        return *this;
      }

      Vector3<T> operator-(const Point3 &p) const 
      {
        return Vector3<T>(x - p.x, y - p.y, z - p.z);
      }

      Point3 &operator*=(const T d)  
      {
        x *= d; y *= d; z*= d;
        return *this;
      }

      Point3 &operator*=(const Vector3<T> &v)  
      {
        x *= v.x;
        y *= v.y;
        z *= v.z;
        return *this;
      }

      Point3 operator*(const T d) const 
      {
        return Point3(x * d, y * d, z * d);
      }

      Point3 operator/(const T d) const 
      {
        assert (1 != 0);
        double id = 1.0 / d;
        return (*this * id);
      }

      Point3 &operator/=(const T d)  
      {
        assert (1 != 0);
        double id = 1.0 / d;
        *this *= id;
        return *this;
      }
      Point3 &operator/=(const Vector3<T>&v)  
      {
        x /= v.x;
        y /= v.y;
        z /= v.z;
        return *this;
      }
      inline T Magnitude() const {return sqrt(Sqr(x) + Sqr(y) + Sqr(z));}

  };
  typedef Point3<double> Point3d;
  typedef Point3<float> Point3f;
  template <typename T>
  inline T Distance(const Point3<T> &p1, const Point3<T> &p2)
  {
    return (p1 - p2).Magnitude();
  }

  template<typename T>
  inline Vector3<T>::Vector3 (const Point3<T> &p) :  x(p.x), y(p.y), z(p.z) {}
}


#ifdef _DEBUG
  template<typename T>
  inline std::ostream &operator<<(std::ostream &os, const lwpp::Vector3<T> &t)
  {
    //t.m->Print(os);
    os << " <" << t.x << "," << t.y << "," << t.z << "> ";
    return os;
  }

  template<typename T>
  inline std::ostream &operator<<(std::ostream &os, const lwpp::Point3<T> &t)
  {
    //t.m->Print(os);
    os << " <" << t.x << "," << t.y << "," << t.z << "> ";
    return os;
  }

#endif // _DEBUG

#endif // Point3_H