vector3.h

#ifndef __VECTOR3D_H__
#define __VECTOR3D_H__

#include <math.h>
#include <algobase.h>
#include <fstream>
#include <iostream>
#include <vector>

#define ABS(x) ((x)>0?(x):(-x))
#define RAD2DEG(x) (180*(x)/M_PI)
#define DEG2RAD(x) (M_PI*(x)/180)
#define ALMOST_ZERO 0.0001


double normalize(double min, double max, double value);

namespace Geometry
{
        // Useful for simplified, more generic code.
        static const unsigned DIM = 3;

        // Messy but needed predeclarations
        template <class T> class Vector3D;
//      template <class T> Vector3D<T> operator- (const Vector3D<T>& u, const Vector3D<T>& v);
        template <class T> Vector3D<T> operator* (T factor, const Vector3D<T>& v);
        template <class T> std::ostream& operator<< (std::ostream& out, const Vector3D<T>& v);
        template <class T> std::istream& operator>> (std::istream& in, Vector3D<T>& v);

        // Vector3D class
        template <class T>
  class Vector3D
  {
  public:
    Vector3D(const Vector3D<T>& v);
    explicit Vector3D();
    explicit Vector3D(const T& x, const T& y, const T& z);
    explicit Vector3D(const T data[3]);
    explicit Vector3D(const Vector3D<T>* v);
    explicit Vector3D(const std::vector<T>& v);

                static unsigned dim() { return DIM; }

    void set(const T&x, const T& y, const T& z);
    void set(const T data[3]);

    Vector3D<T>& operator=(const Vector3D<T>& src);
    bool operator==(const Vector3D<T>& src) const;
    bool operator<(const Vector3D<T>& src) const;

    void getSpheric(double& theta, double& phi) const;
    void getSpheric(double& distance, double& theta, double& phi) const;
    void setSpheric(double distance, double theta, double phi);

    const T& x() const { return _data[0]; };
    const T& y() const { return _data[1]; };
    const T& z() const { return _data[2]; };
    void x(const T& t) { _data[0] = t; };
    void y(const T& t) { _data[1] = t; };
    void z(const T& t) { _data[2] = t; };

    T& operator[](int index);
    const T& operator[](int index) const;
    const T* getData() const {return _data;};
    T* getDataRef() {return _data;};

    friend std::ostream& operator<< <>(std::ostream& out, const Vector3D<T>& v);
    friend std::istream& operator>> <>(std::istream& in, Vector3D<T>& v);

    void normalize();
    void setLength(T len);
    double module() const { return sqrt(squaredModule()); }
    double squaredModule() const;
    double angle(const Vector3D<T>& v) const;
    double distance(const Vector3D<T>& v) const { return sqrt(squaredDistance(v)); }
    double squaredDistance(const Vector3D<T>& v) const;
    double infDistance(const Vector3D<T>& v) const;
    double manhattanDistance(const Vector3D<T>& v) const;
         double distanceToPlane(const Vector3D<T>& P, const Vector3D<T>& N) const;

    void rotateX(double angle);
    void rotateY(double angle);
    void rotateZ(double angle);
                Vector3D<T> rotation(const Vector3D<T>& axis, double angle) const;

    T operator*(const Vector3D<T>& v) const;
    T dotProduct(const Vector3D<T>& v) const { return (*this) * v; }
                T operator*(const std::vector<T>& v) const;

    Vector3D<T> operator/(T factor) const;
    const Vector3D<T>& operator/=(T factor);

    Vector3D<T> operator*(T factor) const;
    const Vector3D<T>& operator*=(T factor);
//    friend Vector3D<T> operator*(T factor, const Vector3D<T>& v);

                Vector3D<T> operator^(const Vector3D<T>& v) const;
                Vector3D<T> crossProduct(const Vector3D<T>& v) const{ return (*this)^v; }

    Vector3D<T> operator-(const Vector3D<T>& v) const;
                Vector3D<T> difference(const Vector3D<T>& v) const{ return (*this) - v; }
                const Vector3D<T>& operator-=(const Vector3D<T>& v);
                const Vector3D<T>& substract(const Vector3D<T>& v) { return (*this) -= v; }

                Vector3D<T> projectX() const;
                Vector3D<T> projectY() const;
                Vector3D<T> projectZ() const;
    Vector3D<T> project(const Vector3D<T>& n) const;
                Vector3D<T> intersect(const Vector3D<T>& center, const Vector3D<T>& normal) const;
                Vector3D<T> perpendicular() const;

    Vector3D<T> operator+(const Vector3D<T>& v) const;
                Vector3D<T> sum(const Vector3D<T>& v) const { return (*this) + v; }
    const Vector3D<T>& operator+=(const Vector3D<T>& v);
                const Vector3D<T>& add(const Vector3D<T>& v){ return (*this) += v; }

  protected:
    T _data[3];
  };

        // Needed operator* that I don't know how to move to the cpp
        template <class T> Vector3D<T> operator* (T factor, const Vector3D<T>& v)
  {
    return v * factor;
  }

        // Needed operator* that I don't know how to move to the cpp
        template <class T> Vector3D<T> operator- (const Vector3D<T>& v)
  {
    return Vector3D<T>(-v.x(), -v.y(), -v.z());
  }

        // Output operator
        // Format: "(a.aa, b.bbb, c.c)"
        template <class T>
  std::ostream& operator<< (std::ostream& out, const Vector3D<T>& v)
  {
    out  << v._data[0] << " " << v._data[1] << " " << v._data[2];

    return out;
  }

        // Input operator
        // Format: "a.aa b.bbb c.c"
        template <class T>
  std::istream& operator>> (std::istream& in, Vector3D<T>& v)
  {
                in >> v._data[0] >> v._data[1] >> v._data[2];

    return in;
  }

        typedef Vector3D<int> Vector3Di;
        typedef Vector3D<float> Vector3Df;
        typedef Vector3D<double> Vector3Dd;
        typedef Vector3D<short> Vector3Ds;
        typedef Vector3D<char> Vector3Dc;
};


#endif

---