basegfx/source/matrix/b2dhommatrix.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <basegfx/matrix/b2dhommatrix.hxx>
  21 #include <basegfx/matrix/hommatrixtemplate.hxx>
  22 #include <basegfx/tuple/b2dtuple.hxx>
  23 #include <basegfx/vector/b2dvector.hxx>
  24 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  25 #include <memory>
  26
  27 namespace basegfx
  28 {
  29     constexpr int RowSize = 3;
  30
  31     void B2DHomMatrix::set3x2(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2)
  32     {
  33         mfValues[0][0] = f_0x0;
  34         mfValues[0][1] = f_0x1;
  35         mfValues[0][2] = f_0x2;
  36         mfValues[1][0] = f_1x0;
  37         mfValues[1][1] = f_1x1;
  38         mfValues[1][2] = f_1x2;
  39     }
  40
  41     bool B2DHomMatrix::isIdentity() const
  42     {
  43         for(sal_uInt16 a(0); a < RowSize - 1; a++)
  44         {
  45             for(sal_uInt16 b(0); b < RowSize; b++)
  46             {
  47                 const double fDefault(internal::implGetDefaultValue(a, b));
  48                 const double fValueAB(get(a, b));
  49
  50                 if(!::basegfx::fTools::equal(fDefault, fValueAB))
  51                 {
  52                     return false;
  53                 }
  54             }
  55         }
  56
  57         return true;
  58     }
  59
  60     void B2DHomMatrix::identity()
  61     {
  62         for(sal_uInt16 a(0); a < RowSize - 1; a++)
  63         {
  64             for(sal_uInt16 b(0); b < RowSize; b++)
  65                 mfValues[a][b] = internal::implGetDefaultValue(a, b);
  66         }
  67     }
  68
  69     bool B2DHomMatrix::isInvertible() const
  70     {
  71         double dst[6];
  72         /* Compute adjoint: */
  73         computeAdjoint(dst);
  74         /* Compute determinant: */
  75         double det = computeDeterminant(dst);
  76         if (fTools::equalZero(det))
  77             return false;
  78         return true;
  79     }
  80
  81     bool B2DHomMatrix::invert()
  82     {
  83         if(isIdentity())
  84             return true;
  85
  86         double dst[6];
  87
  88         /* Compute adjoint: */
  89         computeAdjoint(dst);
  90
  91         /* Compute determinant: */
  92         double det = computeDeterminant(dst);
  93         if (fTools::equalZero(det))
  94             return false;
  95
  96         /* Multiply adjoint with reciprocal of determinant: */
  97         det = 1.0 / det;
  98         mfValues[0][0] = dst[0] * det;
  99         mfValues[0][1] = dst[1] * det;
 100         mfValues[0][2] = dst[2] * det;
 101         mfValues[1][0] = dst[3] * det;
 102         mfValues[1][1] = dst[4] * det;
 103         mfValues[1][2] = dst[5] * det;
 104
 105         return true;
 106     }
 107
 108     /* Compute adjoint, optimised for the case where the last (not stored) row is { 0, 0, 1 } */
 109     void B2DHomMatrix::computeAdjoint(double (&dst)[6]) const
 110     {
 111         dst[0] = + get(1, 1);
 112         dst[1] = - get(0, 1);
 113         dst[2] = + get(0, 1) * get(1, 2) - get(0, 2) * get(1, 1);
 114         dst[3] = - get(1, 0);
 115         dst[4] = + get(0, 0);
 116         dst[5] = - get(0, 0) * get(1, 2) + get(0, 2) * get(1, 0);
 117     }
 118
 119     /* Compute the determinant, given the adjoint matrix */
 120     double B2DHomMatrix::computeDeterminant(double (&dst)[6]) const
 121     {
 122         return mfValues[0][0] * dst[0] + mfValues[0][1] * dst[3];
 123     }
 124
 125     B2DHomMatrix& B2DHomMatrix::operator*=(const B2DHomMatrix& rMat)
 126     {
 127         if(rMat.isIdentity())
 128         {
 129             // multiply with identity, no change -> nothing to do
 130         }
 131         else if(isIdentity())
 132         {
 133             // we are identity, result will be rMat -> assign
 134             *this = rMat;
 135         }
 136         else
 137         {
 138             // multiply
 139             doMulMatrix(rMat);
 140         }
 141
 142         return *this;
 143     }
 144
 145     void B2DHomMatrix::doMulMatrix(const B2DHomMatrix& rMat)
 146     {
 147         // create a copy as source for the original values
 148         const B2DHomMatrix aCopy(*this);
 149
 150         for(sal_uInt16 a(0); a < 2; ++a)
 151         {
 152             for(sal_uInt16 b(0); b < 3; ++b)
 153             {
 154                 double fValue = 0.0;
 155
 156                 for(sal_uInt16 c(0); c < 2; ++c)
 157                     fValue += aCopy.mfValues[c][b] * rMat.mfValues[a][c];
 158
 159                 mfValues[a][b] = fValue;
 160             }
 161             mfValues[a][2] += rMat.mfValues[a][2];
 162         }
 163     }
 164
 165     bool B2DHomMatrix::operator==(const B2DHomMatrix& rMat) const
 166     {
 167         if (&rMat == this)
 168             return true;
 169         for(sal_uInt16 a(0); a < 2; a++)
 170         {
 171             for(sal_uInt16 b(0); b < 3; b++)
 172             {
 173                 const double fValueA(mfValues[a][b]);
 174                 const double fValueB(rMat.mfValues[a][b]);
 175
 176                 if(!::basegfx::fTools::equal(fValueA, fValueB))
 177                 {
 178                     return false;
 179                 }
 180             }
 181         }
 182         return true;
 183     }
 184
 185     void B2DHomMatrix::rotate(double fRadiant)
 186     {
 187         if(fTools::equalZero(fRadiant))
 188             return;
 189
 190         double fSin(0.0);
 191         double fCos(1.0);
 192
 193         utils::createSinCosOrthogonal(fSin, fCos, fRadiant);
 194         B2DHomMatrix aRotMat;
 195
 196         aRotMat.set(0, 0, fCos);
 197         aRotMat.set(1, 1, fCos);
 198         aRotMat.set(1, 0, fSin);
 199         aRotMat.set(0, 1, -fSin);
 200
 201         doMulMatrix(aRotMat);
 202     }
 203
 204     void B2DHomMatrix::translate(double fX, double fY)
 205     {
 206         if(!fTools::equalZero(fX) || !fTools::equalZero(fY))
 207         {
 208             B2DHomMatrix aTransMat;
 209
 210             aTransMat.set(0, 2, fX);
 211             aTransMat.set(1, 2, fY);
 212
 213             doMulMatrix(aTransMat);
 214         }
 215     }
 216
 217     void B2DHomMatrix::translate(const B2DTuple& rTuple)
 218     {
 219         translate(rTuple.getX(), rTuple.getY());
 220     }
 221
 222     void B2DHomMatrix::scale(double fX, double fY)
 223     {
 224         const double fOne(1.0);
 225
 226         if(!fTools::equal(fOne, fX) || !fTools::equal(fOne, fY))
 227         {
 228             B2DHomMatrix aScaleMat;
 229
 230             aScaleMat.set(0, 0, fX);
 231             aScaleMat.set(1, 1, fY);
 232
 233             doMulMatrix(aScaleMat);
 234         }
 235     }
 236
 237     void B2DHomMatrix::scale(const B2DTuple& rTuple)
 238     {
 239         scale(rTuple.getX(), rTuple.getY());
 240     }
 241
 242     void B2DHomMatrix::shearX(double fSx)
 243     {
 244         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
 245         if(!fTools::equalZero(fSx))
 246         {
 247             B2DHomMatrix aShearXMat;
 248
 249             aShearXMat.set(0, 1, fSx);
 250
 251             doMulMatrix(aShearXMat);
 252         }
 253     }
 254
 255     void B2DHomMatrix::shearY(double fSy)
 256     {
 257         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
 258         if(!fTools::equalZero(fSy))
 259         {
 260             B2DHomMatrix aShearYMat;
 261
 262             aShearYMat.set(1, 0, fSy);
 263
 264             doMulMatrix(aShearYMat);
 265         }
 266     }
 267
 268     /** Decomposition
 269
 270        New, optimized version with local shearX detection. Old version (keeping
 271        below, is working well, too) used the 3D matrix decomposition when
 272        shear was used. Keeping old version as comment below since it may get
 273        necessary to add the determinant() test from there here, too.
 274     */
 275     bool B2DHomMatrix::decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const
 276     {
 277         // reset rotate and shear and copy translation values in every case
 278         rRotate = rShearX = 0.0;
 279         rTranslate.setX(get(0, 2));
 280         rTranslate.setY(get(1, 2));
 281
 282         // test for rotation and shear
 283         if(fTools::equalZero(get(0, 1)) && fTools::equalZero(get(1, 0)))
 284         {
 285             // no rotation and shear, copy scale values
 286             rScale.setX(get(0, 0));
 287             rScale.setY(get(1, 1));
 288
 289             // or is there?
 290             if( rScale.getX() < 0 && rScale.getY() < 0 )
 291             {
 292                 // there is - 180 degree rotated
 293                 rScale *= -1;
 294                 rRotate = M_PI;
 295             }
 296         }
 297         else
 298         {
 299             // get the unit vectors of the transformation -> the perpendicular vectors
 300             B2DVector aUnitVecX(get(0, 0), get(1, 0));
 301             B2DVector aUnitVecY(get(0, 1), get(1, 1));
 302             const double fScalarXY(aUnitVecX.scalar(aUnitVecY));
 303
 304             // Test if shear is zero. That's the case if the unit vectors in the matrix
 305             // are perpendicular -> scalar is zero. This is also the case when one of
 306             // the unit vectors is zero.
 307             if(fTools::equalZero(fScalarXY))
 308             {
 309                 // calculate unsigned scale values
 310                 rScale.setX(aUnitVecX.getLength());
 311                 rScale.setY(aUnitVecY.getLength());
 312
 313                 // check unit vectors for zero lengths
 314                 const bool bXIsZero(fTools::equalZero(rScale.getX()));
 315                 const bool bYIsZero(fTools::equalZero(rScale.getY()));
 316
 317                 if(bXIsZero || bYIsZero)
 318                 {
 319                     // still extract as much as possible. Scalings are already set
 320                     if(!bXIsZero)
 321                     {
 322                         // get rotation of X-Axis
 323                         rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
 324                     }
 325                     else if(!bYIsZero)
 326                     {
 327                         // get rotation of X-Axis. When assuming X and Y perpendicular
 328                         // and correct rotation, it's the Y-Axis rotation minus 90 degrees
 329                         rRotate = atan2(aUnitVecY.getY(), aUnitVecY.getX()) - M_PI_2;
 330                     }
 331
 332                     // one or both unit vectors do not exist, determinant is zero, no decomposition possible.
 333                     // Eventually used rotations or shears are lost
 334                     return false;
 335                 }
 336                 else
 337                 {
 338                     // no shear
 339                     // calculate rotation of X unit vector relative to (1, 0)
 340                     rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
 341
 342                     // use orientation to evtl. correct sign of Y-Scale
 343                     const double fCrossXY(aUnitVecX.cross(aUnitVecY));
 344
 345                     if(fCrossXY < 0.0)
 346                     {
 347                         rScale.setY(-rScale.getY());
 348                     }
 349                 }
 350             }
 351             else
 352             {
 353                 // fScalarXY is not zero, thus both unit vectors exist. No need to handle that here
 354                 // shear, extract it
 355                 double fCrossXY(aUnitVecX.cross(aUnitVecY));
 356
 357                 // get rotation by calculating angle of X unit vector relative to (1, 0).
 358                 // This is before the parallel test following the motto to extract
 359                 // as much as possible
 360                 rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
 361
 362                 // get unsigned scale value for X. It will not change and is useful
 363                 // for further corrections
 364                 rScale.setX(aUnitVecX.getLength());
 365
 366                 if(fTools::equalZero(fCrossXY))
 367                 {
 368                     // extract as much as possible
 369                     rScale.setY(aUnitVecY.getLength());
 370
 371                     // unit vectors are parallel, thus not linear independent. No
 372                     // useful decomposition possible. This should not happen since
 373                     // the only way to get the unit vectors nearly parallel is
 374                     // a very big shearing. Anyways, be prepared for hand-filled
 375                     // matrices
 376                     // Eventually used rotations or shears are lost
 377                     return false;
 378                 }
 379                 else
 380                 {
 381                     // calculate the contained shear
 382                     rShearX = fScalarXY / fCrossXY;
 383
 384                     if(!fTools::equalZero(rRotate))
 385                     {
 386                         // To be able to correct the shear for aUnitVecY, rotation needs to be
 387                         // removed first. Correction of aUnitVecX is easy, it will be rotated back to (1, 0).
 388                         aUnitVecX.setX(rScale.getX());
 389                         aUnitVecX.setY(0.0);
 390
 391                         // for Y correction we rotate the UnitVecY back about -rRotate
 392                         const double fNegRotate(-rRotate);
 393                         const double fSin(sin(fNegRotate));
 394                         const double fCos(cos(fNegRotate));
 395
 396                         const double fNewX(aUnitVecY.getX() * fCos - aUnitVecY.getY() * fSin);
 397                         const double fNewY(aUnitVecY.getX() * fSin + aUnitVecY.getY() * fCos);
 398
 399                         aUnitVecY.setX(fNewX);
 400                         aUnitVecY.setY(fNewY);
 401                     }
 402
 403                     // Correct aUnitVecY and fCrossXY to fShear=0. Rotation is already removed.
 404                     // Shear correction can only work with removed rotation
 405                     aUnitVecY.setX(aUnitVecY.getX() - (aUnitVecY.getY() * rShearX));
 406                     fCrossXY = aUnitVecX.cross(aUnitVecY);
 407
 408                     // calculate unsigned scale value for Y, after the corrections since
 409                     // the shear correction WILL change the length of aUnitVecY
 410                     rScale.setY(aUnitVecY.getLength());
 411
 412                     // use orientation to set sign of Y-Scale
 413                     if(fCrossXY < 0.0)
 414                     {
 415                         rScale.setY(-rScale.getY());
 416                     }
 417                 }
 418             }
 419         }
 420
 421         return true;
 422     }
 423 } // end of namespace basegfx
 424
 425 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */