00001
00002
00003
00004
00005
00006
00007
00008
00009
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
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
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
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
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
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
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
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