Vector3D.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   Vector3D.h
//  AUTHOR      :   Liang Liu
//  CREATION    :   2009-05-18
//  Copyright (C) MicroStrategy Incorporated 2009
//  All Rights Reserved
//==============================================================================================

#ifndef MsiChart_Vector3D_h
#define MsiChart_Vector3D_h

#include "Point3D.h"
#include "PDCHeader/PDCcmath"

namespace MsiChart
{
    template <class T = float>
    class Vector3D
    {   
    public:     
        Vector3D(double iX = T(), double iY = T(), double iZ = T()) : x(static_cast<T>(iX)), y(static_cast<T>(iY)), z(static_cast<T>(iZ)){}
        Vector3D(const Point3D<T>& irPoint) : x(irPoint.x), y(irPoint.y), z(irPoint.z){} 
        template <typename U>
        Vector3D(const Point3D<U>& irStart, const Point3D<U>& irEnd) 
            : x(static_cast<T>(irEnd.x - irStart.x)), 
              y(static_cast<T>(irEnd.y - irStart.y)),
              z(static_cast<T>(irEnd.z - irStart.z)){}      

        double LengthSquared() const;
        double Length() const;
        double IncludedAngle(const Vector3D<T>& irVector) const;
        double InnerProduct(const Vector3D<T>& irVector) const;
        double NormalizedInnerProduct(const Vector3D<T>& irVector) const;
        void CrossProduct(const Vector3D<T>& irVector, Vector3D<T>& orCrossProduct) const;  

        Vector3D<T> CrossProduct(const Vector3D<T>& irVector) const;    

        void Normalize();

        void Swap(Vector3D<T>& iorVector);
    
        Vector3D<T> operator - () const;
        Vector3D<T> operator - (const Vector3D<T>& irVector) const;
        Vector3D<T> operator + (const Vector3D<T>& irVector) const;     

        Vector3D<T> MultiplyBy(double iFactor) const;   
    
    public:
        T x;    
        T y;    
        T z;    
    };  

    //get the square length of a vector
    template <class T> 
    inline double Vector3D<T>::LengthSquared() const
    {
        return x * x + y * y + z * z;
    }   
    
    //A . B
    template <class T> 
    inline double Vector3D<T>::InnerProduct(const Vector3D<T>& irVector) const
    {
        return (x * irVector.x + y * irVector.y + z * irVector.z);
    }

    //A . B / (||A|| * ||B||)
    template <class T> 
    inline double Vector3D<T>::NormalizedInnerProduct(const Vector3D<T>& irVector) const
    {
        return InnerProduct(irVector) / (std::sqrt(LengthSquared() * irVector.LengthSquared()));
    }
    
    //A X B
    template <class T> 
    inline void Vector3D<T>::CrossProduct(const Vector3D<T>& irVector, Vector3D<T>& orCrossProduct) const
    {
        orCrossProduct.x = y * irVector.z - z * irVector.y;
        orCrossProduct.y = z * irVector.x - x * irVector.z;
        orCrossProduct.z = x * irVector.y - y * irVector.x;
    }

    //A X B
    template <class T> 
    inline Vector3D<T> Vector3D<T>::CrossProduct(const Vector3D<T>& irVector) const
    {
        return Vector3D<T>(y * irVector.z - z * irVector.y, z * irVector.x - x * irVector.z, x * irVector.y - y * irVector.x);
    }

    template <class T> 
    double Vector3D<T>::IncludedAngle(const Vector3D<T>& irVector) const
    {
        double lTemp = InnerProduct(irVector) / (std::sqrt(LengthSquared() * irVector.LengthSquared()));
        lTemp = (lTemp > 1.0f) ? 1.0f : lTemp;  
        lTemp = (lTemp < -1.0f) ? -1.0f : lTemp;    
        return std::acos(lTemp);
    }

    template <class T> 
    double Vector3D<T>::Length() const
    {
        return std::sqrt(LengthSquared());
    }

    template <class T> 
    inline void Vector3D<T>::Normalize()
    {
        double lLength = Length();
        x = x / lLength;
        y = y / lLength;
        z = z / lLength;
    }

    template<typename T>
    void Vector3D<T>::Swap(Vector3D<T>& iorVector)
    {
        std::swap(x, iorVector.x);
        std::swap(y, iorVector.y);
        std::swap(z, iorVector.z);

    }
    template <class T>
    inline Vector3D<T> Vector3D<T>::operator - () const
    {
        return Vector3D<T>(-x, -y, -z);
    }
    template <class T>
    inline Vector3D<T> Vector3D<T>::operator - (const Vector3D<T>& irVector) const
    {
        return Vector3D<T>(x - irVector.x, y - irVector.y, z - irVector.z);
    }
    template <class T>
    inline Vector3D<T> Vector3D<T>::operator + (const Vector3D<T>& irVector) const
    {
        return Vector3D<T>(x + irVector.x, y + irVector.y, z + irVector.z);
    }
    template <class T>
    Vector3D<T> Vector3D<T>::MultiplyBy(double iFactor) const
    {
        return Vector3D<T>(iFactor * x, iFactor * y, iFactor * z);
    }
    
    typedef Vector3D<float> FVector3D;
    typedef Vector3D<double> DVector3D;
}
#endif