NITE 1.4.1 - API Reference
|
00001 /******************************************************************************* 00002 * * 00003 * PrimeSense NITE 1.3 * 00004 * Copyright (C) 2010 PrimeSense Ltd. * 00005 * * 00006 *******************************************************************************/ 00007 00008 00009 #ifndef _XNV_3DVECTOR_H_ 00010 #define _XNV_3DVECTOR_H_ 00011 00012 //--------------------------------------------------------------------------- 00013 // Includes 00014 //--------------------------------------------------------------------------- 00015 #include <math.h> 00016 #include "XnVNiteDefs.h" 00017 #include "XnVMathCommon.h" 00018 00019 //--------------------------------------------------------------------------- 00020 // Types 00021 //--------------------------------------------------------------------------- 00022 00023 class XNV_NITE_API XnV3DVector : public XnPoint3D 00024 { 00025 public: 00026 // Constructors 00027 inline XnV3DVector(); 00028 inline XnV3DVector(XnFloat fX, XnFloat fY, XnFloat fZ); 00029 inline XnV3DVector(const XnPoint3D& ptOther); 00030 inline XnV3DVector(const XnV3DVector& v3Other); 00031 inline XnV3DVector(XnFloat f); 00032 inline XnV3DVector(XnFloat* pf); 00033 00034 // Assignment 00035 inline XnV3DVector& operator=(const XnV3DVector& v3Rhs); 00036 inline XnV3DVector& operator=(const XnPoint3D& ptRhs); 00037 00038 // Access 00039 inline XnFloat operator[](XnUInt32 index) const; 00040 inline XnFloat& operator[](XnUInt32 index); 00041 00042 // Set 00043 inline XnV3DVector& Set(const XnV3DVector& v3Other); 00044 inline XnV3DVector& Set(const XnPoint3D& ptOther); 00045 inline XnV3DVector& Set(XnFloat fX, XnFloat fY, XnFloat fZ); 00046 inline XnV3DVector& Set(XnFloat f); 00047 00048 // Zero 00049 inline XnV3DVector& SetZero(); 00050 inline XnBool IsZero() const; 00051 00052 // Comparison 00053 inline XnBool operator==(const XnV3DVector& v3Rhs) const; 00054 inline XnBool operator!=(const XnV3DVector& v3Rhs) const; 00055 00056 // Negation 00057 inline XnV3DVector operator-() const; 00058 inline XnV3DVector& Negate(const XnV3DVector& v3Other); 00059 inline XnV3DVector& Negate(); 00060 00061 // Multiplication 00062 inline XnV3DVector operator*(const XnV3DVector& v3Rhs) const; 00063 inline XnV3DVector& operator*=(const XnV3DVector& v3Rhs); 00064 inline XnV3DVector& Multiply(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs); 00065 00066 friend inline XnV3DVector operator*(XnFloat f, const XnV3DVector& v3Rhs); 00067 inline XnV3DVector& Multiply(XnFloat f, const XnV3DVector& v3Rhs); 00068 00069 inline XnV3DVector operator*(XnFloat f) const; 00070 inline XnV3DVector& operator*=(XnFloat f); 00071 inline XnV3DVector& Multiply(const XnV3DVector& v3Lhs, XnFloat f); 00072 00073 // Division 00074 inline XnV3DVector operator/(XnFloat f) const; 00075 inline XnV3DVector& operator/=(XnFloat f); 00076 inline XnV3DVector& Divide(const XnV3DVector& v3Lhs, XnFloat f); 00077 00078 // Addition 00079 inline XnV3DVector operator+(const XnV3DVector& v3Rhs) const; 00080 inline XnV3DVector& operator+=(const XnV3DVector& v3Rhs); 00081 inline XnV3DVector& Add(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs); 00082 00083 inline XnV3DVector operator+(XnFloat f) const; 00084 inline XnV3DVector& operator+=(XnFloat f); 00085 inline XnV3DVector& Add(const XnV3DVector& v3Lhs, XnFloat f); 00086 00087 // Subtraction 00088 inline XnV3DVector operator-(const XnV3DVector& v3Rhs) const; 00089 inline XnV3DVector& operator-=(const XnV3DVector& v3Rhs); 00090 inline XnV3DVector& Subtract(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs); 00091 00092 inline XnV3DVector operator-(XnFloat f) const; 00093 inline XnV3DVector& operator-=(XnFloat f); 00094 inline XnV3DVector& Subtract(const XnV3DVector& v3Lhs, XnFloat f); 00095 00096 inline XnV3DVector& Sqrt(); 00097 inline XnV3DVector& Sqrt(const XnV3DVector& v3Other); 00098 00099 // Magnitude 00100 inline XnFloat Magnitude() const; 00101 inline XnFloat MagnitudeSquared() const; 00102 00103 // Distance 00104 inline XnFloat Distance(const XnV3DVector& v3Other) const; 00105 inline XnFloat DistanceSquared(const XnV3DVector& v3Other) const; 00106 00107 // Normalize 00108 inline XnFloat Normalize(); 00109 00110 // Orthogonal 00111 inline XnV3DVector& OrthogonalVector(const XnV3DVector& v3Other); 00112 inline XnV3DVector& UnitOrthogonalVector(const XnV3DVector& v3Other); 00113 00114 // Cross product 00115 inline XnV3DVector operator^(const XnV3DVector& v3Rhs) const; 00116 inline XnV3DVector& CrossProduct(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs); 00117 00118 // Dot Product 00119 inline XnFloat operator|(const XnV3DVector& v3Rhs) const; 00120 friend inline XnFloat DotProduct(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs); 00121 00122 // Interpolation 00123 inline XnV3DVector& Interpolate(const XnV3DVector& v3Vec1, const XnV3DVector& v3Vec2, XnFloat fAlpha); 00124 00125 inline XnBool IsSameDirection(const XnV3DVector& v3Other) const; 00126 00127 inline XnFloat GetTolerance() const; 00128 inline void SetTolerance(XnFloat fTolerance); 00129 00130 protected: 00131 XnFloat m_fTolerance; 00132 }; 00133 00134 XnFloat XnV3DVector::GetTolerance() const 00135 { 00136 return m_fTolerance; 00137 } 00138 00139 void XnV3DVector::SetTolerance(XnFloat fTolerance) 00140 { 00141 m_fTolerance = fTolerance; 00142 } 00143 00144 XnV3DVector::XnV3DVector() : 00145 m_fTolerance(1e-5f) 00146 { 00147 Set(0); 00148 } 00149 XnV3DVector::XnV3DVector(XnFloat fX, XnFloat fY, XnFloat fZ) : 00150 m_fTolerance(1e-5f) 00151 { 00152 Set(fX, fY, fZ); 00153 } 00154 XnV3DVector::XnV3DVector(const XnV3DVector& v3Other) 00155 { 00156 Set(v3Other); 00157 } 00158 XnV3DVector::XnV3DVector(const XnPoint3D& ptOther) 00159 { 00160 Set(ptOther); 00161 } 00162 XnV3DVector::XnV3DVector(XnFloat f) : 00163 m_fTolerance(1e-5f) 00164 { 00165 Set(f); 00166 } 00167 XnV3DVector::XnV3DVector(XnFloat* pf) : 00168 m_fTolerance(1e-5f) 00169 { 00170 Set(pf[0], pf[1], pf[2]); 00171 } 00172 00173 // Assignment 00174 XnV3DVector& XnV3DVector::operator=(const XnV3DVector& v3Rhs) 00175 { 00176 m_fTolerance = v3Rhs.m_fTolerance; 00177 return Set(v3Rhs.X, v3Rhs.Y, v3Rhs.Z); 00178 } 00179 XnV3DVector& XnV3DVector::operator=(const XnPoint3D& ptRhs) 00180 { 00181 m_fTolerance = 1e-5f; 00182 return Set(ptRhs.X, ptRhs.Y, ptRhs.Z); 00183 } 00184 00185 // Access 00186 XnFloat XnV3DVector::operator[](XnUInt32 nIndex) const 00187 { 00188 switch (nIndex) 00189 { 00190 case 0: 00191 return X; 00192 case 1: 00193 return Y; 00194 case 2: 00195 return Z; 00196 } 00197 00198 return Z; 00199 } 00200 XnFloat& XnV3DVector::operator[](XnUInt32 nIndex) 00201 { 00202 switch (nIndex) 00203 { 00204 case 0: 00205 return X; 00206 case 1: 00207 return Y; 00208 case 2: 00209 return Z; 00210 } 00211 00212 return Z; 00213 } 00214 00215 // Set 00216 XnV3DVector& XnV3DVector::Set(const XnV3DVector& v3Other) 00217 { 00218 return *this = v3Other; 00219 } 00220 XnV3DVector& XnV3DVector::Set(const XnPoint3D& ptOther) 00221 { 00222 return *this = ptOther; 00223 // return Set(ptOther.X, ptOther.Y, ptOther.Z) 00224 } 00225 XnV3DVector& XnV3DVector::Set(XnFloat x, XnFloat y, XnFloat z) 00226 { 00227 X = x; 00228 Y = y; 00229 Z = z; 00230 00231 return *this; 00232 } 00233 XnV3DVector& XnV3DVector::Set(XnFloat f) 00234 { 00235 return Set(f, f, f); 00236 } 00237 00238 // Zero 00239 XnV3DVector& XnV3DVector::SetZero() 00240 { 00241 return Set(0); 00242 } 00243 XnBool XnV3DVector::IsZero() const 00244 { 00245 return (fabs(X) < m_fTolerance && 00246 fabs(Y) < m_fTolerance && 00247 fabs(Z) < m_fTolerance); 00248 } 00249 00250 // Comparison 00251 XnBool XnV3DVector::operator==(const XnV3DVector& v3Rhs) const 00252 { 00253 return (fabs(X - v3Rhs.X) < m_fTolerance && 00254 fabs(Y - v3Rhs.Y) < m_fTolerance && 00255 fabs(Z - v3Rhs.Z) < m_fTolerance); 00256 } 00257 XnBool XnV3DVector::operator!=(const XnV3DVector& v3Rhs) const 00258 { 00259 return !this->operator==(v3Rhs); 00260 } 00261 00262 // Negation 00263 XnV3DVector XnV3DVector::operator-() const 00264 { 00265 return XnV3DVector(-X, -Y, -Z); 00266 } 00267 XnV3DVector& XnV3DVector::Negate(const XnV3DVector& v3Other) 00268 { 00269 return Set(-v3Other.X, -v3Other.Y, -v3Other.Z); 00270 } 00271 XnV3DVector& XnV3DVector::Negate() 00272 { 00273 return Set(-X, -Y, -Z); 00274 } 00275 00276 // Multiplication 00277 XnV3DVector XnV3DVector::operator*(const XnV3DVector& v3Rhs) const 00278 { 00279 return XnV3DVector(X * v3Rhs.X, Y * v3Rhs.Y, Z*v3Rhs.Z); 00280 } 00281 XnV3DVector& XnV3DVector::operator*=(const XnV3DVector& v3Rhs) 00282 { 00283 return Set(X * v3Rhs.X, Y * v3Rhs.Y, Z * v3Rhs.Z); 00284 } 00285 XnV3DVector& XnV3DVector::Multiply(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs) 00286 { 00287 return Set(v3Lhs.X * v3Rhs.X, v3Lhs.Y * v3Rhs.Y, v3Lhs.Z * v3Rhs.Z); 00288 } 00289 00290 XnV3DVector operator*(XnFloat f, const XnV3DVector& v3Rhs) 00291 { 00292 return XnV3DVector(f * v3Rhs.X, f * v3Rhs.Y, f * v3Rhs.Z); 00293 } 00294 XnV3DVector& XnV3DVector::Multiply(XnFloat f, const XnV3DVector& v3Rhs) 00295 { 00296 return Set(f * v3Rhs.X, f * v3Rhs.Y, f * v3Rhs.Z); 00297 } 00298 00299 XnV3DVector XnV3DVector::operator*(XnFloat f) const 00300 { 00301 return XnV3DVector(X * f, Y * f, Z * f); 00302 } 00303 XnV3DVector& XnV3DVector::operator*=(XnFloat f) 00304 { 00305 return Set(X * f, Y * f, Z * f); 00306 } 00307 XnV3DVector& XnV3DVector::Multiply(const XnV3DVector& v3Lhs, XnFloat f) 00308 { 00309 return Set(v3Lhs.X * f, v3Lhs.Y * f, v3Lhs.Z * f); 00310 } 00311 00312 // Division 00313 XnV3DVector XnV3DVector::operator/(XnFloat f) const 00314 { 00315 return XnV3DVector(X / f, Y / f, Z / f); 00316 } 00317 XnV3DVector& XnV3DVector::operator/=(XnFloat f) 00318 { 00319 return Set(X / f, Y / f, Z / f); 00320 } 00321 XnV3DVector& XnV3DVector::Divide(const XnV3DVector& v3Lhs, XnFloat f) 00322 { 00323 return Set(v3Lhs.X / f, v3Lhs.Y / f, v3Lhs.Z / f); 00324 } 00325 00326 // Addition 00327 XnV3DVector XnV3DVector::operator+(const XnV3DVector& v3Rhs) const 00328 { 00329 return XnV3DVector(X + v3Rhs.X, Y + v3Rhs.Y, Z + v3Rhs.Z); 00330 } 00331 XnV3DVector& XnV3DVector::operator+=(const XnV3DVector& v3Rhs) 00332 { 00333 return Set(X + v3Rhs.X, Y + v3Rhs.Y, Z + v3Rhs.Z); 00334 } 00335 XnV3DVector& XnV3DVector::Add(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs) 00336 { 00337 return Set(v3Lhs.X + v3Rhs.X, v3Lhs.Y + v3Rhs.Y, v3Lhs.Z + v3Rhs.Z); 00338 } 00339 00340 XnV3DVector XnV3DVector::operator+(XnFloat f) const 00341 { 00342 return XnV3DVector(X + f, Y + f, Z + f); 00343 } 00344 XnV3DVector& XnV3DVector::operator+=(XnFloat f) 00345 { 00346 return Set(X + f, Y + f, Z + f); 00347 } 00348 XnV3DVector& XnV3DVector::Add(const XnV3DVector& v3Lhs, XnFloat f) 00349 { 00350 return Set(v3Lhs.X + f, v3Lhs.Y + f, v3Lhs.Z + f); 00351 } 00352 00353 // Subtraction 00354 XnV3DVector XnV3DVector::operator-(const XnV3DVector& v3Rhs) const 00355 { 00356 return XnV3DVector(X - v3Rhs.X, Y - v3Rhs.Y, Z - v3Rhs.Z); 00357 } 00358 XnV3DVector& XnV3DVector::operator-=(const XnV3DVector& v3Rhs) 00359 { 00360 return Set(X - v3Rhs.X, Y - v3Rhs.Y, Z - v3Rhs.Z); 00361 } 00362 XnV3DVector& XnV3DVector::Subtract(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs) 00363 { 00364 return Set(v3Lhs.X - v3Rhs.X, v3Lhs.Y - v3Rhs.Y, v3Lhs.Z - v3Rhs.Z); 00365 } 00366 00367 XnV3DVector XnV3DVector::operator-(XnFloat f) const 00368 { 00369 return XnV3DVector(X - f, Y - f, Z - f); 00370 } 00371 XnV3DVector& XnV3DVector::operator-=(XnFloat f) 00372 { 00373 return Set(X - f, Y - f, Z - f); 00374 } 00375 XnV3DVector& XnV3DVector::Subtract(const XnV3DVector& v3Lhs, XnFloat f) 00376 { 00377 return Set(v3Lhs.X - f, v3Lhs.Y - f, v3Lhs.Z - f); 00378 } 00379 00380 XnV3DVector& XnV3DVector::Sqrt() 00381 { 00382 return Set(sqrt(X), sqrt(Y), sqrt(Z)); 00383 } 00384 00385 XnV3DVector& XnV3DVector::Sqrt(const XnV3DVector& v3Other) 00386 { 00387 Set(v3Other); 00388 return Sqrt(); 00389 } 00390 00391 // Magnitude 00392 XnFloat XnV3DVector::Magnitude() const 00393 { 00394 return sqrt(MagnitudeSquared()); 00395 } 00396 XnFloat XnV3DVector::MagnitudeSquared() const 00397 { 00398 return X * X + 00399 Y * Y + 00400 Z * Z; 00401 } 00402 00403 // Distance 00404 XnFloat XnV3DVector::Distance(const XnV3DVector& v3Other) const 00405 { 00406 return sqrt(DistanceSquared(v3Other)); 00407 } 00408 XnFloat XnV3DVector::DistanceSquared(const XnV3DVector& v3Other) const 00409 { 00410 return (*this-v3Other).MagnitudeSquared(); 00411 } 00412 00413 // Normalize 00414 XnFloat XnV3DVector::Normalize() 00415 { 00416 XnFloat fLen = Magnitude(); 00417 if (fLen > m_fTolerance) 00418 *this /= fLen; 00419 else 00420 Set(1, 0, 0); 00421 00422 return fLen; 00423 } 00424 00425 // Orthogonal 00426 XnV3DVector& XnV3DVector::OrthogonalVector(const XnV3DVector& v3Other) 00427 { 00428 XnFloat abs_x = fabs(v3Other.X), abs_y = fabs(v3Other.Y), abs_z = fabs(v3Other.Z); 00429 00430 if (abs_x < abs_y) 00431 if (abs_x < abs_z) 00432 Set(0, v3Other.Z, -v3Other.Y); 00433 else 00434 Set(v3Other.Y, -v3Other.X, 0); 00435 else 00436 if (abs_y < abs_z) 00437 Set(-v3Other.Z, 0, v3Other.X); 00438 else 00439 Set(v3Other.Y, -v3Other.X, 0); 00440 00441 return *this; 00442 } 00443 XnV3DVector& XnV3DVector::UnitOrthogonalVector(const XnV3DVector& v3Other) 00444 { 00445 OrthogonalVector(v3Other); 00446 Normalize(); 00447 00448 return *this; 00449 } 00450 00451 // Cross product 00452 XnV3DVector XnV3DVector::operator^(const XnV3DVector& v3Rhs) const 00453 { 00454 XnV3DVector v3Result; 00455 v3Result.CrossProduct(*this, v3Rhs); 00456 00457 return v3Result; 00458 } 00459 XnV3DVector& XnV3DVector::CrossProduct(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs) 00460 { 00461 return Set(v3Lhs.Y * v3Rhs.Z - v3Lhs.Z * v3Rhs.Y, 00462 v3Lhs.Z * v3Rhs.X - v3Lhs.X * v3Rhs.Z, 00463 v3Lhs.X * v3Rhs.Y - v3Lhs.Y * v3Rhs.X); 00464 } 00465 00466 // Dot Product 00467 XnFloat XnV3DVector::operator|(const XnV3DVector& v3Rhs) const 00468 { 00469 return DotProduct(*this, v3Rhs); 00470 } 00471 XnFloat DotProduct(const XnV3DVector& v3Lhs, const XnV3DVector& v3Rhs) 00472 { 00473 return v3Lhs.X * v3Rhs.X + 00474 v3Lhs.Y * v3Rhs.Y + 00475 v3Lhs.Z * v3Rhs.Z; 00476 } 00477 00478 // Interpolation 00479 XnV3DVector& XnV3DVector::Interpolate(const XnV3DVector& v3Vec1, const XnV3DVector& v3Vec2, XnFloat fAlpha) 00480 { 00481 return Set(v3Vec1.X + fAlpha * (v3Vec2.X - v3Vec1.X), 00482 v3Vec1.Y + fAlpha * (v3Vec2.Y - v3Vec1.Y), 00483 v3Vec1.Z + fAlpha * (v3Vec2.Z - v3Vec1.Z)); 00484 } 00485 XnBool XnV3DVector::IsSameDirection(const XnV3DVector& v3Other) const 00486 { 00487 if (IsZero() || v3Other.IsZero()) 00488 { 00489 return true; 00490 } 00491 00492 XnFloat fRatio = 0; 00493 00494 if (!XnVMathCommon::IsZero(X, m_fTolerance) && !XnVMathCommon::IsZero(v3Other.X, m_fTolerance)) 00495 fRatio = v3Other.X/X; 00496 else if (!XnVMathCommon::IsZero(Y, m_fTolerance) && !XnVMathCommon::IsZero(v3Other.Y, m_fTolerance)) 00497 fRatio = v3Other.Y/Y; 00498 else if (!XnVMathCommon::IsZero(Z, m_fTolerance) && !XnVMathCommon::IsZero(v3Other.Z, m_fTolerance)) 00499 fRatio = v3Other.Z/Z; 00500 else 00501 { 00502 // Combination sof zeros, though not all zeros! 00503 return false; 00504 } 00505 00506 if (v3Other/fRatio == (*this)) 00507 return true; 00508 00509 return false; 00510 } 00511 00512 00513 #endif