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