Source/WebCore/platform/graphics/transforms/AffineTransform.cpp

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