Vector3D.h
Go to the documentation of this file.
00001 /***************************************************************************** 00002 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch) 00003 ***************************************************************************** 00004 * Project : Zeus Math Library 00005 * Module : Vector3D 00006 * Package : Zeus.ZeusMath.Geometry 00007 * Author : Martin Abbuehl 00008 * Date : 27.12.2011 00009 * System : Zeus-Framework 00010 ***************************************************************************** 00011 * Licence: * 00012 * This library is free software; you can redistribute it and/or modify * 00013 * it under the terms of the GNU Lesser General Public License as * 00014 * published by the Free Software Foundation; either version * 00015 * 2.1 of the License, or (at your option) any later version. * 00016 * * 00017 * This library is distributed in the hope that it will be useful, * 00018 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00019 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00020 * GNU Lesser General Public License for more details. * 00021 * * 00022 * You should have received a copy of the GNU Lesser General Public * 00023 * License along with this library; if not, write to the Free Software * 00024 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA * 00025 *****************************************************************************/ 00026 00027 /***************************************************************************** 00028 * Changes: 00029 * 27.12.2011 bha: created zeus 2.0 00030 *****************************************************************************/ 00031 00032 #ifndef Vector3DH 00033 #define Vector3DH 00034 00035 #include <math.h> 00036 #include <memory.h> 00037 #include <zeusmath/Geometry/Interfaces/IVector3D.hpp> 00038 #include <zeusmath/System/Vector.h> 00039 #include <zeusmath/System/Angle.h> 00040 00041 00042 00043 BEGIN_NAMESPACE_Zeus 00044 00045 00046 /*****************************************************************************/ 00052 /*****************************************************************************/ 00053 zeusmath_class TVector3D : public IVector3D 00054 { 00055 public: 00057 inline TVector3D() { initAsZeroVector(); } 00058 00060 inline TVector3D(const Float& fX, const Float& fY, const Float& fZ) { setValues(fX, fY, fZ); } 00061 00063 inline TVector3D(const TVector3D& rVector) { assign3D(rVector); } 00064 00066 inline TVector3D(const TVector& rVector) { assign(rVector); } 00067 00069 inline TVector3D(const IVector3D& rVector) { assign3D(rVector); } 00070 00072 inline TVector3D(const IVector& rVector) { assign(rVector); } 00073 00075 virtual inline ~TVector3D() { } 00076 00077 //Methods of TVector3D 00078 TVector3D getNormalizedVector() const; 00079 TVector3D rotatedX(const IAngle& rAngle) const; 00080 TVector3D rotatedY(const IAngle& rAngle) const; 00081 TVector3D rotatedZ(const IAngle& rAngle) const; 00082 TVector3D rotatedHorizontalAngle(const IAngle& rAngle) const; 00083 TVector3D rotatedVerticalAngle(const IAngle& rAngle) const; 00084 00085 //Methods of IVector3D 00086 virtual void MQUALIFIER assign3D(const IVector3D& rVector); 00087 virtual bool MQUALIFIER isParallel(const IVector3D& rVector) const; 00088 virtual bool MQUALIFIER isCollinear(const IVector3D& rVector) const; 00089 virtual bool MQUALIFIER isZeroVector() const; 00090 virtual bool MQUALIFIER isUnitVectorX() const; 00091 virtual bool MQUALIFIER isUnitVectorY() const; 00092 virtual bool MQUALIFIER isUnitVectorZ() const; 00093 virtual const Float& MQUALIFIER getX() const; 00094 virtual const Float& MQUALIFIER getY() const; 00095 virtual const Float& MQUALIFIER getZ() const; 00096 virtual void MQUALIFIER setX(const Float& fX); 00097 virtual void MQUALIFIER setY(const Float& fY); 00098 virtual void MQUALIFIER setZ(const Float& fZ); 00099 virtual void MQUALIFIER setValues(Float fX, Float fY, Float fZ); 00100 virtual void MQUALIFIER initAsZeroVector(); 00101 virtual void MQUALIFIER initAsUnitVectorX(); 00102 virtual void MQUALIFIER initAsUnitVectorY(); 00103 virtual void MQUALIFIER initAsUnitVectorZ(); 00104 virtual void MQUALIFIER calcVectorProduct(const IVector3D& rVector, IVector3D& rProduct) const; 00105 virtual void MQUALIFIER calcAngleTo(const IVector3D& rVector, IAngle& rAngle) const; 00106 virtual Float MQUALIFIER calcDistanceTo(const IVector3D& rVector) const; 00107 virtual void MQUALIFIER normalize(); 00108 virtual void MQUALIFIER getHorizontalAngle(IAngle& rAngle) const; 00109 virtual void MQUALIFIER getVerticalAngle(IAngle& rAngle) const; 00110 virtual void MQUALIFIER setHorizontalAngle(const IAngle& rAngle); 00111 virtual void MQUALIFIER setVerticalAngle(const IAngle& rAngle); 00112 virtual void MQUALIFIER rotateX(const IAngle& rAngle); 00113 virtual void MQUALIFIER rotateY(const IAngle& rAngle); 00114 virtual void MQUALIFIER rotateZ(const IAngle& rAngle); 00115 virtual void MQUALIFIER rotateHorizontalAngle(const IAngle& rAngle); 00116 virtual void MQUALIFIER rotateVerticalAngle(const IAngle& rAngle); 00117 virtual inline void MQUALIFIER mirrorAtXYPlane() { setZ(-getZ()); } 00118 virtual inline void MQUALIFIER mirrorAtXZPlane() { setY(-getY()); } 00119 virtual inline void MQUALIFIER mirrorAtYZPlane() { setX(-getX()); } 00120 00121 //Methods of IVector 00122 virtual void MQUALIFIER assign(const IVector& rVector); 00123 virtual void MQUALIFIER assignValues(const Float* apValues, Int iSize); 00124 virtual bool MQUALIFIER equals(const IVector& rVector, Float fPrecision = FLOAT_PRECISION) const; 00125 virtual Float MQUALIFIER getComponent(Int iIndex) const; 00126 virtual Float* MQUALIFIER getComponents(); 00127 virtual const Float* MQUALIFIER getComponentsConst() const; 00128 virtual Int MQUALIFIER getDimension() const; 00129 virtual Float MQUALIFIER getNorm() const; 00130 virtual Float MQUALIFIER getNormSquared() const; 00131 virtual Float MQUALIFIER getLength() const; 00132 virtual Float MQUALIFIER getLengthSquared() const; 00133 virtual bool MQUALIFIER setComponent(Int iIndex, Float fValue); 00134 virtual void MQUALIFIER setDimension(Int iValue); 00135 virtual void MQUALIFIER add(const IVector& rVector); 00136 virtual void MQUALIFIER subtract(const IVector& rVector); 00137 virtual Float MQUALIFIER calcScalarProduct(const IVector& rVector) const; 00138 virtual void MQUALIFIER multiply(const Float& f); 00139 virtual void MQUALIFIER divide(const Float& f); 00140 00141 //Mathematical Operators 00142 TVector3D operator+(const IVector& rVector) const; 00143 TVector3D operator-(const IVector& rVector) const; 00144 Float operator*(const IVector& rVector) const; 00145 TVector3D operator*(const Float& f) const; 00146 TVector3D operator/(const Float& f) const; 00147 TVector3D operator^(const IVector3D& rVector) const; 00148 const TVector3D& operator+=(const IVector& rVector); 00149 const TVector3D& operator-=(const IVector& rVector); 00150 const TVector3D& operator*=(const Float& f); 00151 const TVector3D& operator/=(const Float& f); 00152 00153 //assign operators 00154 const TVector3D& operator=(const IVector& rVector); 00155 const TVector3D& operator=(const IVector3D& rVector); 00156 const TVector3D& operator=(const TVector3D& rVector); 00157 00158 //compare operators 00159 bool operator==(const IVector3D& rVector) const; 00160 bool operator==(const IVector& Vector) const; 00161 bool operator!=(const IVector3D& rVector) const; 00162 bool operator!=(const IVector& rVector) const; 00163 bool operator||(const IVector3D& rVector) const; 00164 00165 //special compare used for maps and sets (not mathematically defined) 00166 bool operator < (const TVector3D& rVector) const; 00167 00168 00169 // Special static vectors. 00170 static inline const TVector3D& getZeroVector() { return m_ZeroVector; } 00171 static inline const TVector3D& getUnitVectorX() { return m_UnitVectorX; } 00172 static inline const TVector3D& getUnitVectorY() { return m_UnitVectorY; } 00173 static inline const TVector3D& getUnitVectorZ() { return m_UnitVectorZ; } 00174 00175 private: 00177 Float m_fCoordinates[3]; 00178 00180 static const TVector3D m_ZeroVector; 00181 static const TVector3D m_UnitVectorX; 00182 static const TVector3D m_UnitVectorY; 00183 static const TVector3D m_UnitVectorZ; 00184 }; 00185 00186 //INLINE METHODS 00187 /******************************************************************************/ 00193 /******************************************************************************/ 00194 inline TVector3D TVector3D::getNormalizedVector() const 00195 { 00196 return *this / getNorm(); 00197 } 00198 00199 /******************************************************************************/ 00207 /******************************************************************************/ 00208 inline TVector3D TVector3D::rotatedHorizontalAngle(const IAngle& rAngle) const 00209 { 00210 return rotatedZ(rAngle); 00211 } 00212 00213 00214 /******************************************************************************/ 00217 /******************************************************************************/ 00218 inline const Float& MQUALIFIER TVector3D::getX() const 00219 { 00220 return m_fCoordinates[0]; 00221 } 00222 00223 /******************************************************************************/ 00226 /******************************************************************************/ 00227 inline const Float& MQUALIFIER TVector3D::getY() const 00228 { 00229 return m_fCoordinates[1]; 00230 } 00231 00232 /******************************************************************************/ 00235 /******************************************************************************/ 00236 inline const Float& MQUALIFIER TVector3D::getZ() const 00237 { 00238 return m_fCoordinates[2]; 00239 } 00240 00241 /******************************************************************************/ 00244 /******************************************************************************/ 00245 inline void MQUALIFIER TVector3D::setX(const Float& fX) 00246 { 00247 m_fCoordinates[0] = fX; 00248 } 00249 00250 /******************************************************************************/ 00253 /******************************************************************************/ 00254 inline void MQUALIFIER TVector3D::setY(const Float& fY) 00255 { 00256 m_fCoordinates[1] = fY; 00257 } 00258 00259 /******************************************************************************/ 00262 /******************************************************************************/ 00263 inline void MQUALIFIER TVector3D::setZ(const Float& fZ) 00264 { 00265 m_fCoordinates[2] = fZ; 00266 } 00267 00268 /******************************************************************************/ 00271 /******************************************************************************/ 00272 inline bool MQUALIFIER TVector3D::isZeroVector() const 00273 { 00274 return *this == getZeroVector(); 00275 } 00276 00277 /******************************************************************************/ 00280 /******************************************************************************/ 00281 inline bool MQUALIFIER TVector3D::isUnitVectorX() const 00282 { 00283 return *this == getUnitVectorX(); 00284 } 00285 00286 /******************************************************************************/ 00289 /******************************************************************************/ 00290 inline bool MQUALIFIER TVector3D::isUnitVectorY() const 00291 { 00292 return *this == getUnitVectorY(); 00293 } 00294 00295 /******************************************************************************/ 00298 /******************************************************************************/ 00299 inline bool MQUALIFIER TVector3D::isUnitVectorZ() const 00300 { 00301 return *this == getUnitVectorZ(); 00302 } 00303 00304 /******************************************************************************/ 00307 /******************************************************************************/ 00308 inline void MQUALIFIER TVector3D::setValues(Float fX, Float fY, Float fZ) 00309 { 00310 m_fCoordinates[0] = fX; 00311 m_fCoordinates[1] = fY; 00312 m_fCoordinates[2] = fZ; 00313 } 00314 00315 /******************************************************************************/ 00318 /******************************************************************************/ 00319 inline void MQUALIFIER TVector3D::initAsZeroVector() 00320 { 00321 ::memset(m_fCoordinates, 0, sizeof(m_fCoordinates)); 00322 } 00323 00324 /******************************************************************************/ 00327 /******************************************************************************/ 00328 inline void MQUALIFIER TVector3D::initAsUnitVectorX() 00329 { 00330 assign3D(getUnitVectorX()); 00331 } 00332 00333 /******************************************************************************/ 00336 /******************************************************************************/ 00337 inline void MQUALIFIER TVector3D::initAsUnitVectorY() 00338 { 00339 assign3D(getUnitVectorY()); 00340 } 00341 00342 /******************************************************************************/ 00345 /******************************************************************************/ 00346 inline void MQUALIFIER TVector3D::initAsUnitVectorZ() 00347 { 00348 assign3D(getUnitVectorZ()); 00349 } 00350 00351 /******************************************************************************/ 00354 /******************************************************************************/ 00355 inline void MQUALIFIER TVector3D::calcVectorProduct(const IVector3D& rVector, IVector3D& rProduct) const 00356 { 00357 rProduct.assign(*this ^ rVector); 00358 } 00359 00360 /******************************************************************************/ 00363 /******************************************************************************/ 00364 inline Float MQUALIFIER TVector3D::calcDistanceTo(const IVector3D& rVector) const 00365 { 00366 return (*this - rVector).getNorm(); 00367 } 00368 00369 /******************************************************************************/ 00372 /******************************************************************************/ 00373 inline void MQUALIFIER TVector3D::normalize() 00374 { 00375 *this = getNormalizedVector(); 00376 } 00377 00378 /******************************************************************************/ 00381 /******************************************************************************/ 00382 inline void MQUALIFIER TVector3D::rotateX(const IAngle& rAngle) 00383 { 00384 *this = rotatedX(rAngle); 00385 } 00386 00387 /******************************************************************************/ 00390 /******************************************************************************/ 00391 inline void MQUALIFIER TVector3D::rotateY(const IAngle& rAngle) 00392 { 00393 *this = rotatedY(rAngle); 00394 } 00395 00396 /******************************************************************************/ 00399 /******************************************************************************/ 00400 inline void MQUALIFIER TVector3D::rotateZ(const IAngle& rAngle) 00401 { 00402 *this = rotatedZ(rAngle); 00403 } 00404 00405 /******************************************************************************/ 00408 /******************************************************************************/ 00409 inline void MQUALIFIER TVector3D::rotateHorizontalAngle(const IAngle& rAngle) 00410 { 00411 *this = rotatedHorizontalAngle(rAngle); 00412 } 00413 00414 /******************************************************************************/ 00417 /******************************************************************************/ 00418 inline void MQUALIFIER TVector3D::rotateVerticalAngle(const IAngle& rAngle) 00419 { 00420 *this = rotatedVerticalAngle(rAngle); 00421 } 00422 00423 00424 /******************************************************************************/ 00427 /******************************************************************************/ 00428 inline Float* MQUALIFIER TVector3D::getComponents() 00429 { 00430 return m_fCoordinates; 00431 } 00432 00433 /******************************************************************************/ 00436 /******************************************************************************/ 00437 inline const Float* MQUALIFIER TVector3D::getComponentsConst() const 00438 { 00439 return m_fCoordinates; 00440 } 00441 00442 /******************************************************************************/ 00445 /******************************************************************************/ 00446 inline Int MQUALIFIER TVector3D::getDimension() const 00447 { 00448 return 3; 00449 } 00450 00451 /******************************************************************************/ 00454 /******************************************************************************/ 00455 inline Float MQUALIFIER TVector3D::getLength() const 00456 { 00457 return getNorm(); 00458 } 00459 00460 /******************************************************************************/ 00463 /******************************************************************************/ 00464 inline Float MQUALIFIER TVector3D::getLengthSquared() const 00465 { 00466 return getNormSquared(); 00467 } 00468 00469 /******************************************************************************/ 00472 /******************************************************************************/ 00473 inline void MQUALIFIER TVector3D::setDimension(Int /*iValue*/) 00474 {} 00475 00476 /******************************************************************************/ 00479 /******************************************************************************/ 00480 inline void MQUALIFIER TVector3D::add(const IVector& rVector) 00481 { 00482 *this += rVector; 00483 } 00484 00485 /******************************************************************************/ 00488 /******************************************************************************/ 00489 inline void MQUALIFIER TVector3D::subtract(const IVector& rVector) 00490 { 00491 *this -= rVector; 00492 } 00493 00494 /******************************************************************************/ 00497 /******************************************************************************/ 00498 inline Float MQUALIFIER TVector3D::calcScalarProduct(const IVector& rVector) const 00499 { 00500 return *this * rVector; 00501 } 00502 00503 /******************************************************************************/ 00506 /******************************************************************************/ 00507 inline void MQUALIFIER TVector3D::multiply(const Float& f) 00508 { 00509 *this *= f; 00510 } 00511 00512 /******************************************************************************/ 00515 /******************************************************************************/ 00516 inline void MQUALIFIER TVector3D::divide(const Float& f) 00517 { 00518 *this /= f; 00519 } 00520 00521 //############################################################################## 00522 //Object operators 00523 00524 /******************************************************************************/ 00531 /******************************************************************************/ 00532 inline TVector3D TVector3D::operator*(const Float& f) const 00533 { 00534 return TVector3D(getX() * f, getY() * f, getZ() * f); 00535 } 00536 00537 /******************************************************************************/ 00544 /******************************************************************************/ 00545 inline TVector3D TVector3D::operator/(const Float& f) const 00546 { 00547 return *this * (f == 0 ? 0 : Float(1) / f); 00548 } 00549 00550 /******************************************************************************/ 00557 /******************************************************************************/ 00558 inline const TVector3D& TVector3D::operator+=(const IVector& rVector) 00559 { 00560 *this = *this + rVector; 00561 return *this; 00562 } 00563 00564 /******************************************************************************/ 00572 /******************************************************************************/ 00573 inline const TVector3D& TVector3D::operator-=(const IVector& rVector) 00574 { 00575 *this = *this - rVector; 00576 return *this; 00577 } 00578 00579 /******************************************************************************/ 00587 /******************************************************************************/ 00588 inline const TVector3D& TVector3D::operator*=(const Float& f) 00589 { 00590 *this = *this * f; 00591 return *this; 00592 } 00593 00594 /******************************************************************************/ 00602 /******************************************************************************/ 00603 inline const TVector3D& TVector3D::operator/=(const Float& f) 00604 { 00605 *this = *this / f; 00606 return *this; 00607 } 00608 00609 /******************************************************************************/ 00616 /******************************************************************************/ 00617 inline const TVector3D& TVector3D::operator=(const IVector& rVector) 00618 { 00619 assign(rVector); 00620 return *this; 00621 } 00622 00623 /******************************************************************************/ 00630 /******************************************************************************/ 00631 inline const TVector3D& TVector3D::operator=(const IVector3D& rVector) 00632 { 00633 assign3D(rVector); 00634 return *this; 00635 } 00636 00637 /******************************************************************************/ 00644 /******************************************************************************/ 00645 inline const TVector3D& TVector3D::operator=(const TVector3D& rVector) 00646 { 00647 assign3D(rVector); 00648 return *this; 00649 } 00650 00651 /******************************************************************************/ 00659 /******************************************************************************/ 00660 inline bool TVector3D::operator==(const IVector3D& rVector) const 00661 { 00662 return TFloat::equalsFloat(getX(), rVector.getX()) && 00663 TFloat::equalsFloat(getY(), rVector.getY()) && 00664 TFloat::equalsFloat(getZ(), rVector.getZ()); 00665 } 00666 00667 /******************************************************************************/ 00675 /******************************************************************************/ 00676 inline bool TVector3D::operator==(const IVector& rVector) const 00677 { 00678 return equals(rVector); 00679 } 00680 00681 /******************************************************************************/ 00689 /******************************************************************************/ 00690 inline bool TVector3D::operator!=(const IVector3D& rVector) const 00691 { 00692 return !(*this == rVector); 00693 } 00694 00695 /******************************************************************************/ 00703 /******************************************************************************/ 00704 inline bool TVector3D::operator!=(const IVector& rVector) const 00705 { 00706 return !equals(rVector); 00707 } 00708 00709 /******************************************************************************/ 00718 /******************************************************************************/ 00719 inline bool TVector3D::operator||(const IVector3D& rVector) const 00720 { 00721 return isParallel(rVector); 00722 } 00723 00724 /******************************************************************************/ 00727 /******************************************************************************/ 00728 inline bool TVector3D::operator < (const TVector3D& rVector) const 00729 { 00730 const Float& rfX1 = getX(); 00731 const Float& rfY1 = getY(); 00732 const Float& rfZ1 = getZ(); 00733 const Float& rfX2 = rVector.getX(); 00734 const Float& rfY2 = rVector.getY(); 00735 const Float& rfZ2 = rVector.getZ(); 00736 return (TFloat::isLower(rfX1, rfX2) || 00737 (TFloat::equalsFloat(rfX1, rfX2) && TFloat::isLower(rfY1, rfY2)) || 00738 (TFloat::equalsFloat(rfX1, rfX2) && TFloat::equalsFloat(rfY1, rfY2) && TFloat::isLower(rfZ1, rfZ2))); 00739 } 00740 00741 //############################################################################## 00742 // Global operators. 00743 /******************************************************************************/ 00750 /******************************************************************************/ 00751 inline TVector3D operator-(const IVector3D& rVector) 00752 { 00753 return TVector3D(-rVector.getX(), -rVector.getY(), -rVector.getZ()); 00754 } 00755 00756 00757 /******************************************************************************/ 00764 /******************************************************************************/ 00765 inline const IVector3D& operator+(const IVector3D& rVector) 00766 { 00767 return rVector; 00768 } 00769 00770 00771 /******************************************************************************/ 00779 /******************************************************************************/ 00780 inline TVector3D operator*(const Float& f, const IVector3D& rVector) 00781 { 00782 return TVector3D(rVector) * f; 00783 } 00784 00785 /******************************************************************************/ 00790 /******************************************************************************/ 00791 inline TVector3D TVector3D::operator+(const IVector& rVector) const 00792 { 00793 return TVector3D(getComponent(0) + rVector.getComponent(0), 00794 getComponent(1) + rVector.getComponent(1), 00795 getComponent(2) + rVector.getComponent(2)); 00796 } 00797 00798 00799 00800 /******************************************************************************/ 00805 /******************************************************************************/ 00806 inline TVector3D TVector3D::operator-(const IVector& rVector) const 00807 { 00808 return TVector3D(getComponent(0) - rVector.getComponent(0), 00809 getComponent(1) - rVector.getComponent(1), 00810 getComponent(2) - rVector.getComponent(2)); 00811 } 00812 00813 00814 /******************************************************************************/ 00819 /******************************************************************************/ 00820 inline Float TVector3D::operator*(const IVector& rVector) const 00821 { 00822 return getComponent(0) * rVector.getComponent(0) + 00823 getComponent(1) * rVector.getComponent(1) + 00824 getComponent(2) * rVector.getComponent(2); 00825 } 00826 00827 00828 /******************************************************************************/ 00835 /******************************************************************************/ 00836 inline TVector3D TVector3D::operator^(const IVector3D& rVector) const 00837 { 00838 return TVector3D(getY() * rVector.getZ() - getZ() * rVector.getY(), 00839 getZ() * rVector.getX() - getX() * rVector.getZ(), 00840 getX() * rVector.getY() - getY() * rVector.getX()); 00841 } 00842 00843 END_NAMESPACE_Zeus 00844 00845 #endif 00846