gfx/thebes/gfxMatrix.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef GFX_MATRIX_H
   7 #define GFX_MATRIX_H
   8
   9 #include "gfxPoint.h"
  10 #include "gfxTypes.h"
  11 #include "gfxRect.h"
  12
  13 // XX - I don't think this class should use gfxFloat at all,
  14 // but should use 'double' and be called gfxDoubleMatrix;
  15 // we can then typedef that to gfxMatrix where we typedef
  16 // double to be gfxFloat.
  17
  18 /**
  19  * A matrix that represents an affine transformation. Projective
  20  * transformations are not supported. This matrix looks like:
  21  *
  22  * / a  b  0 \
  23  * | c  d  0 |
  24  * \ tx ty 1 /
  25  *
  26  * So, transforming a point (x, y) results in:
  27  *
  28  *           / a  b  0 \   / a * x + c * y + tx \ T
  29  * (x y 1) * | c  d  0 | = | b * x + d * y + ty |
  30  *           \ tx ty 1 /   \         1          /
  31  *
  32  */
  33 class gfxMatrix {
  34 public:
  35     double _11; double _12;
  36     double _21; double _22;
  37     double _31; double _32;
  38
  39     /**
  40      * Initializes this matrix as the identity matrix.
  41      */
  42     gfxMatrix() { Reset(); }
  43
  44     /**
  45      * Initializes the matrix from individual components. See the class
  46      * description for the layout of the matrix.
  47      */
  48     gfxMatrix(gfxFloat a, gfxFloat b, gfxFloat c, gfxFloat d, gfxFloat tx, gfxFloat ty) :
  49         _11(a),  _12(b),
  50         _21(c),  _22(d),
  51         _31(tx), _32(ty) { }
  52
  53     friend std::ostream& operator<<(std::ostream& stream, const gfxMatrix& m) {
  54       if (m.IsIdentity()) {
  55         return stream << "[identity]";
  56       }
  57
  58       return stream << "["
  59              << m._11 << " " << m._12
  60              << m._21 << " " << m._22
  61              << m._31 << " " << m._32
  62              << "]";
  63     }
  64
  65     /**
  66      * Post-multiplies m onto the matrix.
  67      */
  68     const gfxMatrix& operator *= (const gfxMatrix& m);
  69
  70     /**
  71      * Multiplies *this with m and returns the result.
  72      */
  73     gfxMatrix operator * (const gfxMatrix& m) const {
  74         return gfxMatrix(*this) *= m;
  75     }
  76
  77     /* Returns true if the other matrix is fuzzy-equal to this matrix.
  78      * Note that this isn't a cheap comparison!
  79      */
  80     bool operator==(const gfxMatrix& other) const
  81     {
  82       return FuzzyEqual(_11, other._11) && FuzzyEqual(_12, other._12) &&
  83              FuzzyEqual(_21, other._21) && FuzzyEqual(_22, other._22) &&
  84              FuzzyEqual(_31, other._31) && FuzzyEqual(_32, other._32);
  85     }
  86
  87     bool operator!=(const gfxMatrix& other) const
  88     {
  89       return !(*this == other);
  90     }
  91
  92     // matrix operations
  93     /**
  94      * Resets this matrix to the identity matrix.
  95      */
  96     const gfxMatrix& Reset();
  97
  98     bool IsIdentity() const {
  99        return _11 == 1.0 && _12 == 0.0 &&
 100               _21 == 0.0 && _22 == 1.0 &&
 101               _31 == 0.0 && _32 == 0.0;
 102     }
 103
 104     /**
 105      * Inverts this matrix, if possible. Otherwise, the matrix is left
 106      * unchanged.
 107      *
 108      * XXX should this do something with the return value of
 109      * cairo_matrix_invert?
 110      */
 111     bool Invert();
 112
 113     /**
 114      * Check if matrix is singular (no inverse exists).
 115      */
 116     bool IsSingular() const {
 117         // if the determinant (ad - bc) is zero it's singular
 118         return (_11 * _22) == (_12 * _21);
 119     }
 120
 121     /**
 122      * Scales this matrix. The scale is pre-multiplied onto this matrix,
 123      * i.e. the scaling takes place before the other transformations.
 124      */
 125     const gfxMatrix& Scale(gfxFloat x, gfxFloat y);
 126
 127     /**
 128      * Translates this matrix. The translation is pre-multiplied onto this matrix,
 129      * i.e. the translation takes place before the other transformations.
 130      */
 131     const gfxMatrix& Translate(const gfxPoint& pt);
 132
 133     /**
 134      * Rotates this matrix. The rotation is pre-multiplied onto this matrix,
 135      * i.e. the translation takes place after the other transformations.
 136      *
 137      * @param radians Angle in radians.
 138      */
 139     const gfxMatrix& Rotate(gfxFloat radians);
 140
 141     /**
 142      * Multiplies the current matrix with m.
 143      * This is a pre-multiplication, i.e. the transformations of m are
 144      * applied _before_ the existing transformations.
 145      */
 146     const gfxMatrix& PreMultiply(const gfxMatrix& m);
 147
 148     static gfxMatrix Translation(gfxFloat aX, gfxFloat aY)
 149     {
 150         return gfxMatrix(1.0, 0.0, 0.0, 1.0, aX, aY);
 151     }
 152
 153     static gfxMatrix Translation(gfxPoint aPoint)
 154     {
 155         return Translation(aPoint.x, aPoint.y);
 156     }
 157
 158     static gfxMatrix Rotation(gfxFloat aAngle);
 159
 160     static gfxMatrix Scaling(gfxFloat aX, gfxFloat aY)
 161     {
 162         return gfxMatrix(aX, 0.0, 0.0, aY, 0.0, 0.0);
 163     }
 164
 165     /**
 166      * Transforms a point according to this matrix.
 167      */
 168     gfxPoint Transform(const gfxPoint& point) const;
 169
 170
 171     /**
 172      * Transform a distance according to this matrix. This does not apply
 173      * any translation components.
 174      */
 175     gfxSize Transform(const gfxSize& size) const;
 176
 177     /**
 178      * Transforms both the point and distance according to this matrix.
 179      */
 180     gfxRect Transform(const gfxRect& rect) const;
 181
 182     gfxRect TransformBounds(const gfxRect& rect) const;
 183
 184     /**
 185      * Returns the translation component of this matrix.
 186      */
 187     gfxPoint GetTranslation() const {
 188         return gfxPoint(_31, _32);
 189     }
 190
 191     /**
 192      * Returns true if the matrix is anything other than a straight
 193      * translation by integers.
 194      */
 195     bool HasNonIntegerTranslation() const {
 196         return HasNonTranslation() ||
 197             !FuzzyEqual(_31, floor(_31 + 0.5)) ||
 198             !FuzzyEqual(_32, floor(_32 + 0.5));
 199     }
 200
 201     /**
 202      * Returns true if the matrix has any transform other
 203      * than a straight translation
 204      */
 205     bool HasNonTranslation() const {
 206         return !FuzzyEqual(_11, 1.0) || !FuzzyEqual(_22, 1.0) ||
 207                !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
 208     }
 209
 210     /**
 211      * Returns true if the matrix only has an integer translation.
 212      */
 213     bool HasOnlyIntegerTranslation() const {
 214         return !HasNonIntegerTranslation();
 215     }
 216
 217     /**
 218      * Returns true if the matrix has any transform other
 219      * than a translation or a -1 y scale (y axis flip)
 220      */
 221     bool HasNonTranslationOrFlip() const {
 222         return !FuzzyEqual(_11, 1.0) ||
 223                (!FuzzyEqual(_22, 1.0) && !FuzzyEqual(_22, -1.0)) ||
 224                !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
 225     }
 226
 227     /**
 228      * Returns true if the matrix has any transform other
 229      * than a translation or scale; this is, if there is
 230      * no rotation.
 231      */
 232     bool HasNonAxisAlignedTransform() const {
 233         return !FuzzyEqual(_21, 0.0) || !FuzzyEqual(_12, 0.0);
 234     }
 235
 236     /**
 237      * Computes the determinant of this matrix.
 238      */
 239     double Determinant() const {
 240         return _11*_22 - _12*_21;
 241     }
 242
 243     /* Computes the scale factors of this matrix; that is,
 244      * the amounts each basis vector is scaled by.
 245      * The xMajor parameter indicates if the larger scale is
 246      * to be assumed to be in the X direction or not.
 247      */
 248     gfxSize ScaleFactors(bool xMajor) const {
 249         double det = Determinant();
 250
 251         if (det == 0.0)
 252             return gfxSize(0.0, 0.0);
 253
 254         gfxSize sz = xMajor ? gfxSize(1.0, 0.0) : gfxSize(0.0, 1.0);
 255         sz = Transform(sz);
 256
 257         double major = sqrt(sz.width * sz.width + sz.height * sz.height);
 258         double minor = 0.0;
 259
 260         // ignore mirroring
 261         if (det < 0.0)
 262             det = - det;
 263
 264         if (major)
 265             minor = det / major;
 266
 267         if (xMajor)
 268             return gfxSize(major, minor);
 269
 270         return gfxSize(minor, major);
 271     }
 272
 273     /**
 274      * Snap matrix components that are close to integers
 275      * to integers. In particular, components that are integral when
 276      * converted to single precision are set to those integers.
 277      */
 278     void NudgeToIntegers(void);
 279
 280     /**
 281      * Returns true if matrix is multiple of 90 degrees rotation with flipping,
 282      * scaling and translation.
 283      */
 284     bool PreservesAxisAlignedRectangles() const {
 285         return ((FuzzyEqual(_11, 0.0) && FuzzyEqual(_22, 0.0))
 286             || (FuzzyEqual(_21, 0.0) && FuzzyEqual(_12, 0.0)));
 287     }
 288
 289 private:
 290     static bool FuzzyEqual(gfxFloat aV1, gfxFloat aV2) {
 291         return fabs(aV2 - aV1) < 1e-6;
 292     }
 293 };
 294
 295 #endif /* GFX_MATRIX_H */