LCOV - code coverage report
Current view: top level - basegfx/source/matrix - b2dhommatrix.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 173 0.0 %
Date: 2014-04-14 Functions: 0 29 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 <osl/diagnose.h>
      21             : #include <rtl/instance.hxx>
      22             : #include <basegfx/matrix/b2dhommatrix.hxx>
      23             : #include <hommatrixtemplate.hxx>
      24             : #include <basegfx/tuple/b2dtuple.hxx>
      25             : #include <basegfx/vector/b2dvector.hxx>
      26             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      27             : 
      28             : 
      29             : 
      30             : namespace basegfx
      31             : {
      32           0 :     class Impl2DHomMatrix : public ::basegfx::internal::ImplHomMatrixTemplate< 3 >
      33             :     {
      34             :     };
      35             : 
      36             :     namespace { struct IdentityMatrix : public rtl::Static< B2DHomMatrix::ImplType,
      37             :                                                             IdentityMatrix > {}; }
      38             : 
      39           0 :     B2DHomMatrix::B2DHomMatrix() :
      40           0 :         mpImpl( IdentityMatrix::get() ) // use common identity matrix
      41             :     {
      42           0 :     }
      43             : 
      44           0 :     B2DHomMatrix::B2DHomMatrix(const B2DHomMatrix& rMat) :
      45           0 :         mpImpl(rMat.mpImpl)
      46             :     {
      47           0 :     }
      48             : 
      49           0 :     B2DHomMatrix::~B2DHomMatrix()
      50             :     {
      51           0 :     }
      52             : 
      53           0 :     B2DHomMatrix::B2DHomMatrix(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2)
      54           0 :     :   mpImpl( IdentityMatrix::get() ) // use common identity matrix, will be made unique with 1st set-call
      55             :     {
      56           0 :         mpImpl->set(0, 0, f_0x0);
      57           0 :         mpImpl->set(0, 1, f_0x1);
      58           0 :         mpImpl->set(0, 2, f_0x2);
      59           0 :         mpImpl->set(1, 0, f_1x0);
      60           0 :         mpImpl->set(1, 1, f_1x1);
      61           0 :         mpImpl->set(1, 2, f_1x2);
      62           0 :     }
      63             : 
      64           0 :     B2DHomMatrix& B2DHomMatrix::operator=(const B2DHomMatrix& rMat)
      65             :     {
      66           0 :         mpImpl = rMat.mpImpl;
      67           0 :         return *this;
      68             :     }
      69             : 
      70           0 :     double B2DHomMatrix::get(sal_uInt16 nRow, sal_uInt16 nColumn) const
      71             :     {
      72           0 :         return mpImpl->get(nRow, nColumn);
      73             :     }
      74             : 
      75           0 :     void B2DHomMatrix::set(sal_uInt16 nRow, sal_uInt16 nColumn, double fValue)
      76             :     {
      77           0 :         mpImpl->set(nRow, nColumn, fValue);
      78           0 :     }
      79             : 
      80           0 :     void B2DHomMatrix::set3x2(double f_0x0, double f_0x1, double f_0x2, double f_1x0, double f_1x1, double f_1x2)
      81             :     {
      82           0 :         mpImpl->set(0, 0, f_0x0);
      83           0 :         mpImpl->set(0, 1, f_0x1);
      84           0 :         mpImpl->set(0, 2, f_0x2);
      85           0 :         mpImpl->set(1, 0, f_1x0);
      86           0 :         mpImpl->set(1, 1, f_1x1);
      87           0 :         mpImpl->set(1, 2, f_1x2);
      88           0 :     }
      89             : 
      90           0 :     bool B2DHomMatrix::isLastLineDefault() const
      91             :     {
      92           0 :         return mpImpl->isLastLineDefault();
      93             :     }
      94             : 
      95           0 :     bool B2DHomMatrix::isIdentity() const
      96             :     {
      97           0 :         if(mpImpl.same_object(IdentityMatrix::get()))
      98           0 :             return true;
      99             : 
     100           0 :         return mpImpl->isIdentity();
     101             :     }
     102             : 
     103           0 :     void B2DHomMatrix::identity()
     104             :     {
     105           0 :         mpImpl = IdentityMatrix::get();
     106           0 :     }
     107             : 
     108           0 :     bool B2DHomMatrix::isInvertible() const
     109             :     {
     110           0 :         return mpImpl->isInvertible();
     111             :     }
     112             : 
     113           0 :     bool B2DHomMatrix::invert()
     114             :     {
     115           0 :         Impl2DHomMatrix aWork(*mpImpl);
     116           0 :         sal_uInt16* pIndex = new sal_uInt16[mpImpl->getEdgeLength()];
     117             :         sal_Int16 nParity;
     118             : 
     119           0 :         if(aWork.ludcmp(pIndex, nParity))
     120             :         {
     121           0 :             mpImpl->doInvert(aWork, pIndex);
     122           0 :             delete[] pIndex;
     123             : 
     124           0 :             return true;
     125             :         }
     126             : 
     127           0 :         delete[] pIndex;
     128           0 :         return false;
     129             :     }
     130             : 
     131           0 :     B2DHomMatrix& B2DHomMatrix::operator+=(const B2DHomMatrix& rMat)
     132             :     {
     133           0 :         mpImpl->doAddMatrix(*rMat.mpImpl);
     134           0 :         return *this;
     135             :     }
     136             : 
     137           0 :     B2DHomMatrix& B2DHomMatrix::operator-=(const B2DHomMatrix& rMat)
     138             :     {
     139           0 :         mpImpl->doSubMatrix(*rMat.mpImpl);
     140           0 :         return *this;
     141             :     }
     142             : 
     143           0 :     B2DHomMatrix& B2DHomMatrix::operator*=(double fValue)
     144             :     {
     145           0 :         const double fOne(1.0);
     146             : 
     147           0 :         if(!fTools::equal(fOne, fValue))
     148           0 :             mpImpl->doMulMatrix(fValue);
     149             : 
     150           0 :         return *this;
     151             :     }
     152             : 
     153           0 :     B2DHomMatrix& B2DHomMatrix::operator/=(double fValue)
     154             :     {
     155           0 :         const double fOne(1.0);
     156             : 
     157           0 :         if(!fTools::equal(fOne, fValue))
     158           0 :             mpImpl->doMulMatrix(1.0 / fValue);
     159             : 
     160           0 :         return *this;
     161             :     }
     162             : 
     163           0 :     B2DHomMatrix& B2DHomMatrix::operator*=(const B2DHomMatrix& rMat)
     164             :     {
     165           0 :         if(!rMat.isIdentity())
     166           0 :             mpImpl->doMulMatrix(*rMat.mpImpl);
     167             : 
     168           0 :         return *this;
     169             :     }
     170             : 
     171           0 :     bool B2DHomMatrix::operator==(const B2DHomMatrix& rMat) const
     172             :     {
     173           0 :         if(mpImpl.same_object(rMat.mpImpl))
     174           0 :             return true;
     175             : 
     176           0 :         return mpImpl->isEqual(*rMat.mpImpl);
     177             :     }
     178             : 
     179           0 :     bool B2DHomMatrix::operator!=(const B2DHomMatrix& rMat) const
     180             :     {
     181           0 :         return !(*this == rMat);
     182             :     }
     183             : 
     184           0 :     void B2DHomMatrix::rotate(double fRadiant)
     185             :     {
     186           0 :         if(!fTools::equalZero(fRadiant))
     187             :         {
     188           0 :             double fSin(0.0);
     189           0 :             double fCos(1.0);
     190             : 
     191           0 :             tools::createSinCosOrthogonal(fSin, fCos, fRadiant);
     192           0 :             Impl2DHomMatrix aRotMat;
     193             : 
     194           0 :             aRotMat.set(0, 0, fCos);
     195           0 :             aRotMat.set(1, 1, fCos);
     196           0 :             aRotMat.set(1, 0, fSin);
     197           0 :             aRotMat.set(0, 1, -fSin);
     198             : 
     199           0 :             mpImpl->doMulMatrix(aRotMat);
     200             :         }
     201           0 :     }
     202             : 
     203           0 :     void B2DHomMatrix::translate(double fX, double fY)
     204             :     {
     205           0 :         if(!fTools::equalZero(fX) || !fTools::equalZero(fY))
     206             :         {
     207           0 :             Impl2DHomMatrix aTransMat;
     208             : 
     209           0 :             aTransMat.set(0, 2, fX);
     210           0 :             aTransMat.set(1, 2, fY);
     211             : 
     212           0 :             mpImpl->doMulMatrix(aTransMat);
     213             :         }
     214           0 :     }
     215             : 
     216           0 :     void B2DHomMatrix::scale(double fX, double fY)
     217             :     {
     218           0 :         const double fOne(1.0);
     219             : 
     220           0 :         if(!fTools::equal(fOne, fX) || !fTools::equal(fOne, fY))
     221             :         {
     222           0 :             Impl2DHomMatrix aScaleMat;
     223             : 
     224           0 :             aScaleMat.set(0, 0, fX);
     225           0 :             aScaleMat.set(1, 1, fY);
     226             : 
     227           0 :             mpImpl->doMulMatrix(aScaleMat);
     228             :         }
     229           0 :     }
     230             : 
     231           0 :     void B2DHomMatrix::shearX(double fSx)
     232             :     {
     233             :         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
     234           0 :         if(!fTools::equalZero(fSx))
     235             :         {
     236           0 :             Impl2DHomMatrix aShearXMat;
     237             : 
     238           0 :             aShearXMat.set(0, 1, fSx);
     239             : 
     240           0 :             mpImpl->doMulMatrix(aShearXMat);
     241             :         }
     242           0 :     }
     243             : 
     244           0 :     void B2DHomMatrix::shearY(double fSy)
     245             :     {
     246             :         // #i76239# do not test against 1.0, but against 0.0. We are talking about a value not on the diagonal (!)
     247           0 :         if(!fTools::equalZero(fSy))
     248             :         {
     249           0 :             Impl2DHomMatrix aShearYMat;
     250             : 
     251           0 :             aShearYMat.set(1, 0, fSy);
     252             : 
     253           0 :             mpImpl->doMulMatrix(aShearYMat);
     254             :         }
     255           0 :     }
     256             : 
     257             :     /** Decomposition
     258             : 
     259             :        New, optimized version with local shearX detection. Old version (keeping
     260             :        below, is working well, too) used the 3D matrix decomposition when
     261             :        shear was used. Keeping old version as comment below since it may get
     262             :        necessary to add the determinant() test from there here, too.
     263             :     */
     264           0 :     bool B2DHomMatrix::decompose(B2DTuple& rScale, B2DTuple& rTranslate, double& rRotate, double& rShearX) const
     265             :     {
     266             :         // when perspective is used, decompose is not made here
     267           0 :         if(!mpImpl->isLastLineDefault())
     268             :         {
     269           0 :             return false;
     270             :         }
     271             : 
     272             :         // reset rotate and shear and copy translation values in every case
     273           0 :         rRotate = rShearX = 0.0;
     274           0 :         rTranslate.setX(get(0, 2));
     275           0 :         rTranslate.setY(get(1, 2));
     276             : 
     277             :         // test for rotation and shear
     278           0 :         if(fTools::equalZero(get(0, 1)) && fTools::equalZero(get(1, 0)))
     279             :         {
     280             :             // no rotation and shear, copy scale values
     281           0 :             rScale.setX(get(0, 0));
     282           0 :             rScale.setY(get(1, 1));
     283             : 
     284             :             // or is there?
     285           0 :             if( rScale.getX() < 0 && rScale.getY() < 0 )
     286             :             {
     287             :                 // there is - 180 degree rotated
     288           0 :                 rScale *= -1;
     289           0 :                 rRotate = 180*F_PI180;
     290             :             }
     291             :         }
     292             :         else
     293             :         {
     294             :             // get the unit vectors of the transformation -> the perpendicular vectors
     295           0 :             B2DVector aUnitVecX(get(0, 0), get(1, 0));
     296           0 :             B2DVector aUnitVecY(get(0, 1), get(1, 1));
     297           0 :             const double fScalarXY(aUnitVecX.scalar(aUnitVecY));
     298             : 
     299             :             // Test if shear is zero. That's the case if the unit vectors in the matrix
     300             :             // are perpendicular -> scalar is zero. This is also the case when one of
     301             :             // the unit vectors is zero.
     302           0 :             if(fTools::equalZero(fScalarXY))
     303             :             {
     304             :                 // calculate unsigned scale values
     305           0 :                 rScale.setX(aUnitVecX.getLength());
     306           0 :                 rScale.setY(aUnitVecY.getLength());
     307             : 
     308             :                 // check unit vectors for zero lengths
     309           0 :                 const bool bXIsZero(fTools::equalZero(rScale.getX()));
     310           0 :                 const bool bYIsZero(fTools::equalZero(rScale.getY()));
     311             : 
     312           0 :                 if(bXIsZero || bYIsZero)
     313             :                 {
     314             :                     // still extract as much as possible. Scalings are already set
     315           0 :                     if(!bXIsZero)
     316             :                     {
     317             :                         // get rotation of X-Axis
     318           0 :                         rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
     319             :                     }
     320           0 :                     else if(!bYIsZero)
     321             :                     {
     322             :                         // get rotation of X-Axis. When assuming X and Y perpendicular
     323             :                         // and correct rotation, it's the Y-Axis rotation minus 90 degrees
     324           0 :                         rRotate = atan2(aUnitVecY.getY(), aUnitVecY.getX()) - M_PI_2;
     325             :                     }
     326             : 
     327             :                     // one or both unit vectors do not extist, determinant is zero, no decomposition possible.
     328             :                     // Eventually used rotations or shears are lost
     329           0 :                     return false;
     330             :                 }
     331             :                 else
     332             :                 {
     333             :                     // no shear
     334             :                     // calculate rotation of X unit vector relative to (1, 0)
     335           0 :                     rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
     336             : 
     337             :                     // use orientation to evtl. correct sign of Y-Scale
     338           0 :                     const double fCrossXY(aUnitVecX.cross(aUnitVecY));
     339             : 
     340           0 :                     if(fCrossXY < 0.0)
     341             :                     {
     342           0 :                         rScale.setY(-rScale.getY());
     343             :                     }
     344             :                 }
     345             :             }
     346             :             else
     347             :             {
     348             :                 // fScalarXY is not zero, thus both unit vectors exist. No need to handle that here
     349             :                 // shear, extract it
     350           0 :                 double fCrossXY(aUnitVecX.cross(aUnitVecY));
     351             : 
     352             :                 // get rotation by calculating angle of X unit vector relative to (1, 0).
     353             :                 // This is before the parallell test following the motto to extract
     354             :                 // as much as possible
     355           0 :                 rRotate = atan2(aUnitVecX.getY(), aUnitVecX.getX());
     356             : 
     357             :                 // get unsigned scale value for X. It will not change and is useful
     358             :                 // for further corrections
     359           0 :                 rScale.setX(aUnitVecX.getLength());
     360             : 
     361           0 :                 if(fTools::equalZero(fCrossXY))
     362             :                 {
     363             :                     // extract as much as possible
     364           0 :                     rScale.setY(aUnitVecY.getLength());
     365             : 
     366             :                     // unit vectors are parallel, thus not linear independent. No
     367             :                     // useful decomposition possible. This should not happen since
     368             :                     // the only way to get the unit vectors nearly parallell is
     369             :                     // a very big shearing. Anyways, be prepared for hand-filled
     370             :                     // matrices
     371             :                     // Eventually used rotations or shears are lost
     372           0 :                     return false;
     373             :                 }
     374             :                 else
     375             :                 {
     376             :                     // calculate the contained shear
     377           0 :                     rShearX = fScalarXY / fCrossXY;
     378             : 
     379           0 :                     if(!fTools::equalZero(rRotate))
     380             :                     {
     381             :                         // To be able to correct the shear for aUnitVecY, rotation needs to be
     382             :                         // removed first. Correction of aUnitVecX is easy, it will be rotated back to (1, 0).
     383           0 :                         aUnitVecX.setX(rScale.getX());
     384           0 :                         aUnitVecX.setY(0.0);
     385             : 
     386             :                         // for Y correction we rotate the UnitVecY back about -rRotate
     387           0 :                         const double fNegRotate(-rRotate);
     388           0 :                         const double fSin(sin(fNegRotate));
     389           0 :                         const double fCos(cos(fNegRotate));
     390             : 
     391           0 :                         const double fNewX(aUnitVecY.getX() * fCos - aUnitVecY.getY() * fSin);
     392           0 :                         const double fNewY(aUnitVecY.getX() * fSin + aUnitVecY.getY() * fCos);
     393             : 
     394           0 :                         aUnitVecY.setX(fNewX);
     395           0 :                         aUnitVecY.setY(fNewY);
     396             :                     }
     397             : 
     398             :                     // Correct aUnitVecY and fCrossXY to fShear=0. Rotation is already removed.
     399             :                     // Shear correction can only work with removed rotation
     400           0 :                     aUnitVecY.setX(aUnitVecY.getX() - (aUnitVecY.getY() * rShearX));
     401           0 :                     fCrossXY = aUnitVecX.cross(aUnitVecY);
     402             : 
     403             :                     // calculate unsigned scale value for Y, after the corrections since
     404             :                     // the shear correction WILL change the length of aUnitVecY
     405           0 :                     rScale.setY(aUnitVecY.getLength());
     406             : 
     407             :                     // use orientation to set sign of Y-Scale
     408           0 :                     if(fCrossXY < 0.0)
     409             :                     {
     410           0 :                         rScale.setY(-rScale.getY());
     411             :                     }
     412             :                 }
     413           0 :             }
     414             :         }
     415             : 
     416           0 :         return true;
     417             :     }
     418             : } // end of namespace basegfx
     419             : 
     420             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10