LCOV - code coverage report
Current view: top level - basegfx/source/matrix - b3dhommatrix.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 268 0.0 %
Date: 2014-04-14 Functions: 0 30 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10