third_party/WebKit/Source/platform/transforms/AffineTransform.cpp

   1 /*
   2  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
   3  *               2010 Dirk Schulze <krit@webkit.org>
   4  * Copyright (C) 2013 Google Inc. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "config.h"
  29 #include "platform/transforms/AffineTransform.h"
  30
  31 #include "platform/FloatConversion.h"
  32 #include "platform/geometry/FloatQuad.h"
  33 #include "platform/geometry/FloatRect.h"
  34 #include "platform/geometry/IntRect.h"
  35 #include "wtf/MathExtras.h"
  36
  37 namespace blink {
  38
  39 AffineTransform::AffineTransform()
  40 {
  41     setMatrix(1, 0, 0, 1, 0, 0);
  42 }
  43
  44 AffineTransform::AffineTransform(double a, double b, double c, double d, double e, double f)
  45 {
  46     setMatrix(a, b, c, d, e, f);
  47 }
  48
  49 void AffineTransform::makeIdentity()
  50 {
  51     setMatrix(1, 0, 0, 1, 0, 0);
  52 }
  53
  54 void AffineTransform::setMatrix(double a, double b, double c, double d, double e, double f)
  55 {
  56     m_transform[0] = a;
  57     m_transform[1] = b;
  58     m_transform[2] = c;
  59     m_transform[3] = d;
  60     m_transform[4] = e;
  61     m_transform[5] = f;
  62 }
  63
  64 bool AffineTransform::isIdentity() const
  65 {
  66     return (m_transform[0] == 1 && m_transform[1] == 0
  67          && m_transform[2] == 0 && m_transform[3] == 1
  68          && m_transform[4] == 0 && m_transform[5] == 0);
  69 }
  70
  71 double AffineTransform::xScale() const
  72 {
  73     return sqrt(m_transform[0] * m_transform[0] + m_transform[1] * m_transform[1]);
  74 }
  75
  76 double AffineTransform::yScale() const
  77 {
  78     return sqrt(m_transform[2] * m_transform[2] + m_transform[3] * m_transform[3]);
  79 }
  80
  81 double AffineTransform::det() const
  82 {
  83     return m_transform[0] * m_transform[3] - m_transform[1] * m_transform[2];
  84 }
  85
  86 bool AffineTransform::isInvertible() const
  87 {
  88     return det() != 0.0;
  89 }
  90
  91 AffineTransform AffineTransform::inverse() const
  92 {
  93     double determinant = det();
  94     if (determinant == 0.0)
  95         return AffineTransform();
  96
  97     AffineTransform result;
  98     if (isIdentityOrTranslation()) {
  99         result.m_transform[4] = -m_transform[4];
 100         result.m_transform[5] = -m_transform[5];
 101         return result;
 102     }
 103
 104     result.m_transform[0] = m_transform[3] / determinant;
 105     result.m_transform[1] = -m_transform[1] / determinant;
 106     result.m_transform[2] = -m_transform[2] / determinant;
 107     result.m_transform[3] = m_transform[0] / determinant;
 108     result.m_transform[4] = (m_transform[2] * m_transform[5]
 109                            - m_transform[3] * m_transform[4]) / determinant;
 110     result.m_transform[5] = (m_transform[1] * m_transform[4]
 111                            - m_transform[0] * m_transform[5]) / determinant;
 112
 113     return result;
 114 }
 115
 116 namespace {
 117
 118 // res = t1 * t2
 119 inline void doMultiply(const AffineTransform& t1, const AffineTransform& t2, AffineTransform* res)
 120 {
 121     res->setA(t1.a() * t2.a() + t1.c() * t2.b());
 122     res->setB(t1.b() * t2.a() + t1.d() * t2.b());
 123     res->setC(t1.a() * t2.c() + t1.c() * t2.d());
 124     res->setD(t1.b() * t2.c() + t1.d() * t2.d());
 125     res->setE(t1.a() * t2.e() + t1.c() * t2.f() + t1.e());
 126     res->setF(t1.b() * t2.e() + t1.d() * t2.f() + t1.f());
 127 }
 128
 129 } // anonymous namespace
 130
 131 AffineTransform& AffineTransform::multiply(const AffineTransform& other)
 132 {
 133     if (other.isIdentityOrTranslation()) {
 134         if (other.m_transform[4] || other.m_transform[5])
 135             translate(other.m_transform[4], other.m_transform[5]);
 136         return *this;
 137     }
 138
 139     AffineTransform trans;
 140     doMultiply(*this, other, &trans);
 141     setMatrix(trans.m_transform);
 142
 143     return *this;
 144 }
 145
 146 AffineTransform& AffineTransform::preMultiply(const AffineTransform& other)
 147 {
 148     if (other.isIdentityOrTranslation()) {
 149         if (other.m_transform[4] || other.m_transform[5]) {
 150             m_transform[4] += other.m_transform[4];
 151             m_transform[5] += other.m_transform[5];
 152         }
 153         return *this;
 154     }
 155
 156     AffineTransform trans;
 157     doMultiply(other, *this, &trans);
 158     setMatrix(trans.m_transform);
 159
 160     return *this;
 161 }
 162
 163 AffineTransform& AffineTransform::rotate(double a)
 164 {
 165     // angle is in degree. Switch to radian
 166     return rotateRadians(deg2rad(a));
 167 }
 168
 169 AffineTransform& AffineTransform::rotateRadians(double a)
 170 {
 171     double cosAngle = cos(a);
 172     double sinAngle = sin(a);
 173     AffineTransform rot(cosAngle, sinAngle, -sinAngle, cosAngle, 0, 0);
 174
 175     multiply(rot);
 176     return *this;
 177 }
 178
 179 AffineTransform& AffineTransform::scale(double s)
 180 {
 181     return scale(s, s);
 182 }
 183
 184 AffineTransform& AffineTransform::scale(double sx, double sy)
 185 {
 186     m_transform[0] *= sx;
 187     m_transform[1] *= sx;
 188     m_transform[2] *= sy;
 189     m_transform[3] *= sy;
 190     return *this;
 191 }
 192
 193 // *this = *this * translation
 194 AffineTransform& AffineTransform::translate(double tx, double ty)
 195 {
 196     if (isIdentityOrTranslation()) {
 197         m_transform[4] += tx;
 198         m_transform[5] += ty;
 199         return *this;
 200     }
 201
 202     m_transform[4] += tx * m_transform[0] + ty * m_transform[2];
 203     m_transform[5] += tx * m_transform[1] + ty * m_transform[3];
 204     return *this;
 205 }
 206
 207 AffineTransform& AffineTransform::scaleNonUniform(double sx, double sy)
 208 {
 209     return scale(sx, sy);
 210 }
 211
 212 AffineTransform& AffineTransform::rotateFromVector(double x, double y)
 213 {
 214     return rotateRadians(atan2(y, x));
 215 }
 216
 217 AffineTransform& AffineTransform::flipX()
 218 {
 219     return scale(-1, 1);
 220 }
 221
 222 AffineTransform& AffineTransform::flipY()
 223 {
 224     return scale(1, -1);
 225 }
 226
 227 AffineTransform& AffineTransform::shear(double sx, double sy)
 228 {
 229     double a = m_transform[0];
 230     double b = m_transform[1];
 231
 232     m_transform[0] += sy * m_transform[2];
 233     m_transform[1] += sy * m_transform[3];
 234     m_transform[2] += sx * a;
 235     m_transform[3] += sx * b;
 236
 237     return *this;
 238 }
 239
 240 AffineTransform& AffineTransform::skew(double angleX, double angleY)
 241 {
 242     return shear(tan(deg2rad(angleX)), tan(deg2rad(angleY)));
 243 }
 244
 245 AffineTransform& AffineTransform::skewX(double angle)
 246 {
 247     return shear(tan(deg2rad(angle)), 0);
 248 }
 249
 250 AffineTransform& AffineTransform::skewY(double angle)
 251 {
 252     return shear(0, tan(deg2rad(angle)));
 253 }
 254
 255 void AffineTransform::map(double x, double y, double& x2, double& y2) const
 256 {
 257     x2 = (m_transform[0] * x + m_transform[2] * y + m_transform[4]);
 258     y2 = (m_transform[1] * x + m_transform[3] * y + m_transform[5]);
 259 }
 260
 261 IntPoint AffineTransform::mapPoint(const IntPoint& point) const
 262 {
 263     double x2, y2;
 264     map(point.x(), point.y(), x2, y2);
 265
 266     // Round the point.
 267     return IntPoint(lround(x2), lround(y2));
 268 }
 269
 270 FloatPoint AffineTransform::mapPoint(const FloatPoint& point) const
 271 {
 272     double x2, y2;
 273     map(point.x(), point.y(), x2, y2);
 274
 275     return FloatPoint(narrowPrecisionToFloat(x2), narrowPrecisionToFloat(y2));
 276 }
 277
 278 IntSize AffineTransform::mapSize(const IntSize& size) const
 279 {
 280     double width2 = size.width() * xScale();
 281     double height2 = size.height() * yScale();
 282
 283     return IntSize(lround(width2), lround(height2));
 284 }
 285
 286 FloatSize AffineTransform::mapSize(const FloatSize& size) const
 287 {
 288     double width2 = size.width() * xScale();
 289     double height2 = size.height() * yScale();
 290
 291     return FloatSize(narrowPrecisionToFloat(width2), narrowPrecisionToFloat(height2));
 292 }
 293
 294 IntRect AffineTransform::mapRect(const IntRect &rect) const
 295 {
 296     return enclosingIntRect(mapRect(FloatRect(rect)));
 297 }
 298
 299 FloatRect AffineTransform::mapRect(const FloatRect& rect) const
 300 {
 301     if (isIdentityOrTranslation()) {
 302         if (!m_transform[4] && !m_transform[5])
 303             return rect;
 304
 305         FloatRect mappedRect(rect);
 306         mappedRect.move(narrowPrecisionToFloat(m_transform[4]), narrowPrecisionToFloat(m_transform[5]));
 307         return mappedRect;
 308     }
 309
 310     FloatQuad result;
 311     result.setP1(mapPoint(rect.location()));
 312     result.setP2(mapPoint(FloatPoint(rect.maxX(), rect.y())));
 313     result.setP3(mapPoint(FloatPoint(rect.maxX(), rect.maxY())));
 314     result.setP4(mapPoint(FloatPoint(rect.x(), rect.maxY())));
 315     return result.boundingBox();
 316 }
 317
 318 FloatQuad AffineTransform::mapQuad(const FloatQuad& q) const
 319 {
 320     if (isIdentityOrTranslation()) {
 321         FloatQuad mappedQuad(q);
 322         mappedQuad.move(narrowPrecisionToFloat(m_transform[4]), narrowPrecisionToFloat(m_transform[5]));
 323         return mappedQuad;
 324     }
 325
 326     FloatQuad result;
 327     result.setP1(mapPoint(q.p1()));
 328     result.setP2(mapPoint(q.p2()));
 329     result.setP3(mapPoint(q.p3()));
 330     result.setP4(mapPoint(q.p4()));
 331     return result;
 332 }
 333
 334 TransformationMatrix AffineTransform::toTransformationMatrix() const
 335 {
 336     return TransformationMatrix(m_transform[0], m_transform[1], m_transform[2],
 337                                 m_transform[3], m_transform[4], m_transform[5]);
 338 }
 339
 340 bool AffineTransform::decompose(DecomposedType& decomp) const
 341 {
 342     AffineTransform m(*this);
 343
 344     // Compute scaling factors
 345     double sx = xScale();
 346     double sy = yScale();
 347
 348     // Compute cross product of transformed unit vectors. If negative,
 349     // one axis was flipped.
 350     if (m.a() * m.d() - m.c() * m.b() < 0) {
 351         // Flip axis with minimum unit vector dot product
 352         if (m.a() < m.d())
 353             sx = -sx;
 354         else
 355             sy = -sy;
 356     }
 357
 358     // Remove scale from matrix
 359     m.scale(1 / sx, 1 / sy);
 360
 361     // Compute rotation
 362     double angle = atan2(m.b(), m.a());
 363
 364     // Remove rotation from matrix
 365     m.rotateRadians(-angle);
 366
 367     // Return results
 368     decomp.scaleX = sx;
 369     decomp.scaleY = sy;
 370     decomp.angle = angle;
 371     decomp.remainderA = m.a();
 372     decomp.remainderB = m.b();
 373     decomp.remainderC = m.c();
 374     decomp.remainderD = m.d();
 375     decomp.translateX = m.e();
 376     decomp.translateY = m.f();
 377
 378     return true;
 379 }
 380
 381 void AffineTransform::recompose(const DecomposedType& decomp)
 382 {
 383     this->setA(decomp.remainderA);
 384     this->setB(decomp.remainderB);
 385     this->setC(decomp.remainderC);
 386     this->setD(decomp.remainderD);
 387     this->setE(decomp.translateX);
 388     this->setF(decomp.translateY);
 389     this->rotateRadians(decomp.angle);
 390     this->scale(decomp.scaleX, decomp.scaleY);
 391 }
 392
 393 }