include/basegfx/matrix/b2dhommatrixtools.hxx

   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 #ifndef INCLUDED_BASEGFX_MATRIX_B2DHOMMATRIXTOOLS_HXX
  21 #define INCLUDED_BASEGFX_MATRIX_B2DHOMMATRIXTOOLS_HXX
  22
  23 #include <sal/types.h>
  24 #include <basegfx/matrix/b2dhommatrix.hxx>
  25 #include <basegfx/vector/b2dvector.hxx>
  26 #include <basegfx/range/b2drange.hxx>
  27 #include <basegfx/basegfxdllapi.h>
  28
  29
  30 namespace basegfx
  31 {
  32     namespace tools
  33     {
  34         /** If the rotation angle is an approximate multiple of pi/2,
  35             force fSin/fCos to -1/0/1, to maintain orthogonality (which
  36             might also be advantageous for the other cases, but: for
  37             multiples of pi/2, the exact values _can_ be attained. It
  38             would be largely unintuitive, if a 180 degrees rotation
  39             would introduce slight roundoff errors, instead of exactly
  40             mirroring the coordinate system)
  41          */
  42         BASEGFX_DLLPUBLIC void createSinCosOrthogonal(double& o_rSin, double& rCos, double fRadiant);
  43
  44         /** Tooling methods for on-the-fly matrix generation e.g. for inline
  45             multiplications
  46          */
  47         BASEGFX_DLLPUBLIC B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY);
  48         BASEGFX_DLLPUBLIC B2DHomMatrix createShearXB2DHomMatrix(double fShearX);
  49         BASEGFX_DLLPUBLIC B2DHomMatrix createShearYB2DHomMatrix(double fShearY);
  50         BASEGFX_DLLPUBLIC B2DHomMatrix createRotateB2DHomMatrix(double fRadiant);
  51         BASEGFX_DLLPUBLIC B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY);
  52
  53         /// inline versions for parameters as tuples
  54         inline B2DHomMatrix createScaleB2DHomMatrix(const B2DTuple& rScale)
  55         {
  56             return createScaleB2DHomMatrix(rScale.getX(), rScale.getY());
  57         }
  58
  59         inline B2DHomMatrix createTranslateB2DHomMatrix(const B2DTuple& rTranslate)
  60         {
  61             return createTranslateB2DHomMatrix(rTranslate.getX(), rTranslate.getY());
  62         }
  63
  64         /** Tooling methods for faster completely combined matrix creation
  65             when scale, shearX, rotation and translation needs to be done in
  66             exactly that order. It's faster since it direcly calculates
  67             each matrix value based on a symbolic calculation of the three
  68             matrix multiplications.
  69             Inline versions for parameters as tuples added, too.
  70          */
  71         BASEGFX_DLLPUBLIC B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
  72             double fScaleX, double fScaleY,
  73             double fShearX,
  74             double fRadiant,
  75             double fTranslateX, double fTranslateY);
  76         inline B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
  77             const B2DTuple& rScale,
  78             double fShearX,
  79             double fRadiant,
  80             const B2DTuple& rTranslate)
  81         {
  82             return createScaleShearXRotateTranslateB2DHomMatrix(
  83                 rScale.getX(), rScale.getY(),
  84                 fShearX,
  85                 fRadiant,
  86                 rTranslate.getX(), rTranslate.getY());
  87         }
  88
  89         BASEGFX_DLLPUBLIC B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
  90             double fShearX,
  91             double fRadiant,
  92             double fTranslateX, double fTranslateY);
  93         inline B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
  94             double fShearX,
  95             double fRadiant,
  96             const B2DTuple& rTranslate)
  97         {
  98             return createShearXRotateTranslateB2DHomMatrix(
  99                 fShearX,
 100                 fRadiant,
 101                 rTranslate.getX(), rTranslate.getY());
 102         }
 103
 104         BASEGFX_DLLPUBLIC B2DHomMatrix createScaleTranslateB2DHomMatrix(
 105             double fScaleX, double fScaleY,
 106             double fTranslateX, double fTranslateY);
 107         inline B2DHomMatrix createScaleTranslateB2DHomMatrix(
 108             const B2DTuple& rScale,
 109             const B2DTuple& rTranslate)
 110         {
 111             return createScaleTranslateB2DHomMatrix(
 112                 rScale.getX(), rScale.getY(),
 113                 rTranslate.getX(), rTranslate.getY());
 114         }
 115
 116         /// special for the often used case of rotation around a point
 117         BASEGFX_DLLPUBLIC B2DHomMatrix createRotateAroundPoint(
 118             double fPointX, double fPointY,
 119             double fRadiant);
 120         inline B2DHomMatrix createRotateAroundPoint(
 121             const B2DTuple& rPoint,
 122             double fRadiant)
 123         {
 124             return createRotateAroundPoint(
 125                 rPoint.getX(), rPoint.getY(),
 126                 fRadiant);
 127         }
 128
 129         /// special for the case to map from source range to target range
 130         BASEGFX_DLLPUBLIC B2DHomMatrix createSourceRangeTargetRangeTransform(
 131             const B2DRange& rSourceRange,
 132             const B2DRange& rTargetRange);
 133
 134     } // end of namespace tools
 135 } // end of namespace basegfx
 136
 137
 138 namespace basegfx
 139 {
 140     namespace tools
 141     {
 142         class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedDecompose
 143         {
 144         private:
 145             B2DVector              maScale;
 146             B2DVector              maTranslate;
 147             double                 mfRotate;
 148             double                 mfShearX;
 149
 150         public:
 151             B2DHomMatrixBufferedDecompose(const B2DHomMatrix& rB2DHomMatrix = B2DHomMatrix())
 152             :   maScale(),
 153                 maTranslate(),
 154                 mfRotate(0.0),
 155                 mfShearX(0.0)
 156             {
 157                 rB2DHomMatrix.decompose(maScale, maTranslate, mfRotate, mfShearX);
 158             }
 159
 160             // data access
 161             B2DHomMatrix getB2DHomMatrix() const
 162             {
 163                 return createScaleShearXRotateTranslateB2DHomMatrix(
 164                     maScale, mfShearX, mfRotate, maTranslate);
 165             }
 166
 167             const B2DVector& getScale() const { return maScale; }
 168             const B2DVector& getTranslate() const { return maTranslate; }
 169             double getRotate() const { return mfRotate; }
 170             double getShearX() const { return mfShearX; }
 171         };
 172     } // end of namespace tools
 173 } // end of namespace basegfx
 174
 175
 176 namespace basegfx
 177 {
 178     namespace tools
 179     {
 180         class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedOnDemandDecompose
 181         {
 182         private:
 183             B2DHomMatrix           maB2DHomMatrix;
 184             B2DVector              maScale;
 185             B2DVector              maTranslate;
 186             double                 mfRotate;
 187             double                 mfShearX;
 188
 189             bool                   mbDecomposed : 1;
 190
 191             void impCheckDecompose()
 192             {
 193                 if(!mbDecomposed)
 194                 {
 195                     maB2DHomMatrix.decompose(maScale, maTranslate, mfRotate, mfShearX);
 196                     mbDecomposed = true;
 197                 }
 198             }
 199
 200         public:
 201             B2DHomMatrixBufferedOnDemandDecompose(const B2DHomMatrix& rB2DHomMatrix = B2DHomMatrix())
 202             :   maB2DHomMatrix(rB2DHomMatrix),
 203                 maScale(),
 204                 maTranslate(),
 205                 mfRotate(0.0),
 206                 mfShearX(0.0),
 207                 mbDecomposed(false)
 208             {
 209             }
 210
 211             // data access
 212             const B2DHomMatrix& getB2DHomMatrix() const { return maB2DHomMatrix; }
 213             const B2DVector& getScale() const { const_cast< B2DHomMatrixBufferedOnDemandDecompose* >(this)->impCheckDecompose(); return maScale; }
 214             const B2DVector& getTranslate() const { const_cast< B2DHomMatrixBufferedOnDemandDecompose* >(this)->impCheckDecompose(); return maTranslate; }
 215             double getRotate() const { const_cast< B2DHomMatrixBufferedOnDemandDecompose* >(this)->impCheckDecompose(); return mfRotate; }
 216         };
 217     } // end of namespace tools
 218
 219 } // end of namespace basegfx
 220
 221
 222 #endif // INCLUDED_BASEGFX_MATRIX_B2DHOMMATRIXTOOLS_HXX
 223
 224 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */