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