summaryrefslogtreecommitdiff
path: root/basegfx/inc/basegfx/tuple
diff options
context:
space:
mode:
Diffstat (limited to 'basegfx/inc/basegfx/tuple')
-rw-r--r--basegfx/inc/basegfx/tuple/b2dtuple.hxx499
-rw-r--r--basegfx/inc/basegfx/tuple/b3dtuple.hxx647
2 files changed, 570 insertions, 576 deletions
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
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-30 18:27:41 +0000