SkMatrixPriv Class Reference

#include <SkMatrixPriv.h>

Public Types
enum	{ kMaxFlattenSize = 9 * sizeof(SkScalar) + sizeof(uint32_t) }
typedef SkMatrix::MapXYProc	MapXYProc
typedef SkMatrix::MapPtsProc	MapPtsProc

Static Public Member Functions
static size_t	WriteToMemory (const SkMatrix &matrix, void *buffer)
static size_t	ReadFromMemory (SkMatrix *matrix, const void *buffer, size_t length)
static MapPtsProc	GetMapPtsProc (const SkMatrix &matrix)
static MapXYProc	GetMapXYProc (const SkMatrix &matrix)
static bool	InverseMapRect (const SkMatrix &mx, SkRect *dst, const SkRect &src)
static void	MapPointsWithStride (const SkMatrix &mx, SkPoint pts[], size_t stride, int count)
static void	MapPointsWithStride (const SkMatrix &mx, SkPoint dst[], size_t dstStride, const SkPoint src[], size_t srcStride, int count)
static void	MapHomogeneousPointsWithStride (const SkMatrix &mx, SkPoint3 dst[], size_t dstStride, const SkPoint3 src[], size_t srcStride, int count)
static bool	PostIDiv (SkMatrix *matrix, int divx, int divy)
static bool	CheapEqual (const SkMatrix &a, const SkMatrix &b)
static const SkScalar *	M44ColMajor (const SkM44 &m)
static bool	IsScaleTranslateAsM33 (const SkM44 &m)
static SkRect	MapRect (const SkM44 &m, const SkRect &r)
static SkScalar	DifferentialAreaScale (const SkMatrix &m, const SkPoint &p)
static bool	NearlyAffine (const SkMatrix &m, const SkRect &bounds, SkScalar tolerance=SK_ScalarNearlyZero)
static SkScalar	ComputeResScaleForStroking (const SkMatrix &matrix)

Detailed Description

Definition at line 23 of file SkMatrixPriv.h.

Member Typedef Documentation

MapPtsProc

typedef SkMatrix::MapPtsProc SkMatrixPriv::MapPtsProc

Definition at line 39 of file SkMatrixPriv.h.

MapXYProc

typedef SkMatrix::MapXYProc SkMatrixPriv::MapXYProc

Definition at line 38 of file SkMatrixPriv.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kMaxFlattenSize

Definition at line 25 of file SkMatrixPriv.h.

         {
        // writeTo/readFromMemory will never return a value larger than this
        kMaxFlattenSize = 9 * sizeof(SkScalar) + sizeof(uint32_t),
    };

Member Function Documentation

CheapEqual()

static bool SkMatrixPriv::CheapEqual ( const SkMatrix &  a, const SkMatrix &  b  )

inlinestatic

Definition at line 181 of file SkMatrixPriv.h.

                                                                 {
        return &a == &b || 0 == memcmp(a.fMat, b.fMat, sizeof(a.fMat));
    }

ComputeResScaleForStroking()

SkScalar SkMatrixPriv::ComputeResScaleForStroking ( const SkMatrix &  matrix )

static

Definition at line 1877 of file SkMatrix.cpp.

                                                                        {
    // Not sure how to handle perspective differently, so we just don't try (yet)
    SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
    SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY]);
    if (SkIsFinite(sx, sy)) {
        SkScalar scale = std::max(sx, sy);
        if (scale > 0) {
            return scale;
        }
    }
    return 1;
}

DifferentialAreaScale()

SkScalar SkMatrixPriv::DifferentialAreaScale ( const SkMatrix &  m, const SkPoint &  p  )

static

Definition at line 1786 of file SkMatrix.cpp.

                                                                                {
    //              [m00 m01 m02]                                 [f(u,v)]
    // Assuming M = [m10 m11 m12], define the projected p'(u,v) = [g(u,v)] where
    //              [m20 m12 m22]
    //                                                        [x]     [u]
    // f(u,v) = x(u,v) / w(u,v), g(u,v) = y(u,v) / w(u,v) and [y] = M*[v]
    //                                                        [w]     [1]
    //
    // Then the differential scale factor between p = (u,v) and p' is |det J|,
    // where J is the Jacobian for p': [df/du dg/du]
    //                                 [df/dv dg/dv]
    // and df/du = (w*dx/du - x*dw/du)/w^2,   dg/du = (w*dy/du - y*dw/du)/w^2
    //     df/dv = (w*dx/dv - x*dw/dv)/w^2,   dg/dv = (w*dy/dv - y*dw/dv)/w^2
    //
    // From here, |det J| can be rewritten as |det J'/w^3|, where
    //      [x     y     w    ]   [x   y   w  ]
    // J' = [dx/du dy/du dw/du] = [m00 m10 m20]
    //      [dx/dv dy/dv dw/dv]   [m01 m11 m21]
    SkPoint3 xyw;
    m.mapHomogeneousPoints(&xyw, &p, 1);
 
    if (xyw.fZ < SK_ScalarNearlyZero) {
        // Reaching the discontinuity of xy/w and where the point would clip to w >= 0
        return SK_ScalarInfinity;
    }
    SkMatrix jacobian = SkMatrix::MakeAll(xyw.fX, xyw.fY, xyw.fZ,
                                          m.getScaleX(), m.getSkewY(), m.getPerspX(),
                                          m.getSkewX(), m.getScaleY(), m.getPerspY());
 
    double denom = 1.0 / xyw.fZ;   // 1/w
    denom = denom * denom * denom; // 1/w^3
    return SkScalarAbs(SkDoubleToScalar(sk_determinant(jacobian.fMat, true) * denom));
}

GetMapPtsProc()

static MapPtsProc SkMatrixPriv::GetMapPtsProc ( const SkMatrix &  matrix )

inlinestatic

Definition at line 42 of file SkMatrixPriv.h.

                                                            {
        return SkMatrix::GetMapPtsProc(matrix.getType());
    }

GetMapXYProc()

static MapXYProc SkMatrixPriv::GetMapXYProc ( const SkMatrix &  matrix )

inlinestatic

Definition at line 46 of file SkMatrixPriv.h.

                                                          {
        return SkMatrix::GetMapXYProc(matrix.getType());
    }

InverseMapRect()

static bool SkMatrixPriv::InverseMapRect ( const SkMatrix &  mx, SkRect *  dst, const SkRect &  src  )

inlinestatic

Attempt to map the rect through the inverse of the matrix. If it is not invertible, then this returns false and dst is unchanged.

Definition at line 54 of file SkMatrixPriv.h.

                                                                                                 {
        if (mx.isScaleTranslate()) {
            // A scale-translate matrix with a 0 scale factor is not invertible.
            if (mx.getScaleX() == 0.f || mx.getScaleY() == 0.f) {
                return false;
            }
 
            const SkScalar tx = mx.getTranslateX();
            const SkScalar ty = mx.getTranslateY();
            // mx maps coordinates as ((sx*x + tx), (sy*y + ty)) so the inverse is
            // ((x - tx)/sx), (y - ty)/sy). If sx or sy are negative, we have to swap the edge
            // values to maintain a sorted rect.
            auto inverted = skvx::float4::Load(&src.fLeft);
            inverted -= skvx::float4(tx, ty, tx, ty);
 
            if (mx.getType() > SkMatrix::kTranslate_Mask) {
                const SkScalar sx = 1.f / mx.getScaleX();
                const SkScalar sy = 1.f / mx.getScaleY();
                inverted *= skvx::float4(sx, sy, sx, sy);
                if (sx < 0.f && sy < 0.f) {
                    inverted = skvx::shuffle<2, 3, 0, 1>(inverted); // swap L|R and T|B
                } else if (sx < 0.f) {
                    inverted = skvx::shuffle<2, 1, 0, 3>(inverted); // swap L|R
                } else if (sy < 0.f) {
                    inverted = skvx::shuffle<0, 3, 2, 1>(inverted); // swap T|B
                }
            }
            inverted.store(&dst->fLeft);
            return true;
        }
 
        // general case
        SkMatrix inverse;
        if (mx.invert(&inverse)) {
            inverse.mapRect(dst, src);
            return true;
        }
        return false;
    }

IsScaleTranslateAsM33()

static bool SkMatrixPriv::IsScaleTranslateAsM33 ( const SkM44 &  m )

inlinestatic

Definition at line 190 of file SkMatrixPriv.h.

                                                      {
        return m.rc(1,0) == 0 && m.rc(3,0) == 0 &&
               m.rc(0,1) == 0 && m.rc(3,1) == 0 &&
               m.rc(3,3) == 1;
 
    }

M44ColMajor()

static const SkScalar * SkMatrixPriv::M44ColMajor ( const SkM44 &  m )

inlinestatic

Definition at line 185 of file SkMatrixPriv.h.

{ return m.fMat; }

MapHomogeneousPointsWithStride()

void SkMatrixPriv::MapHomogeneousPointsWithStride ( const SkMatrix &  mx, SkPoint3  dst[], size_t  dstStride, const SkPoint3  src[], size_t  srcStride, int  count  )

static

Definition at line 1026 of file SkMatrix.cpp.

                                                                               {
    SkASSERT((dst && src && count > 0) || 0 == count);
    // no partial overlap
    SkASSERT(src == dst || &dst[count] <= &src[0] || &src[count] <= &dst[0]);
 
    if (count > 0) {
        if (mx.isIdentity()) {
            if (src != dst) {
                if (srcStride == sizeof(SkPoint3) && dstStride == sizeof(SkPoint3)) {
                    memcpy(dst, src, count * sizeof(SkPoint3));
                } else {
                    for (int i = 0; i < count; ++i) {
                        *dst = *src;
                        dst = reinterpret_cast<SkPoint3*>(reinterpret_cast<char*>(dst) + dstStride);
                        src = reinterpret_cast<const SkPoint3*>(reinterpret_cast<const char*>(src) +
                                                                srcStride);
                    }
                }
            }
            return;
        }
        do {
            SkScalar sx = src->fX;
            SkScalar sy = src->fY;
            SkScalar sw = src->fZ;
            src = reinterpret_cast<const SkPoint3*>(reinterpret_cast<const char*>(src) + srcStride);
            const SkScalar* mat = mx.fMat;
            typedef SkMatrix M;
            SkScalar x = sdot(sx, mat[M::kMScaleX], sy, mat[M::kMSkewX],  sw, mat[M::kMTransX]);
            SkScalar y = sdot(sx, mat[M::kMSkewY],  sy, mat[M::kMScaleY], sw, mat[M::kMTransY]);
            SkScalar w = sdot(sx, mat[M::kMPersp0], sy, mat[M::kMPersp1], sw, mat[M::kMPersp2]);
 
            dst->set(x, y, w);
            dst = reinterpret_cast<SkPoint3*>(reinterpret_cast<char*>(dst) + dstStride);
        } while (--count);
    }
}

MapPointsWithStride() [1/2]

static void SkMatrixPriv::MapPointsWithStride ( const SkMatrix &  mx, SkPoint  dst[], size_t  dstStride, const SkPoint  src[], size_t  srcStride, int  count  )

inlinestatic

Maps src SkPoint array of length count to dst SkPoint array, skipping stride bytes to advance from one SkPoint to the next. Points are mapped by multiplying each SkPoint by SkMatrix. Given:

         | A B C |         | x |
Matrix = | D E F |,  src = | y |
         | G H I |         | 1 |

each resulting dst SkPoint is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

mx	matrix used to map the points
dst	storage for mapped points
src	points to transform
stride	size of record starting with SkPoint, in bytes
count	number of points to transform

Definition at line 161 of file SkMatrixPriv.h.

                                                                                      {
        SkASSERT(srcStride >= sizeof(SkPoint));
        SkASSERT(dstStride >= sizeof(SkPoint));
        SkASSERT(0 == srcStride % sizeof(SkScalar));
        SkASSERT(0 == dstStride % sizeof(SkScalar));
        for (int i = 0; i < count; ++i) {
            mx.mapPoints(dst, src, 1);
            src = (SkPoint*)((intptr_t)src + srcStride);
            dst = (SkPoint*)((intptr_t)dst + dstStride);
        }
    }

MapPointsWithStride() [2/2]

static void SkMatrixPriv::MapPointsWithStride ( const SkMatrix &  mx, SkPoint  pts[], size_t  stride, int  count  )

inlinestatic

Maps count pts, skipping stride bytes to advance from one SkPoint to the next. Points are mapped by multiplying each SkPoint by SkMatrix. Given:

         | A B C |        | x |
Matrix = | D E F |,  pt = | y |
         | G H I |        | 1 |

each resulting pts SkPoint is computed as:

              |A B C| |x|                               Ax+By+C   Dx+Ey+F
Matrix * pt = |D E F| |y| = |Ax+By+C Dx+Ey+F Gx+Hy+I| = ------- , -------
              |G H I| |1|                               Gx+Hy+I   Gx+Hy+I

Parameters

mx	matrix used to map the points
pts	storage for mapped points
stride	size of record starting with SkPoint, in bytes
count	number of points to transform

Definition at line 112 of file SkMatrixPriv.h.

                                                                                                 {
        SkASSERT(stride >= sizeof(SkPoint));
        SkASSERT(0 == stride % sizeof(SkScalar));
 
        SkMatrix::TypeMask tm = mx.getType();
 
        if (SkMatrix::kIdentity_Mask == tm) {
            return;
        }
        if (SkMatrix::kTranslate_Mask == tm) {
            const SkScalar tx = mx.getTranslateX();
            const SkScalar ty = mx.getTranslateY();
            skvx::float2 trans(tx, ty);
            for (int i = 0; i < count; ++i) {
                (skvx::float2::Load(&pts->fX) + trans).store(&pts->fX);
                pts = (SkPoint*)((intptr_t)pts + stride);
            }
            return;
        }
        // Insert other special-cases here (e.g. scale+translate)
 
        // general case
        SkMatrix::MapXYProc proc = mx.getMapXYProc();
        for (int i = 0; i < count; ++i) {
            proc(mx, pts->fX, pts->fY, pts);
            pts = (SkPoint*)((intptr_t)pts + stride);
        }
    }

MapRect()

SkRect SkMatrixPriv::MapRect ( const SkM44 &  m, const SkRect &  r  )

static

Definition at line 216 of file SkM44.cpp.

                                                              {
    const bool hasPerspective =
            m.fMat[3] != 0 || m.fMat[7] != 0 || m.fMat[11] != 0 || m.fMat[15] != 1;
    if (hasPerspective) {
        return map_rect_perspective(src, m.fMat);
    } else {
        return map_rect_affine(src, m.fMat);
    }
}

NearlyAffine()

bool SkMatrixPriv::NearlyAffine ( const SkMatrix &  m, const SkRect &  bounds, SkScalar  tolerance = SK_ScalarNearlyZero  )

static

Definition at line 1820 of file SkMatrix.cpp.

                                                    {
    if (!m.hasPerspective()) {
        return true;
    }
 
    // The idea here is that we are computing the differential area scale at each corner,
    // and comparing them with some tolerance value. If they are similar, then we can say
    // that the transformation is nearly affine.
 
    // We can map the four points simultaneously.
    SkPoint quad[4];
    bounds.toQuad(quad);
    SkPoint3 xyw[4];
    m.mapHomogeneousPoints(xyw, quad, 4);
 
    // Since the Jacobian is a 3x3 matrix, the determinant is a scalar triple product,
    // and the initial cross product is constant across all four points.
    SkPoint3 v1{m.getScaleX(), m.getSkewY(), m.getPerspX()};
    SkPoint3 v2{m.getSkewX(), m.getScaleY(), m.getPerspY()};
    SkPoint3 detCrossProd = v1.cross(v2);
 
    // Start with the calculations at P0.
    if (xyw[0].fZ < SK_ScalarNearlyZero) {
        // Reaching the discontinuity of xy/w and where the point would clip to w >= 0
        return false;
    }
 
    // Performing a dot product with the pre-w divide transformed point completes
    // the scalar triple product and the determinant calculation.
    double det = detCrossProd.dot(xyw[0]);
    // From that we can compute the differential area scale at P0.
    double denom = 1.0 / xyw[0].fZ;   // 1/w
    denom = denom * denom * denom; // 1/w^3
    SkScalar a0 = SkScalarAbs(SkDoubleToScalar(det*denom));
 
    // Now we compare P0's scale with that at the other three points
    tolerance *= tolerance; // squared tolerance since we're comparing area
    for (int i = 1; i < 4; ++i) {
        if (xyw[i].fZ < SK_ScalarNearlyZero) {
            // Reaching the discontinuity of xy/w and where the point would clip to w >= 0
            return false;
        }
 
        det = detCrossProd.dot(xyw[i]);  // completing scalar triple product
        denom = 1.0 / xyw[i].fZ;   // 1/w
        denom = denom * denom * denom; // 1/w^3
        SkScalar a = SkScalarAbs(SkDoubleToScalar(det*denom));
        if (!SkScalarNearlyEqual(a0, a, tolerance)) {
            return false;
        }
    }
 
    return true;
}

PostIDiv()

static bool SkMatrixPriv::PostIDiv ( SkMatrix *  matrix, int  divx, int  divy  )

inlinestatic

Definition at line 177 of file SkMatrixPriv.h.

                                                               {
        return matrix->postIDiv(divx, divy);
    }

ReadFromMemory()

static size_t SkMatrixPriv::ReadFromMemory ( SkMatrix *  matrix, const void *  buffer, size_t  length  )

inlinestatic

Definition at line 34 of file SkMatrixPriv.h.

                                                                                      {
        return matrix->readFromMemory(buffer, length);
    }

WriteToMemory()

static size_t SkMatrixPriv::WriteToMemory ( const SkMatrix &  matrix, void *  buffer  )

inlinestatic

Definition at line 30 of file SkMatrixPriv.h.

                                                                      {
        return matrix.writeToMemory(buffer);
    }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkMatrixPriv.h
• third_party/skia/src/core/SkM44.cpp
• third_party/skia/src/core/SkMatrix.cpp