Vector3.h

00001 /*************************************************************************************************
00002  *
00003  * Modeling and animation (TNM079) 2007
00004  * Code base for lab assignments. Copyright:
00005  *   Gunnar Johansson (gunnar.johansson@itn.liu.se)
00006  *   Ken Museth (ken.museth@itn.liu.se)
00007  *   Michael Bang Nielsen (bang@daimi.au.dk)
00008  *   Ola Nilsson (ola.nilsson@itn.liu.se)
00009  *   Andreas Söderström (andreas.soderstrom@itn.liu.se)
00010  *
00011  *************************************************************************************************/
00012 #ifndef _vector3_h
00013 #define _vector3_h
00014 
00015 #include "Vector4.h"
00016 #include <cmath>
00017 #include <iostream>
00018 #include <string>
00019 #include <sstream>
00020 
00021 template <typename Real>
00022 class Vector3
00023 {
00024 public:
00025   typedef Real ValueType;
00026 
00027 public:
00028   // Constructors, destructor and assignment operators
00030   Vector3() 
00031   {
00032     v[0] = v[1] = v[2] = Real(0.0);
00033   }
00034   Vector3(Real v0) 
00035   {
00036     v[0] = v[1] = v[2] = v0;
00037   }
00038   Vector3(Real v0, Real v1, Real v2) 
00039   {
00040     v[0] = v0;
00041     v[1] = v1;
00042     v[2] = v2;
00043   }
00045   Vector3(const Vector4<Real>& vec4) 
00046   {
00047     v[0]=vec4[0]/vec4[3];
00048     v[1]=vec4[1]/vec4[3];
00049     v[2]=vec4[2]/vec4[3];
00050   }
00052   template <typename Real2>
00053   Vector3(const Vector3<Real2>& vec3) 
00054   {
00055     *this = vec3;
00056   }
00058   template <typename Real2>
00059   Vector3& operator=(const Vector3<Real2>& vec3) 
00060   {
00061     v[0]=(Real)vec3[0];
00062     v[1]=(Real)vec3[1];
00063     v[2]=(Real)vec3[2];
00064     return *this;
00065   }
00067   template <typename Scalar>
00068   Vector3& operator=(Scalar s) 
00069   {
00070     v[0]=(Real)s;
00071     v[1]=(Real)s;
00072     v[2]=(Real)s;
00073     return *this;
00074   }
00076   Vector3(std::string str) 
00077   {
00078     std::stringstream s;
00079     s << str;
00080     load(s);
00081   } 
00083   ~Vector3() { }
00085   void load(std::istream& is) 
00086   {
00087     is >> v[0] >> v[1] >> v[2];
00088   }
00090   void save(std::ostream& os) const 
00091   {
00092     os << v[0] << " " << v[1] << " " << v[2];
00093   }
00094 
00095   // Access operators
00096   Real& operator[](unsigned int i) 
00097   {
00098     return v[i];
00099   }
00100   
00101   Real operator[](unsigned int i) const 
00102   {
00103     return v[i];
00104   }
00105   Real x() const {return v[0];}
00106   Real y() const {return v[1];}
00107   Real z() const {return v[2];}
00108   Real& x() {return v[0];}
00109   Real& y() {return v[1];}
00110   Real& z() {return v[2];}
00111   Real *getArrayPtr() { return v; }
00112   
00113   // Algebraic operators
00114   Vector3 operator-(const Vector3& vec3) const 
00115   {
00116     return Vector3(v[0]-vec3.v[0], v[1]-vec3.v[1], v[2]-vec3.v[2]);
00117   }
00118   
00119   Vector3 operator+(const Vector3& vec3) const 
00120   {
00121     return Vector3(v[0]+vec3.v[0], v[1]+vec3.v[1], v[2]+vec3.v[2]);
00122   }
00123   
00124   Vector3 & operator+=(const Vector3& vec3) 
00125   {
00126     v[0]+=vec3.v[0];
00127     v[1]+=vec3.v[1];
00128     v[2]+=vec3.v[2];
00129     return *this;
00130   }
00131   
00132   Vector3 & operator-=(const Vector3& vec3) 
00133   {
00134     v[0]-=vec3.v[0];
00135     v[1]-=vec3.v[1];
00136     v[2]-=vec3.v[2];
00137     return *this;
00138   }
00140   
00141   Real operator*(const Vector3<Real>& vec3) const 
00142   {
00143     return v[0]*vec3[0] + v[1]*vec3[1] + v[2]*vec3[2];
00144   }
00145   
00147   template<typename Scalar>
00148   Vector3<Real> operator*(Scalar s) const 
00149   { 
00150     return Vector3<Real>((Real)(s*v[0]), (Real)(s*v[1]), (Real)(s*v[2]));
00151   }
00152   
00153   template<typename Scalar>
00154   Vector3<Real>& operator*=(Scalar s) 
00155   {
00156     v[0]*=(Real)s;
00157     v[1]*=(Real)s;
00158     v[2]*=(Real)s;
00159     return *this;
00160   }
00161   
00163   template<typename Scalar>
00164   Vector3<Real> operator/(Scalar s) const 
00165   {
00166     Real invS = 1.0/s;
00167     return Vector3<Real>(v[0]*invS, v[1]*invS, v[2]*invS);
00168   }
00169   
00171   Vector3 entryMult(const Vector3& vec3) const 
00172   {
00173     return Vector3(v[0]*vec3.v[0], v[1]*vec3.v[1], v[2]*vec3.v[2]);
00174   }
00175                 
00176   // Comparison operators
00178   bool operator >  ( const Vector3<Real> &A ) const;
00180   bool operator <  ( const Vector3<Real> &A ) const;
00182   bool operator <= ( const Vector3<Real> &A ) const;
00184   bool operator >= ( const Vector3<Real> &A ) const;
00186   bool operator == ( const Vector3<Real> &A ) const;
00188   bool operator != (const Vector3<Real>& other) const {return !(*this == other);}
00190   template <typename Real2>
00191   bool operator==(const Vector3<Real2>& vec3) const 
00192   {
00193     return v[0]==(Real)vec3[0] && v[1]==(Real)vec3[1] && v[2]==(Real)vec3[2];
00194   }
00195         
00196   // Geometric operators
00198   Real norm() const 
00199   {
00200     return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
00201   }
00203   Real length() const 
00204   {
00205     return sqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
00206   }
00208   Vector3& normalize() 
00209   {
00210     Real len = length();
00211     v[0] /= len;
00212     v[1] /= len;
00213     v[2] /= len;
00214     return *this;
00215   }
00216   
00217   
00218   // static methods
00219   static Vector3 floor(const Vector3& vec3) 
00220   {
00221     return Vector3(::floor(vec3[0]), ::floor(vec3[1]), ::floor(vec3[2]));
00222   }
00223   
00224   static Vector3 ceil(const Vector3& vec3) 
00225   {
00226     return Vector3(::ceil(vec3[0]), ::ceil(vec3[1]), ::ceil(vec3[2]));
00227   }
00228 
00229 protected:
00230   Real v[3];
00231   // friends
00233   template<typename Real2>
00234   friend Vector3<Real2> cross(const Vector3<Real2>& v1, const Vector3<Real2>& v2);
00235 };
00236 
00238 template<>
00239 inline float Vector3<float>::length() const
00240 {
00241   return sqrtf( v[0]*v[0] + v[1]*v[1] + v[2]*v[2] );
00242 }
00243 
00245 template <typename Real2>
00246 Vector3<Real2> cross(const Vector3<Real2>& v1, const Vector3<Real2>& v2)
00247 {
00248   Vector3<Real2> res;
00249 
00250   res[0] = v1[1] * v2[2] - v1[2] * v2[1];
00251   res[1] = v1[2] * v2[0] - v1[0] * v2[2];
00252   res[2] = v1[0] * v2[1] - v1[1] * v2[0];
00253 
00254   return res;
00255 }
00256         
00258 template <class Real>
00259 inline bool Vector3<Real>::operator < ( const Vector3<Real> &A ) const
00260 {
00261   if ( v[0]<A[0] ) 
00262     return true;
00263   else if ( v[0]>A[0] )
00264     return false;
00265   else if ( v[1]<A[1] )
00266     return true;
00267   else if ( v[1]>A[1] )
00268     return false;
00269   else if ( v[2]<A[2] )
00270     return true;
00271   else
00272     return false;
00273 }
00274 template <class Real>
00275 inline bool Vector3<Real>::operator > ( const Vector3<Real> &A ) const
00276 {
00277   if ( v[0]>A[0] ) 
00278     return true;
00279   else if ( v[0]<A[0] )
00280     return false;
00281   else if ( v[1]>A[1] )
00282     return true;
00283   else if ( v[1]<A[1] )
00284     return false;
00285   else if ( v[2]>A[2] )
00286     return true;
00287   else
00288     return false;
00289 }
00290 template <class Real>
00291 inline bool Vector3<Real>::operator <= ( const Vector3<Real> &A ) const
00292 {
00293   if ( v[0]<A[0] ) 
00294     return true;
00295   else if ( v[0]>A[0] )
00296     return false;
00297   else if ( v[1]<A[1] )
00298     return true;
00299   else if ( v[1]>A[1] )
00300     return false;
00301   else if ( v[2]<=A[2] )
00302     return true;
00303   else
00304     return false;
00305 }
00306 template <class Real>
00307 inline bool Vector3<Real>::operator >= ( const Vector3<Real> &A ) const
00308 {
00309   if ( v[0]>A[0] ) 
00310     return true;
00311   else if ( v[0]<A[0] )
00312     return false;
00313   else if ( v[1]>A[1] )
00314     return true;
00315   else if ( v[1]<A[1] )
00316     return false;
00317   else if ( v[2]>=A[2] )
00318     return true;
00319   else
00320     return false;
00321 }
00322 template <class Real>
00323 inline bool Vector3<Real>::operator == ( const Vector3<Real> &A ) const
00324 {
00325   return ( v[0]==A[0] && v[1]==A[1] && v[2]==A[2] );
00326 }
00327         
00328         
00329 
00330 template <typename Real1, typename Real2>
00331 Vector3<Real2> operator*(Real1 r, const Vector3<Real2>& v)
00332 {
00333   Vector3<Real2> res;
00334   
00335   res[0] = v[0]*r;
00336   res[1] = v[1]*r;
00337   res[2] = v[2]*r;
00338   
00339   return res;
00340 }
00341 
00342 template <typename Real>
00343 const Vector3<Real> operator-(const Vector3<Real>& vec3) 
00344 {
00345   return Vector3<Real>(-vec3[0], -vec3[1], -vec3[2]);
00346 }
00347 
00348 namespace std
00349 {
00350   template <typename Real>
00351   ostream& operator<<(ostream& os, const Vector3<Real>& m)
00352   {
00353     m.save(os);
00354     return os;
00355   }
00356   
00357   template <typename Real>
00358   istream& operator>>(istream& is, Vector3<Real>& m)
00359   {
00360     m.load(is);
00361     return is;
00362   }
00363 }
00364 
00365 
00366 #endif

Generated on Fri Jul 20 23:57:42 2007 for HalfEdge by  doxygen 1.5.1