basegfx/source/matrix/b3dhommatrix.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/b3dhommatrix.hxx>
  21 #include <basegfx/matrix/hommatrixtemplate.hxx>
  22 #include <basegfx/vector/b3dvector.hxx>
  23 #include <memory>
  24
  25 namespace basegfx
  26 {
  27     typedef ::basegfx::internal::ImplHomMatrixTemplate< 4 >Impl3DHomMatrix_Base;
  28     class Impl3DHomMatrix : public Impl3DHomMatrix_Base
  29     {
  30     };
  31
  32     B3DHomMatrix::B3DHomMatrix() = default;
  33
  34     B3DHomMatrix::B3DHomMatrix(const B3DHomMatrix&) = default;
  35
  36     B3DHomMatrix::B3DHomMatrix(B3DHomMatrix&&) = default;
  37
  38     B3DHomMatrix::~B3DHomMatrix() = default;
  39
  40     B3DHomMatrix& B3DHomMatrix::operator=(const B3DHomMatrix&) = default;
  41
  42     B3DHomMatrix& B3DHomMatrix::operator=(B3DHomMatrix&&) = default;
  43
  44     double B3DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
  45     {
  46         return mpImpl->get(nRow, nColumn);
  47     }
  48
  49     void B3DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
  50     {
  51         mpImpl->set(nRow, nColumn, fValue);
  52     }
  53
  54     bool B3DHomMatrix::isLastLineDefault() const
  55     {
  56         return mpImpl->isLastLineDefault();
  57     }
  58
  59     bool B3DHomMatrix::isIdentity() const
  60     {
  61         return mpImpl->isIdentity();
  62     }
  63
  64     void B3DHomMatrix::identity()
  65     {
  66         *mpImpl = Impl3DHomMatrix();
  67     }
  68
  69     void B3DHomMatrix::invert()
  70     {
  71         Impl3DHomMatrix aWork(*mpImpl);
  72         std::unique_ptr<sal_uInt16[]> pIndex( new sal_uInt16[Impl3DHomMatrix_Base::getEdgeLength()] );
  73         sal_Int16 nParity;
  74
  75         if(aWork.ludcmp(pIndex.get(), nParity))
  76         {
  77             mpImpl->doInvert(aWork, pIndex.get());
  78         }
  79     }
  80
  81     double B3DHomMatrix::determinant() const
  82     {
  83         return mpImpl->doDeterminant();
  84     }
  85
  86     B3DHomMatrix& B3DHomMatrix::operator+=(const B3DHomMatrix& rMat)
  87     {
  88         mpImpl->doAddMatrix(*rMat.mpImpl);
  89         return *this;
  90     }
  91
  92     B3DHomMatrix& B3DHomMatrix::operator-=(const B3DHomMatrix& rMat)
  93     {
  94         mpImpl->doSubMatrix(*rMat.mpImpl);
  95         return *this;
  96     }
  97
  98     B3DHomMatrix& B3DHomMatrix::operator*=(double fValue)
  99     {
 100         const double fOne(1.0);
 101
 102         if(!fTools::equal(fOne, fValue))
 103             mpImpl->doMulMatrix(fValue);
 104
 105         return *this;
 106     }
 107
 108     B3DHomMatrix& B3DHomMatrix::operator/=(double fValue)
 109     {
 110         const double fOne(1.0);
 111
 112         if(!fTools::equal(fOne, fValue))
 113             mpImpl->doMulMatrix(1.0 / fValue);
 114
 115         return *this;
 116     }
 117
 118     B3DHomMatrix& B3DHomMatrix::operator*=(const B3DHomMatrix& rMat)
 119     {
 120         if(rMat.isIdentity())
 121         {
 122             // multiply with identity, no change -> nothing to do
 123         }
 124         else if(isIdentity())
 125         {
 126             // we are identity, result will be rMat -> assign
 127             *this = rMat;
 128         }
 129         else
 130         {
 131             // multiply
 132             mpImpl->doMulMatrix(*rMat.mpImpl);
 133         }
 134         return *this;
 135     }
 136
 137     bool B3DHomMatrix::operator==(const B3DHomMatrix& rMat) const
 138     {
 139         if(mpImpl.same_object(rMat.mpImpl))
 140             return true;
 141
 142         return mpImpl->isEqual(*rMat.mpImpl);
 143     }
 144
 145     void B3DHomMatrix::rotate(double fAngleX,double fAngleY,double fAngleZ)
 146     {
 147         if(fTools::equalZero(fAngleX) && fTools::equalZero(fAngleY) && fTools::equalZero(fAngleZ))
 148             return;
 149
 150         if(!fTools::equalZero(fAngleX))
 151         {
 152             Impl3DHomMatrix aRotMatX;
 153             double fSin(sin(fAngleX));
 154             double fCos(cos(fAngleX));
 155
 156             aRotMatX.set(1, 1, fCos);
 157             aRotMatX.set(2, 2, fCos);
 158             aRotMatX.set(2, 1, fSin);
 159             aRotMatX.set(1, 2, -fSin);
 160
 161             mpImpl->doMulMatrix(aRotMatX);
 162         }
 163
 164         if(!fTools::equalZero(fAngleY))
 165         {
 166             Impl3DHomMatrix aRotMatY;
 167             double fSin(sin(fAngleY));
 168             double fCos(cos(fAngleY));
 169
 170             aRotMatY.set(0, 0, fCos);
 171             aRotMatY.set(2, 2, fCos);
 172             aRotMatY.set(0, 2, fSin);
 173             aRotMatY.set(2, 0, -fSin);
 174
 175             mpImpl->doMulMatrix(aRotMatY);
 176         }
 177
 178         if(fTools::equalZero(fAngleZ))
 179             return;
 180
 181         Impl3DHomMatrix aRotMatZ;
 182         double fSin(sin(fAngleZ));
 183         double fCos(cos(fAngleZ));
 184
 185         aRotMatZ.set(0, 0, fCos);
 186         aRotMatZ.set(1, 1, fCos);
 187         aRotMatZ.set(1, 0, fSin);
 188         aRotMatZ.set(0, 1, -fSin);
 189
 190         mpImpl->doMulMatrix(aRotMatZ);
 191     }
 192
 193     void B3DHomMatrix::rotate(const B3DTuple& rRotation)
 194     {
 195         rotate(rRotation.getX(), rRotation.getY(), rRotation.getZ());
 196     }
 197
 198     void B3DHomMatrix::translate(double fX, double fY, double fZ)
 199     {
 200         if(!fTools::equalZero(fX) || !fTools::equalZero(fY) || !fTools::equalZero(fZ))
 201         {
 202             Impl3DHomMatrix aTransMat;
 203
 204             aTransMat.set(0, 3, fX);
 205             aTransMat.set(1, 3, fY);
 206             aTransMat.set(2, 3, fZ);
 207
 208             mpImpl->doMulMatrix(aTransMat);
 209         }
 210     }
 211
 212     void B3DHomMatrix::translate(const B3DTuple& rRotation)
 213     {
 214         translate(rRotation.getX(), rRotation.getY(), rRotation.getZ());
 215     }
 216
 217     void B3DHomMatrix::scale(double fX, double fY, double fZ)
 218     {
 219         const double fOne(1.0);
 220
 221         if(!fTools::equal(fOne, fX) || !fTools::equal(fOne, fY) ||!fTools::equal(fOne, fZ))
 222         {
 223             Impl3DHomMatrix aScaleMat;
 224
 225             aScaleMat.set(0, 0, fX);
 226             aScaleMat.set(1, 1, fY);
 227             aScaleMat.set(2, 2, fZ);
 228
 229             mpImpl->doMulMatrix(aScaleMat);
 230         }
 231     }
 232
 233     void B3DHomMatrix::scale(const B3DTuple& rRotation)
 234     {
 235         scale(rRotation.getX(), rRotation.getY(), rRotation.getZ());
 236     }
 237
 238     void B3DHomMatrix::shearXY(double fSx, double fSy)
 239     {
 240         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
 241         if(!fTools::equalZero(fSx) || !fTools::equalZero(fSy))
 242         {
 243             Impl3DHomMatrix aShearXYMat;
 244
 245             aShearXYMat.set(0, 2, fSx);
 246             aShearXYMat.set(1, 2, fSy);
 247
 248             mpImpl->doMulMatrix(aShearXYMat);
 249         }
 250     }
 251
 252     void B3DHomMatrix::shearXZ(double fSx, double fSz)
 253     {
 254         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
 255         if(!fTools::equalZero(fSx) || !fTools::equalZero(fSz))
 256         {
 257             Impl3DHomMatrix aShearXZMat;
 258
 259             aShearXZMat.set(0, 1, fSx);
 260             aShearXZMat.set(2, 1, fSz);
 261
 262             mpImpl->doMulMatrix(aShearXZMat);
 263         }
 264     }
 265     void B3DHomMatrix::frustum(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
 266     {
 267         const double fZero(0.0);
 268         const double fOne(1.0);
 269
 270         if(!fTools::more(fNear, fZero))
 271         {
 272             fNear = 0.001;
 273         }
 274
 275         if(!fTools::more(fFar, fZero))
 276         {
 277             fFar = fOne;
 278         }
 279
 280         if(fTools::equal(fNear, fFar))
 281         {
 282             fFar = fNear + fOne;
 283         }
 284
 285         if(fTools::equal(fLeft, fRight))
 286         {
 287             fLeft -= fOne;
 288             fRight += fOne;
 289         }
 290
 291         if(fTools::equal(fTop, fBottom))
 292         {
 293             fBottom -= fOne;
 294             fTop += fOne;
 295         }
 296
 297         Impl3DHomMatrix aFrustumMat;
 298
 299         aFrustumMat.set(0, 0, 2.0 * fNear / (fRight - fLeft));
 300         aFrustumMat.set(1, 1, 2.0 * fNear / (fTop - fBottom));
 301         aFrustumMat.set(0, 2, (fRight + fLeft) / (fRight - fLeft));
 302         aFrustumMat.set(1, 2, (fTop + fBottom) / (fTop - fBottom));
 303         aFrustumMat.set(2, 2, -fOne * ((fFar + fNear) / (fFar - fNear)));
 304         aFrustumMat.set(3, 2, -fOne);
 305         aFrustumMat.set(2, 3, -fOne * ((2.0 * fFar * fNear) / (fFar - fNear)));
 306         aFrustumMat.set(3, 3, fZero);
 307
 308         mpImpl->doMulMatrix(aFrustumMat);
 309     }
 310
 311     void B3DHomMatrix::ortho(double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
 312     {
 313         if(fTools::equal(fNear, fFar))
 314         {
 315             fFar = fNear + 1.0;
 316         }
 317
 318         if(fTools::equal(fLeft, fRight))
 319         {
 320             fLeft -= 1.0;
 321             fRight += 1.0;
 322         }
 323
 324         if(fTools::equal(fTop, fBottom))
 325         {
 326             fBottom -= 1.0;
 327             fTop += 1.0;
 328         }
 329
 330         Impl3DHomMatrix aOrthoMat;
 331
 332         aOrthoMat.set(0, 0, 2.0 / (fRight - fLeft));
 333         aOrthoMat.set(1, 1, 2.0 / (fTop - fBottom));
 334         aOrthoMat.set(2, 2, -1.0 * (2.0 / (fFar - fNear)));
 335         aOrthoMat.set(0, 3, -1.0 * ((fRight + fLeft) / (fRight - fLeft)));
 336         aOrthoMat.set(1, 3, -1.0 * ((fTop + fBottom) / (fTop - fBottom)));
 337         aOrthoMat.set(2, 3, -1.0 * ((fFar + fNear) / (fFar - fNear)));
 338
 339         mpImpl->doMulMatrix(aOrthoMat);
 340     }
 341
 342     void B3DHomMatrix::orientation(const B3DPoint& rVRP, B3DVector aVPN, B3DVector aVUV)
 343     {
 344         Impl3DHomMatrix aOrientationMat;
 345
 346         // translate -VRP
 347         aOrientationMat.set(0, 3, -rVRP.getX());
 348         aOrientationMat.set(1, 3, -rVRP.getY());
 349         aOrientationMat.set(2, 3, -rVRP.getZ());
 350
 351         // build rotation
 352         aVUV.normalize();
 353         aVPN.normalize();
 354
 355         // build x-axis as perpendicular from aVUV and aVPN
 356         B3DVector aRx(aVUV.getPerpendicular(aVPN));
 357         aRx.normalize();
 358
 359         // y-axis perpendicular to that
 360         B3DVector aRy(aVPN.getPerpendicular(aRx));
 361         aRy.normalize();
 362
 363         // the calculated normals are the line vectors of the rotation matrix,
 364         // set them to create rotation
 365         aOrientationMat.set(0, 0, aRx.getX());
 366         aOrientationMat.set(0, 1, aRx.getY());
 367         aOrientationMat.set(0, 2, aRx.getZ());
 368         aOrientationMat.set(1, 0, aRy.getX());
 369         aOrientationMat.set(1, 1, aRy.getY());
 370         aOrientationMat.set(1, 2, aRy.getZ());
 371         aOrientationMat.set(2, 0, aVPN.getX());
 372         aOrientationMat.set(2, 1, aVPN.getY());
 373         aOrientationMat.set(2, 2, aVPN.getZ());
 374
 375         mpImpl->doMulMatrix(aOrientationMat);
 376     }
 377
 378     void B3DHomMatrix::decompose(B3DTuple& rScale, B3DTuple& rTranslate, B3DTuple& rRotate, B3DTuple& rShear) const
 379     {
 380         // when perspective is used, decompose is not made here
 381         if(!mpImpl->isLastLineDefault())
 382             return;
 383
 384         // If determinant is zero, decomposition is not possible
 385         if(determinant() == 0.0)
 386             return;
 387
 388         // isolate translation
 389         rTranslate.setX(mpImpl->get(0, 3));
 390         rTranslate.setY(mpImpl->get(1, 3));
 391         rTranslate.setZ(mpImpl->get(2, 3));
 392
 393         // correct translate values
 394         rTranslate.correctValues();
 395
 396         // get scale and shear
 397         B3DVector aCol0(mpImpl->get(0, 0), mpImpl->get(1, 0), mpImpl->get(2, 0));
 398         B3DVector aCol1(mpImpl->get(0, 1), mpImpl->get(1, 1), mpImpl->get(2, 1));
 399         B3DVector aCol2(mpImpl->get(0, 2), mpImpl->get(1, 2), mpImpl->get(2, 2));
 400         B3DVector aTemp;
 401
 402         // get ScaleX
 403         rScale.setX(aCol0.getLength());
 404         aCol0.normalize();
 405
 406         // get ShearXY
 407         rShear.setX(aCol0.scalar(aCol1));
 408
 409         if(fTools::equalZero(rShear.getX()))
 410         {
 411             rShear.setX(0.0);
 412         }
 413         else
 414         {
 415             aTemp.setX(aCol1.getX() - rShear.getX() * aCol0.getX());
 416             aTemp.setY(aCol1.getY() - rShear.getX() * aCol0.getY());
 417             aTemp.setZ(aCol1.getZ() - rShear.getX() * aCol0.getZ());
 418             aCol1 = aTemp;
 419         }
 420
 421         // get ScaleY
 422         rScale.setY(aCol1.getLength());
 423         aCol1.normalize();
 424
 425         const double fShearX(rShear.getX());
 426
 427         if(!fTools::equalZero(fShearX))
 428         {
 429             rShear.setX(rShear.getX() / rScale.getY());
 430         }
 431
 432         // get ShearXZ
 433         rShear.setY(aCol0.scalar(aCol2));
 434
 435         if(fTools::equalZero(rShear.getY()))
 436         {
 437             rShear.setY(0.0);
 438         }
 439         else
 440         {
 441             aTemp.setX(aCol2.getX() - rShear.getY() * aCol0.getX());
 442             aTemp.setY(aCol2.getY() - rShear.getY() * aCol0.getY());
 443             aTemp.setZ(aCol2.getZ() - rShear.getY() * aCol0.getZ());
 444             aCol2 = aTemp;
 445         }
 446
 447         // get ShearYZ
 448         rShear.setZ(aCol1.scalar(aCol2));
 449
 450         if(fTools::equalZero(rShear.getZ()))
 451         {
 452             rShear.setZ(0.0);
 453         }
 454         else
 455         {
 456             aTemp.setX(aCol2.getX() - rShear.getZ() * aCol1.getX());
 457             aTemp.setY(aCol2.getY() - rShear.getZ() * aCol1.getY());
 458             aTemp.setZ(aCol2.getZ() - rShear.getZ() * aCol1.getZ());
 459             aCol2 = aTemp;
 460         }
 461
 462         // get ScaleZ
 463         rScale.setZ(aCol2.getLength());
 464         aCol2.normalize();
 465
 466         const double fShearY(rShear.getY());
 467
 468         if(!fTools::equalZero(fShearY))
 469         {
 470             // coverity[copy_paste_error : FALSE] - this is correct getZ, not getY
 471             rShear.setY(rShear.getY() / rScale.getZ());
 472         }
 473
 474         const double fShearZ(rShear.getZ());
 475
 476         if(!fTools::equalZero(fShearZ))
 477         {
 478             // coverity[original] - this is not an original copy-and-paste source for ^^^
 479             rShear.setZ(rShear.getZ() / rScale.getZ());
 480         }
 481
 482         // correct shear values
 483         rShear.correctValues();
 484
 485         // Coordinate system flip?
 486         if(0.0 > aCol0.scalar(aCol1.getPerpendicular(aCol2)))
 487         {
 488             rScale = -rScale;
 489             aCol0 = -aCol0;
 490             aCol1 = -aCol1;
 491             aCol2 = -aCol2;
 492         }
 493
 494         // correct scale values
 495         rScale.correctValues(1.0);
 496
 497         // Get rotations
 498         {
 499             double fy=0;
 500             double cy=0;
 501
 502             if( ::basegfx::fTools::equal( aCol0.getZ(), 1.0 )
 503                 || aCol0.getZ() > 1.0 )
 504             {
 505                 fy = -M_PI/2.0;
 506                 cy = 0.0;
 507             }
 508             else if( ::basegfx::fTools::equal( aCol0.getZ(), -1.0 )
 509                 || aCol0.getZ() < -1.0 )
 510             {
 511                 fy = M_PI/2.0;
 512                 cy = 0.0;
 513             }
 514             else
 515             {
 516                 fy = asin( -aCol0.getZ() );
 517                 cy = cos(fy);
 518             }
 519
 520             rRotate.setY(fy);
 521             if( ::basegfx::fTools::equalZero( cy ) )
 522             {
 523                 if( aCol0.getZ() > 0.0 )
 524                     rRotate.setX(atan2(-1.0*aCol1.getX(), aCol1.getY()));
 525                 else
 526                     rRotate.setX(atan2(aCol1.getX(), aCol1.getY()));
 527                 rRotate.setZ(0.0);
 528             }
 529             else
 530             {
 531                 rRotate.setX(atan2(aCol1.getZ(), aCol2.getZ()));
 532                 rRotate.setZ(atan2(aCol0.getY(), aCol0.getX()));
 533             }
 534
 535             // correct rotate values
 536             rRotate.correctValues();
 537         }
 538     }
 539 } // end of namespace basegfx
 540
 541 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */