OpenPaperOpt/V3.h

Go to the documentation of this file.

#ifndef V3_H
#define V3_H

#include "V2.h"
#include <math.h>
#include <iostream>

#ifndef PI
#define PI 3.1415926535897932384626433832795
#endif

template <class T>
class V3 {

private:
    T x, y, z;

public:
        V3() : x(0), y(0), z(0) {}
        V3(const T _x, const T _y, const T _z) : x(_x), y(_y), z(_z) {}
        V3(const V3 <T>& v) : x(v.x), y(v.y), z(v.z) {}
        V3(const V2 <T> &v,T _z)      {x=v.X();y=v.Y();z=_z;}

        T X()                   const { return x; }
        T Y()                   const { return y; }
        T Z()                   const { return z; }
        T P(int i) const {
                switch (i) {
                        case 0: return x;
                        case 1: return y;
                        case 2: return z;
                        default: return 0;
                }
        }
        V2 <T> Drop(int i) const {
                switch (i){
                        case 0: return V2 <T>(y,z);
                        case 1: return V2 <T>(x,z);
                        default: return V2 <T>(x,y);
                }
        }

        void X(T _x) { x = _x; }
        void Y(T _y) { y = _y; }
        void Z(T _z) { z = _z; }

        T LengthVector() { return sqrt(x*x + y*y + z*z); }
        T LengthVector2() { return (x*x + y*y + z*z); }

        void NormalizeVector() {
                T temp = sqrt(x*x + y*y + z*z);
                if (temp!=0) {
                        x /= temp;
                        y /= temp;
                        z /= temp;
                }               
        }
        V3 <T>& Normalize() {
                operator*=((T)(1.0/sqrt(LengthVector2())));
                return *this;
        }
    
        T Sum() const {return x+y+z;}
    
        V3 <T> AbsVec() const {return V3 <T>((T)fabs(x),(T)fabs(y),(T)fabs(z));}
        T AbsMax()   const {T dd,d=fabs(x);dd=fabs(y);if (dd>d) d=dd;dd=fabs(z);if (dd>d) d=dd;return d;}
        int GetCDrop() const {if (fabs(x)>fabs(y) && fabs(x)>fabs(z)) return 0;if (fabs(y)>fabs(z)) return 1;return 2;}
    V3 <T>&   ClipOne()      {if (x>1) x=1;if (y>1) y=1;if (z>1) z=1;return *this;}
    V3 <T>&   Rotate90XY()   {T t=x;x=-y;y=t;return *this;}

    void  SetMin(const V3 <T>& v)    {if (v.x<x) x=v.x;if (v.y<y) y=v.y;if (v.z<z) z=v.z;}
    void  SetMax(const V3 <T>& v)    {if (v.x>x) x=v.x;if (v.y>y) y=v.y;if (v.z>z) z=v.z;}

        //operator overloaded for different return type---void
        void operator+=(const V3 <T>& v) { x += v.x; y +=v.y; z += v.z; }
        void operator-=(const V3 <T>& v) { x -= v.x; y -=v.y; z -= v.z; }
        void operator*=(const V3 <T>& v) { x *= v.x; y *=v.y; z *= v.z; }
        void operator*=(const double k) { x *= k; y *= k; z *= k; }
        void operator/=(const V3 <T>& v) { x /= v.x; y /= v.y; z /= v.z; }
        void operator/=(T f)     {operator*=((T)(1.0/f));}
        
        //Negate Operation
        void negate() {x = -x;y = -y;z = -z;}
        V3 <T> operator-(void) const   {return V3 <T> (-x,-y,-z);}
        
        //operator overloaded for different return type---V3
        V3 <T>operator+(const V3 <T> & b) const { return V3 <T>(x+b.x, y+b.y, z+b.z); }
        V3 <T>operator-(const V3 <T> & b) const { return V3 <T>(x-b.x, y-b.y, z-b.z); }
        
        T operator*(const V3 <T> & b) const { return x*b.x + y*b.y + z*b.z; }
        V3 <T> operator*(T f) const { return V3 <T>(x*f, y*f, z*f); }
        V3 <T> operator/(T f) const { return (*this)*(1.0/f); }
        

        //friend ostream& operator<<(ostream&, const V3 <T>&);

        void CrossProduct(const V3<T>& u, const V3<T>& v) {
                x = u.y * v.z - u.z * v.y;
                y = u.z * v.x - u.x * v.z;
        z = u.x * v.y - u.y * v.x;
  }


        T vectMult(const V3 <T> & u) const {
                return x * u.x + y * u.y + z * u.z;
        }

        void VectDivConst(const T& v) { x /= v; y /= v; z /= v; }
        void VectMulConst(const T& v) { x *= v; y *= v; z *= v; }
};
template <class T>
inline V3 <T> cross(const V3 <T> & a,const V3 <T> & b){
        return V3 <T>(a.Y()*b.Z()-a.Z()*b.Y(),a.Z()*b.X()-a.X()*b.Z(),a.X()*b.Y()-a.Y()*b.X());
}

template <class T>
inline V3 <T> reflect(const V3 <T> & i,const V3 <T> & n){
        T s=-(i*n)*2;
        return i+(n*s);
}
#endif