Vector2D.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 : Vector2D 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 Vector2DH 00033 #define Vector2DH 00034 00035 #include <math.h> 00036 #include <memory.h> 00037 #include <zeusmath/Geometry/Interfaces/IVector2D.hpp> 00038 #include <zeusmath/System/Angle.h> 00039 #include <zeusmath/System/Vector.h> 00040 00041 00042 BEGIN_NAMESPACE_Zeus 00043 00044 00045 /*****************************************************************************/ 00051 /*****************************************************************************/ 00052 zeusmath_class TVector2D : public IVector2D 00053 { 00054 public: 00056 inline TVector2D() { initAsZeroVector(); } 00057 00059 inline TVector2D(const Float& fX, const Float& fY) { setValues(fX, fY); } 00060 00062 inline TVector2D(const TVector2D& rVector) { assign2D(rVector); } 00063 00065 inline TVector2D(const TVector& rVector) { assign(rVector); } 00066 00068 inline TVector2D(const IVector2D& rVector) { assign2D(rVector); } 00069 00071 inline TVector2D(const IVector& rVector) { assign(rVector); } 00072 00074 virtual inline ~TVector2D() { } 00075 00076 //Methods of TVector2D 00077 TVector2D getNormalizedVector() const; 00078 TVector2D rotated(const IAngle& rAngle) const; 00079 00080 //Methods of IVector2D 00081 virtual void MQUALIFIER assign2D(const IVector2D& Vector); 00082 virtual bool MQUALIFIER isParallel(const IVector2D& Vector) const; 00083 virtual bool MQUALIFIER isCollinear(const IVector2D& Vector) const; 00084 virtual bool MQUALIFIER isZeroVector() const; 00085 virtual bool MQUALIFIER isUnitVectorX() const; 00086 virtual bool MQUALIFIER isUnitVectorY() const; 00087 virtual const Float& MQUALIFIER getX() const; 00088 virtual const Float& MQUALIFIER getY() const; 00089 virtual void MQUALIFIER setX(const Float& fX); 00090 virtual void MQUALIFIER setY(const Float& fY); 00091 virtual void MQUALIFIER setValues(Float fX, Float fY); 00092 virtual void MQUALIFIER initAsZeroVector(); 00093 virtual void MQUALIFIER initAsUnitVectorX(); 00094 virtual void MQUALIFIER initAsUnitVectorY(); 00095 virtual void MQUALIFIER calcAngleTo(const IVector2D& rVector, bool bAbsolute, IAngle& rAngle) const; 00096 virtual Float MQUALIFIER calcDistanceTo(const IVector2D& rVector) const; 00097 virtual void MQUALIFIER normalize(); 00098 virtual void MQUALIFIER getAngle(IAngle& rAngle) const; 00099 virtual void MQUALIFIER setAngle(const IAngle& rAngle); 00100 virtual void MQUALIFIER rotate(const IAngle& rAngle); 00101 00102 //Methods of IVector 00103 virtual void MQUALIFIER assign(const IVector& rVector); 00104 virtual void MQUALIFIER assignValues(const Float* apValues, Int iSize); 00105 virtual bool MQUALIFIER equals(const IVector& rVector, Float fPrecision = FLOAT_PRECISION) const; 00106 virtual Float MQUALIFIER getComponent(Int iIndex) const; 00107 virtual Float* MQUALIFIER getComponents(); 00108 virtual const Float* MQUALIFIER getComponentsConst() const; 00109 virtual Int MQUALIFIER getDimension() const; 00110 virtual Float MQUALIFIER getNorm() const; 00111 virtual Float MQUALIFIER getNormSquared() const; 00112 virtual Float MQUALIFIER getLength() const; 00113 virtual Float MQUALIFIER getLengthSquared() const; 00114 virtual bool MQUALIFIER setComponent(Int iIndex, Float fValue); 00115 virtual void MQUALIFIER setDimension(Int iValue); 00116 virtual void MQUALIFIER add(const IVector& rVector); 00117 virtual void MQUALIFIER subtract(const IVector& rVector); 00118 virtual Float MQUALIFIER calcScalarProduct(const IVector& rVector) const; 00119 virtual void MQUALIFIER multiply(const Float& f); 00120 virtual void MQUALIFIER divide(const Float& f); 00121 00122 //Mathematical Operators 00123 TVector2D operator+(const IVector& rVector) const; 00124 TVector2D operator-(const IVector& rVector) const; 00125 Float operator*(const IVector& rVector) const; 00126 TVector2D operator*(const Float& f) const; 00127 TVector2D operator/(const Float& f) const; 00128 TVector2D operator^(const IVector2D& rVector) const; 00129 const TVector2D& operator+=(const IVector& rVector); 00130 const TVector2D& operator-=(const IVector& rVector); 00131 const TVector2D& operator*=(const Float& f); 00132 const TVector2D& operator/=(const Float& f); 00133 00134 //assign operators 00135 const TVector2D& operator=(const IVector& rVector); 00136 const TVector2D& operator=(const IVector2D& rVector); 00137 const TVector2D& operator=(const TVector2D& rVector); 00138 00139 //compare operators 00140 bool operator==(const IVector2D& Vector) const; 00141 bool operator==(const IVector& Vector) const; 00142 bool operator!=(const IVector2D& rVector) const; 00143 bool operator!=(const IVector& rVector) const; 00144 bool operator||(const IVector2D& rVector) const; 00145 00146 //special compare used for maps and sets (not mathematically defined) 00147 bool operator < (const TVector2D& rVector) const; 00148 00149 // Special static vectors. 00150 static inline const TVector2D& getZeroVector() { return m_ZeroVector; } 00151 static inline const TVector2D& getUnitVectorX() { return m_UnitVectorX; } 00152 static inline const TVector2D& getUnitVectorY() { return m_UnitVectorY; } 00153 00154 private: 00156 Float m_fCoordinates[2]; 00157 00159 static const TVector2D m_ZeroVector; 00160 static const TVector2D m_UnitVectorX; 00161 static const TVector2D m_UnitVectorY; 00162 }; 00163 00164 //INLINE METHODS 00165 /******************************************************************************/ 00171 /******************************************************************************/ 00172 inline TVector2D TVector2D::getNormalizedVector() const 00173 { 00174 return *this / getNorm(); 00175 } 00176 00177 00178 /******************************************************************************/ 00181 /******************************************************************************/ 00182 inline const Float& MQUALIFIER TVector2D::getX() const 00183 { 00184 return m_fCoordinates[0]; 00185 } 00186 00187 00188 /******************************************************************************/ 00191 /******************************************************************************/ 00192 inline const Float& MQUALIFIER TVector2D::getY() const 00193 { 00194 return m_fCoordinates[1]; 00195 } 00196 00197 00198 /******************************************************************************/ 00201 /******************************************************************************/ 00202 inline void MQUALIFIER TVector2D::setX(const Float& fX) 00203 { 00204 m_fCoordinates[0] = fX; 00205 } 00206 00207 00208 /******************************************************************************/ 00211 /******************************************************************************/ 00212 inline void MQUALIFIER TVector2D::setY(const Float& fY) 00213 { 00214 m_fCoordinates[1] = fY; 00215 } 00216 00217 00218 /******************************************************************************/ 00221 /******************************************************************************/ 00222 inline bool MQUALIFIER TVector2D::isZeroVector() const 00223 { 00224 return *this == getZeroVector(); 00225 } 00226 00227 /******************************************************************************/ 00230 /******************************************************************************/ 00231 inline bool MQUALIFIER TVector2D::isUnitVectorX() const 00232 { 00233 return *this == getUnitVectorX(); 00234 } 00235 00236 /******************************************************************************/ 00239 /******************************************************************************/ 00240 inline bool MQUALIFIER TVector2D::isUnitVectorY() const 00241 { 00242 return *this == getUnitVectorY(); 00243 } 00244 00245 00246 /******************************************************************************/ 00249 /******************************************************************************/ 00250 inline void MQUALIFIER TVector2D::setValues(Float fX, Float fY) 00251 { 00252 m_fCoordinates[0] = fX; 00253 m_fCoordinates[1] = fY; 00254 } 00255 00256 00257 /******************************************************************************/ 00260 /******************************************************************************/ 00261 inline void MQUALIFIER TVector2D::initAsZeroVector() 00262 { 00263 ::memset(m_fCoordinates, 0, sizeof(m_fCoordinates)); 00264 } 00265 00266 00267 /******************************************************************************/ 00270 /******************************************************************************/ 00271 inline void MQUALIFIER TVector2D::initAsUnitVectorX() 00272 { 00273 assign2D(getUnitVectorX()); 00274 } 00275 00276 00277 /******************************************************************************/ 00280 /******************************************************************************/ 00281 inline void MQUALIFIER TVector2D::initAsUnitVectorY() 00282 { 00283 assign2D(getUnitVectorY()); 00284 } 00285 00286 00287 /******************************************************************************/ 00290 /******************************************************************************/ 00291 inline Float MQUALIFIER TVector2D::calcDistanceTo(const IVector2D& rVector) const 00292 { 00293 return (*this - rVector).getNorm(); 00294 } 00295 00296 00297 /******************************************************************************/ 00300 /******************************************************************************/ 00301 inline void MQUALIFIER TVector2D::normalize() 00302 { 00303 *this = getNormalizedVector(); 00304 } 00305 00306 00307 /******************************************************************************/ 00310 /******************************************************************************/ 00311 inline void MQUALIFIER TVector2D::rotate(const IAngle& rAngle) 00312 { 00313 *this = rotated(rAngle); 00314 } 00315 00316 00317 /******************************************************************************/ 00320 /******************************************************************************/ 00321 inline Float* MQUALIFIER TVector2D::getComponents() 00322 { 00323 return m_fCoordinates; 00324 } 00325 00326 00327 /******************************************************************************/ 00330 /******************************************************************************/ 00331 inline const Float* MQUALIFIER TVector2D::getComponentsConst() const 00332 { 00333 return m_fCoordinates; 00334 } 00335 00336 00337 /******************************************************************************/ 00340 /******************************************************************************/ 00341 inline Int MQUALIFIER TVector2D::getDimension() const 00342 { 00343 return 2; 00344 } 00345 00346 00347 /******************************************************************************/ 00350 /******************************************************************************/ 00351 inline Float MQUALIFIER TVector2D::getLength() const 00352 { 00353 return getNorm(); 00354 } 00355 00356 00357 /******************************************************************************/ 00360 /******************************************************************************/ 00361 inline Float MQUALIFIER TVector2D::getLengthSquared() const 00362 { 00363 return getNormSquared(); 00364 } 00365 00366 00367 /******************************************************************************/ 00370 /******************************************************************************/ 00371 inline void MQUALIFIER TVector2D::setDimension(Int /* iValue */) 00372 { 00373 } 00374 00375 00376 /******************************************************************************/ 00379 /******************************************************************************/ 00380 inline void MQUALIFIER TVector2D::add(const IVector& rVector) 00381 { 00382 *this += rVector; 00383 } 00384 00385 00386 /******************************************************************************/ 00389 /******************************************************************************/ 00390 inline void MQUALIFIER TVector2D::subtract(const IVector& rVector) 00391 { 00392 *this -= rVector; 00393 } 00394 00395 00396 /******************************************************************************/ 00399 /******************************************************************************/ 00400 inline Float MQUALIFIER TVector2D::calcScalarProduct(const IVector& rVector) const 00401 { 00402 return *this * rVector; 00403 } 00404 00405 00406 /******************************************************************************/ 00409 /******************************************************************************/ 00410 inline void MQUALIFIER TVector2D::multiply(const Float& f) 00411 { 00412 *this *= f; 00413 } 00414 00415 00416 /******************************************************************************/ 00419 /******************************************************************************/ 00420 inline void MQUALIFIER TVector2D::divide(const Float& f) 00421 { 00422 *this /= f; 00423 } 00424 00425 //############################################################################## 00426 //Object operators 00427 00428 /******************************************************************************/ 00435 /******************************************************************************/ 00436 inline TVector2D TVector2D::operator*(const Float& f) const 00437 { 00438 return TVector2D(getX() * f, getY() * f); 00439 } 00440 00441 00442 /******************************************************************************/ 00449 /******************************************************************************/ 00450 inline TVector2D TVector2D::operator/(const Float& f) const 00451 { 00452 return *this * (f == 0 ? 0 : Float(1) / f); 00453 } 00454 00455 00456 /******************************************************************************/ 00463 /******************************************************************************/ 00464 inline const TVector2D& TVector2D::operator+=(const IVector& rVector) 00465 { 00466 *this = *this + rVector; 00467 return *this; 00468 } 00469 00470 00471 /******************************************************************************/ 00479 /******************************************************************************/ 00480 inline const TVector2D& TVector2D::operator-=(const IVector& rVector) 00481 { 00482 *this = *this - rVector; 00483 return *this; 00484 } 00485 00486 00487 /******************************************************************************/ 00495 /******************************************************************************/ 00496 inline const TVector2D& TVector2D::operator*=(const Float& f) 00497 { 00498 *this = *this * f; 00499 return *this; 00500 } 00501 00502 00503 /******************************************************************************/ 00511 /******************************************************************************/ 00512 inline const TVector2D& TVector2D::operator/=(const Float& f) 00513 { 00514 *this = *this / f; 00515 return *this; 00516 } 00517 00518 00519 /******************************************************************************/ 00526 /******************************************************************************/ 00527 inline const TVector2D& TVector2D::operator=(const IVector& rVector) 00528 { 00529 assign(rVector); 00530 return *this; 00531 } 00532 00533 00534 /******************************************************************************/ 00541 /******************************************************************************/ 00542 inline const TVector2D& TVector2D::operator=(const IVector2D& rVector) 00543 { 00544 assign2D(rVector); 00545 return *this; 00546 } 00547 00548 00549 /******************************************************************************/ 00556 /******************************************************************************/ 00557 inline const TVector2D& TVector2D::operator=(const TVector2D& rVector) 00558 { 00559 assign2D(rVector); 00560 return *this; 00561 } 00562 00563 00564 /******************************************************************************/ 00572 /******************************************************************************/ 00573 inline bool TVector2D::operator==(const IVector2D& rVector) const 00574 { 00575 return TFloat::equalsFloat(getX(), rVector.getX()) && 00576 TFloat::equalsFloat(getY(), rVector.getY()); 00577 } 00578 00579 00580 /******************************************************************************/ 00588 /******************************************************************************/ 00589 inline bool TVector2D::operator==(const IVector& rVector) const 00590 { 00591 return equals(rVector); 00592 } 00593 00594 00595 /******************************************************************************/ 00603 /******************************************************************************/ 00604 inline bool TVector2D::operator!=(const IVector2D& rVector) const 00605 { 00606 return !(*this == rVector); 00607 } 00608 00609 00610 /******************************************************************************/ 00618 /******************************************************************************/ 00619 inline bool TVector2D::operator!=(const IVector& rVector) const 00620 { 00621 return !equals(rVector); 00622 } 00623 00624 00625 /******************************************************************************/ 00634 /******************************************************************************/ 00635 inline bool TVector2D::operator||(const IVector2D& rVector) const 00636 { 00637 return isParallel(rVector); 00638 } 00639 00640 /******************************************************************************/ 00643 /******************************************************************************/ 00644 inline bool TVector2D::operator < (const TVector2D& rVector) const 00645 { 00646 const Float& rfX1 = getX(); 00647 const Float& rfY1 = getY(); 00648 const Float& rfX2 = rVector.getX(); 00649 const Float& rfY2 = rVector.getY(); 00650 return (TFloat::isLower(rfX1, rfX2) || 00651 (TFloat::equalsFloat(rfX1, rfX2) && TFloat::isLower(rfY1, rfY2))); 00652 } 00653 00654 //############################################################################## 00655 // Global operators. 00656 /******************************************************************************/ 00663 /******************************************************************************/ 00664 inline TVector2D operator-(const IVector2D& rVector) 00665 { 00666 return TVector2D(-rVector.getX(), -rVector.getY()); 00667 } 00668 00669 00670 /******************************************************************************/ 00677 /******************************************************************************/ 00678 inline const IVector2D& operator+(const IVector2D& rVector) 00679 { 00680 return rVector; 00681 } 00682 00683 00684 /******************************************************************************/ 00692 /******************************************************************************/ 00693 inline TVector2D operator*(const Float& f, const IVector2D& rVector) 00694 { 00695 return TVector2D(rVector) * f; 00696 } 00697 00698 00699 /******************************************************************************/ 00704 /******************************************************************************/ 00705 inline TVector2D TVector2D::operator+(const IVector& rVector) const 00706 { 00707 return TVector2D(getComponent(0) + rVector.getComponent(0), 00708 getComponent(1) + rVector.getComponent(1)); 00709 } 00710 00711 00712 /******************************************************************************/ 00717 /******************************************************************************/ 00718 inline TVector2D TVector2D::operator-(const IVector& rVector) const 00719 { 00720 return TVector2D(getComponent(0) - rVector.getComponent(0), 00721 getComponent(1) - rVector.getComponent(1)); 00722 } 00723 00724 00725 /******************************************************************************/ 00730 /******************************************************************************/ 00731 inline Float TVector2D::operator*(const IVector& rVector) const 00732 { 00733 return getComponent(0) * rVector.getComponent(0) + 00734 getComponent(1) * rVector.getComponent(1); 00735 } 00736 00737 00738 END_NAMESPACE_Zeus 00739 00740 #endif 00741