From d539c95155ccc7030411f7494704894a3ac610a8 Mon Sep 17 00:00:00 2001 From: Armin Weiss Date: Fri, 28 Nov 2003 10:18:16 +0000 Subject: Removed in-between namespaces (curve, matrix, numeric, point, polygon, range, tuple, vector). Names were too common and e.g. vector leaded to problems with some defines. This is now avoided. Also some bug fixes, addition of 3d polygon tooling etc. --- basegfx/inc/basegfx/tuple/b2dtuple.hxx | 499 +++++++++++++------------ basegfx/inc/basegfx/tuple/b3dtuple.hxx | 647 ++++++++++++++++----------------- 2 files changed, 570 insertions(+), 576 deletions(-) (limited to 'basegfx/inc/basegfx/tuple') diff --git a/basegfx/inc/basegfx/tuple/b2dtuple.hxx b/basegfx/inc/basegfx/tuple/b2dtuple.hxx index dd775d8c399e..4f555481c2c2 100644 --- a/basegfx/inc/basegfx/tuple/b2dtuple.hxx +++ b/basegfx/inc/basegfx/tuple/b2dtuple.hxx @@ -2,9 +2,9 @@ * * $RCSfile: b2dtuple.hxx,v $ * - * $Revision: 1.3 $ + * $Revision: 1.4 $ * - * last change: $Author: aw $ $Date: 2003-11-10 11:45:48 $ + * last change: $Author: aw $ $Date: 2003-11-28 11:17:57 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -72,301 +72,298 @@ namespace basegfx { - namespace tuple + /** Base class for all Points/Vectors with two double values + + This class provides all methods common to Point + avd Vector classes which are derived from here. + + @derive Use this class to implement Points or Vectors + which are based on two double values + */ + class B2DTuple { - /** Base class for all Points/Vectors with two double values + private: + static B2DTuple maEmptyTuple; + + protected: + double mfX; + double mfY; + + public: + /** Create a 2D Tuple + + @param fVal + This parameter is used to initialize the coordinate + part of the 2D Tuple. + */ + B2DTuple(double fVal = 0.0) + : mfX(fVal), + mfY(fVal) + {} + + /** Create a 2D Tuple - This class provides all methods common to Point - avd Vector classes which are derived from here. + @param fX + This parameter is used to initialize the X-coordinate + of the 2D Tuple. - @derive Use this class to implement Points or Vectors - which are based on two double values + @param fY + This parameter is used to initialize the Y-coordinate + of the 2D Tuple. */ - class B2DTuple + B2DTuple(double fX, double fY) + : mfX( fX ), + mfY( fY ) + {} + + /** Create a copy of a 2D Tuple + + @param rTup + The 2D Tuple which will be copied. + */ + B2DTuple(const B2DTuple& rTup) + : mfX( rTup.mfX ), + mfY( rTup.mfY ) + {} + + ~B2DTuple() + {} + + /// Get X-Coordinate of 2D Tuple + double getX() const + { + return mfX; + } + + /// Get Y-Coordinate of 2D Tuple + double getY() const { - private: - static B2DTuple maEmptyTuple; - - protected: - double mfX; - double mfY; - - public: - /** Create a 2D Tuple - - @param fVal - This parameter is used to initialize the coordinate - part of the 2D Tuple. - */ - B2DTuple(double fVal = 0.0) - : mfX(fVal), - mfY(fVal) - {} - - /** Create a 2D Tuple - - @param fX - This parameter is used to initialize the X-coordinate - of the 2D Tuple. - - @param fY - This parameter is used to initialize the Y-coordinate - of the 2D Tuple. - */ - B2DTuple(double fX, double fY) - : mfX( fX ), - mfY( fY ) - {} - - /** Create a copy of a 2D Tuple - - @param rTup - The 2D Tuple which will be copied. - */ - B2DTuple(const B2DTuple& rTup) - : mfX( rTup.mfX ), - mfY( rTup.mfY ) - {} - - ~B2DTuple() - {} - - /// Get X-Coordinate of 2D Tuple - double getX() const - { - return mfX; - } - - /// Get Y-Coordinate of 2D Tuple - double getY() const - { - return mfY; - } - - /// Set X-Coordinate of 2D Tuple - void setX(double fX) - { - mfX = fX; - } - - /// Set Y-Coordinate of 2D Tuple - void setY(double fY) - { - mfY = fY; - } - - /// Array-access to 2D Tuple - const double& operator[] (int nPos) const - { - // Here, normally one if(...) should be used. In the assumption that - // both double members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mfX; return mfY; - return *((&mfX) + nPos); - } - - /// Array-access to 2D Tuple - double& operator[] (int nPos) - { - // Here, normally one if(...) should be used. In the assumption that - // both double members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mfX; return mfY; - return *((&mfX) + nPos); - } - - // comparators with tolerance - ////////////////////////////////////////////////////////////////////// - - sal_Bool equalZero() const; - - sal_Bool equalZero(const double& rfSmallValue) const; - - sal_Bool equal(const B2DTuple& rTup) const; - - sal_Bool equal(const B2DTuple& rTup, const double& rfSmallValue) const; - - // operators - ////////////////////////////////////////////////////////////////////// - - B2DTuple& operator+=( const B2DTuple& rTup ) - { - mfX += rTup.mfX; - mfY += rTup.mfY; - return *this; - } - - B2DTuple& operator-=( const B2DTuple& rTup ) - { - mfX -= rTup.mfX; - mfY -= rTup.mfY; - return *this; - } - - B2DTuple& operator/=( const B2DTuple& rTup ) - { - mfX /= rTup.mfX; - mfY /= rTup.mfY; - return *this; - } - - B2DTuple& operator*=( const B2DTuple& rTup ) - { - mfX *= rTup.mfX; - mfY *= rTup.mfY; - return *this; - } - - B2DTuple& operator*=(double t) - { - mfX *= t; - mfY *= t; - return *this; - } - - B2DTuple& operator/=(double t) - { - const double fVal(1.0 / t); - mfX *= fVal; - mfY *= fVal; - return *this; - } - - B2DTuple operator-(void) const - { - return B2DTuple(-mfX, -mfY); - } - - sal_Bool operator==( const B2DTuple& rTup ) const - { - return equal(rTup); - } - - sal_Bool operator!=( const B2DTuple& rTup ) const - { - return !equal(rTup); - } - - B2DTuple& operator=( const B2DTuple& rTup ) - { - mfX = rTup.mfX; - mfY = rTup.mfY; - return *this; - } - - void correctValues(const double fCompareValue = 0.0); - - static const B2DTuple& getEmptyTuple() - { - return maEmptyTuple; - } - }; - - // external operators - ////////////////////////////////////////////////////////////////////////// - - inline B2DTuple min(const B2DTuple& rTupA, const B2DTuple& rTupB) + return mfY; + } + + /// Set X-Coordinate of 2D Tuple + void setX(double fX) { - B2DTuple aMin( - (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(), - (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY()); - return aMin; + mfX = fX; } - inline B2DTuple max(const B2DTuple& rTupA, const B2DTuple& rTupB) + /// Set Y-Coordinate of 2D Tuple + void setY(double fY) { - B2DTuple aMax( - (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(), - (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY()); - return aMax; + mfY = fY; } - inline B2DTuple abs(const B2DTuple& rTup) + /// Array-access to 2D Tuple + const double& operator[] (int nPos) const { - B2DTuple aAbs( - (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(), - (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY()); - return aAbs; + // Here, normally one if(...) should be used. In the assumption that + // both double members can be accessed as an array a shortcut is used here. + // if(0 == nPos) return mfX; return mfY; + return *((&mfX) + nPos); } - inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t) + /// Array-access to 2D Tuple + double& operator[] (int nPos) + { + // Here, normally one if(...) should be used. In the assumption that + // both double members can be accessed as an array a shortcut is used here. + // if(0 == nPos) return mfX; return mfY; + return *((&mfX) + nPos); + } + + // comparators with tolerance + ////////////////////////////////////////////////////////////////////// + + sal_Bool equalZero() const; + + sal_Bool equalZero(const double& rfSmallValue) const; + + sal_Bool equal(const B2DTuple& rTup) const; + + sal_Bool equal(const B2DTuple& rTup, const double& rfSmallValue) const; + + // operators + ////////////////////////////////////////////////////////////////////// + + B2DTuple& operator+=( const B2DTuple& rTup ) { - B2DTuple aInt( - ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(), - ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY()); - return aInt; + mfX += rTup.mfX; + mfY += rTup.mfY; + return *this; } - inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2) + B2DTuple& operator-=( const B2DTuple& rTup ) { - B2DTuple aAvg( - (rOld1.getX() + rOld2.getX()) * 0.5, - (rOld1.getY() + rOld2.getY()) * 0.5); - return aAvg; + mfX -= rTup.mfX; + mfY -= rTup.mfY; + return *this; } - inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2, const B2DTuple& rOld3) + B2DTuple& operator/=( const B2DTuple& rTup ) { - B2DTuple aAvg( - (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0), - (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0)); - return aAvg; + mfX /= rTup.mfX; + mfY /= rTup.mfY; + return *this; } - inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB) + B2DTuple& operator*=( const B2DTuple& rTup ) { - B2DTuple aSum(rTupA); - aSum += rTupB; - return aSum; + mfX *= rTup.mfX; + mfY *= rTup.mfY; + return *this; } - inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB) + B2DTuple& operator*=(double t) { - B2DTuple aSub(rTupA); - aSub -= rTupB; - return aSub; + mfX *= t; + mfY *= t; + return *this; } - inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB) + B2DTuple& operator/=(double t) { - B2DTuple aDiv(rTupA); - aDiv /= rTupB; - return aDiv; + const double fVal(1.0 / t); + mfX *= fVal; + mfY *= fVal; + return *this; } - inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB) + B2DTuple operator-(void) const { - B2DTuple aMul(rTupA); - aMul *= rTupB; - return aMul; + return B2DTuple(-mfX, -mfY); } - inline B2DTuple operator*(const B2DTuple& rTup, double t) + sal_Bool operator==( const B2DTuple& rTup ) const { - B2DTuple aNew(rTup); - aNew *= t; - return aNew; + return equal(rTup); } - inline B2DTuple operator*(double t, const B2DTuple& rTup) + sal_Bool operator!=( const B2DTuple& rTup ) const { - B2DTuple aNew(rTup); - aNew *= t; - return aNew; + return !equal(rTup); } - inline B2DTuple operator/(const B2DTuple& rTup, double t) + B2DTuple& operator=( const B2DTuple& rTup ) { - B2DTuple aNew(rTup); - aNew /= t; - return aNew; + mfX = rTup.mfX; + mfY = rTup.mfY; + return *this; } - inline B2DTuple operator/(double t, const B2DTuple& rTup) + void correctValues(const double fCompareValue = 0.0); + + static const B2DTuple& getEmptyTuple() { - B2DTuple aNew(rTup); - aNew /= t; - return aNew; + return maEmptyTuple; } - } // end of namespace tuple + }; + + // external operators + ////////////////////////////////////////////////////////////////////////// + + inline B2DTuple min(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aMin( + (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(), + (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY()); + return aMin; + } + + inline B2DTuple max(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aMax( + (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(), + (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY()); + return aMax; + } + + inline B2DTuple abs(const B2DTuple& rTup) + { + B2DTuple aAbs( + (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(), + (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY()); + return aAbs; + } + + inline B2DTuple interpolate(const B2DTuple& rOld1, const B2DTuple& rOld2, double t) + { + B2DTuple aInt( + ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(), + ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY()); + return aInt; + } + + inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2) + { + B2DTuple aAvg( + (rOld1.getX() + rOld2.getX()) * 0.5, + (rOld1.getY() + rOld2.getY()) * 0.5); + return aAvg; + } + + inline B2DTuple average(const B2DTuple& rOld1, const B2DTuple& rOld2, const B2DTuple& rOld3) + { + B2DTuple aAvg( + (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0), + (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0)); + return aAvg; + } + + inline B2DTuple operator+(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aSum(rTupA); + aSum += rTupB; + return aSum; + } + + inline B2DTuple operator-(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aSub(rTupA); + aSub -= rTupB; + return aSub; + } + + inline B2DTuple operator/(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aDiv(rTupA); + aDiv /= rTupB; + return aDiv; + } + + inline B2DTuple operator*(const B2DTuple& rTupA, const B2DTuple& rTupB) + { + B2DTuple aMul(rTupA); + aMul *= rTupB; + return aMul; + } + + inline B2DTuple operator*(const B2DTuple& rTup, double t) + { + B2DTuple aNew(rTup); + aNew *= t; + return aNew; + } + + inline B2DTuple operator*(double t, const B2DTuple& rTup) + { + B2DTuple aNew(rTup); + aNew *= t; + return aNew; + } + + inline B2DTuple operator/(const B2DTuple& rTup, double t) + { + B2DTuple aNew(rTup); + aNew /= t; + return aNew; + } + + inline B2DTuple operator/(double t, const B2DTuple& rTup) + { + B2DTuple aNew(rTup); + aNew /= t; + return aNew; + } } // end of namespace basegfx #endif // _BGFX_TUPLE_B2DTUPLE_HXX diff --git a/basegfx/inc/basegfx/tuple/b3dtuple.hxx b/basegfx/inc/basegfx/tuple/b3dtuple.hxx index 48f1fde48a24..928f1f081855 100644 --- a/basegfx/inc/basegfx/tuple/b3dtuple.hxx +++ b/basegfx/inc/basegfx/tuple/b3dtuple.hxx @@ -2,9 +2,9 @@ * * $RCSfile: b3dtuple.hxx,v $ * - * $Revision: 1.4 $ + * $Revision: 1.5 $ * - * last change: $Author: aw $ $Date: 2003-11-26 14:40:04 $ + * last change: $Author: aw $ $Date: 2003-11-28 11:17:57 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -68,394 +68,391 @@ namespace basegfx { - namespace tuple - { - /** Base class for all Points/Vectors with three double values - - This class provides all methods common to Point - avd Vector classes which are derived from here. - - @derive Use this class to implement Points or Vectors - which are based on three double values - */ - class B3DTuple - { - private: - static B3DTuple maEmptyTuple; - - protected: - double mfX; - double mfY; - double mfZ; - - public: - /** Create a 3D Tuple - - @param fVal - This parameter is used to initialize the coordinate - part of the 3D Tuple. - */ - B3DTuple(double fVal = 0.0) - : mfX(fVal), - mfY(fVal), - mfZ(fVal) - {} - - /** Create a 3D Tuple - - @param fX - This parameter is used to initialize the X-coordinate - of the 3D Tuple. - - @param fY - This parameter is used to initialize the Y-coordinate - of the 3D Tuple. - - @param fZ - This parameter is used to initialize the Z-coordinate - of the 3D Tuple. - */ - B3DTuple(double fX, double fY, double fZ) - : mfX(fX), - mfY(fY), - mfZ(fZ) - {} - - /** Create a copy of a 3D Tuple - - @param rTup - The 3D Tuple which will be copied. - */ - B3DTuple(const B3DTuple& rTup) - : mfX( rTup.mfX ), - mfY( rTup.mfY ), - mfZ( rTup.mfZ ) - {} - - ~B3DTuple() - {} - - /// get X-Coordinate of 3D Tuple - double getX() const - { - return mfX; - } - - /// get Y-Coordinate of 3D Tuple - double getY() const - { - return mfY; - } - - /// get Z-Coordinate of 3D Tuple - double getZ() const - { - return mfZ; - } - - /// set X-Coordinate of 3D Tuple - void setX(double fX) - { - mfX = fX; - } + /** Base class for all Points/Vectors with three double values - /// set Y-Coordinate of 3D Tuple - void setY(double fY) - { - mfY = fY; - } + This class provides all methods common to Point + avd Vector classes which are derived from here. - /// set Z-Coordinate of 3D Tuple - void setZ(double fZ) - { - mfZ = fZ; - } + @derive Use this class to implement Points or Vectors + which are based on three double values + */ + class B3DTuple + { + private: + static B3DTuple maEmptyTuple; - /// Array-access to 3D Tuple - const double& operator[] (int nPos) const - { - // Here, normally two if(...)'s should be used. In the assumption that - // both double members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ; - return *((&mfX) + nPos); - } + protected: + double mfX; + double mfY; + double mfZ; - /// Array-access to 3D Tuple - double& operator[] (int nPos) - { - // Here, normally two if(...)'s should be used. In the assumption that - // both double members can be accessed as an array a shortcut is used here. - // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ; - return *((&mfX) + nPos); - } + public: + /** Create a 3D Tuple - // comparators with tolerance - ////////////////////////////////////////////////////////////////////// + @param fVal + This parameter is used to initialize the coordinate + part of the 3D Tuple. + */ + B3DTuple(double fVal = 0.0) + : mfX(fVal), + mfY(fVal), + mfZ(fVal) + {} - sal_Bool equalZero() const - { - return (this == &maEmptyTuple || - (::basegfx::numeric::fTools::equalZero(mfX) - && ::basegfx::numeric::fTools::equalZero(mfY) - && ::basegfx::numeric::fTools::equalZero(mfZ))); - } + /** Create a 3D Tuple - sal_Bool equalZero(const double& rfSmallValue) const - { - return (this == &maEmptyTuple || - (::basegfx::numeric::fTools::equalZero(mfX, rfSmallValue) - && ::basegfx::numeric::fTools::equalZero(mfY, rfSmallValue) - && ::basegfx::numeric::fTools::equalZero(mfZ, rfSmallValue))); - } + @param fX + This parameter is used to initialize the X-coordinate + of the 3D Tuple. - sal_Bool equal(const B3DTuple& rTup) const - { - return ( - ::basegfx::numeric::fTools::equal(mfX, rTup.mfX) && - ::basegfx::numeric::fTools::equal(mfY, rTup.mfY) && - ::basegfx::numeric::fTools::equal(mfZ, rTup.mfZ)); - } + @param fY + This parameter is used to initialize the Y-coordinate + of the 3D Tuple. - sal_Bool equal(const B3DTuple& rTup, const double& rfSmallValue) const - { - return ( - ::basegfx::numeric::fTools::equal(mfX, rTup.mfX, rfSmallValue) && - ::basegfx::numeric::fTools::equal(mfY, rTup.mfY, rfSmallValue) && - ::basegfx::numeric::fTools::equal(mfZ, rTup.mfZ, rfSmallValue)); - } + @param fZ + This parameter is used to initialize the Z-coordinate + of the 3D Tuple. + */ + B3DTuple(double fX, double fY, double fZ) + : mfX(fX), + mfY(fY), + mfZ(fZ) + {} - // operators - ////////////////////////////////////////////////////////////////////// + /** Create a copy of a 3D Tuple - B3DTuple& operator+=( const B3DTuple& rTup ) - { - mfX += rTup.mfX; - mfY += rTup.mfY; - mfZ += rTup.mfZ; - return *this; - } + @param rTup + The 3D Tuple which will be copied. + */ + B3DTuple(const B3DTuple& rTup) + : mfX( rTup.mfX ), + mfY( rTup.mfY ), + mfZ( rTup.mfZ ) + {} - B3DTuple& operator-=( const B3DTuple& rTup ) - { - mfX -= rTup.mfX; - mfY -= rTup.mfY; - mfZ -= rTup.mfZ; - return *this; - } + ~B3DTuple() + {} - B3DTuple& operator/=( const B3DTuple& rTup ) - { - mfX /= rTup.mfX; - mfY /= rTup.mfY; - mfZ /= rTup.mfZ; - return *this; - } + /// get X-Coordinate of 3D Tuple + double getX() const + { + return mfX; + } - B3DTuple& operator*=( const B3DTuple& rTup ) - { - mfX *= rTup.mfX; - mfY *= rTup.mfY; - mfZ *= rTup.mfZ; - return *this; - } + /// get Y-Coordinate of 3D Tuple + double getY() const + { + return mfY; + } - B3DTuple& operator*=(double t) - { - mfX *= t; - mfY *= t; - mfZ *= t; - return *this; - } + /// get Z-Coordinate of 3D Tuple + double getZ() const + { + return mfZ; + } - B3DTuple& operator/=(double t) - { - const double fVal(1.0 / t); - mfX *= t; - mfY *= t; - mfZ *= t; - return *this; - } + /// set X-Coordinate of 3D Tuple + void setX(double fX) + { + mfX = fX; + } - B3DTuple operator-(void) const - { - return B3DTuple(-mfX, -mfY, -mfZ); - } + /// set Y-Coordinate of 3D Tuple + void setY(double fY) + { + mfY = fY; + } - sal_Bool operator==( const B3DTuple& rTup ) const - { - return equal(rTup); - } + /// set Z-Coordinate of 3D Tuple + void setZ(double fZ) + { + mfZ = fZ; + } - sal_Bool operator!=( const B3DTuple& rTup ) const - { - return !equal(rTup); - } + /// Array-access to 3D Tuple + const double& operator[] (int nPos) const + { + // Here, normally two if(...)'s should be used. In the assumption that + // both double members can be accessed as an array a shortcut is used here. + // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ; + return *((&mfX) + nPos); + } - B3DTuple& operator=( const B3DTuple& rTup ) - { - mfX = rTup.mfX; - mfY = rTup.mfY; - mfZ = rTup.mfZ; - return *this; - } + /// Array-access to 3D Tuple + double& operator[] (int nPos) + { + // Here, normally two if(...)'s should be used. In the assumption that + // both double members can be accessed as an array a shortcut is used here. + // if(0 == nPos) return mfX; if(1 == nPos) return mfY; return mfZ; + return *((&mfX) + nPos); + } - void correctValues(const double fCompareValue = 0.0) - { - if(0.0 == fCompareValue) - { - if(::basegfx::numeric::fTools::equalZero(mfX)) - { - mfX = 0.0; - } - - if(::basegfx::numeric::fTools::equalZero(mfY)) - { - mfY = 0.0; - } - - if(::basegfx::numeric::fTools::equalZero(mfZ)) - { - mfZ = 0.0; - } - } - else - { - if(::basegfx::numeric::fTools::equal(mfX, fCompareValue)) - { - mfX = fCompareValue; - } - - if(::basegfx::numeric::fTools::equal(mfY, fCompareValue)) - { - mfY = fCompareValue; - } - - if(::basegfx::numeric::fTools::equal(mfZ, fCompareValue)) - { - mfZ = fCompareValue; - } - } - } + // comparators with tolerance + ////////////////////////////////////////////////////////////////////// - static const B3DTuple& getEmptyTuple() - { - return maEmptyTuple; - } - }; + sal_Bool equalZero() const + { + return (this == &maEmptyTuple || + (::basegfx::fTools::equalZero(mfX) + && ::basegfx::fTools::equalZero(mfY) + && ::basegfx::fTools::equalZero(mfZ))); + } - // external operators - ////////////////////////////////////////////////////////////////////////// + sal_Bool equalZero(const double& rfSmallValue) const + { + return (this == &maEmptyTuple || + (::basegfx::fTools::equalZero(mfX, rfSmallValue) + && ::basegfx::fTools::equalZero(mfY, rfSmallValue) + && ::basegfx::fTools::equalZero(mfZ, rfSmallValue))); + } - inline B3DTuple min(const B3DTuple& rTupA, const B3DTuple& rTupB) + sal_Bool equal(const B3DTuple& rTup) const { - B3DTuple aMin( - (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(), - (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY(), - (rTupB.getZ() < rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ()); - return aMin; + return ( + ::basegfx::fTools::equal(mfX, rTup.mfX) && + ::basegfx::fTools::equal(mfY, rTup.mfY) && + ::basegfx::fTools::equal(mfZ, rTup.mfZ)); } - inline B3DTuple max(const B3DTuple& rTupA, const B3DTuple& rTupB) + sal_Bool equal(const B3DTuple& rTup, const double& rfSmallValue) const { - B3DTuple aMax( - (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(), - (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY(), - (rTupB.getZ() > rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ()); - return aMax; + return ( + ::basegfx::fTools::equal(mfX, rTup.mfX, rfSmallValue) && + ::basegfx::fTools::equal(mfY, rTup.mfY, rfSmallValue) && + ::basegfx::fTools::equal(mfZ, rTup.mfZ, rfSmallValue)); } - inline B3DTuple abs(const B3DTuple& rTup) + // operators + ////////////////////////////////////////////////////////////////////// + + B3DTuple& operator+=( const B3DTuple& rTup ) { - B3DTuple aAbs( - (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(), - (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY(), - (0.0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ()); - return aAbs; + mfX += rTup.mfX; + mfY += rTup.mfY; + mfZ += rTup.mfZ; + return *this; } - inline B3DTuple interpolate(const B3DTuple& rOld1, const B3DTuple& rOld2, double t) + B3DTuple& operator-=( const B3DTuple& rTup ) { - B3DTuple aInt( - ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(), - ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(), - ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ()); - return aInt; + mfX -= rTup.mfX; + mfY -= rTup.mfY; + mfZ -= rTup.mfZ; + return *this; } - inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2) + B3DTuple& operator/=( const B3DTuple& rTup ) { - B3DTuple aAvg( - (rOld1.getX() + rOld2.getX()) * 0.5, - (rOld1.getY() + rOld2.getY()) * 0.5, - (rOld1.getZ() + rOld2.getZ()) * 0.5); - return aAvg; + mfX /= rTup.mfX; + mfY /= rTup.mfY; + mfZ /= rTup.mfZ; + return *this; } - inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2, const B3DTuple& rOld3) + B3DTuple& operator*=( const B3DTuple& rTup ) { - B3DTuple aAvg( - (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0), - (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0), - (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0)); - return aAvg; + mfX *= rTup.mfX; + mfY *= rTup.mfY; + mfZ *= rTup.mfZ; + return *this; } - inline B3DTuple operator+(const B3DTuple& rTupA, const B3DTuple& rTupB) + B3DTuple& operator*=(double t) { - B3DTuple aSum(rTupA); - aSum += rTupB; - return aSum; + mfX *= t; + mfY *= t; + mfZ *= t; + return *this; } - inline B3DTuple operator-(const B3DTuple& rTupA, const B3DTuple& rTupB) + B3DTuple& operator/=(double t) { - B3DTuple aSub(rTupA); - aSub -= rTupB; - return aSub; + const double fVal(1.0 / t); + mfX *= t; + mfY *= t; + mfZ *= t; + return *this; } - inline B3DTuple operator/(const B3DTuple& rTupA, const B3DTuple& rTupB) + B3DTuple operator-(void) const { - B3DTuple aDiv(rTupA); - aDiv /= rTupB; - return aDiv; + return B3DTuple(-mfX, -mfY, -mfZ); } - inline B3DTuple operator*(const B3DTuple& rTupA, const B3DTuple& rTupB) + sal_Bool operator==( const B3DTuple& rTup ) const { - B3DTuple aMul(rTupA); - aMul *= rTupB; - return aMul; + return equal(rTup); } - inline B3DTuple operator*(const B3DTuple& rTup, double t) + sal_Bool operator!=( const B3DTuple& rTup ) const { - B3DTuple aNew(rTup); - aNew *= t; - return aNew; + return !equal(rTup); } - inline B3DTuple operator*(double t, const B3DTuple& rTup) + B3DTuple& operator=( const B3DTuple& rTup ) { - B3DTuple aNew(rTup); - aNew *= t; - return aNew; + mfX = rTup.mfX; + mfY = rTup.mfY; + mfZ = rTup.mfZ; + return *this; } - inline B3DTuple operator/(const B3DTuple& rTup, double t) + void correctValues(const double fCompareValue = 0.0) { - B3DTuple aNew(rTup); - aNew /= t; - return aNew; + if(0.0 == fCompareValue) + { + if(::basegfx::fTools::equalZero(mfX)) + { + mfX = 0.0; + } + + if(::basegfx::fTools::equalZero(mfY)) + { + mfY = 0.0; + } + + if(::basegfx::fTools::equalZero(mfZ)) + { + mfZ = 0.0; + } + } + else + { + if(::basegfx::fTools::equal(mfX, fCompareValue)) + { + mfX = fCompareValue; + } + + if(::basegfx::fTools::equal(mfY, fCompareValue)) + { + mfY = fCompareValue; + } + + if(::basegfx::fTools::equal(mfZ, fCompareValue)) + { + mfZ = fCompareValue; + } + } } - inline B3DTuple operator/(double t, const B3DTuple& rTup) + static const B3DTuple& getEmptyTuple() { - B3DTuple aNew(rTup); - aNew /= t; - return aNew; + return maEmptyTuple; } - } // end of namespace tuple + }; + + // external operators + ////////////////////////////////////////////////////////////////////////// + + inline B3DTuple min(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aMin( + (rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(), + (rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY(), + (rTupB.getZ() < rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ()); + return aMin; + } + + inline B3DTuple max(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aMax( + (rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(), + (rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY(), + (rTupB.getZ() > rTupA.getZ()) ? rTupB.getZ() : rTupA.getZ()); + return aMax; + } + + inline B3DTuple abs(const B3DTuple& rTup) + { + B3DTuple aAbs( + (0.0 > rTup.getX()) ? -rTup.getX() : rTup.getX(), + (0.0 > rTup.getY()) ? -rTup.getY() : rTup.getY(), + (0.0 > rTup.getZ()) ? -rTup.getZ() : rTup.getZ()); + return aAbs; + } + + inline B3DTuple interpolate(const B3DTuple& rOld1, const B3DTuple& rOld2, double t) + { + B3DTuple aInt( + ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(), + ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY(), + ((rOld2.getZ() - rOld1.getZ()) * t) + rOld1.getZ()); + return aInt; + } + + inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2) + { + B3DTuple aAvg( + (rOld1.getX() + rOld2.getX()) * 0.5, + (rOld1.getY() + rOld2.getY()) * 0.5, + (rOld1.getZ() + rOld2.getZ()) * 0.5); + return aAvg; + } + + inline B3DTuple average(const B3DTuple& rOld1, const B3DTuple& rOld2, const B3DTuple& rOld3) + { + B3DTuple aAvg( + (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0), + (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0), + (rOld1.getZ() + rOld2.getZ() + rOld3.getZ()) * (1.0 / 3.0)); + return aAvg; + } + + inline B3DTuple operator+(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aSum(rTupA); + aSum += rTupB; + return aSum; + } + + inline B3DTuple operator-(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aSub(rTupA); + aSub -= rTupB; + return aSub; + } + + inline B3DTuple operator/(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aDiv(rTupA); + aDiv /= rTupB; + return aDiv; + } + + inline B3DTuple operator*(const B3DTuple& rTupA, const B3DTuple& rTupB) + { + B3DTuple aMul(rTupA); + aMul *= rTupB; + return aMul; + } + + inline B3DTuple operator*(const B3DTuple& rTup, double t) + { + B3DTuple aNew(rTup); + aNew *= t; + return aNew; + } + + inline B3DTuple operator*(double t, const B3DTuple& rTup) + { + B3DTuple aNew(rTup); + aNew *= t; + return aNew; + } + + inline B3DTuple operator/(const B3DTuple& rTup, double t) + { + B3DTuple aNew(rTup); + aNew /= t; + return aNew; + } + + inline B3DTuple operator/(double t, const B3DTuple& rTup) + { + B3DTuple aNew(rTup); + aNew /= t; + return aNew; + } } // end of namespace basegfx #endif // _BGFX_TUPLE_B3DTUPLE_HXX -- cgit v1.2.3