basegfx/source/point/b2dhompoint.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b2dhompoint.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <basegfx/point/b2dhompoint.hxx>
  34 #include <basegfx/matrix/b2dhommatrix.hxx>
  35 #include <basegfx/numeric/ftools.hxx>
  36
  37 namespace basegfx
  38 {
  39     bool B2DHomPoint::implIsHomogenized() const
  40     {
  41         const double fOne(1.0);
  42         return ::basegfx::fTools::equal(fOne, mfW);
  43     }
  44
  45     void B2DHomPoint::implHomogenize()
  46     {
  47         const double fFactor(1.0 / mfW);
  48         maTuple.setX(maTuple.getX() * fFactor);
  49         maTuple.setY(maTuple.getY() * fFactor);
  50         mfW = 1.0;
  51     }
  52
  53     void B2DHomPoint::implTestAndHomogenize() const
  54     {
  55         if(!implIsHomogenized())
  56             ((B2DHomPoint*)this)->implHomogenize();
  57     }
  58
  59     B2DPoint B2DHomPoint::getB2DPoint() const
  60     {
  61         implTestAndHomogenize();
  62         return B2DPoint(maTuple.getX(), maTuple.getY());
  63     }
  64
  65     double B2DHomPoint::getX() const
  66     {
  67         implTestAndHomogenize();
  68         return maTuple.getX();
  69     }
  70
  71     double B2DHomPoint::getY() const
  72     {
  73         implTestAndHomogenize();
  74         return maTuple.getY();
  75     }
  76
  77     void B2DHomPoint::setX(double fX)
  78     {
  79         maTuple.setX(implIsHomogenized() ? fX : fX * mfW );
  80     }
  81
  82     void B2DHomPoint::setY(double fY)
  83     {
  84         maTuple.setY(implIsHomogenized() ? fY : fY * mfW );
  85     }
  86
  87     B2DHomPoint& B2DHomPoint::operator+=( const B2DHomPoint& rPnt )
  88     {
  89         maTuple.setX(getX() * rPnt.mfW + rPnt.getX() * mfW);
  90         maTuple.setY(getY() * rPnt.mfW + rPnt.getY() * mfW);
  91         mfW = mfW * rPnt.mfW;
  92
  93         return *this;
  94     }
  95
  96     B2DHomPoint& B2DHomPoint::operator-=( const B2DHomPoint& rPnt )
  97     {
  98         maTuple.setX(getX() * rPnt.mfW - rPnt.getX() * mfW);
  99         maTuple.setY(getY() * rPnt.mfW - rPnt.getY() * mfW);
 100         mfW = mfW * rPnt.mfW;
 101
 102         return *this;
 103     }
 104
 105     B2DHomPoint& B2DHomPoint::operator*=(double t)
 106     {
 107         if(!::basegfx::fTools::equalZero(t))
 108         {
 109             mfW /= t;
 110         }
 111
 112         return *this;
 113     }
 114
 115     B2DHomPoint& B2DHomPoint::operator*=( const B2DHomMatrix& rMat )
 116     {
 117         const double fTempX( rMat.get(0,0)*maTuple.getX() +
 118                             rMat.get(0,1)*maTuple.getY() +
 119                             rMat.get(0,2)*mfW );
 120
 121         const double fTempY( rMat.get(1,0)*maTuple.getX() +
 122                             rMat.get(1,1)*maTuple.getY() +
 123                             rMat.get(1,2)*mfW );
 124
 125         const double fTempZ( rMat.get(2,0)*maTuple.getX() +
 126                             rMat.get(2,1)*maTuple.getY() +
 127                             rMat.get(2,2)*mfW );
 128         maTuple.setX( fTempX );
 129         maTuple.setY( fTempY );
 130         mfW = fTempZ;
 131
 132         return *this;
 133     }
 134
 135     B2DHomPoint& B2DHomPoint::operator/=(double t)
 136     {
 137         mfW *= t;
 138         return *this;
 139     }
 140
 141     B2DHomPoint& B2DHomPoint::operator-(void)
 142     {
 143         mfW = -mfW;
 144         return *this;
 145     }
 146
 147     bool B2DHomPoint::operator==( const B2DHomPoint& rPnt ) const
 148     {
 149         implTestAndHomogenize();
 150         return (maTuple == rPnt.maTuple);
 151     }
 152
 153     bool B2DHomPoint::operator!=( const B2DHomPoint& rPnt ) const
 154     {
 155         implTestAndHomogenize();
 156         return (maTuple != rPnt.maTuple);
 157     }
 158
 159     B2DHomPoint& B2DHomPoint::operator=( const B2DHomPoint& rPnt )
 160     {
 161         maTuple = rPnt.maTuple;
 162         mfW = rPnt.mfW;
 163         return *this;
 164     }
 165
 166     B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
 167     {
 168         B2DHomPoint aMin(
 169             (rVecB.getX() < rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
 170             (rVecB.getY() < rVecA.getY()) ? rVecB.getY() : rVecA.getY());
 171         return aMin;
 172     }
 173
 174     B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
 175     {
 176         B2DHomPoint aMax(
 177             (rVecB.getX() > rVecA.getX()) ? rVecB.getX() : rVecA.getX(),
 178             (rVecB.getY() > rVecA.getY()) ? rVecB.getY() : rVecA.getY());
 179         return aMax;
 180     }
 181     B2DHomPoint absolute(const B2DHomPoint& rVec)
 182     {
 183         B2DHomPoint aAbs(
 184             (0.0 > rVec.getX()) ? -rVec.getX() : rVec.getX(),
 185             (0.0 > rVec.getY()) ? -rVec.getY() : rVec.getY());
 186         return aAbs;
 187     }
 188
 189     B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t)
 190     {
 191         B2DHomPoint aInt(
 192             ((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
 193             ((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
 194         return aInt;
 195     }
 196
 197     B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2)
 198     {
 199         B2DHomPoint aAvg(
 200             (rOld1.getX() + rOld2.getX()) * 0.5,
 201             (rOld1.getY() + rOld2.getY()) * 0.5);
 202         return aAvg;
 203     }
 204
 205     B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3)
 206     {
 207         B2DHomPoint aAvg(
 208             (rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
 209             (rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
 210         return aAvg;
 211     }
 212
 213     B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
 214     {
 215         B2DHomPoint aSum(rVecA);
 216         aSum += rVecB;
 217         return aSum;
 218     }
 219
 220     B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB)
 221     {
 222         B2DHomPoint aSub(rVecA);
 223         aSub -= rVecB;
 224         return aSub;
 225     }
 226
 227     B2DHomPoint operator*(const B2DHomPoint& rVec, double t)
 228     {
 229         B2DHomPoint aNew(rVec);
 230         aNew *= t;
 231         return aNew;
 232     }
 233
 234     B2DHomPoint operator*(double t, const B2DHomPoint& rVec)
 235     {
 236         B2DHomPoint aNew(rVec);
 237         aNew *= t;
 238         return aNew;
 239     }
 240
 241     B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint )
 242     {
 243         B2DHomPoint aNew(rPoint);
 244         return aNew*=rMat;
 245     }
 246
 247     B2DHomPoint operator/(const B2DHomPoint& rVec, double t)
 248     {
 249         B2DHomPoint aNew(rVec);
 250         aNew /= t;
 251         return aNew;
 252     }
 253
 254     B2DHomPoint operator/(double t, const B2DHomPoint& rVec)
 255     {
 256         B2DHomPoint aNew(rVec);
 257         aNew /= t;
 258         return aNew;
 259     }
 260 } // end of namespace basegfx
 261
 262 // eof