SkMatrix.cpp File Reference

#include "include/core/SkMatrix.h"
#include "include/core/SkPath.h"
#include "include/core/SkPoint3.h"
#include "include/core/SkRSXform.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkFloatBits.h"
#include "src/base/SkVx.h"
#include "src/core/SkMatrixPriv.h"
#include "src/core/SkMatrixUtils.h"
#include "src/core/SkSamplingPriv.h"
#include <algorithm>
#include <cmath>

Go to the source code of this file.

Typedefs
typedef bool(*	PolyMapProc) (const SkPoint[], SkMatrix *)

Enumerations
enum	{   kTranslate_Shift , kScale_Shift , kAffine_Shift , kPerspective_Shift ,   kRectStaysRect_Shift }
enum	MinMaxOrBoth { kMin_MinMaxOrBoth , kMax_MinMaxOrBoth , kBoth_MinMaxOrBoth }

Functions
bool	operator== (const SkMatrix &a, const SkMatrix &b)
static bool	is_degenerate_2x2 (SkScalar scaleX, SkScalar skewX, SkScalar skewY, SkScalar scaleY)
static SkScalar	sdot (SkScalar a, SkScalar b, SkScalar c, SkScalar d)
static SkScalar	sdot (SkScalar a, SkScalar b, SkScalar c, SkScalar d, SkScalar e, SkScalar f)
static SkScalar	scross (SkScalar a, SkScalar b, SkScalar c, SkScalar d)
static float	muladdmul (float a, float b, float c, float d)
static float	rowcol3 (const float row[], const float col[])
static bool	only_scale_and_translate (unsigned mask)
static SkScalar	scross_dscale (SkScalar a, SkScalar b, SkScalar c, SkScalar d, double scale)
static double	dcross (double a, double b, double c, double d)
static SkScalar	dcross_dscale (double a, double b, double c, double d, double scale)
static double	sk_determinant (const float mat[9], int isPerspective)
static double	sk_inv_determinant (const float mat[9], int isPerspective)
static skvx::float4	sort_as_rect (const skvx::float4 &ltrb)
static bool	checkForZero (float x)
template<MinMaxOrBoth MIN_MAX_OR_BOTH>
bool	get_scale_factor (SkMatrix::TypeMask typeMask, const SkScalar m[9], SkScalar results[])
bool	SkTreatAsSprite (const SkMatrix &mat, const SkISize &size, const SkSamplingOptions &sampling, bool isAntiAlias)
bool	SkDecomposeUpper2x2 (const SkMatrix &matrix, SkPoint *rotation1, SkPoint *scale, SkPoint *rotation2)

Variables
static const int32_t	kScalar1Int = 0x3f800000

Typedef Documentation

PolyMapProc

typedef bool(* PolyMapProc) (const SkPoint[], SkMatrix *)

Definition at line 1381 of file SkMatrix.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kTranslate_Shift
kScale_Shift
kAffine_Shift
kPerspective_Shift
kRectStaysRect_Shift

Definition at line 72 of file SkMatrix.cpp.

     {
    kTranslate_Shift,
    kScale_Shift,
    kAffine_Shift,
    kPerspective_Shift,
    kRectStaysRect_Shift
};

MinMaxOrBoth

enum MinMaxOrBoth

Enumerator
kMin_MinMaxOrBoth
kMax_MinMaxOrBoth
kBoth_MinMaxOrBoth

Definition at line 1422 of file SkMatrix.cpp.

                  {
    kMin_MinMaxOrBoth,
    kMax_MinMaxOrBoth,
    kBoth_MinMaxOrBoth
};

Function Documentation

checkForZero()

static bool checkForZero ( float  x )

inlinestatic

Definition at line 1289 of file SkMatrix.cpp.

                                         {
    return x*x == 0;
}

dcross()

static double dcross ( double  a, double  b, double  c, double  d  )

inlinestatic

Definition at line 705 of file SkMatrix.cpp.

                                                                    {
    return a * b - c * d;
}

dcross_dscale()

static SkScalar dcross_dscale ( double  a, double  b, double  c, double  d, double  scale  )

inlinestatic

Definition at line 709 of file SkMatrix.cpp.

                                                                       {
    return SkDoubleToScalar(dcross(a, b, c, d) * scale);
}

get_scale_factor()

template<MinMaxOrBoth MIN_MAX_OR_BOTH>

bool get_scale_factor	(	SkMatrix::TypeMask	typeMask,
		const SkScalar	m[9],
		SkScalar	results[]
	)

Definition at line 1428 of file SkMatrix.cpp.

                                                                                   {
    if (typeMask & SkMatrix::kPerspective_Mask) {
        return false;
    }
    if (SkMatrix::kIdentity_Mask == typeMask) {
        results[0] = SK_Scalar1;
        if (kBoth_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
            results[1] = SK_Scalar1;
        }
        return true;
    }
    if (!(typeMask & SkMatrix::kAffine_Mask)) {
        if (kMin_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
             results[0] = std::min(SkScalarAbs(m[SkMatrix::kMScaleX]),
                                   SkScalarAbs(m[SkMatrix::kMScaleY]));
        } else if (kMax_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
             results[0] = std::max(SkScalarAbs(m[SkMatrix::kMScaleX]),
                                   SkScalarAbs(m[SkMatrix::kMScaleY]));
        } else {
            results[0] = SkScalarAbs(m[SkMatrix::kMScaleX]);
            results[1] = SkScalarAbs(m[SkMatrix::kMScaleY]);
             if (results[0] > results[1]) {
                 using std::swap;
                 swap(results[0], results[1]);
             }
        }
        return true;
    }
    // ignore the translation part of the matrix, just look at 2x2 portion.
    // compute singular values, take largest or smallest abs value.
    // [a b; b c] = A^T*A
    SkScalar a = sdot(m[SkMatrix::kMScaleX], m[SkMatrix::kMScaleX],
                      m[SkMatrix::kMSkewY],  m[SkMatrix::kMSkewY]);
    SkScalar b = sdot(m[SkMatrix::kMScaleX], m[SkMatrix::kMSkewX],
                      m[SkMatrix::kMScaleY], m[SkMatrix::kMSkewY]);
    SkScalar c = sdot(m[SkMatrix::kMSkewX],  m[SkMatrix::kMSkewX],
                      m[SkMatrix::kMScaleY], m[SkMatrix::kMScaleY]);
    // eigenvalues of A^T*A are the squared singular values of A.
    // characteristic equation is det((A^T*A) - l*I) = 0
    // l^2 - (a + c)l + (ac-b^2)
    // solve using quadratic equation (divisor is non-zero since l^2 has 1 coeff
    // and roots are guaranteed to be pos and real).
    SkScalar bSqd = b * b;
    // if upper left 2x2 is orthogonal save some math
    if (bSqd <= SK_ScalarNearlyZero*SK_ScalarNearlyZero) {
        if (kMin_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
            results[0] = std::min(a, c);
        } else if (kMax_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
            results[0] = std::max(a, c);
        } else {
            results[0] = a;
            results[1] = c;
            if (results[0] > results[1]) {
                using std::swap;
                swap(results[0], results[1]);
            }
        }
    } else {
        SkScalar aminusc = a - c;
        SkScalar apluscdiv2 = SkScalarHalf(a + c);
        SkScalar x = SkScalarHalf(SkScalarSqrt(aminusc * aminusc + 4 * bSqd));
        if (kMin_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
            results[0] = apluscdiv2 - x;
        } else if (kMax_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
            results[0] = apluscdiv2 + x;
        } else {
            results[0] = apluscdiv2 - x;
            results[1] = apluscdiv2 + x;
        }
    }
    if (!SkIsFinite(results[0])) {
        return false;
    }
    // Due to the floating point inaccuracy, there might be an error in a, b, c
    // calculated by sdot, further deepened by subsequent arithmetic operations
    // on them. Therefore, we allow and cap the nearly-zero negative values.
    if (results[0] < 0) {
        results[0] = 0;
    }
    results[0] = SkScalarSqrt(results[0]);
    if (kBoth_MinMaxOrBoth == MIN_MAX_OR_BOTH) {
        if (!SkIsFinite(results[1])) {
            return false;
        }
        if (results[1] < 0) {
            results[1] = 0;
        }
        results[1] = SkScalarSqrt(results[1]);
    }
    return true;
}

is_degenerate_2x2()

static bool is_degenerate_2x2 ( SkScalar  scaleX, SkScalar  skewX, SkScalar  skewY, SkScalar  scaleY  )

inlinestatic

Definition at line 172 of file SkMatrix.cpp.

                                                                       {
    SkScalar perp_dot = scaleX*scaleY - skewX*skewY;
    return SkScalarNearlyZero(perp_dot, SK_ScalarNearlyZero*SK_ScalarNearlyZero);
}

muladdmul()

static float muladdmul ( float  a, float  b, float  c, float  d  )

inlinestatic

Definition at line 591 of file SkMatrix.cpp.

                                                                  {
    return sk_double_to_float((double)a * b + (double)c * d);
}

only_scale_and_translate()

static bool only_scale_and_translate ( unsigned  mask )

static

Definition at line 599 of file SkMatrix.cpp.

                                                    {
    return 0 == (mask & (SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask));
}

operator==()

bool operator==	(	const SkMatrix &	a,
		const SkMatrix &	b
	)

Compares a and b; returns true if a and b are numerically equal. Returns true even if sign of zero values are different. Returns false if either SkMatrix contains NaN, even if the other SkMatrix also contains NaN.

Parameters

a	SkMatrix to compare
b	SkMatrix to compare

Returns

true if SkMatrix a and SkMatrix b are numerically equal

Definition at line 160 of file SkMatrix.cpp.

                                                      {
    const SkScalar* SK_RESTRICT ma = a.fMat;
    const SkScalar* SK_RESTRICT mb = b.fMat;
 
    return  ma[0] == mb[0] && ma[1] == mb[1] && ma[2] == mb[2] &&
            ma[3] == mb[3] && ma[4] == mb[4] && ma[5] == mb[5] &&
            ma[6] == mb[6] && ma[7] == mb[7] && ma[8] == mb[8];
}

rowcol3()

static float rowcol3 ( const float  row[], const float  col[]  )

inlinestatic

Definition at line 595 of file SkMatrix.cpp.

                                                                  {
    return row[0] * col[0] + row[1] * col[3] + row[2] * col[6];
}

scross()

static SkScalar scross ( SkScalar  a, SkScalar  b, SkScalar  c, SkScalar  d  )

inlinestatic

Definition at line 250 of file SkMatrix.cpp.

                                                                              {
    return a * b - c * d;
}

scross_dscale()

static SkScalar scross_dscale ( SkScalar  a, SkScalar  b, SkScalar  c, SkScalar  d, double  scale  )

inlinestatic

Definition at line 700 of file SkMatrix.cpp.

                                                                           {
    return SkDoubleToScalar(scross(a, b, c, d) * scale);
}

sdot() [1/2]

static SkScalar sdot ( SkScalar  a, SkScalar  b, SkScalar  c, SkScalar  d  )

inlinestatic

Definition at line 241 of file SkMatrix.cpp.

                                                                            {
    return a * b + c * d;
}

sdot() [2/2]

static SkScalar sdot ( SkScalar  a, SkScalar  b, SkScalar  c, SkScalar  d, SkScalar  e, SkScalar  f  )

inlinestatic

Definition at line 245 of file SkMatrix.cpp.

                                                     {
    return a * b + c * d + e * f;
}

sk_determinant()

static double sk_determinant ( const float  mat[9], int  isPerspective  )

static

Definition at line 714 of file SkMatrix.cpp.

                                                                    {
    if (isPerspective) {
        return mat[SkMatrix::kMScaleX] *
                    dcross(mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp2],
                           mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp1])
                    +
                    mat[SkMatrix::kMSkewX]  *
                    dcross(mat[SkMatrix::kMTransY], mat[SkMatrix::kMPersp0],
                           mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp2])
                    +
                    mat[SkMatrix::kMTransX] *
                    dcross(mat[SkMatrix::kMSkewY],  mat[SkMatrix::kMPersp1],
                           mat[SkMatrix::kMScaleY], mat[SkMatrix::kMPersp0]);
    } else {
        return dcross(mat[SkMatrix::kMScaleX], mat[SkMatrix::kMScaleY],
                      mat[SkMatrix::kMSkewX], mat[SkMatrix::kMSkewY]);
    }
}

sk_inv_determinant()

static double sk_inv_determinant ( const float  mat[9], int  isPerspective  )

static

Definition at line 733 of file SkMatrix.cpp.

                                                                        {
    double det = sk_determinant(mat, isPerspective);
 
    // Since the determinant is on the order of the cube of the matrix members,
    // compare to the cube of the default nearly-zero constant (although an
    // estimate of the condition number would be better if it wasn't so expensive).
    if (SkScalarNearlyZero(sk_double_to_float(det),
                           SK_ScalarNearlyZero * SK_ScalarNearlyZero * SK_ScalarNearlyZero)) {
        return 0;
    }
    return 1.0 / det;
}

SkDecomposeUpper2x2()

bool SkDecomposeUpper2x2	(	const SkMatrix &	matrix,
		SkPoint *	rotation1,
		SkPoint *	scale,
		SkPoint *	rotation2
	)

Decomposes the upper-left 2x2 of the matrix into a rotation (represented by the cosine and sine of the rotation angle), followed by a non-uniform scale, followed by another rotation. If there is a reflection, one of the scale factors will be negative. Returns true if successful. Returns false if the matrix is degenerate.

Definition at line 1689 of file SkMatrix.cpp.

                                             {
 
    SkScalar A = matrix[SkMatrix::kMScaleX];
    SkScalar B = matrix[SkMatrix::kMSkewX];
    SkScalar C = matrix[SkMatrix::kMSkewY];
    SkScalar D = matrix[SkMatrix::kMScaleY];
 
    if (is_degenerate_2x2(A, B, C, D)) {
        return false;
    }
 
    double w1, w2;
    SkScalar cos1, sin1;
    SkScalar cos2, sin2;
 
    // do polar decomposition (M = Q*S)
    SkScalar cosQ, sinQ;
    double Sa, Sb, Sd;
    // if M is already symmetric (i.e., M = I*S)
    if (SkScalarNearlyEqual(B, C)) {
        cosQ = 1;
        sinQ = 0;
 
        Sa = A;
        Sb = B;
        Sd = D;
    } else {
        cosQ = A + D;
        sinQ = C - B;
        SkScalar reciplen = SkScalarInvert(SkScalarSqrt(cosQ*cosQ + sinQ*sinQ));
        cosQ *= reciplen;
        sinQ *= reciplen;
 
        // S = Q^-1*M
        // we don't calc Sc since it's symmetric
        Sa = A*cosQ + C*sinQ;
        Sb = B*cosQ + D*sinQ;
        Sd = -B*sinQ + D*cosQ;
    }
 
    // Now we need to compute eigenvalues of S (our scale factors)
    // and eigenvectors (bases for our rotation)
    // From this, should be able to reconstruct S as U*W*U^T
    if (SkScalarNearlyZero(SkDoubleToScalar(Sb))) {
        // already diagonalized
        cos1 = 1;
        sin1 = 0;
        w1 = Sa;
        w2 = Sd;
        cos2 = cosQ;
        sin2 = sinQ;
    } else {
        double diff = Sa - Sd;
        double discriminant = sqrt(diff*diff + 4.0*Sb*Sb);
        double trace = Sa + Sd;
        if (diff > 0) {
            w1 = 0.5*(trace + discriminant);
            w2 = 0.5*(trace - discriminant);
        } else {
            w1 = 0.5*(trace - discriminant);
            w2 = 0.5*(trace + discriminant);
        }
 
        cos1 = SkDoubleToScalar(Sb); sin1 = SkDoubleToScalar(w1 - Sa);
        SkScalar reciplen = SkScalarInvert(SkScalarSqrt(cos1*cos1 + sin1*sin1));
        cos1 *= reciplen;
        sin1 *= reciplen;
 
        // rotation 2 is composition of Q and U
        cos2 = cos1*cosQ - sin1*sinQ;
        sin2 = sin1*cosQ + cos1*sinQ;
 
        // rotation 1 is U^T
        sin1 = -sin1;
    }
 
    if (scale) {
        scale->fX = SkDoubleToScalar(w1);
        scale->fY = SkDoubleToScalar(w2);
    }
    if (rotation1) {
        rotation1->fX = cos1;
        rotation1->fY = sin1;
    }
    if (rotation2) {
        rotation2->fX = cos2;
        rotation2->fY = sin2;
    }
 
    return true;
}

SkTreatAsSprite()

bool SkTreatAsSprite	(	const SkMatrix &	mat,
		const SkISize &	size,
		const SkSamplingOptions &	sampling,
		bool	isAntiAlias
	)

Given a matrix, size and an antialias setting, return true if the computed dst-rect would align such that there is a 1-to-1 coorspondence between src and dst pixels. This can be called by drawing code to see if drawBitmap can be turned into drawSprite (which is faster).

The src-rect is defined to be { 0, 0, size.width(), size.height() }

Definition at line 1614 of file SkMatrix.cpp.

                                       {
    if (!SkSamplingPriv::NoChangeWithIdentityMatrix(sampling)) {
        return false;
    }
 
    // Our path aa is 2-bits, and our rect aa is 8, so we could use 8,
    // but in practice 4 seems enough (still looks smooth) and allows
    // more slightly fractional cases to fall into the fast (sprite) case.
    static const unsigned kAntiAliasSubpixelBits = 4;
 
    const unsigned subpixelBits = isAntiAlias ? kAntiAliasSubpixelBits : 0;
 
    // quick reject on affine or perspective
    if (mat.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
        return false;
    }
 
    // We don't want to snap to pixels if we're asking for linear filtering with
    // a subpixel translation. (b/41322892).
    // This mirrors `tweak_sampling` in SkImageShader.cpp
    if (sampling.filter == SkFilterMode::kLinear &&
        (mat.getTranslateX() != (int)mat.getTranslateX() ||
         mat.getTranslateY() != (int)mat.getTranslateY())) {
        return false;
    }
 
    // quick success check
    if (!subpixelBits && !(mat.getType() & ~SkMatrix::kTranslate_Mask)) {
        return true;
    }
 
    // mapRect supports negative scales, so we eliminate those first
    if (mat.getScaleX() < 0 || mat.getScaleY() < 0) {
        return false;
    }
 
    SkRect dst;
    SkIRect isrc = SkIRect::MakeSize(size);
 
    {
        SkRect src;
        src.set(isrc);
        mat.mapRect(&dst, src);
    }
 
    // just apply the translate to isrc
    isrc.offset(SkScalarRoundToInt(mat.getTranslateX()),
                SkScalarRoundToInt(mat.getTranslateY()));
 
    if (subpixelBits) {
        isrc.fLeft = SkLeftShift(isrc.fLeft, subpixelBits);
        isrc.fTop = SkLeftShift(isrc.fTop, subpixelBits);
        isrc.fRight = SkLeftShift(isrc.fRight, subpixelBits);
        isrc.fBottom = SkLeftShift(isrc.fBottom, subpixelBits);
 
        const float scale = 1 << subpixelBits;
        dst.fLeft *= scale;
        dst.fTop *= scale;
        dst.fRight *= scale;
        dst.fBottom *= scale;
    }
 
    SkIRect idst;
    dst.round(&idst);
    return isrc == idst;
}

sort_as_rect()

static skvx::float4 sort_as_rect ( const skvx::float4 &  ltrb )

static

Definition at line 1119 of file SkMatrix.cpp.

                                                       {
    skvx::float4 rblt(ltrb[2], ltrb[3], ltrb[0], ltrb[1]);
    auto min = skvx::min(ltrb, rblt);
    auto max = skvx::max(ltrb, rblt);
    // We can extract either pair [0,1] or [2,3] from min and max and be correct, but on
    // ARM this sequence generates the fastest (a single instruction).
    return skvx::float4(min[2], min[3], max[0], max[1]);
}

Variable Documentation

kScalar1Int

const int32_t kScalar1Int = 0x3f800000

static

Definition at line 80 of file SkMatrix.cpp.