2017-10-26 11:58:48 +00:00
SkMatrix Reference
===
# <a name="Matrix"></a> Matrix
# <a name="SkMatrix"></a> Class SkMatrix
< a href = "#Matrix" > Matrix< / a > holds a 3x3 matrix for transforming coordinates. This allows mapping
< a href = "#Point" > Points< / a > and < a href = "#Vector" > Vectors< / a > with translation, scaling, skewing, rotation, and
perspective.
< a href = "#Matrix" > Matrix< / a > elements are in row major order. < a href = "#Matrix" > Matrix< / a > does not have a constructor,
so it must be explicitly initialized. < a href = "#SkMatrix_setIdentity" > setIdentity< / a > initializes < a href = "#Matrix" > Matrix< / a >
so it has no effect. < a href = "#SkMatrix_setTranslate" > setTranslate< / a > , < a href = "#SkMatrix_setScale" > setScale< / a > , < a href = "#SkMatrix_setSkew" > setSkew< / a > , < a href = "#SkMatrix_setRotate" > setRotate< / a > , < a href = "#SkMatrix_set9" > set9< / a > and < a href = "#SkMatrix_setAll" > setAll< / a >
initializes all < a href = "#Matrix" > Matrix< / a > elements with the corresponding mapping.
< a href = "#Matrix" > Matrix< / a > includes a hidden variable that classifies the type of matrix to
improve performance. < a href = "#Matrix" > Matrix< / a > is not thread safe unless < a href = "#SkMatrix_getType" > getType< / a > is called first.
# <a name="Overview"></a> Overview
## <a name="Subtopics"></a> Subtopics
| topics | description |
| --- | --- |
## <a name="Operators"></a> Operators
| function | description |
| --- | --- |
| < a href = "#SkMatrix_not_equal_operator" > operator!=(const SkMatrix& a, const SkMatrix& b)< / a > | Returns true if members are unequal. |
| < a href = "#SkMatrix_equal_operator" > operator==(const SkMatrix& a, const SkMatrix& b)< / a > | Returns true if members are equal. |
| < a href = "#SkMatrix_subscript_operator_const" > operator[](int index)< / a > const | Returns < a href = "#Matrix" > Matrix< / a > value. |
| < a href = "#SkMatrix_subscript_operator_const" > operator[](int index)< / a > | Returns writable reference to < a href = "#Matrix" > Matrix< / a > value. |
## <a name="Member_Functions"></a> Member Functions
| function | description |
| --- | --- |
| < a href = "#SkMatrix_Concat" > Concat< / a > | Returns the concatenation of < a href = "#Matrix" > Matrix< / a > pair. |
| < a href = "#SkMatrix_I" > I< / a > | Returns a reference to a const identity < a href = "#Matrix" > Matrix< / a > . |
| < a href = "#SkMatrix_InvalidMatrix" > InvalidMatrix< / a > | Returns a reference to a const invalid < a href = "#Matrix" > Matrix< / a > . |
2017-10-31 19:44:45 +00:00
| < a href = "#SkMatrix_MakeAll" > MakeAll< / a > | Constructs all nine values. |
2017-10-26 11:58:48 +00:00
| < a href = "#SkMatrix_MakeRectToRect" > MakeRectToRect< / a > | Constructs from source < a href = "SkRect_Reference#Rect" > Rect< / a > to destination < a href = "SkRect_Reference#Rect" > Rect< / a > . |
| < a href = "#SkMatrix_MakeScale" > MakeScale< / a > | Constructs from scale in x and y. |
| < a href = "#SkMatrix_MakeTrans" > MakeTrans< / a > | Constructs from translate in x and y. |
| < a href = "#SkMatrix_SetAffineIdentity" > SetAffineIdentity< / a > | Sets 3x2 array to identity. |
| < a href = "#SkMatrix_asAffine" > asAffine< / a > | Copies to 3x2 array. |
| < a href = "#SkMatrix_cheapEqualTo" > cheapEqualTo< / a > | Compares < a href = "#Matrix" > Matrix< / a > pair using memcmp(). |
| < a href = "#SkMatrix_decomposeScale" > decomposeScale< / a > | Separates scale if possible. |
| < a href = "#SkMatrix_dirtyMatrixTypeCache" > dirtyMatrixTypeCache< / a > | Sets internal cache to unknown state. |
| < a href = "#SkMatrix_dump" > dump< / a > | Sends text representation using floats to standard output. |
| < a href = "#SkMatrix_fixedStepInX" > fixedStepInX< / a > | Returns step in x for a position in y. |
| < a href = "#SkMatrix_get" > get< / a > | Returns one of nine < a href = "#Matrix" > Matrix< / a > values. |
| < a href = "#SkMatrix_get9" > get9< / a > | Returns all nine < a href = "#Matrix" > Matrix< / a > values. |
| < a href = "#SkMatrix_getMaxScale" > getMaxScale< / a > | Returns maximum scaling, if possible. |
| < a href = "#SkMatrix_getMinMaxScales" > getMinMaxScales< / a > | Returns minimum and maximum scaling, if possible. |
| < a href = "#SkMatrix_getMinScale" > getMinScale< / a > | Returns minimum scaling, if possible. |
| < a href = "#SkMatrix_getPerspX" > getPerspX< / a > | Returns input x perspective factor. |
| < a href = "#SkMatrix_getPerspY" > getPerspY< / a > | Returns input y perspective factor. |
| < a href = "#SkMatrix_getScaleX" > getScaleX< / a > | Returns horizontal scale factor. |
| < a href = "#SkMatrix_getScaleY" > getScaleY< / a > | Returns vertical scale factor. |
| < a href = "#SkMatrix_getSkewX" > getSkewX< / a > | Returns horizontal skew factor. |
| < a href = "#SkMatrix_getSkewY" > getSkewY< / a > | Returns vertical skew factor. |
| < a href = "#SkMatrix_getTranslateX" > getTranslateX< / a > | Returns horizontal translation. |
| < a href = "#SkMatrix_getTranslateY" > getTranslateY< / a > | Returns vertical translation. |
| < a href = "#SkMatrix_getType" > getType< / a > | Returns transform complexity. |
| < a href = "#SkMatrix_hasPerspective" > hasPerspective< / a > | Returns if transform includes perspective. |
| < a href = "#SkMatrix_invert" > invert< / a > | Returns inverse, if possible. |
| < a href = "#SkMatrix_isFinite" > isFinite< / a > | Returns if all < a href = "#Matrix" > Matrix< / a > values are not infinity, < a href = "undocumented#NaN" > NaN< / a > . |
| < a href = "#SkMatrix_isFixedStepInX" > isFixedStepInX< / a > | Returns if transformation supports fixed step in x. |
| < a href = "#SkMatrix_isIdentity" > isIdentity< / a > | Returns if matrix equals the identity < a href = "#Matrix" > Matrix< / a > . |
| < a href = "#SkMatrix_isScaleTranslate" > isScaleTranslate< / a > | Returns if transform is limited to scale and translate. |
| < a href = "#SkMatrix_isSimilarity" > isSimilarity< / a > | Returns if transform is limited to square scale and rotation. |
| < a href = "#SkMatrix_isTranslate" > isTranslate< / a > | Returns if transform is limited to translate. |
| < a href = "#SkMatrix_mapHomogeneousPoints" > mapHomogeneousPoints< / a > | Maps < a href = "undocumented#Point3" > Point3< / a > array. |
| < a href = "#SkMatrix_mapPoints" > mapPoints< / a > | Maps < a href = "undocumented#Point" > Point< / a > array. |
| < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > | Maps < a href = "undocumented#Point" > Point< / a > array with padding. |
| < a href = "#SkMatrix_mapRadius" > mapRadius< / a > | Returns mean radius of mapped < a href = "undocumented#Circle" > Circle< / a > . |
| < a href = "#SkMatrix_mapRect" > mapRect< / a > | Returns bounds of mapped < a href = "SkRect_Reference#Rect" > Rect< / a > . |
| < a href = "#SkMatrix_mapRectScaleTranslate" > mapRectScaleTranslate< / a > | Returns bounds of mapped < a href = "SkRect_Reference#Rect" > Rect< / a > . |
| < a href = "#SkMatrix_mapRectToQuad" > mapRectToQuad< / a > | Maps < a href = "SkRect_Reference#Rect" > Rect< / a > to < a href = "undocumented#Point" > Point< / a > array. |
| < a href = "#SkMatrix_mapVector" > mapVector< / a > | Maps < a href = "undocumented#Vector" > Vector< / a > . |
| < a href = "#SkMatrix_mapVectors" > mapVectors< / a > | Maps < a href = "undocumented#Vector" > Vector< / a > array. |
| < a href = "#SkMatrix_mapXY" > mapXY< / a > | Maps < a href = "undocumented#Point" > Point< / a > . |
| < a href = "#SkMatrix_postConcat" > postConcat< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by < a href = "#Matrix" > Matrix< / a > parameter. |
| < a href = "#SkMatrix_postIDiv" > postIDiv< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by inverse scale. |
| < a href = "#SkMatrix_postRotate" > postRotate< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by rotation. |
| < a href = "#SkMatrix_postScale" > postScale< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by scale. |
| < a href = "#SkMatrix_postSkew" > postSkew< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by skew. |
| < a href = "#SkMatrix_postTranslate" > postTranslate< / a > | Post-multiplies < a href = "#Matrix" > Matrix< / a > by translation. |
| < a href = "#SkMatrix_preConcat" > preConcat< / a > | Pre-multiplies < a href = "#Matrix" > Matrix< / a > by < a href = "#Matrix" > Matrix< / a > parameter. |
| < a href = "#SkMatrix_preRotate" > preRotate< / a > | Pre-multiplies < a href = "#Matrix" > Matrix< / a > by rotation. |
| < a href = "#SkMatrix_preScale" > preScale< / a > | Pre-multiplies < a href = "#Matrix" > Matrix< / a > by scale. |
| < a href = "#SkMatrix_preSkew" > preSkew< / a > | Pre-multiplies < a href = "#Matrix" > Matrix< / a > by skew. |
| < a href = "#SkMatrix_preTranslate" > preTranslate< / a > | Pre-multiplies < a href = "#Matrix" > Matrix< / a > by translation. |
| < a href = "#SkMatrix_preservesAxisAlignment" > preservesAxisAlignment< / a > | Returns if mapping restricts to 90 degree multiples and mirroring. |
| < a href = "#SkMatrix_preservesRightAngles" > preservesRightAngles< / a > | Returns if mapped 90 angle remains 90 degrees. |
| < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > | Returns if mapped < a href = "SkRect_Reference#Rect" > Rect< / a > can be represented by another < a href = "SkRect_Reference#Rect" > Rect< / a > . |
| < a href = "#SkMatrix_reset" > reset< / a > | Sets < a href = "#Matrix" > Matrix< / a > to identity. |
| < a href = "#SkMatrix_set" > set< / a > | Sets one value. |
| < a href = "#SkMatrix_set9" > set9< / a > | Sets all values from < a href = "#Scalar" > Scalar< / a > array. |
| < a href = "#SkMatrix_setAffine" > setAffine< / a > | Sets left two columns. |
| < a href = "#SkMatrix_setAll" > setAll< / a > | Sets all values from parameters. |
| < a href = "#SkMatrix_setConcat" > setConcat< / a > | Sets to < a href = "#Matrix" > Matrix< / a > parameter multiplied by < a href = "#Matrix" > Matrix< / a > parameter. |
| < a href = "#SkMatrix_setIdentity" > setIdentity< / a > | Sets < a href = "#Matrix" > Matrix< / a > to identity. |
| < a href = "#SkMatrix_setPerspX" > setPerspX< / a > | Sets input x perspective factor. |
| < a href = "#SkMatrix_setPerspY" > setPerspY< / a > | Sets input y perspective factor. |
| < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > | Sets to map one to four points to an equal array of points. |
| < a href = "#SkMatrix_setRSXform" > setRSXform< / a > | Sets to rotate, scale, and translate. |
| < a href = "#SkMatrix_setRectToRect" > setRectToRect< / a > | Sets to map one < a href = "SkRect_Reference#Rect" > Rect< / a > to another. |
| < a href = "#SkMatrix_setRotate" > setRotate< / a > | Sets to rotate about a point. |
| < a href = "#SkMatrix_setScale" > setScale< / a > | Sets to scale about a point. |
| < a href = "#SkMatrix_setScaleTranslate" > setScaleTranslate< / a > | Sets to scale and translate. |
| < a href = "#SkMatrix_setScaleX" > setScaleX< / a > | Sets horizontal scale factor. |
| < a href = "#SkMatrix_setScaleY" > setScaleY< / a > | Sets vertical scale factor |
| < a href = "#SkMatrix_setSinCos" > setSinCos< / a > | Sets to rotate and scale about a point. |
| < a href = "#SkMatrix_setSkew" > setSkew< / a > | Sets to skew about a point. |
| < a href = "#SkMatrix_setSkewX" > setSkewX< / a > | Sets horizontal skew factor. |
| < a href = "#SkMatrix_setSkewY" > setSkewY< / a > | Sets vertical skew factor. |
| < a href = "#SkMatrix_setTranslate" > setTranslate< / a > | Sets to translate in x and y. |
| < a href = "#SkMatrix_setTranslateX" > setTranslateX< / a > | Sets horizontal translation. |
| < a href = "#SkMatrix_setTranslateY" > setTranslateY< / a > | Sets vertical translation. |
| < a href = "#SkMatrix_toString" > toString< / a > | Converts < a href = "#Matrix" > Matrix< / a > to machine readable form. |
< a name = "SkMatrix_MakeScale" > < / a >
## MakeScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix SK_WARN_UNUSED_RESULT MakeScale(SkScalar sx, SkScalar sy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to scale by (< a href = "#SkMatrix_MakeScale_sx" > sx< / a > , < a href = "#SkMatrix_MakeScale_sy" > sy< / a > ). Returned matrix is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| sx 0 0 |
| 0 sy 0 |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_MakeScale_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeScale_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > with scale
### Example
< div > < fiddle-embed name = "7ff17718111df6d6f95381d8a8f1b389" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_postScale" > postScale< / a > < a href = "#SkMatrix_preScale" > preScale< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix SK_WARN_UNUSED_RESULT MakeScale(SkScalar scale)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#SkMatrix_MakeScale_2_scale" > scale< / a > by (< a href = "#SkMatrix_MakeScale_2_scale" > scale< / a > , < a href = "#SkMatrix_MakeScale_2_scale" > scale< / a > ). Returned matrix is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale 0 0 |
| 0 scale 0 |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_MakeScale_2_scale" > < code > < strong > scale < / strong > < / code > < / a > < / td > < td >
horizontal and vertical < a href = "#SkMatrix_MakeScale_2_scale" > scale< / a > factor< / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > with < a href = "#SkMatrix_MakeScale_2_scale" > scale< / a >
### Example
< div > < fiddle-embed name = "2956aeb50fa862cdb13995e1e56a4bc8" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_postScale" > postScale< / a > < a href = "#SkMatrix_preScale" > preScale< / a >
---
< a name = "SkMatrix_MakeTrans" > < / a >
## MakeTrans
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix SK_WARN_UNUSED_RESULT MakeTrans(SkScalar dx, SkScalar dy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to translate by (< a href = "#SkMatrix_MakeTrans_dx" > dx< / a > , < a href = "#SkMatrix_MakeTrans_dy" > dy< / a > ). Returned matrix is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
2017-10-26 14:34:05 +00:00
| 1 0 dx |
| 0 1 dy |
| 0 0 1 |< / pre >
2017-10-26 11:58:48 +00:00
### Parameters
< table > < tr > < td > < a name = "SkMatrix_MakeTrans_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
horizontal translation< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeTrans_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
vertical translation< / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > with translation
### Example
< div > < fiddle-embed name = "b2479df0d9cf296ff64ac31e36684557" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_postTranslate" > postTranslate< / a > < a href = "#SkMatrix_preTranslate" > preTranslate< / a >
---
2017-10-31 19:44:45 +00:00
< a name = "SkMatrix_MakeAll" > < / a >
## MakeAll
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix SK_WARN_UNUSED_RESULT MakeAll(SkScalar scaleX, SkScalar skewX,
SkScalar transX, SkScalar skewY,
SkScalar scaleY, SkScalar transY,
SkScalar pers0, SkScalar pers1,
SkScalar pers2)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scaleX skewX transX |
| skewY scaleY transY |
| pers0 pers1 pers2 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_MakeAll_scaleX" > < code > < strong > scaleX < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_skewX" > < code > < strong > skewX < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_transX" > < code > < strong > transX < / strong > < / code > < / a > < / td > < td >
horizontal translation< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_skewY" > < code > < strong > skewY < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_scaleY" > < code > < strong > scaleY < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_transY" > < code > < strong > transY < / strong > < / code > < / a > < / td > < td >
vertical translation< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_pers0" > < code > < strong > pers0 < / strong > < / code > < / a > < / td > < td >
input x perspective factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_pers1" > < code > < strong > pers1 < / strong > < / code > < / a > < / td > < td >
input y perspective factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeAll_pers2" > < code > < strong > pers2 < / strong > < / code > < / a > < / td > < td >
perspective scale factor< / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > constructed from parameters
### Example
< div > < fiddle-embed name = "6bad83b64de9266e323c29d550e04188" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setAll" > setAll< / a > < a href = "#SkMatrix_set9" > set9< / a > < a href = "#SkMatrix_postConcat" > postConcat< / a > < a href = "#SkMatrix_preConcat" > preConcat< / a >
---
2017-10-26 11:58:48 +00:00
## <a name="SkMatrix_TypeMask"></a> Enum SkMatrix::TypeMask
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
enum < a href = "#SkMatrix_TypeMask" > TypeMask< / a > {
< a href = "#SkMatrix_kIdentity_Mask" > kIdentity Mask< / a > = 0,
< a href = "#SkMatrix_kTranslate_Mask" > kTranslate Mask< / a > = 0x01,
< a href = "#SkMatrix_kScale_Mask" > kScale Mask< / a > = 0x02,
< a href = "#SkMatrix_kAffine_Mask" > kAffine Mask< / a > = 0x04,
< a href = "#SkMatrix_kPerspective_Mask" > kPerspective Mask< / a > = 0x08,
};< / pre >
Enum of bit fields for mask returned by < a href = "#SkMatrix_getType" > getType< / a > .
Used to identify the complexity of < a href = "#Matrix" > Matrix< / a > , to optimize performance.
### Constants
< table >
< tr >
< td > < a name = "SkMatrix_kIdentity_Mask" > < code > < strong > SkMatrix::kIdentity_Mask < / strong > < / code > < / a > < / td > < td > 0< / td > < td > all bits clear if < a href = "#Matrix" > Matrix< / a > is identity< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kTranslate_Mask" > < code > < strong > SkMatrix::kTranslate_Mask < / strong > < / code > < / a > < / td > < td > 1< / td > < td > < a href = "#SkMatrix_set" > set< / a > if < a href = "#Matrix" > Matrix< / a > has translation< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kScale_Mask" > < code > < strong > SkMatrix::kScale_Mask < / strong > < / code > < / a > < / td > < td > 2< / td > < td > < a href = "#SkMatrix_set" > set< / a > if < a href = "#Matrix" > Matrix< / a > has x or y scale< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kAffine_Mask" > < code > < strong > SkMatrix::kAffine_Mask < / strong > < / code > < / a > < / td > < td > 4< / td > < td > < a href = "#SkMatrix_set" > set< / a > if < a href = "#Matrix" > Matrix< / a > skews or rotates< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kPerspective_Mask" > < code > < strong > SkMatrix::kPerspective_Mask < / strong > < / code > < / a > < / td > < td > 8< / td > < td > < a href = "#SkMatrix_set" > set< / a > if < a href = "#Matrix" > Matrix< / a > has perspective< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "ba19b36df8cd78586f3dff54e2d4c093" >
#### Example Output
~~~~
after reset: kIdentity_Mask
after postTranslate: kTranslate_Mask
after postScale: kTranslate_Mask kScale_Mask
after postScale: kTranslate_Mask kScale_Mask kAffine_Mask
after setPolyToPoly: kTranslate_Mask kScale_Mask kAffine_Mask kPerspective_Mask
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_getType" > getType< / a >
< a name = "SkMatrix_getType" > < / a >
## getType
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
TypeMask getType() const
< / pre >
Returns a bit field describing the transformations the matrix may
perform. The bit field is computed conservatively, so it may include
false positives. For example, when < a href = "#SkMatrix_kPerspective_Mask" > kPerspective Mask< / a > is < a href = "#SkMatrix_set" > set< / a > , all
other bits are < a href = "#SkMatrix_set" > set< / a > .
### Return Value
< a href = "#SkMatrix_kIdentity_Mask" > kIdentity Mask< / a > , or combinations of: < a href = "#SkMatrix_kTranslate_Mask" > kTranslate Mask< / a > , < a href = "#SkMatrix_kScale_Mask" > kScale Mask< / a > ,
< a href = "#SkMatrix_kAffine_Mask" > kAffine Mask< / a > , < a href = "#SkMatrix_kPerspective_Mask" > kPerspective Mask< / a >
### Example
< div > < fiddle-embed name = "8e45fe2dd52731bb2d4318686257e1d7" >
#### Example Output
~~~~
identity flags hex: 0 decimal: 0
set all flags hex: f decimal: 15
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_TypeMask" > TypeMask< / a >
---
< a name = "SkMatrix_isIdentity" > < / a >
## isIdentity
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isIdentity() const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > is identity. Identity matrix is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |< / pre >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > has no effect
### Example
< div > < fiddle-embed name = "780ab376325b3cfa889ea26c0769ec11" >
#### Example Output
~~~~
is identity: true
is identity: false
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_reset" > reset< / a > < a href = "#SkMatrix_setIdentity" > setIdentity< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_isScaleTranslate" > < / a >
## isScaleTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isScaleTranslate() const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > at most scales and translates. < a href = "#Matrix" > Matrix< / a > may be identity,
contain only scale elements, only translate elements, or both. < a href = "#Matrix" > Matrix< / a > form is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x 0 translate-x |
| 0 scale-y translate-y |
| 0 0 1 |< / pre >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > is identity; or scales, translates, or both
### Example
< div > < fiddle-embed name = "6287e29674a487eb94174992d45b9a34" >
#### Example Output
~~~~
is scale-translate: true
is scale-translate: true
is scale-translate: true
is scale-translate: true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_isTranslate" > isTranslate< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_isTranslate" > < / a >
## isTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isTranslate() const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > is identity, or translates. < a href = "#Matrix" > Matrix< / a > form is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 translate-x |
| 0 1 translate-y |
| 0 0 1 |< / pre >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > is identity, or translates
### Example
< div > < fiddle-embed name = "73ac71a8a30841873577c11c6c9b38ee" >
#### Example Output
~~~~
is translate: true
is translate: true
is translate: false
is translate: false
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_rectStaysRect" > < / a >
## rectStaysRect
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool rectStaysRect() const
< / pre >
Returns true < a href = "#Matrix" > Matrix< / a > maps < a href = "SkRect_Reference#Rect" > Rect< / a > to another < a href = "SkRect_Reference#Rect" > Rect< / a > . If true, < a href = "#Matrix" > Matrix< / a > is identity,
or scales, or rotates a multiple of 90 degrees, or mirrors in x or y. In all
cases, < a href = "#Matrix" > Matrix< / a > may also have translation. < a href = "#Matrix" > Matrix< / a > form is either:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x 0 translate-x |
| 0 scale-y translate-y |
| 0 0 1 |< / pre >
or
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 0 rotate-x translate-x |
| rotate-y 0 translate-y |
| 0 0 1 |< / pre >
for non-zero values of scale-x, scale-y, rotate-x, and rotate-y.
Also called < a href = "#SkMatrix_preservesAxisAlignment" > preservesAxisAlignment< / a > ; use the one that provides better inline
documentation.
### Return Value
true if < a href = "#Matrix" > Matrix< / a > maps one < a href = "SkRect_Reference#Rect" > Rect< / a > into another
### Example
< div > < fiddle-embed name = "ce5319c036c9b5086da8a0009fe409f8" >
#### Example Output
~~~~
rectStaysRect: true
rectStaysRect: true
rectStaysRect: true
rectStaysRect: true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preservesAxisAlignment" > preservesAxisAlignment< / a > < a href = "#SkMatrix_preservesRightAngles" > preservesRightAngles< / a >
---
< a name = "SkMatrix_preservesAxisAlignment" > < / a >
## preservesAxisAlignment
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool preservesAxisAlignment() const
< / pre >
Returns true < a href = "#Matrix" > Matrix< / a > maps < a href = "SkRect_Reference#Rect" > Rect< / a > to another < a href = "SkRect_Reference#Rect" > Rect< / a > . If true, < a href = "#Matrix" > Matrix< / a > is identity,
or scales, or rotates a multiple of 90 degrees, or mirrors in x or y. In all
cases, < a href = "#Matrix" > Matrix< / a > may also have translation. < a href = "#Matrix" > Matrix< / a > form is either:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x 0 translate-x |
| 0 scale-y translate-y |
| 0 0 1 |< / pre >
or
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 0 rotate-x translate-x |
| rotate-y 0 translate-y |
| 0 0 1 |< / pre >
for non-zero values of scale-x, scale-y, rotate-x, and rotate-y.
Also called < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > ; use the one that provides better inline
documentation.
### Return Value
true if < a href = "#Matrix" > Matrix< / a > maps one < a href = "SkRect_Reference#Rect" > Rect< / a > into another
### Example
< div > < fiddle-embed name = "7a234c96608fb7cb8135b9940b0b15f7" >
#### Example Output
~~~~
preservesAxisAlignment: true
preservesAxisAlignment: true
preservesAxisAlignment: true
preservesAxisAlignment: true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > < a href = "#SkMatrix_preservesRightAngles" > preservesRightAngles< / a >
---
< a name = "SkMatrix_hasPerspective" > < / a >
## hasPerspective
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool hasPerspective() const
< / pre >
Returns true if the matrix contains perspective elements. < a href = "#Matrix" > Matrix< / a > form is:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| -- -- -- |
| -- -- -- |
| perspective-x perspective-y perspective-scale |< / pre >
where perspective-x or perspective-y is non-zero, or perspective-scale is
not one. All other elements may have any value.
### Return Value
true if < a href = "#Matrix" > Matrix< / a > is in most general form
### Example
< div > < fiddle-embed name = "688123908c733169bbbfaf11f41ecff6" > < / fiddle-embed > < / div >
### See Also
2017-10-31 19:44:45 +00:00
< a href = "#SkMatrix_setAll" > setAll< / a > < a href = "#SkMatrix_set9" > set9< / a > < a href = "#SkMatrix_MakeAll" > MakeAll< / a >
2017-10-26 11:58:48 +00:00
---
< a name = "SkMatrix_isSimilarity" > < / a >
## isSimilarity
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isSimilarity(SkScalar tol = SK_ScalarNearlyZero) const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > contains only translation, rotation, reflection, and
uniform scale.
Returns false if < a href = "#Matrix" > Matrix< / a > contains different scales, skewing, perspective, or
degenerate forms that collapse to a line or point.
Describes that the < a href = "#Matrix" > Matrix< / a > makes rendering with and without the matrix are
visually alike; a transformed circle remains a circle. Mathematically, this is
referred to as similarity of a < a href = "undocumented#Euclidean" > Euclidean< / a > space, or a similarity transformation.
Preserves right angles, keeping the arms of the angle equal lengths.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_isSimilarity_tol" > < code > < strong > tol < / strong > < / code > < / a > < / td > < td >
to be deprecated< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > only rotates, uniformly scales, translates
### Example
< div > < fiddle-embed name = "98d60230ad633ae74d851de3a65d72d6" > < div > < a href = "undocumented#String" > String< / a > is drawn four times through but only two are visible. Drawing the pair
with < a href = "#SkMatrix_isSimilarity" > isSimilarity< / a > false reveals the pair not visible through the matrix.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_isScaleTranslate" > isScaleTranslate< / a > < a href = "#SkMatrix_preservesRightAngles" > preservesRightAngles< / a > < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > < a href = "#SkMatrix_isFixedStepInX" > isFixedStepInX< / a >
---
< a name = "SkMatrix_preservesRightAngles" > < / a >
## preservesRightAngles
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool preservesRightAngles(SkScalar tol = SK_ScalarNearlyZero) const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > contains only translation, rotation, reflection, and
scale. Scale may differ along rotated axes.
Returns false if < a href = "#Matrix" > Matrix< / a > skewing, perspective, or degenerate forms that collapse
to a line or point.
Preserves right angles, but not requiring that the arms of the angle
retain equal lengths.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preservesRightAngles_tol" > < code > < strong > tol < / strong > < / code > < / a > < / td > < td >
to be deprecated< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > only rotates, scales, translates
### Example
< div > < fiddle-embed name = "a3d5bfebc1c3423fb983d30aaf4ac5f4" > < div > Equal scale is both similar and preserves right angles.
Unequal scale is not similar but preserves right angles.
Skews are not similar and do not preserve right angles.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_isScaleTranslate" > isScaleTranslate< / a > < a href = "#SkMatrix_isSimilarity" > isSimilarity< / a > < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > < a href = "#SkMatrix_isFixedStepInX" > isFixedStepInX< / a >
---
## <a name="SkMatrix__anonymous"></a> Enum SkMatrix::_anonymous
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
enum {
< a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > ,
< a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > ,
< a href = "#SkMatrix_kMTransX" > kMTransX< / a > ,
< a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > ,
< a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > ,
< a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > ,
< a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > ,
< a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > ,
};< / pre >
< a href = "#Matrix" > Matrix< / a > organizes its values in row order. These members correspond to
each value in < a href = "#Matrix" > Matrix< / a > .
### Constants
< table >
< tr >
< td > < a name = "SkMatrix_kMScaleX" > < code > < strong > SkMatrix::kMScaleX < / strong > < / code > < / a > < / td > < td > 0< / td > < td > horizontal scale factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMSkewX" > < code > < strong > SkMatrix::kMSkewX < / strong > < / code > < / a > < / td > < td > 1< / td > < td > horizontal skew factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMTransX" > < code > < strong > SkMatrix::kMTransX < / strong > < / code > < / a > < / td > < td > 2< / td > < td > horizontal translation< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMSkewY" > < code > < strong > SkMatrix::kMSkewY < / strong > < / code > < / a > < / td > < td > 3< / td > < td > vertical skew factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMScaleY" > < code > < strong > SkMatrix::kMScaleY < / strong > < / code > < / a > < / td > < td > 4< / td > < td > vertical scale factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMTransY" > < code > < strong > SkMatrix::kMTransY < / strong > < / code > < / a > < / td > < td > 5< / td > < td > vertical translation< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMPersp0" > < code > < strong > SkMatrix::kMPersp0 < / strong > < / code > < / a > < / td > < td > 6< / td > < td > input x perspective factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMPersp1" > < code > < strong > SkMatrix::kMPersp1 < / strong > < / code > < / a > < / td > < td > 7< / td > < td > input y perspective factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kMPersp2" > < code > < strong > SkMatrix::kMPersp2 < / strong > < / code > < / a > < / td > < td > 8< / td > < td > perspective bias< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "3bbf75f4748420810aa2586e3c8548d9" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_set" > set< / a >
## <a name="SkMatrix__anonymous_2"></a> Enum SkMatrix::_anonymous_2
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
enum {
< a href = "#SkMatrix_kAScaleX" > kAScaleX< / a > ,
< a href = "#SkMatrix_kASkewY" > kASkewY< / a > ,
< a href = "#SkMatrix_kASkewX" > kASkewX< / a > ,
< a href = "#SkMatrix_kAScaleY" > kAScaleY< / a > ,
< a href = "#SkMatrix_kATransX" > kATransX< / a > ,
< a href = "#SkMatrix_kATransY" > kATransY< / a > ,
};< / pre >
Affine arrays are in column major order to match the matrix used by
< a href = "undocumented#PDF" > PDF< / a > and < a href = "undocumented#XPS" > XPS< / a > .
### Constants
< table >
< tr >
< td > < a name = "SkMatrix_kAScaleX" > < code > < strong > SkMatrix::kAScaleX < / strong > < / code > < / a > < / td > < td > 0< / td > < td > horizontal scale factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kASkewY" > < code > < strong > SkMatrix::kASkewY < / strong > < / code > < / a > < / td > < td > 1< / td > < td > vertical skew factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kASkewX" > < code > < strong > SkMatrix::kASkewX < / strong > < / code > < / a > < / td > < td > 2< / td > < td > horizontal skew factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kAScaleY" > < code > < strong > SkMatrix::kAScaleY < / strong > < / code > < / a > < / td > < td > 3< / td > < td > vertical scale factor< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kATransX" > < code > < strong > SkMatrix::kATransX < / strong > < / code > < / a > < / td > < td > 4< / td > < td > horizontal translation< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kATransY" > < code > < strong > SkMatrix::kATransY < / strong > < / code > < / a > < / td > < td > 5< / td > < td > vertical translation< / td >
< / tr >
< / table >
### See Also
< a href = "#SkMatrix_SetAffineIdentity" > SetAffineIdentity< / a > < a href = "#SkMatrix_asAffine" > asAffine< / a > < a href = "#SkMatrix_setAffine" > setAffine< / a >
< a name = "SkMatrix_subscript_operator_const" > < / a >
## operator[]
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar operator[](int index) const
< / pre >
Returns one matrix value. Asserts if < a href = "#SkMatrix_subscript_operator_const_index" > index< / a > is out of range and < a href = "undocumented#SK_DEBUG" > SK DEBUG< / a > is
defined.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_subscript_operator_const_index" > < code > < strong > index < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > , < a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > < / td >
< / tr >
< / table >
### Return Value
value corresponding to < a href = "#SkMatrix_subscript_operator_const_index" > index< / a >
### Example
< div > < fiddle-embed name = "e8740493abdf0c6341762db9cee56b89" >
#### Example Output
~~~~
matrix[SkMatrix::kMScaleX] == 42
matrix[SkMatrix::kMScaleY] == 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_set" > set< / a >
---
< a name = "SkMatrix_get" > < / a >
## get
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar get(int index) const
< / pre >
Returns one matrix value. Asserts if < a href = "#SkMatrix_get_index" > index< / a > is out of range and < a href = "undocumented#SK_DEBUG" > SK DEBUG< / a > is
defined.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_get_index" > < code > < strong > index < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > , < a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > < / td >
< / tr >
< / table >
### Return Value
value corresponding to < a href = "#SkMatrix_get_index" > index< / a >
### Example
< div > < fiddle-embed name = "f5ed382bd04fa7d50b2398cce2fca23a" >
#### Example Output
~~~~
matrix.get(SkMatrix::kMSkewX) == 42
matrix.get(SkMatrix::kMSkewY) == 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_subscript_operator_const" > operator[](int index)< / a > < a href = "#SkMatrix_set" > set< / a >
---
< a name = "SkMatrix_getScaleX" > < / a >
## getScaleX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getScaleX() const
< / pre >
Returns scale factor multiplied by x input, contributing to x output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , scales < a href = "#Point" > Points< / a > along the x-axis.
### Return Value
horizontal scale factor
### Example
< div > < fiddle-embed name = "ab746d9be63975041ae8e50cba84dc3d" >
#### Example Output
~~~~
matrix.getScaleX() == 42
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getScaleY" > getScaleY< / a > < a href = "#SkMatrix_setScaleX" > setScaleX< / a > < a href = "#SkMatrix_setScale" > setScale< / a >
---
< a name = "SkMatrix_getScaleY" > < / a >
## getScaleY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getScaleY() const
< / pre >
Returns scale factor multiplied by y input, contributing to y output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , scales < a href = "#Point" > Points< / a > along the y-axis.
### Return Value
vertical scale factor
### Example
< div > < fiddle-embed name = "708b1a548a2f8661b2ab570782fbc751" >
#### Example Output
~~~~
matrix.getScaleY() == 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getScaleX" > getScaleX< / a > < a href = "#SkMatrix_setScaleY" > setScaleY< / a > < a href = "#SkMatrix_setScale" > setScale< / a >
---
< a name = "SkMatrix_getSkewY" > < / a >
## getSkewY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getSkewY() const
< / pre >
Returns scale factor multiplied by x input, contributing to y output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , skews < a href = "#Point" > Points< / a > along the y-axis.
Skew x and y together can rotate < a href = "#Point" > Points< / a > .
### Return Value
vertical skew factor
### Example
< div > < fiddle-embed name = "6be5704506d029ffc91ba03b1d3e674b" >
#### Example Output
~~~~
matrix.getSkewY() == 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getSkewX" > getSkewX< / a > < a href = "#SkMatrix_setSkewY" > setSkewY< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< a name = "SkMatrix_getSkewX" > < / a >
## getSkewX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getSkewX() const
< / pre >
Returns scale factor multiplied by y input, contributing to x output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , skews < a href = "#Point" > Points< / a > along the x-axis.
Skew x and y together can rotate < a href = "#Point" > Points< / a > .
### Return Value
horizontal scale factor
### Example
< div > < fiddle-embed name = "df3a5d3c688e7597eae1e4e07bf91ae6" >
#### Example Output
~~~~
matrix.getSkewX() == 42
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getSkewY" > getSkewY< / a > < a href = "#SkMatrix_setSkewX" > setSkewX< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< a name = "SkMatrix_getTranslateX" > < / a >
## getTranslateX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getTranslateX() const
< / pre >
Returns translation contributing to x output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , moves < a href = "#Point" > Points< / a > along the x-axis.
### Return Value
horizontal translation factor
### Example
< div > < fiddle-embed name = "6236f7f2b91aff977a66ba2ee2558ca4" >
#### Example Output
~~~~
matrix.getTranslateX() == 42
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getTranslateY" > getTranslateY< / a > < a href = "#SkMatrix_setTranslateX" > setTranslateX< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a >
---
< a name = "SkMatrix_getTranslateY" > < / a >
## getTranslateY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getTranslateY() const
< / pre >
Returns translation contributing to y output.
With < a href = "#SkMatrix_mapPoints" > mapPoints< / a > , moves < a href = "#Point" > Points< / a > along the y-axis.
### Return Value
vertical translation factor
### Example
< div > < fiddle-embed name = "08464e32d22421d2b254c71a84545ef5" >
#### Example Output
~~~~
matrix.getTranslateY() == 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_getTranslateX" > getTranslateX< / a > < a href = "#SkMatrix_setTranslateY" > setTranslateY< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a >
---
< a name = "SkMatrix_getPerspX" > < / a >
## getPerspX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getPerspX() const
< / pre >
Returns factor scaling input x relative to input y.
### Return Value
input x perspective factor
### Example
< div > < fiddle-embed name = "a0f5bf4b55e8c33bfda29bf67e34306f" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > < a href = "#SkMatrix_getPerspY" > getPerspY< / a >
---
< a name = "SkMatrix_getPerspY" > < / a >
## getPerspY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getPerspY() const
< / pre >
Returns factor scaling input y relative to input x.
### Return Value
input y perspective factor
### Example
< div > < fiddle-embed name = "424a00a73675dbd99ad20feb0267442b" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > < a href = "#SkMatrix_getPerspX" > getPerspX< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar& operator[](int index)
< / pre >
Returns writable < a href = "#Matrix" > Matrix< / a > value. Asserts if < a href = "#SkMatrix_subscript_operator_index" > index< / a > is out of range and < a href = "undocumented#SK_DEBUG" > SK DEBUG< / a > is
defined. Clears internal cache anticipating that caller will change < a href = "#Matrix" > Matrix< / a > value.
Next call to read < a href = "#Matrix" > Matrix< / a > state may recompute cache; subsequent writes to < a href = "#Matrix" > Matrix< / a >
value must be followed by < a href = "#SkMatrix_dirtyMatrixTypeCache" > dirtyMatrixTypeCache< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_subscript_operator_index" > < code > < strong > index < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > , < a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > < / td >
< / tr >
< / table >
### Return Value
writable value corresponding to < a href = "#SkMatrix_subscript_operator_index" > index< / a >
### Example
< div > < fiddle-embed name = "f4365ef332f51f7fd25040e0771ba9a2" >
#### Example Output
~~~~
with identity matrix: x = 24
after skew x mod: x = 24
after 2nd skew x mod: x = 24
after dirty cache: x = 66
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_get" > get< / a > < a href = "#SkMatrix_dirtyMatrixTypeCache" > dirtyMatrixTypeCache< / a > < a href = "#SkMatrix_set" > set< / a >
---
< a name = "SkMatrix_set" > < / a >
## set
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void set(int index, SkScalar value)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_set_value" > value< / a > . Asserts if < a href = "#SkMatrix_set_index" > index< / a > is out of range and < a href = "undocumented#SK_DEBUG" > SK DEBUG< / a > is
defined. Safer than operator[]; internal cache is always maintained.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_set_index" > < code > < strong > index < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > , < a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_set_value" > < code > < strong > value < / strong > < / code > < / a > < / td > < td >
< a href = "#Scalar" > Scalar< / a > to store in < a href = "#Matrix" > Matrix< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "1d400a92ca826cc89bcb88ea051f28c8" >
#### Example Output
~~~~
with identity matrix: x = 24
after skew x mod: x = 24
after 2nd skew x mod: x = 66
~~~~
< / fiddle-embed > < / div >
### See Also
operator[] < a href = "#SkMatrix_get" > get< / a >
---
< a name = "SkMatrix_setScaleX" > < / a >
## setScaleX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setScaleX(SkScalar v)
< / pre >
Sets horizontal scale factor.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setScaleX_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
horizontal scale factor to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "a39dfed98c3c3c3a56be9ad59fe4e21e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_setScaleY" > setScaleY< / a >
---
< a name = "SkMatrix_setScaleY" > < / a >
## setScaleY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setScaleY(SkScalar v)
< / pre >
Sets vertical scale factor.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setScaleY_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
vertical scale factor to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "f040c6dd85a02e94eaca00d5c2832604" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_setScaleX" > setScaleX< / a >
---
< a name = "SkMatrix_setSkewY" > < / a >
## setSkewY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSkewY(SkScalar v)
< / pre >
Sets vertical skew factor.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSkewY_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
vertical skew factor to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "b418d15df9829aefcc6aca93a37428bb" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a > < a href = "#SkMatrix_setSkewX" > setSkewX< / a >
---
< a name = "SkMatrix_setSkewX" > < / a >
## setSkewX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSkewX(SkScalar v)
< / pre >
Sets horizontal skew factor.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSkewX_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
horizontal skew factor to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "c7177a6fbc1545be95a5ebca87e0cd0d" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a > < a href = "#SkMatrix_setSkewX" > setSkewX< / a >
---
< a name = "SkMatrix_setTranslateX" > < / a >
## setTranslateX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setTranslateX(SkScalar v)
< / pre >
Sets horizontal translation.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setTranslateX_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
horizontal translation to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "a18bc2e3607ac3a8e438bcb61fb13130" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_setTranslateY" > setTranslateY< / a >
---
< a name = "SkMatrix_setTranslateY" > < / a >
## setTranslateY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setTranslateY(SkScalar v)
< / pre >
Sets vertical translation.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setTranslateY_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
vertical translation to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "34e3c70a72b836abf7f4858d35eecc98" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_setTranslateX" > setTranslateX< / a >
---
< a name = "SkMatrix_setPerspX" > < / a >
## setPerspX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setPerspX(SkScalar v)
< / pre >
Sets input x perspective factor, which causes < a href = "#SkMatrix_mapXY" > mapXY< / a > to vary input x inversely
proportional to input y.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setPerspX_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
perspective factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "830a9e4e4bb93d25afd83b2fea63929e" > < / fiddle-embed > < / div >
### See Also
2017-10-31 19:44:45 +00:00
< a href = "#SkMatrix_getPerspX" > getPerspX< / a > < a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setAll" > setAll< / a > < a href = "#SkMatrix_set9" > set9< / a > < a href = "#SkMatrix_MakeAll" > MakeAll< / a >
2017-10-26 11:58:48 +00:00
---
< a name = "SkMatrix_setPerspY" > < / a >
## setPerspY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setPerspY(SkScalar v)
< / pre >
Sets input y perspective factor, which causes < a href = "#SkMatrix_mapXY" > mapXY< / a > to vary input y inversely
proportional to input x.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setPerspY_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
perspective factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "aeb258b7922c1a11b698b00f562182ec" > < / fiddle-embed > < / div >
### See Also
2017-10-31 19:44:45 +00:00
< a href = "#SkMatrix_getPerspY" > getPerspY< / a > < a href = "#SkMatrix_set" > set< / a > < a href = "#SkMatrix_setAll" > setAll< / a > < a href = "#SkMatrix_set9" > set9< / a > < a href = "#SkMatrix_MakeAll" > MakeAll< / a >
2017-10-26 11:58:48 +00:00
---
< a name = "SkMatrix_setAll" > < / a >
## setAll
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setAll(SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY,
SkScalar scaleY, SkScalar transY, SkScalar persp0, SkScalar persp1,
SkScalar persp2)
< / pre >
Sets all values from parameters. Sets matrix to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scaleX skewX transX |
| skewY scaleY transY |
| persp0 persp1 persp2 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setAll_scaleX" > < code > < strong > scaleX < / strong > < / code > < / a > < / td > < td >
horizontal scale factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_skewX" > < code > < strong > skewX < / strong > < / code > < / a > < / td > < td >
horizontal skew factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_transX" > < code > < strong > transX < / strong > < / code > < / a > < / td > < td >
horizontal translation to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_skewY" > < code > < strong > skewY < / strong > < / code > < / a > < / td > < td >
vertical skew factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_scaleY" > < code > < strong > scaleY < / strong > < / code > < / a > < / td > < td >
vertical scale factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_transY" > < code > < strong > transY < / strong > < / code > < / a > < / td > < td >
vertical translation to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_persp0" > < code > < strong > persp0 < / strong > < / code > < / a > < / td > < td >
input x perspective factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_persp1" > < code > < strong > persp1 < / strong > < / code > < / a > < / td > < td >
input y perspective factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setAll_persp2" > < code > < strong > persp2 < / strong > < / code > < / a > < / td > < td >
perspective scale factor to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "c51d81b637b58da30fb9ae2d68877167" > < / fiddle-embed > < / div >
### See Also
2017-10-31 19:44:45 +00:00
< a href = "#SkMatrix_set9" > set9< / a > < a href = "#SkMatrix_MakeAll" > MakeAll< / a >
2017-10-26 11:58:48 +00:00
---
< a name = "SkMatrix_get9" > < / a >
## get9
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void get9(SkScalar buffer[9]) const
< / pre >
Copies nine < a href = "#Scalar" > Scalar< / a > values contained by < a href = "#Matrix" > Matrix< / a > into < a href = "#SkMatrix_get9_buffer" > buffer< / a > , in member value
ascending order: < a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > ,
< a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > , < a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_get9_buffer" > < code > < strong > buffer < / strong > < / code > < / a > < / td > < td >
storage for nine < a href = "#Scalar" > Scalar< / a > values< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "df509d73b47cb98b0475e4465db7b246" >
#### Example Output
~~~~
{4, 0, 3},
{0, 5, 4},
{0, 0, 1}
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_set9" > set9< / a >
---
< a name = "SkMatrix_set9" > < / a >
## set9
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void set9(const SkScalar buffer[9])
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to nine < a href = "#Scalar" > Scalar< / a > values in < a href = "#SkMatrix_set9_buffer" > buffer< / a > , in member value ascending order:
< a href = "#SkMatrix_kMScaleX" > kMScaleX< / a > , < a href = "#SkMatrix_kMSkewX" > kMSkewX< / a > , < a href = "#SkMatrix_kMTransX" > kMTransX< / a > , < a href = "#SkMatrix_kMSkewY" > kMSkewY< / a > , < a href = "#SkMatrix_kMScaleY" > kMScaleY< / a > , < a href = "#SkMatrix_kMTransY" > kMTransY< / a > , < a href = "#SkMatrix_kMPersp0" > kMPersp0< / a > , < a href = "#SkMatrix_kMPersp1" > kMPersp1< / a > ,
< a href = "#SkMatrix_kMPersp2" > kMPersp2< / a > .
Sets matrix to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| buffer[0] buffer[1] buffer[2] |
| buffer[3] buffer[4] buffer[5] |
| buffer[6] buffer[7] buffer[8] |< / pre >
In the future, < a href = "#SkMatrix_set9" > set9< / a > followed by < a href = "#SkMatrix_get9" > get9< / a > may not return the same values. Since < a href = "#Matrix" > Matrix< / a >
maps non-homogeneous coordinates, scaling all nine values produces an equivalent
transformation, possibly improving precision.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_set9_buffer" > < code > < strong > buffer < / strong > < / code > < / a > < / td > < td >
nine < a href = "#Scalar" > Scalar< / a > values< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "ec5de0d23e5fe28ba7628625d1402e85" > < / fiddle-embed > < / div >
### See Also
2017-10-31 19:44:45 +00:00
< a href = "#SkMatrix_setAll" > setAll< / a > < a href = "#SkMatrix_get9" > get9< / a > < a href = "#SkMatrix_MakeAll" > MakeAll< / a >
2017-10-26 11:58:48 +00:00
---
< a name = "SkMatrix_reset" > < / a >
## reset
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void reset()
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to identity; which has no effect on mapped < a href = "#Point" > Points< / a > . Sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |< / pre >
Also called < a href = "#SkMatrix_setIdentity" > setIdentity< / a > ; use the one that provides better inline
documentation.
### Example
< div > < fiddle-embed name = "ca94f7922bc37ef03bbc51ad70536fcf" >
#### Example Output
~~~~
m.isIdentity(): true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_isIdentity" > isIdentity< / a > < a href = "#SkMatrix_setIdentity" > setIdentity< / a >
---
< a name = "SkMatrix_setIdentity" > < / a >
## setIdentity
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setIdentity()
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to identity; which has no effect on mapped < a href = "#Point" > Points< / a > . Sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |< / pre >
Also called < a href = "#SkMatrix_reset" > reset< / a > ; use the one that provides better inline
documentation.
### Example
< div > < fiddle-embed name = "3979c865bb482e6ef1fafc71e56bbb91" >
#### Example Output
~~~~
m.isIdentity(): true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_isIdentity" > isIdentity< / a > < a href = "#SkMatrix_reset" > reset< / a >
---
< a name = "SkMatrix_setTranslate" > < / a >
## setTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setTranslate(SkScalar dx, SkScalar dy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to translate by (< a href = "#SkMatrix_setTranslate_dx" > dx< / a > , < a href = "#SkMatrix_setTranslate_dy" > dy< / a > ).
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setTranslate_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
horizontal translation< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setTranslate_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
vertical translation< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "63ca62985741b1bccb5e8b9cf734874e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setTranslateX" > setTranslateX< / a > < a href = "#SkMatrix_setTranslateY" > setTranslateY< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setTranslate(const SkVector& v)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to translate by (< a href = "#SkMatrix_setTranslate_2_v" > v< / a > .fX, < a href = "#SkMatrix_setTranslate_2_v" > v< / a > .fY).
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setTranslate_2_v" > < code > < strong > v < / strong > < / code > < / a > < / td > < td >
< a href = "undocumented#Vector" > Vector< / a > containing horizontal and vertical translation< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "ccfc734aff2ddea0b097c83f5621de5e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setTranslateX" > setTranslateX< / a > < a href = "#SkMatrix_setTranslateY" > setTranslateY< / a > < a href = "#SkMatrix_MakeTrans" > MakeTrans< / a >
---
< a name = "SkMatrix_setScale" > < / a >
## setScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to scale by < a href = "#SkMatrix_setScale_sx" > sx< / a > and < a href = "#SkMatrix_setScale_sy" > sy< / a > , about a pivot point at (< a href = "#SkMatrix_setScale_px" > px< / a > , < a href = "#SkMatrix_setScale_py" > py< / a > ).
The pivot point is unchanged when mapped with < a href = "#Matrix" > Matrix< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setScale_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScale_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScale_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScale_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "397db8da89bc92e7c576ad013d64ed24" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScaleX" > setScaleX< / a > < a href = "#SkMatrix_setScaleY" > setScaleY< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a > < a href = "#SkMatrix_preScale" > preScale< / a > < a href = "#SkMatrix_postScale" > postScale< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setScale(SkScalar sx, SkScalar sy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to scale by < a href = "#SkMatrix_setScale_2_sx" > sx< / a > and < a href = "#SkMatrix_setScale_2_sy" > sy< / a > about at pivot point at (0, 0).
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setScale_2_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScale_2_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "94a9ec11b994580dca14aa2159a796a9" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScaleX" > setScaleX< / a > < a href = "#SkMatrix_setScaleY" > setScaleY< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a > < a href = "#SkMatrix_preScale" > preScale< / a > < a href = "#SkMatrix_postScale" > postScale< / a >
---
< a name = "SkMatrix_setRotate" > < / a >
## setRotate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setRotate(SkScalar degrees, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to rotate by < a href = "#SkMatrix_setRotate_degrees" > degrees< / a > about a pivot point at (< a href = "#SkMatrix_setRotate_px" > px< / a > , < a href = "#SkMatrix_setRotate_py" > py< / a > ).
The pivot point is unchanged when mapped with < a href = "#Matrix" > Matrix< / a > .
Positive < a href = "#SkMatrix_setRotate_degrees" > degrees< / a > rotates clockwise.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setRotate_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setRotate_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setRotate_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "8c28db3add9cd0177225088f6df6bbb5" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setSinCos" > setSinCos< / a > < a href = "#SkMatrix_preRotate" > preRotate< / a > < a href = "#SkMatrix_postRotate" > postRotate< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setRotate(SkScalar degrees)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to rotate by < a href = "#SkMatrix_setRotate_2_degrees" > degrees< / a > about a pivot point at (0, 0).
Positive < a href = "#SkMatrix_setRotate_2_degrees" > degrees< / a > rotates clockwise.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setRotate_2_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "93efb9d191bf1b9710c173513e014d6c" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setSinCos" > setSinCos< / a > < a href = "#SkMatrix_preRotate" > preRotate< / a > < a href = "#SkMatrix_postRotate" > postRotate< / a >
---
< a name = "SkMatrix_setSinCos" > < / a >
## setSinCos
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSinCos(SkScalar sinValue, SkScalar cosValue, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to rotate by < a href = "#SkMatrix_setSinCos_sinValue" > sinValue< / a > and < a href = "#SkMatrix_setSinCos_cosValue" > cosValue< / a > , about a pivot point at (< a href = "#SkMatrix_setSinCos_px" > px< / a > , < a href = "#SkMatrix_setSinCos_py" > py< / a > ).
The pivot point is unchanged when mapped with < a href = "#Matrix" > Matrix< / a > .
< a href = "undocumented#Vector" > Vector< / a > (< a href = "#SkMatrix_setSinCos_sinValue" > sinValue< / a > , < a href = "#SkMatrix_setSinCos_cosValue" > cosValue< / a > ) describes the angle of rotation relative to (0, 1).
< a href = "undocumented#Vector" > Vector< / a > length specifies scale.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSinCos_sinValue" > < code > < strong > sinValue < / strong > < / code > < / a > < / td > < td >
rotation vector x component< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSinCos_cosValue" > < code > < strong > cosValue < / strong > < / code > < / a > < / td > < td >
rotation vector y component< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSinCos_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSinCos_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "187e1d9228e2e4341ef820bd77b6fda9" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setRotate" > setRotate< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_setRSXform" > setRSXform< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSinCos(SkScalar sinValue, SkScalar cosValue)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to rotate by < a href = "#SkMatrix_setSinCos_2_sinValue" > sinValue< / a > and < a href = "#SkMatrix_setSinCos_2_cosValue" > cosValue< / a > , about a pivot point at (0, 0).
< a href = "undocumented#Vector" > Vector< / a > (< a href = "#SkMatrix_setSinCos_2_sinValue" > sinValue< / a > , < a href = "#SkMatrix_setSinCos_2_cosValue" > cosValue< / a > ) describes the angle of rotation relative to (0, 1).
< a href = "undocumented#Vector" > Vector< / a > length specifies scale.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSinCos_2_sinValue" > < code > < strong > sinValue < / strong > < / code > < / a > < / td > < td >
rotation vector x component< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSinCos_2_cosValue" > < code > < strong > cosValue < / strong > < / code > < / a > < / td > < td >
rotation vector y component< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "e37a94a53c959951b059fcd624639ef6" > < div > < a href = "SkCanvas_Reference#Canvas" > Canvas< / a > needs offset after applying < a href = "#Matrix" > Matrix< / a > to pivot about < a href = "SkRect_Reference#Rect" > Rect< / a > center.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setRotate" > setRotate< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_setRSXform" > setRSXform< / a >
---
< a name = "SkMatrix_setRSXform" > < / a >
## setRSXform
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkMatrix& setRSXform(const SkRSXform& rsxForm)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to rotate, scale, and translate using a compressed matrix form.
< a href = "undocumented#Vector" > Vector< / a > (< a href = "#SkMatrix_setRSXform_rsxForm" > rsxForm< / a > .fSSin, < a href = "#SkMatrix_setRSXform_rsxForm" > rsxForm< / a > .fSCos) describes the angle of rotation relative
to (0, 1). < a href = "undocumented#Vector" > Vector< / a > length specifies scale. Mapped point is rotated and scaled
by < a href = "undocumented#Vector" > Vector< / a > , then translated by (< a href = "#SkMatrix_setRSXform_rsxForm" > rsxForm< / a > .fTx, < a href = "#SkMatrix_setRSXform_rsxForm" > rsxForm< / a > .fTy).
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setRSXform_rsxForm" > < code > < strong > rsxForm < / strong > < / code > < / a > < / td > < td >
compressed < a href = "undocumented#RSXform" > RSXform< / a > matrix< / td >
< / tr >
< / table >
### Return Value
reference to < a href = "#Matrix" > Matrix< / a >
### Example
< div > < fiddle-embed name = "c3f5faddca466f78278b32b88fd5f5eb" > < div > < a href = "SkCanvas_Reference#Canvas" > Canvas< / a > needs offset after applying < a href = "#Matrix" > Matrix< / a > to pivot about < a href = "SkRect_Reference#Rect" > Rect< / a > center.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setSinCos" > setSinCos< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a >
---
< a name = "SkMatrix_setSkew" > < / a >
## setSkew
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to skew by < a href = "#SkMatrix_setSkew_kx" > kx< / a > and < a href = "#SkMatrix_setSkew_ky" > ky< / a > , about a pivot point at (< a href = "#SkMatrix_setSkew_px" > px< / a > , < a href = "#SkMatrix_setSkew_py" > py< / a > ).
The pivot point is unchanged when mapped with < a href = "#Matrix" > Matrix< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSkew_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSkew_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSkew_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSkew_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "55e0431adc6c5b1987ebb8123cc10342" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setSkewX" > setSkewX< / a > < a href = "#SkMatrix_setSkewY" > setSkewY< / a > < a href = "#SkMatrix_preSkew" > preSkew< / a > < a href = "#SkMatrix_postSkew" > postSkew< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setSkew(SkScalar kx, SkScalar ky)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to skew by < a href = "#SkMatrix_setSkew_2_kx" > kx< / a > and < a href = "#SkMatrix_setSkew_2_ky" > ky< / a > , about a pivot point at (0, 0).
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setSkew_2_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setSkew_2_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "05be7844e9afdd7b9bfc31c5423a70a2" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setSkewX" > setSkewX< / a > < a href = "#SkMatrix_setSkewY" > setSkewY< / a > < a href = "#SkMatrix_preSkew" > preSkew< / a > < a href = "#SkMatrix_postSkew" > postSkew< / a >
---
< a name = "SkMatrix_setConcat" > < / a >
## setConcat
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setConcat(const SkMatrix& a, const SkMatrix& b)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_setConcat_a" > a< / a > multiplied by < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_setConcat_b" > b< / a > . Either < a href = "#SkMatrix_setConcat_a" > a< / a > or < a href = "#SkMatrix_setConcat_b" > b< / a > may be this.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L |
a = | D E F |, b = | M N O |
| G H I | | P Q R |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR |
a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
| G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setConcat_a" > < code > < strong > a < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on left side of multiply expression< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setConcat_b" > < code > < strong > b < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on right side of multiply expression< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "0381a10ac69bdefdf9d15b47cbb9fefe" > < div > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > creates perspective matrices, one the inverse of the other.
Multiplying the matrix by its inverse turns into an identity matrix.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_Concat" > Concat< / a > < a href = "#SkMatrix_preConcat" > preConcat< / a > < a href = "#SkMatrix_postConcat" > postConcat< / a > < a href = "#SkCanvas_concat" > SkCanvas::concat< / a >
---
< a name = "SkMatrix_preTranslate" > < / a >
## preTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preTranslate(SkScalar dx, SkScalar dy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from translation (< a href = "#SkMatrix_preTranslate_dx" > dx< / a > , < a href = "#SkMatrix_preTranslate_dy" > dy< / a > ).
This can be thought of as moving the point to be mapped before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 0 dx |
Matrix = | D E F |, T(dx, dy) = | 0 1 dy |
| G H I | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 0 dx | | A B A*dx+B*dy+C |
Matrix * T(dx, dy) = | D E F | | 0 1 dy | = | D E D*dx+E*dy+F |
| G H I | | 0 0 1 | | G H G*dx+H*dy+I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preTranslate_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
x translation before applying < a href = "#Matrix" > Matrix< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_preTranslate_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
y translation before applying < a href = "#Matrix" > Matrix< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "08f6749933f4ce541073077ab506fd9b" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postTranslate" > postTranslate< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_MakeTrans" > MakeTrans< / a >
---
< a name = "SkMatrix_preScale" > < / a >
## preScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from scaling by (< a href = "#SkMatrix_preScale_sx" > sx< / a > , < a href = "#SkMatrix_preScale_sy" > sy< / a > )
about pivot point (< a href = "#SkMatrix_preScale_px" > px< / a > , < a href = "#SkMatrix_preScale_py" > py< / a > ).
This can be thought of as scaling about a pivot point before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | sx 0 dx |
Matrix = | D E F |, S(sx, sy, px, py) = | 0 sy dy |
| G H I | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
dx = px - sx * px
dy = py - sy * py< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | sx 0 dx | | A*sx B*sy A*dx+B*dy+C |
Matrix * S(sx, sy, px, py) = | D E F | | 0 sy dy | = | D*sx E*sy D*dx+E*dy+F |
| G H I | | 0 0 1 | | G*sx H*sy G*dx+H*dy+I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preScale_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preScale_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preScale_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preScale_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "2531f8d1e05d7b6dc22f3efcd2fb84e4" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postScale" > postScale< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preScale(SkScalar sx, SkScalar sy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from scaling by (< a href = "#SkMatrix_preScale_2_sx" > sx< / a > , < a href = "#SkMatrix_preScale_2_sy" > sy< / a > )
about pivot point (0, 0).
This can be thought of as scaling about the origin before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | sx 0 0 |
Matrix = | D E F |, S(sx, sy) = | 0 sy 0 |
| G H I | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | sx 0 0 | | A*sx B*sy C |
Matrix * S(sx, sy) = | D E F | | 0 sy 0 | = | D*sx E*sy F |
| G H I | | 0 0 1 | | G*sx H*sy I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preScale_2_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preScale_2_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "3edbdea8e43d06086abf33ec4a9b415b" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postScale" > postScale< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< a name = "SkMatrix_preRotate" > < / a >
## preRotate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preRotate(SkScalar degrees, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from rotating by < a href = "#SkMatrix_preRotate_degrees" > degrees< / a >
about pivot point (< a href = "#SkMatrix_preRotate_px" > px< / a > , < a href = "#SkMatrix_preRotate_py" > py< / a > ).
This can be thought of as rotating about a pivot point before applying < a href = "#Matrix" > Matrix< / a > .
Positive < a href = "#SkMatrix_preRotate_degrees" > degrees< / a > rotates clockwise.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | c -s dx |
Matrix = | D E F |, R(degrees, px, py) = | s c dy |
| G H I | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
c = cos(degrees)
s = sin(degrees)
dx = s * py + (1 - c) * px
dy = -s * px + (1 - c) * py</ pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | c -s dx | | Ac+Bs -As+Bc A*dx+B*dy+C |
Matrix * R(degrees, px, py) = | D E F | | s c dy | = | Dc+Es -Ds+Ec D*dx+E*dy+F |
| G H I | | 0 0 1 | | Gc+Hs -Gs+Hc G*dx+H*dy+I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preRotate_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preRotate_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preRotate_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "a70bb18d67c06a20ab514e7a47924e5a" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postRotate" > postRotate< / a > < a href = "#SkMatrix_setRotate" > setRotate< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preRotate(SkScalar degrees)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from rotating by < a href = "#SkMatrix_preRotate_2_degrees" > degrees< / a >
about pivot point (0, 0).
This can be thought of as rotating about the origin before applying < a href = "#Matrix" > Matrix< / a > .
Positive < a href = "#SkMatrix_preRotate_2_degrees" > degrees< / a > rotates clockwise.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | c -s 0 |
Matrix = | D E F |, R(degrees, px, py) = | s c 0 |
| G H I | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
c = cos(degrees)
s = sin(degrees)< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | c -s 0 | | Ac+Bs -As+Bc C |
Matrix * R(degrees, px, py) = | D E F | | s c 0 | = | Dc+Es -Ds+Ec F |
| G H I | | 0 0 1 | | Gc+Hs -Gs+Hc I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preRotate_2_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "5acd49bd931c79a808dd6c7cc0e92f72" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postRotate" > postRotate< / a > < a href = "#SkMatrix_setRotate" > setRotate< / a >
---
< a name = "SkMatrix_preSkew" > < / a >
## preSkew
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from skewing by (< a href = "#SkMatrix_preSkew_kx" > kx< / a > , < a href = "#SkMatrix_preSkew_ky" > ky< / a > )
about pivot point (< a href = "#SkMatrix_preSkew_px" > px< / a > , < a href = "#SkMatrix_preSkew_py" > py< / a > ).
This can be thought of as skewing about a pivot point before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 kx dx |
Matrix = | D E F |, K(kx, ky, px, py) = | ky 1 dy |
| G H I | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
dx = -kx * py
dy = -ky * px< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 kx dx | | A+B*ky A*kx+B A*dx+B*dy+C |
Matrix * K(kx, ky, px, py) = | D E F | | ky 1 dy | = | D+E*ky D*kx+E D*dx+E*dy+F |
| G H I | | 0 0 1 | | G+H*ky G*kx+H G*dx+H*dy+I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preSkew_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preSkew_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preSkew_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preSkew_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "199a18ad61d702664ce6df1d7037aa48" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postSkew" > postSkew< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preSkew(SkScalar kx, SkScalar ky)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > constructed from skewing by (< a href = "#SkMatrix_preSkew_2_kx" > kx< / a > , < a href = "#SkMatrix_preSkew_2_ky" > ky< / a > )
about pivot point (0, 0).
This can be thought of as skewing about the origin before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 kx 0 |
Matrix = | D E F |, K(kx, ky) = | ky 1 0 |
| G H I | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | 1 kx 0 | | A+B*ky A*kx+B C |
Matrix * K(kx, ky) = | D E F | | ky 1 0 | = | D+E*ky D*kx+E F |
| G H I | | 0 0 1 | | G+H*ky G*kx+H I |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preSkew_2_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_preSkew_2_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "e100c543869fe8fd516ba69de79444ba" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postSkew" > postSkew< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< a name = "SkMatrix_preConcat" > < / a >
## preConcat
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void preConcat(const SkMatrix& other)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > multiplied by < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_preConcat_other" > other< / a > .
This can be thought of mapping by < a href = "#SkMatrix_preConcat_other" > other< / a > before applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L |
Matrix = | D E F |, other = | M N O |
| G H I | | P Q R |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR |
Matrix * other = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
| G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_preConcat_other" > < code > < strong > other < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on right side of multiply expression< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "b07e62298e7b0ab5683db199faffceb2" > < div > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > creates perspective matrices, one the inverse of the < a href = "#SkMatrix_preConcat_other" > other< / a > .
Multiplying the matrix by its inverse turns into an identity matrix.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postConcat" > postConcat< / a > < a href = "#SkMatrix_setConcat" > setConcat< / a > < a href = "#SkMatrix_Concat" > Concat< / a >
---
< a name = "SkMatrix_postTranslate" > < / a >
## postTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postTranslate(SkScalar dx, SkScalar dy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from translation (< a href = "#SkMatrix_postTranslate_dx" > dx< / a > , < a href = "#SkMatrix_postTranslate_dy" > dy< / a > ) multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as moving the point to be mapped after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | 1 0 dx |
Matrix = | M N O |, T(dx, dy) = | 0 1 dy |
| P Q R | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 dx | | J K L | | J+dx*P K+dx*Q L+dx*R |
T(dx, dy) * Matrix = | 0 1 dy | | M N O | = | M+dy*P N+dy*Q O+dy*R |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postTranslate_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
x translation after applying < a href = "#Matrix" > Matrix< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_postTranslate_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
y translation after applying < a href = "#Matrix" > Matrix< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "57e4cff302c0d754ac6c66050d741772" > < div > Compare with < a href = "#SkMatrix_preTranslate" > preTranslate< / a > example.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preTranslate" > preTranslate< / a > < a href = "#SkMatrix_setTranslate" > setTranslate< / a > < a href = "#SkMatrix_MakeTrans" > MakeTrans< / a >
---
< a name = "SkMatrix_postScale" > < / a >
## postScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from scaling by (< a href = "#SkMatrix_postScale_sx" > sx< / a > , < a href = "#SkMatrix_postScale_sy" > sy< / a > ) about pivot point
(< a href = "#SkMatrix_postScale_px" > px< / a > , < a href = "#SkMatrix_postScale_py" > py< / a > ), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as scaling about a pivot point after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | sx 0 dx |
Matrix = | M N O |, S(sx, sy, px, py) = | 0 sy dy |
| P Q R | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
dx = px - sx * px
dy = py - sy * py< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| sx 0 dx | | J K L | | sx*J+dx*P sx*K+dx*Q sx*L+dx+R |
S(sx, sy, px, py) * Matrix = | 0 sy dy | | M N O | = | sy*M+dy*P sy*N+dy*Q sy*O+dy*R |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postScale_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postScale_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postScale_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postScale_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "ed3aa18ba0ea95c85cc49aa3829fe384" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preScale" > preScale< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postScale(SkScalar sx, SkScalar sy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from scaling by (< a href = "#SkMatrix_postScale_2_sx" > sx< / a > , < a href = "#SkMatrix_postScale_2_sy" > sy< / a > ) about pivot point
(0, 0), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as scaling about the origin after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | sx 0 0 |
Matrix = | M N O |, S(sx, sy) = | 0 sy 0 |
| P Q R | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| sx 0 0 | | J K L | | sx*J sx*K sx*L |
S(sx, sy) * Matrix = | 0 sy 0 | | M N O | = | sy*M sy*N sy*O |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postScale_2_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postScale_2_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "1931017698766a67d3a26423453b8095" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preScale" > preScale< / a > < a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< a name = "SkMatrix_postIDiv" > < / a >
## postIDiv
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool postIDiv(int divx, int divy)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from scaling by(1/< a href = "#SkMatrix_postIDiv_divx" > divx< / a > , 1/< a href = "#SkMatrix_postIDiv_divy" > divy< / a > )about pivot point (px, py), multiplied by < a href = "#Matrix" > Matrix< / a > .
Returns false if either < a href = "#SkMatrix_postIDiv_divx" > divx< / a > or < a href = "#SkMatrix_postIDiv_divy" > divy< / a > is zero.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | sx 0 0 |
Matrix = | M N O |, I(divx, divy) = | 0 sy 0 |
| P Q R | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
sx = 1 / divx
sy = 1 / divy< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| sx 0 0 | | J K L | | sx*J sx*K sx*L |
I(divx, divy) * Matrix = | 0 sy 0 | | M N O | = | sy*M sy*N sy*O |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postIDiv_divx" > < code > < strong > divx < / strong > < / code > < / a > < / td > < td >
integer divisor for inverse scale in x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postIDiv_divy" > < code > < strong > divy < / strong > < / code > < / a > < / td > < td >
integer divisor for inverse scale in y< / td >
< / tr >
< / table >
### Return Value
true on successful scale
### Example
< div > < fiddle-embed name = "58c844b8f0c36acdbc8211e8c929c253" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_postScale" > postScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< a name = "SkMatrix_postRotate" > < / a >
## postRotate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postRotate(SkScalar degrees, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from rotating by < a href = "#SkMatrix_postRotate_degrees" > degrees< / a > about pivot point
(< a href = "#SkMatrix_postRotate_px" > px< / a > , < a href = "#SkMatrix_postRotate_py" > py< / a > ), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as rotating about a pivot point after applying < a href = "#Matrix" > Matrix< / a > .
Positive < a href = "#SkMatrix_postRotate_degrees" > degrees< / a > rotates clockwise.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | c -s dx |
Matrix = | M N O |, R(degrees, px, py) = | s c dy |
| P Q R | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
c = cos(degrees)
s = sin(degrees)
dx = s * py + (1 - c) * px
dy = -s * px + (1 - c) * py</ pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|c -s dx| |J K L| |cJ-sM+dx*P cK-sN+dx*Q cL-sO+dx+R|
R(degrees, px, py) * Matrix = |s c dy| |M N O| = |sJ+cM+dy*P sK+cN+dy*Q sL+cO+dy*R|
|0 0 1| |P Q R| | P Q R|< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postRotate_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postRotate_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postRotate_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "e09194ee48a81e7b375ade473d340f0d" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preRotate" > preRotate< / a > < a href = "#SkMatrix_setRotate" > setRotate< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postRotate(SkScalar degrees)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from rotating by < a href = "#SkMatrix_postRotate_2_degrees" > degrees< / a > about pivot point
(0, 0), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as rotating about the origin after applying < a href = "#Matrix" > Matrix< / a > .
Positive < a href = "#SkMatrix_postRotate_2_degrees" > degrees< / a > rotates clockwise.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | c -s 0 |
Matrix = | M N O |, R(degrees, px, py) = | s c 0 |
| P Q R | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
c = cos(degrees)
s = sin(degrees)< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| c -s dx | | J K L | | cJ-sM cK-sN cL-sO |
R(degrees, px, py) * Matrix = | s c dy | | M N O | = | sJ+cM sK+cN sL+cO |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postRotate_2_degrees" > < code > < strong > degrees < / strong > < / code > < / a > < / td > < td >
angle of axes relative to upright axes< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "52e4c53e26971af5576b30de60fa70c2" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preRotate" > preRotate< / a > < a href = "#SkMatrix_setRotate" > setRotate< / a >
---
< a name = "SkMatrix_postSkew" > < / a >
## postSkew
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postSkew(SkScalar kx, SkScalar ky, SkScalar px, SkScalar py)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from skewing by (< a href = "#SkMatrix_postSkew_kx" > kx< / a > , < a href = "#SkMatrix_postSkew_ky" > ky< / a > ) about pivot point
(< a href = "#SkMatrix_postSkew_px" > px< / a > , < a href = "#SkMatrix_postSkew_py" > py< / a > ), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as skewing about a pivot point after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | 1 kx dx |
Matrix = | M N O |, K(kx, ky, px, py) = | ky 1 dy |
| P Q R | | 0 0 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
dx = -kx * py
dy = -ky * px< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 kx dx| |J K L| |J+kx*M+dx*P K+kx*N+dx*Q L+kx*O+dx+R|
K(kx, ky, px, py) * Matrix = |ky 1 dy| |M N O| = |ky*J+M+dy*P ky*K+N+dy*Q ky*L+O+dy*R|
| 0 0 1| |P Q R| | P Q R|< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postSkew_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postSkew_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postSkew_px" > < code > < strong > px < / strong > < / code > < / a > < / td > < td >
pivot x< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postSkew_py" > < code > < strong > py < / strong > < / code > < / a > < / td > < td >
pivot y< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "8c34ae3a2b7e2742bb969819737365ec" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preSkew" > preSkew< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postSkew(SkScalar kx, SkScalar ky)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > constructed from skewing by (< a href = "#SkMatrix_postSkew_2_kx" > kx< / a > , < a href = "#SkMatrix_postSkew_2_ky" > ky< / a > ) about pivot point
(0, 0), multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of as skewing about the origin after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | 1 kx 0 |
Matrix = | M N O |, K(kx, ky) = | ky 1 0 |
| P Q R | | 0 0 1 |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 kx 0 | | J K L | | J+kx*M K+kx*N L+kx*O |
K(kx, ky) * Matrix = | ky 1 0 | | M N O | = | ky*J+M ky*K+N ky*L+O |
| 0 0 1 | | P Q R | | P Q R |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postSkew_2_kx" > < code > < strong > kx < / strong > < / code > < / a > < / td > < td >
horizontal skew factor< / td >
< / tr > < tr > < td > < a name = "SkMatrix_postSkew_2_ky" > < code > < strong > ky < / strong > < / code > < / a > < / td > < td >
vertical skew factor< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "3aa2603225dff72ac53dd359f897f494" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preSkew" > preSkew< / a > < a href = "#SkMatrix_setSkew" > setSkew< / a >
---
< a name = "SkMatrix_postConcat" > < / a >
## postConcat
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void postConcat(const SkMatrix& other)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_postConcat_other" > other< / a > multiplied by < a href = "#Matrix" > Matrix< / a > .
This can be thought of mapping by < a href = "#SkMatrix_postConcat_other" > other< / a > after applying < a href = "#Matrix" > Matrix< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| J K L | | A B C |
Matrix = | M N O |, other = | D E F |
| P Q R | | G H I |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR |
other * Matrix = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
| G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_postConcat_other" > < code > < strong > other < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on left side of multiply expression< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "0a4214289249c77f48d59227c4ac4d9e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preConcat" > preConcat< / a > < a href = "#SkMatrix_setConcat" > setConcat< / a > < a href = "#SkMatrix_Concat" > Concat< / a >
---
## <a name="SkMatrix_ScaleToFit"></a> Enum SkMatrix::ScaleToFit
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
enum < a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > {
< a href = "#SkMatrix_kFill_ScaleToFit" > kFill ScaleToFit< / a > ,
< a href = "#SkMatrix_kStart_ScaleToFit" > kStart ScaleToFit< / a > ,
< a href = "#SkMatrix_kCenter_ScaleToFit" > kCenter ScaleToFit< / a > ,
< a href = "#SkMatrix_kEnd_ScaleToFit" > kEnd ScaleToFit< / a > ,
};< / pre >
< a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > describes how < a href = "#Matrix" > Matrix< / a > is constructed to map one < a href = "SkRect_Reference#Rect" > Rect< / a > to another.
< a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > may allow < a href = "#Matrix" > Matrix< / a > to have unequal horizontal and vertical scaling,
or may restrict < a href = "#Matrix" > Matrix< / a > to square scaling. If restricted, < a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > specifies
how < a href = "#Matrix" > Matrix< / a > maps to the side or center of the destination < a href = "SkRect_Reference#Rect" > Rect< / a > .
### Constants
< table >
< tr >
< td > < a name = "SkMatrix_kFill_ScaleToFit" > < code > < strong > SkMatrix::kFill_ScaleToFit < / strong > < / code > < / a > < / td > < td > 0< / td > < td > Computes < a href = "#Matrix" > Matrix< / a > that scales in x and y independently, so that source < a href = "SkRect_Reference#Rect" > Rect< / a > is
mapped to completely fill destination < a href = "SkRect_Reference#Rect" > Rect< / a > . The aspect ratio of source < a href = "SkRect_Reference#Rect" > Rect< / a >
may change.< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kStart_ScaleToFit" > < code > < strong > SkMatrix::kStart_ScaleToFit < / strong > < / code > < / a > < / td > < td > 1< / td > < td > Computes < a href = "#Matrix" > Matrix< / a > that maintains source < a href = "SkRect_Reference#Rect" > Rect< / a > aspect ratio, mapping source < a href = "SkRect_Reference#Rect" > Rect< / a >
width or height to destination < a href = "SkRect_Reference#Rect" > Rect< / a > . Aligns mapping to left and top edges
of destination < a href = "SkRect_Reference#Rect" > Rect< / a > .< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kCenter_ScaleToFit" > < code > < strong > SkMatrix::kCenter_ScaleToFit < / strong > < / code > < / a > < / td > < td > 2< / td > < td > Computes < a href = "#Matrix" > Matrix< / a > that maintains source < a href = "SkRect_Reference#Rect" > Rect< / a > aspect ratio, mapping source < a href = "SkRect_Reference#Rect" > Rect< / a >
width or height to destination < a href = "SkRect_Reference#Rect" > Rect< / a > . Aligns mapping to center of destination
< a href = "SkRect_Reference#Rect" > Rect< / a > .< / td >
< / tr >
< tr >
< td > < a name = "SkMatrix_kEnd_ScaleToFit" > < code > < strong > SkMatrix::kEnd_ScaleToFit < / strong > < / code > < / a > < / td > < td > 3< / td > < td > Computes < a href = "#Matrix" > Matrix< / a > that maintains source < a href = "SkRect_Reference#Rect" > Rect< / a > aspect ratio, mapping source < a href = "SkRect_Reference#Rect" > Rect< / a >
width or height to destination < a href = "SkRect_Reference#Rect" > Rect< / a > . Aligns mapping to right and bottom
edges of destination < a href = "SkRect_Reference#Rect" > Rect< / a > .< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "17c3070b31b700ea8f52e48af9a66b6e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setRectToRect" > setRectToRect< / a > < a href = "#SkMatrix_MakeRectToRect" > MakeRectToRect< / a > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a >
< a name = "SkMatrix_setRectToRect" > < / a >
## setRectToRect
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool setRectToRect(const SkRect& src, const SkRect& dst, ScaleToFit stf)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to scale and translate < a href = "#SkMatrix_setRectToRect_src" > src< / a > < a href = "SkRect_Reference#Rect" > Rect< / a > to < a href = "#SkMatrix_setRectToRect_dst" > dst< / a > < a href = "SkRect_Reference#Rect" > Rect< / a > . < a href = "#SkMatrix_setRectToRect_stf" > stf< / a > selects whether
mapping completely fills < a href = "#SkMatrix_setRectToRect_dst" > dst< / a > or preserves the aspect ratio, and how to align
< a href = "#SkMatrix_setRectToRect_src" > src< / a > within < a href = "#SkMatrix_setRectToRect_dst" > dst< / a > . Returns false if < a href = "#SkMatrix_setRectToRect_src" > src< / a > is empty, and sets < a href = "#Matrix" > Matrix< / a > to identity.
Returns true if < a href = "#SkMatrix_setRectToRect_dst" > dst< / a > is empty, and sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 0 0 0 |
| 0 0 0 |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setRectToRect_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map from< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setRectToRect_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map to< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setRectToRect_stf" > < code > < strong > stf < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kFill_ScaleToFit" > kFill ScaleToFit< / a > , < a href = "#SkMatrix_kStart_ScaleToFit" > kStart ScaleToFit< / a > ,
< a href = "#SkMatrix_kCenter_ScaleToFit" > kCenter ScaleToFit< / a > , < a href = "#SkMatrix_kEnd_ScaleToFit" > kEnd ScaleToFit< / a > < / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > can represent < a href = "SkRect_Reference#Rect" > Rect< / a > mapping
### Example
< div > < fiddle-embed name = "69cdea599dcaaec35efcb24403f4287b" >
#### Example Output
~~~~
src: 0, 0, 0, 0 dst: 0, 0, 0, 0 success: false
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 0, 0, 0, 0 dst: 5, 6, 8, 9 success: false
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 1, 2, 3, 4 dst: 0, 0, 0, 0 success: true
[ 0.0000 0.0000 0.0000][ 0.0000 0.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 1, 2, 3, 4 dst: 5, 6, 8, 9 success: true
[ 1.5000 0.0000 3.5000][ 0.0000 1.5000 3.0000][ 0.0000 0.0000 1.0000]
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_MakeRectToRect" > MakeRectToRect< / a > < a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > < a href = "#SkRect_isEmpty" > SkRect::isEmpty< / a >
---
< a name = "SkMatrix_MakeRectToRect" > < / a >
## MakeRectToRect
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix MakeRectToRect(const SkRect& src, const SkRect& dst,
ScaleToFit stf)
< / pre >
Returns < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_set" > set< / a > to scale and translate < a href = "#SkMatrix_MakeRectToRect_src" > src< / a > < a href = "SkRect_Reference#Rect" > Rect< / a > to < a href = "#SkMatrix_MakeRectToRect_dst" > dst< / a > < a href = "SkRect_Reference#Rect" > Rect< / a > . < a href = "#SkMatrix_MakeRectToRect_stf" > stf< / a > selects
whether mapping completely fills < a href = "#SkMatrix_MakeRectToRect_dst" > dst< / a > or preserves the aspect ratio, and how to
align < a href = "#SkMatrix_MakeRectToRect_src" > src< / a > within < a href = "#SkMatrix_MakeRectToRect_dst" > dst< / a > . Returns the identity < a href = "#Matrix" > Matrix< / a > if < a href = "#SkMatrix_MakeRectToRect_src" > src< / a > is empty. If < a href = "#SkMatrix_MakeRectToRect_dst" > dst< / a > is
empty, returns < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_set" > set< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 0 0 0 |
| 0 0 0 |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_MakeRectToRect_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map from< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeRectToRect_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map to< / td >
< / tr > < tr > < td > < a name = "SkMatrix_MakeRectToRect_stf" > < code > < strong > stf < / strong > < / code > < / a > < / td > < td >
one of: < a href = "#SkMatrix_kFill_ScaleToFit" > kFill ScaleToFit< / a > , < a href = "#SkMatrix_kStart_ScaleToFit" > kStart ScaleToFit< / a > ,
< a href = "#SkMatrix_kCenter_ScaleToFit" > kCenter ScaleToFit< / a > , < a href = "#SkMatrix_kEnd_ScaleToFit" > kEnd ScaleToFit< / a > < / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > mapping < a href = "#SkMatrix_MakeRectToRect_src" > src< / a > to < a href = "#SkMatrix_MakeRectToRect_dst" > dst< / a >
### Example
< div > < fiddle-embed name = "a1d6a6721b39350f81021f71a1b93208" >
#### Example Output
~~~~
src: 0, 0, 0, 0 dst: 0, 0, 0, 0
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 0, 0, 0, 0 dst: 5, 6, 8, 9
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 1, 2, 3, 4 dst: 0, 0, 0, 0
[ 0.0000 0.0000 0.0000][ 0.0000 0.0000 0.0000][ 0.0000 0.0000 1.0000]
src: 1, 2, 3, 4 dst: 5, 6, 8, 9
[ 1.5000 0.0000 3.5000][ 0.0000 1.5000 3.0000][ 0.0000 0.0000 1.0000]
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setRectToRect" > setRectToRect< / a > < a href = "#SkMatrix_ScaleToFit" > ScaleToFit< / a > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > < a href = "#SkRect_isEmpty" > SkRect::isEmpty< / a >
---
< a name = "SkMatrix_setPolyToPoly" > < / a >
## setPolyToPoly
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count)
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to map < a href = "#SkMatrix_setPolyToPoly_src" > src< / a > to < a href = "#SkMatrix_setPolyToPoly_dst" > dst< / a > . < a href = "#SkMatrix_setPolyToPoly_count" > count< / a > must be zero or greater, and four or less.
If < a href = "#SkMatrix_setPolyToPoly_count" > count< / a > is zero, sets < a href = "#Matrix" > Matrix< / a > to identity and returns true.
If < a href = "#SkMatrix_setPolyToPoly_count" > count< / a > is one, sets < a href = "#Matrix" > Matrix< / a > to translate and returns true.
If < a href = "#SkMatrix_setPolyToPoly_count" > count< / a > is two or more, sets < a href = "#Matrix" > Matrix< / a > to map < a href = "#Point" > Points< / a > if possible; returns false
if < a href = "#Matrix" > Matrix< / a > cannot be constructed. If < a href = "#SkMatrix_setPolyToPoly_count" > count< / a > is four, < a href = "#Matrix" > Matrix< / a > may include
perspective.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setPolyToPoly_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "#Point" > Points< / a > to map from< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setPolyToPoly_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
< a href = "#Point" > Points< / a > to map to< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setPolyToPoly_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Point" > Points< / a > in < a href = "#SkMatrix_setPolyToPoly_src" > src< / a > and < a href = "#SkMatrix_setPolyToPoly_dst" > dst< / a > < / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > was constructed successfully
### Example
< div > < fiddle-embed name = "c851d1313e8909aaea4f0591699fdb7b" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setRectToRect" > setRectToRect< / a > < a href = "#SkMatrix_MakeRectToRect" > MakeRectToRect< / a >
---
< a name = "SkMatrix_invert" > < / a >
## invert
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool SK_WARN_UNUSED_RESULT invert(SkMatrix* inverse) const
< / pre >
Sets < a href = "#SkMatrix_invert_inverse" > inverse< / a > to reciprocal matrix, returning true if < a href = "#Matrix" > Matrix< / a > can be inverted.
Geometrically, if < a href = "#Matrix" > Matrix< / a > maps from source to destination, < a href = "#SkMatrix_invert_inverse" > inverse< / a > < a href = "#Matrix" > Matrix< / a >
maps from destination to source. If < a href = "#Matrix" > Matrix< / a > can not be inverted, < a href = "#SkMatrix_invert_inverse" > inverse< / a > is
unchanged.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_invert_inverse" > < code > < strong > inverse < / strong > < / code > < / a > < / td > < td >
storage for inverted < a href = "#Matrix" > Matrix< / a > ; may be nullptr< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > can be inverted
### Example
< div > < fiddle-embed name = "10a10c5bf2ac7ec88e84204441fc83b6" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_Concat" > Concat< / a >
---
< a name = "SkMatrix_SetAffineIdentity" > < / a >
## SetAffineIdentity
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static void SetAffineIdentity(SkScalar affine[6])
< / pre >
Fills < a href = "#SkMatrix_SetAffineIdentity_affine" > affine< / a > with identity values in column major order.
Sets < a href = "#SkMatrix_SetAffineIdentity_affine" > affine< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 0 |
| 0 1 0 |< / pre >
Affine 3x2 matrices in column major order are used by < a href = "undocumented#OpenGL" > OpenGL< / a > and < a href = "undocumented#XPS" > XPS< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_SetAffineIdentity_affine" > < code > < strong > affine < / strong > < / code > < / a > < / td > < td >
storage for 3x2 < a href = "#SkMatrix_SetAffineIdentity_affine" > affine< / a > matrix< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "e10adbd0bcc940c5d4d872db0e78e892" >
#### Example Output
~~~~
ScaleX: 1 SkewY: 0 SkewX: 0 ScaleY: 1 TransX: 0 TransY: 0
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setAffine" > setAffine< / a > < a href = "#SkMatrix_asAffine" > asAffine< / a >
---
< a name = "SkMatrix_asAffine" > < / a >
## asAffine
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool SK_WARN_UNUSED_RESULT asAffine(SkScalar affine[6]) const
< / pre >
Fills < a href = "#SkMatrix_asAffine_affine" > affine< / a > in column major order. Sets < a href = "#SkMatrix_asAffine_affine" > affine< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x skew-x translate-x |
| skew-y scale-y translate-y |< / pre >
If < a href = "#Matrix" > Matrix< / a > contains perspective, returns false and leaves < a href = "#SkMatrix_asAffine_affine" > affine< / a > unchanged.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_asAffine_affine" > < code > < strong > affine < / strong > < / code > < / a > < / td > < td >
storage for 3x2 < a href = "#SkMatrix_asAffine_affine" > affine< / a > matrix; may be nullptr< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#Matrix" > Matrix< / a > does not contain perspective
### Example
< div > < fiddle-embed name = "752e4a48ed1dae05765a2499c390f277" >
#### Example Output
~~~~
ScaleX: 2 SkewY: 5 SkewX: 3 ScaleY: 6 TransX: 4 TransY: 7
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setAffine" > setAffine< / a > < a href = "#SkMatrix_SetAffineIdentity" > SetAffineIdentity< / a >
---
< a name = "SkMatrix_setAffine" > < / a >
## setAffine
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setAffine(const SkScalar affine[6])
< / pre >
Sets < a href = "#Matrix" > Matrix< / a > to < a href = "#SkMatrix_setAffine_affine" > affine< / a > values, passed in column major order. Given < a href = "#SkMatrix_setAffine_affine" > affine< / a > ,
column, then row, as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x skew-x translate-x |
| skew-y scale-y translate-y |< / pre >
< a href = "#Matrix" > Matrix< / a > is < a href = "#SkMatrix_set" > set< / a > , row, then column, to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| scale-x skew-x translate-x |
| skew-y scale-y translate-y |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setAffine_affine" > < code > < strong > affine < / strong > < / code > < / a > < / td > < td >
3x2 < a href = "#SkMatrix_setAffine_affine" > affine< / a > matrix< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "403370bd53526f59020a7141955d70b0" >
#### Example Output
~~~~
ScaleX: 2 SkewY: 5 SkewX: 3 ScaleY: 6 TransX: 4 TransY: 7
[ 2.0000 3.0000 4.0000][ 5.0000 6.0000 7.0000][ 0.0000 0.0000 1.0000]
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_asAffine" > asAffine< / a > < a href = "#SkMatrix_SetAffineIdentity" > SetAffineIdentity< / a >
---
< a name = "SkMatrix_mapPoints" > < / a >
## mapPoints
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapPoints(SkPoint dst[], const SkPoint src[], int count) const
< / pre >
Maps < a href = "#SkMatrix_mapPoints_src" > src< / a > < a href = "undocumented#Point" > Point< / a > array of length < a href = "#SkMatrix_mapPoints_count" > count< / a > to < a href = "#SkMatrix_mapPoints_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > array of equal or greater
length. < a href = "#Point" > Points< / a > are mapped by multiplying each < a href = "undocumented#Point" > Point< / a > by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
for (i = 0; i < count ; + + i ) {
x = src[i].fX
y = src[i].fY
}< / pre >
each < a href = "#SkMatrix_mapPoints_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
< a href = "#SkMatrix_mapPoints_src" > src< / a > and < a href = "#SkMatrix_mapPoints_dst" > dst< / a > may point to the same storage.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapPoints_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPoints_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "#Point" > Points< / a > to transform< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPoints_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Point" > Points< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "f99dcb00296d0c56b6c0e178e94b3534" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a > < a href = "#SkMatrix_mapHomogeneousPoints" > mapHomogeneousPoints< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapPoints(SkPoint pts[], int count) const
< / pre >
Maps < a href = "#SkMatrix_mapPoints_2_pts" > pts< / a > < a href = "undocumented#Point" > Point< / a > array of length < a href = "#SkMatrix_mapPoints_2_count" > count< / a > in place. < a href = "#Point" > Points< / a > are mapped by multiplying
each < a href = "undocumented#Point" > Point< / a > by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
for (i = 0; i < count ; + + i ) {
x = pts[i].fX
y = pts[i].fY
}< / pre >
each resulting < a href = "#SkMatrix_mapPoints_2_pts" > pts< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapPoints_2_pts" > < code > < strong > pts < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPoints_2_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Point" > Points< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "428ca171ae3bd0d3f992458ac598b97b" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a > < a href = "#SkMatrix_mapHomogeneousPoints" > mapHomogeneousPoints< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< a name = "SkMatrix_mapPointsWithStride" > < / a >
## mapPointsWithStride
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapPointsWithStride(SkPoint pts[], size_t stride, int count) const
< / pre >
Maps < a href = "#SkMatrix_mapPointsWithStride_count" > count< / a > < a href = "#SkMatrix_mapPointsWithStride_pts" > pts< / a > , skipping < a href = "#SkMatrix_mapPointsWithStride_stride" > stride< / a > bytes to advance from one < a href = "undocumented#Point" > Point< / a > to the next.
< a href = "#Point" > Points< / a > are mapped by multiplying each < a href = "undocumented#Point" > Point< / a > by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
each resulting < a href = "#SkMatrix_mapPointsWithStride_pts" > pts< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_pts" > < code > < strong > pts < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_stride" > < code > < strong > stride < / strong > < / code > < / a > < / td > < td >
size of record starting with < a href = "undocumented#Point" > Point< / a > , in bytes< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Point" > Points< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "02c50c7bb5d5dd1fe7e54b0d3bf64c2a" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a > < a href = "#SkMatrix_mapHomogeneousPoints" > mapHomogeneousPoints< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapPointsWithStride(SkPoint dst[], const SkPoint src[], size_t stride,
int count) const
< / pre >
Maps < a href = "#SkMatrix_mapPointsWithStride_2_src" > src< / a > < a href = "undocumented#Point" > Point< / a > array of length < a href = "#SkMatrix_mapPointsWithStride_2_count" > count< / a > to < a href = "#SkMatrix_mapPointsWithStride_2_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > array, skipping < a href = "#SkMatrix_mapPointsWithStride_2_stride" > stride< / a > bytes
to advance from one < a href = "undocumented#Point" > Point< / a > to the next.
< a href = "#Point" > Points< / a > are mapped by multiplying each < a href = "undocumented#Point" > Point< / a > by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, src = | y |
| G H I | | 1 |< / pre >
each resulting < a href = "#SkMatrix_mapPointsWithStride_2_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_2_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_2_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "#Point" > Points< / a > to transform< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_2_stride" > < code > < strong > stride < / strong > < / code > < / a > < / td > < td >
size of record starting with < a href = "undocumented#Point" > Point< / a > , in bytes< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapPointsWithStride_2_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Point" > Points< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "08e32de52131e6859db16729b2e56e4e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a > < a href = "#SkMatrix_mapHomogeneousPoints" > mapHomogeneousPoints< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< a name = "SkMatrix_mapHomogeneousPoints" > < / a >
## mapHomogeneousPoints
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapHomogeneousPoints(SkPoint3 dst[], const SkPoint3 src[], int count) const
< / pre >
Maps < a href = "#SkMatrix_mapHomogeneousPoints_src" > src< / a > < a href = "undocumented#Point3" > Point3< / a > array of length < a href = "#SkMatrix_mapHomogeneousPoints_count" > count< / a > to < a href = "#SkMatrix_mapHomogeneousPoints_dst" > dst< / a > < a href = "undocumented#Point3" > Point3< / a > array, which must of length < a href = "#SkMatrix_mapHomogeneousPoints_count" > count< / a > or
greater. < a href = "undocumented#Point3" > Point3< / a > array is mapped by multiplying each < a href = "undocumented#Point3" > Point3< / a > by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, src = | y |
| G H I | | z |< / pre >
each resulting < a href = "#SkMatrix_mapHomogeneousPoints_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|A B C| |x|
Matrix * src = |D E F| |y| = |Ax+By+Cz Dx+Ey+Fz Gx+Hy+Iz|
|G H I| |z|< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapHomogeneousPoints_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "undocumented#Point3" > Point3< / a > array< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapHomogeneousPoints_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "undocumented#Point3" > Point3< / a > array to transform< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapHomogeneousPoints_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
items in < a href = "undocumented#Point3" > Point3< / a > array to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "0d8c7aa7249048f2b83d32cf13f88560" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< a name = "SkMatrix_mapXY" > < / a >
## mapXY
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapXY(SkScalar x, SkScalar y, SkPoint* result) const
< / pre >
Maps < a href = "undocumented#Point" > Point< / a > (< a href = "#SkMatrix_mapXY_x" > x< / a > , < a href = "#SkMatrix_mapXY_y" > y< / a > ) to < a href = "#SkMatrix_mapXY_result" > result< / a > . < a href = "undocumented#Point" > Point< / a > is mapped by multiplying by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
< a href = "#SkMatrix_mapXY_result" > result< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapXY_x" > < code > < strong > x < / strong > < / code > < / a > < / td > < td >
x-coordinate of < a href = "undocumented#Point" > Point< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapXY_y" > < code > < strong > y < / strong > < / code > < / a > < / td > < td >
y-coordinate of < a href = "undocumented#Point" > Point< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapXY_result" > < code > < strong > result < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "undocumented#Point" > Point< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "9e50185d502dc6903783679a84106089" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkPoint mapXY(SkScalar x, SkScalar y) const
< / pre >
Returns < a href = "undocumented#Point" > Point< / a > (< a href = "#SkMatrix_mapXY_2_x" > x< / a > , < a href = "#SkMatrix_mapXY_2_y" > y< / a > ) multiplied by < a href = "#Matrix" > Matrix< / a > . Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
result is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapXY_2_x" > < code > < strong > x < / strong > < / code > < / a > < / td > < td >
x-coordinate of < a href = "undocumented#Point" > Point< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapXY_2_y" > < code > < strong > y < / strong > < / code > < / a > < / td > < td >
y-coordinate of < a href = "undocumented#Point" > Point< / a > to map< / td >
< / tr >
< / table >
### Return Value
mapped < a href = "undocumented#Point" > Point< / a >
### Example
< div > < fiddle-embed name = "b1ead09c67a177ab8eace12b061610a7" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapVectors" > mapVectors< / a >
---
< a name = "SkMatrix_mapVectors" > < / a >
## mapVectors
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapVectors(SkVector dst[], const SkVector src[], int count) const
< / pre >
Maps < a href = "#SkMatrix_mapVectors_src" > src< / a > < a href = "undocumented#Vector" > Vector< / a > array of length < a href = "#SkMatrix_mapVectors_count" > count< / a > to < a href = "undocumented#Vector" > Vector< / a > < a href = "undocumented#Point" > Point< / a > array of equal or greater
length. < a href = "#Vector" > Vectors< / a > are mapped by multiplying each < a href = "undocumented#Vector" > Vector< / a > by < a href = "#Matrix" > Matrix< / a > , treating
< a href = "#Matrix" > Matrix< / a > translation as zero. Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B 0 | | x |
Matrix = | D E 0 |, src = | y |
| G H I | | 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
for (i = 0; i < count ; + + i ) {
x = src[i].fX
y = src[i].fY
}< / pre >
each < a href = "#SkMatrix_mapVectors_dst" > dst< / a > < a href = "undocumented#Vector" > Vector< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|A B 0| |x| Ax+By Dx+Ey
Matrix * src = |D E 0| |y| = |Ax+By Dx+Ey Gx+Hy+I| = ------- , -------
|G H I| |1| Gx+Hy+I Gx+Hy+I< / pre >
< a href = "#SkMatrix_mapVectors_src" > src< / a > and < a href = "#SkMatrix_mapVectors_dst" > dst< / a > may point to the same storage.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapVectors_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "#Vector" > Vectors< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVectors_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "#Vector" > Vectors< / a > to transform< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVectors_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Vector" > Vectors< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "918a9778c3d7d5cb306692784399f6dc" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapVector" > mapVector< / a > < a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapVectors(SkVector vecs[], int count) const
< / pre >
Maps < a href = "#SkMatrix_mapVectors_2_vecs" > vecs< / a > < a href = "undocumented#Vector" > Vector< / a > array of length < a href = "#SkMatrix_mapVectors_2_count" > count< / a > in place, multiplying each < a href = "undocumented#Vector" > Vector< / a > by
< a href = "#Matrix" > Matrix< / a > , treating < a href = "#Matrix" > Matrix< / a > translation as zero. Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B 0 | | x |
Matrix = | D E 0 |, vec = | y |
| G H I | | 1 |< / pre >
where
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
for (i = 0; i < count ; + + i ) {
x = vecs[i].fX
y = vecs[i].fY
}< / pre >
each result < a href = "undocumented#Vector" > Vector< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|A B 0| |x| Ax+By Dx+Ey
Matrix * vec = |D E 0| |y| = |Ax+By Dx+Ey Gx+Hy+I| = ------- , -------
|G H I| |1| Gx+Hy+I Gx+Hy+I< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapVectors_2_vecs" > < code > < strong > vecs < / strong > < / code > < / a > < / td > < td >
< a href = "#Vector" > Vectors< / a > to transform, and storage for mapped < a href = "#Vector" > Vectors< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVectors_2_count" > < code > < strong > count < / strong > < / code > < / a > < / td > < td >
number of < a href = "#Vector" > Vectors< / a > to transform< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "5754501a00a1323e76353fb53153e939" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapVector" > mapVector< / a > < a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a >
---
< a name = "SkMatrix_mapVector" > < / a >
## mapVector
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapVector(SkScalar dx, SkScalar dy, SkVector* result) const
< / pre >
Maps < a href = "undocumented#Vector" > Vector< / a > (x, y) to < a href = "#SkMatrix_mapVector_result" > result< / a > . < a href = "undocumented#Vector" > Vector< / a > is mapped by multiplying by < a href = "#Matrix" > Matrix< / a > ,
treating < a href = "#Matrix" > Matrix< / a > translation as zero. Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B 0 | | dx |
Matrix = | D E 0 |, vec = | dy |
| G H I | | 1 |< / pre >
each < a href = "#SkMatrix_mapVector_result" > result< / a > < a href = "undocumented#Vector" > Vector< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|A B 0| |dx| A*dx+B*dy D*dx+E*dy
Matrix * vec = |D E 0| |dy| = |A*dx+B*dy D*dx+E*dy G*dx+H*dy+I| = ----------- , -----------
|G H I| | 1| G*dx+H*dy+I G*dx+*dHy+I< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapVector_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
x-coordinate of < a href = "undocumented#Vector" > Vector< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVector_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
y-coordinate of < a href = "undocumented#Vector" > Vector< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVector_result" > < code > < strong > result < / strong > < / code > < / a > < / td > < td >
storage for mapped < a href = "undocumented#Vector" > Vector< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "aed143fc6cd0bce4ed029b98d1e61f2d" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapVectors" > mapVectors< / a > < a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkVector mapVector(SkScalar dx, SkScalar dy) const
< / pre >
Returns < a href = "undocumented#Vector" > Vector< / a > (x, y) multiplied by < a href = "#Matrix" > Matrix< / a > , treating < a href = "#Matrix" > Matrix< / a > translation as zero.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B 0 | | dx |
Matrix = | D E 0 |, vec = | dy |
| G H I | | 1 |< / pre >
each result < a href = "undocumented#Vector" > Vector< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|A B 0| |dx| A*dx+B*dy D*dx+E*dy
Matrix * vec = |D E 0| |dy| = |A*dx+B*dy D*dx+E*dy G*dx+H*dy+I| = ----------- , -----------
|G H I| | 1| G*dx+H*dy+I G*dx+*dHy+I< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapVector_2_dx" > < code > < strong > dx < / strong > < / code > < / a > < / td > < td >
x-coordinate of < a href = "undocumented#Vector" > Vector< / a > to map< / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapVector_2_dy" > < code > < strong > dy < / strong > < / code > < / a > < / td > < td >
y-coordinate of < a href = "undocumented#Vector" > Vector< / a > to map< / td >
< / tr >
< / table >
### Return Value
mapped < a href = "undocumented#Vector" > Vector< / a >
### Example
< div > < fiddle-embed name = "8bf1518db3f369696cd3065b541a8bd7" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapVectors" > mapVectors< / a > < a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_mapPointsWithStride" > mapPointsWithStride< / a > < a href = "#SkMatrix_mapXY" > mapXY< / a >
---
< a name = "SkMatrix_mapRect" > < / a >
## mapRect
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool mapRect(SkRect* dst, const SkRect& src) const
< / pre >
Sets < a href = "#SkMatrix_mapRect_dst" > dst< / a > to bounds of < a href = "#SkMatrix_mapRect_src" > src< / a > corners mapped by < a href = "#Matrix" > Matrix< / a > .
Returns true if mapped corners are < a href = "#SkMatrix_mapRect_dst" > dst< / a > corners.
Returned value is the same as calling < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapRect_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for bounds of mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapRect_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#SkMatrix_mapRect_dst" > dst< / a > is equivalent to mapped < a href = "#SkMatrix_mapRect_src" > src< / a >
### Example
< div > < fiddle-embed name = "dbcf928b035a31ca69c99392e2e2cca9" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a >
---
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool mapRect(SkRect* rect) const
< / pre >
Sets < a href = "#SkMatrix_mapRect_2_rect" > rect< / a > to bounds of < a href = "#SkMatrix_mapRect_2_rect" > rect< / a > corners mapped by < a href = "#Matrix" > Matrix< / a > .
Returns true if mapped corners are computed < a href = "#SkMatrix_mapRect_2_rect" > rect< / a > corners.
Returned value is the same as calling < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapRect_2_rect" > < code > < strong > rect < / strong > < / code > < / a > < / td > < td >
rectangle to map, and storage for bounds of mapped corners< / td >
< / tr >
< / table >
### Return Value
true if result is equivalent to mapped src
### Example
< div > < fiddle-embed name = "5fafd0bd23d1ed37425b970b4a3c6cc9" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapRectScaleTranslate" > mapRectScaleTranslate< / a > < a href = "#SkMatrix_mapPoints" > mapPoints< / a > < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a >
---
< a name = "SkMatrix_mapRectToQuad" > < / a >
## mapRectToQuad
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapRectToQuad(SkPoint dst[4], const SkRect& rect) const
< / pre >
Maps four corners of < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > to < a href = "#SkMatrix_mapRectToQuad_dst" > dst< / a > . < a href = "#Point" > Points< / a > are mapped by multiplying each
< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > corner by < a href = "#Matrix" > Matrix< / a > . < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > corner is processed in this order:
(< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fLeft, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fTop), (< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fRight, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fTop), (< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fRight, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fBottom),
(< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fLeft, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fBottom).
< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > may be empty: < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fLeft may be greater than or equal to < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fRight;
< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fTop may be greater than or equal to < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fBottom.
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | x |
Matrix = | D E F |, pt = | y |
| G H I | | 1 |< / pre >
where pt is initialized from each of (< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fLeft, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fTop),
(< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fRight, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fTop), (< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fRight, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fBottom), (< a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fLeft, < a href = "#SkMatrix_mapRectToQuad_rect" > rect< / a > .fBottom),
each < a href = "#SkMatrix_mapRectToQuad_dst" > dst< / a > < a href = "undocumented#Point" > Point< / a > is computed as:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
|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< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapRectToQuad_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for mapped corner < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapRectToQuad_rect" > < code > < strong > rect < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "3bf9404624735d7cf34b47b9c7b27bcc" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapRect" > mapRect< / a > < a href = "#SkMatrix_mapRectScaleTranslate" > mapRectScaleTranslate< / a >
---
< a name = "SkMatrix_mapRectScaleTranslate" > < / a >
## mapRectScaleTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void mapRectScaleTranslate(SkRect* dst, const SkRect& src) const
< / pre >
Sets < a href = "#SkMatrix_mapRectScaleTranslate_dst" > dst< / a > to bounds of < a href = "#SkMatrix_mapRectScaleTranslate_src" > src< / a > corners mapped by < a href = "#Matrix" > Matrix< / a > . If matrix contains
elements other than scale or translate: asserts if < a href = "undocumented#SK_DEBUG" > SK DEBUG< / a > is defined;
otherwise, results are undefined.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapRectScaleTranslate_dst" > < code > < strong > dst < / strong > < / code > < / a > < / td > < td >
storage for bounds of mapped < a href = "#Point" > Points< / a > < / td >
< / tr > < tr > < td > < a name = "SkMatrix_mapRectScaleTranslate_src" > < code > < strong > src < / strong > < / code > < / a > < / td > < td >
< a href = "SkRect_Reference#Rect" > Rect< / a > to map< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "62bc26989c2b4c2a54d516596a71dd97" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapRect" > mapRect< / a > < a href = "#SkMatrix_mapRectToQuad" > mapRectToQuad< / a > < a href = "#SkMatrix_isScaleTranslate" > isScaleTranslate< / a > < a href = "#SkMatrix_rectStaysRect" > rectStaysRect< / a >
---
< a name = "SkMatrix_mapRadius" > < / a >
## mapRadius
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar mapRadius(SkScalar radius) const
< / pre >
Returns geometric mean < a href = "#SkMatrix_mapRadius_radius" > radius< / a > of ellipse formed by constructing < a href = "undocumented#Circle" > Circle< / a > of
size < a href = "#SkMatrix_mapRadius_radius" > radius< / a > , and mapping constructed < a href = "undocumented#Circle" > Circle< / a > with < a href = "#Matrix" > Matrix< / a > . The result squared is
equal to the major axis length times the minor axis length.
Result is not meaningful if < a href = "#Matrix" > Matrix< / a > contains perspective elements.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_mapRadius_radius" > < code > < strong > radius < / strong > < / code > < / a > < / td > < td >
< a href = "undocumented#Circle" > Circle< / a > size to map< / td >
< / tr >
< / table >
### Return Value
average mapped < a href = "#SkMatrix_mapRadius_radius" > radius< / a >
### Example
< div > < fiddle-embed name = "6d6f2082fcf59d9f02bfb1758b87db69" > < div > The area enclosed by a square with sides equal to mappedRadius is the same as
the area enclosed by the ellipse major and minor axes.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_mapVector" > mapVector< / a >
---
< a name = "SkMatrix_isFixedStepInX" > < / a >
## isFixedStepInX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isFixedStepInX() const
< / pre >
Returns true if a unit step in x at some y mapped through < a href = "#Matrix" > Matrix< / a > can be
represented by a constant < a href = "undocumented#Vector" > Vector< / a > . Returns true if < a href = "#SkMatrix_getType" > getType< / a > returns < a href = "#SkMatrix_kIdentity_Mask" > kIdentity Mask< / a > ,
or combinations of: < a href = "#SkMatrix_kTranslate_Mask" > kTranslate Mask< / a > , < a href = "#SkMatrix_kScale_Mask" > kScale Mask< / a > , and < a href = "#SkMatrix_kAffine_Mask" > kAffine Mask< / a > .
May return true if < a href = "#SkMatrix_getType" > getType< / a > returns < a href = "#SkMatrix_kPerspective_Mask" > kPerspective Mask< / a > , but only when < a href = "#Matrix" > Matrix< / a >
does not include rotation or skewing along the y-axis.
### Return Value
true if < a href = "#Matrix" > Matrix< / a > does not have complex perspective
### Example
< div > < fiddle-embed name = "ab57b232acef69f26de9cb23d23c8a1a" >
#### Example Output
~~~~
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
isFixedStepInX: true
[ 1.0000 0.0000 0.0000][ 0.0000 2.0000 0.0000][ 0.0000 0.0000 1.0000]
isFixedStepInX: true
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.0000 0.1000 1.0000]
isFixedStepInX: true
[ 1.0000 0.0000 0.0000][ 0.0000 2.0000 0.0000][ 0.0000 0.1000 1.0000]
isFixedStepInX: true
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.1000 0.0000 1.0000]
isFixedStepInX: false
[ 1.0000 0.0000 0.0000][ 0.0000 2.0000 0.0000][ 0.1000 0.0000 1.0000]
isFixedStepInX: false
[ 1.0000 0.0000 0.0000][ 0.0000 1.0000 0.0000][ 0.1000 0.1000 1.0000]
isFixedStepInX: false
[ 1.0000 0.0000 0.0000][ 0.0000 2.0000 0.0000][ 0.1000 0.1000 1.0000]
isFixedStepInX: false
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_fixedStepInX" > fixedStepInX< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_fixedStepInX" > < / a >
## fixedStepInX
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkVector fixedStepInX(SkScalar y) const
< / pre >
Returns < a href = "undocumented#Vector" > Vector< / a > representing a unit step in x at < a href = "#SkMatrix_fixedStepInX_y" > y< / a > mapped through < a href = "#Matrix" > Matrix< / a > .
If < a href = "#SkMatrix_isFixedStepInX" > isFixedStepInX< / a > is false, returned value is undefined.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_fixedStepInX_y" > < code > < strong > y < / strong > < / code > < / a > < / td > < td >
position of line parallel to x-axis< / td >
< / tr >
< / table >
### Return Value
< a href = "undocumented#Vector" > Vector< / a > advance of mapped unit step in x
### Example
< div > < fiddle-embed name = "fad6b92b21b1e1deeae61978cec2d232" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_isFixedStepInX" > isFixedStepInX< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_cheapEqualTo" > < / a >
## cheapEqualTo
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool cheapEqualTo(const SkMatrix& m) const
< / pre >
Returns true if < a href = "#Matrix" > Matrix< / a > equals < a href = "#SkMatrix_cheapEqualTo_m" > m< / a > , using an efficient comparison.
Returns false when the sign of zero values is the different; when one
matrix has positive zero value and the other has negative zero value.
Returns true even when both < a href = "#Matrix" > Matrices< / a > contain < a href = "undocumented#NaN" > NaN< / a > .
< a href = "undocumented#NaN" > NaN< / a > never equals any value, including itself. To improve performance, < a href = "undocumented#NaN" > NaN< / a > values
are treated as bit patterns that are equal if their bit patterns are equal.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_cheapEqualTo_m" > < code > < strong > m < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > to compare< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#SkMatrix_cheapEqualTo_m" > m< / a > and < a href = "#Matrix" > Matrix< / a > are represented by identical bit patterns
### Example
< div > < fiddle-embed name = "39016b3cfc6bbabb09348a53822ce508" >
#### Example Output
~~~~
identity: a == b a.cheapEqualTo(b): true
neg zero: a == b a.cheapEqualTo(b): false
one NaN: a != b a.cheapEqualTo(b): false
both NaN: a != b a.cheapEqualTo(b): true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_equal_operator" > operator==(const SkMatrix& a, const SkMatrix& b)< / a >
---
< a name = "SkMatrix_equal_operator" > < / a >
## operator==
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool operator==(const SkMatrix& a, const SkMatrix& b)
< / pre >
Compares < a href = "#SkMatrix_equal_operator_a" > a< / a > and < a href = "#SkMatrix_equal_operator_b" > b< / a > ; returns true if < a href = "#SkMatrix_equal_operator_a" > a< / a > and < a href = "#SkMatrix_equal_operator_b" > b< / a > are numerically equal. Returns true
even if sign of zero values are different. Returns false if either < a href = "#Matrix" > Matrix< / a >
contains < a href = "undocumented#NaN" > NaN< / a > , even if the other < a href = "#Matrix" > Matrix< / a > also contains < a href = "undocumented#NaN" > NaN< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_equal_operator_a" > < code > < strong > a < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > to compare< / td >
< / tr > < tr > < td > < a name = "SkMatrix_equal_operator_b" > < code > < strong > b < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > to compare< / td >
< / tr >
< / table >
### Return Value
true if m and < a href = "#Matrix" > Matrix< / a > are numerically equal
### Example
< div > < fiddle-embed name = "3902859150b0f0c4aeb1f25d00434baa" >
#### Example Output
~~~~
identity: a == b a.cheapEqualTo(b): true
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_cheapEqualTo" > cheapEqualTo< / a > < a href = "#SkMatrix_not_equal_operator" > operator!=(const SkMatrix& a, const SkMatrix& b)< / a >
---
< a name = "SkMatrix_not_equal_operator" > < / a >
## operator!=
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool operator!=(const SkMatrix& a, const SkMatrix& b)
< / pre >
Compares < a href = "#SkMatrix_not_equal_operator_a" > a< / a > and < a href = "#SkMatrix_not_equal_operator_b" > b< / a > ; returns true if < a href = "#SkMatrix_not_equal_operator_a" > a< / a > and < a href = "#SkMatrix_not_equal_operator_b" > b< / a > are not numerically equal. Returns false
even if sign of zero values are different. Returns true if either < a href = "#Matrix" > Matrix< / a >
contains < a href = "undocumented#NaN" > NaN< / a > , even if the other < a href = "#Matrix" > Matrix< / a > also contains < a href = "undocumented#NaN" > NaN< / a > .
### Parameters
< table > < tr > < td > < a name = "SkMatrix_not_equal_operator_a" > < code > < strong > a < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > to compare< / td >
< / tr > < tr > < td > < a name = "SkMatrix_not_equal_operator_b" > < code > < strong > b < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > to compare< / td >
< / tr >
< / table >
### Return Value
true if m and < a href = "#Matrix" > Matrix< / a > are numerically not equal
### Example
< div > < fiddle-embed name = "8a8fadf5fd294daa4ee152833cc0dc0e" > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_cheapEqualTo" > cheapEqualTo< / a > < a href = "#SkMatrix_equal_operator" > operator==(const SkMatrix& a, const SkMatrix& b)< / a >
---
< a name = "SkMatrix_dump" > < / a >
## dump
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void dump() const
< / pre >
Writes text representation of < a href = "#Matrix" > Matrix< / a > to standard output. Floating point values
are written with limited precision; it may not be possible to reconstruct
original < a href = "#Matrix" > Matrix< / a > from output.
### Example
< div > < fiddle-embed name = "8d72a4818e5a9188348f6c08ab5d8a40" >
#### Example Output
~~~~
[ 0.7071 -0.7071 0.0000][ 0.7071 0.7071 0.0000][ 0.0000 0.0000 1.0000]
[ 0.7071 -0.7071 0.0000][ 0.7071 0.7071 0.0000][ 0.0000 0.0000 1.0000]
matrix != nearlyEqual
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_toString" > toString< / a >
---
< a name = "SkMatrix_toString" > < / a >
## toString
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void toString(SkString* str) const
< / pre >
Creates string representation of < a href = "#Matrix" > Matrix< / a > . Floating point values
are written with limited precision; it may not be possible to reconstruct
original < a href = "#Matrix" > Matrix< / a > from output.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_toString_str" > < code > < strong > str < / strong > < / code > < / a > < / td > < td >
storage for string representation of < a href = "#Matrix" > Matrix< / a > < / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "1d86e43958e42b8eaaa9b16df1baa4c8" >
#### Example Output
~~~~
mStr [ 0.7071 -0.7071 0.0000][ 0.7071 0.7071 0.0000][ 0.0000 0.0000 1.0000]
neStr [ 0.7071 -0.7071 0.0000][ 0.7071 0.7071 0.0000][ 0.0000 0.0000 1.0000]
matrix != nearlyEqual
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_dump" > dump< / a >
---
< a name = "SkMatrix_getMinScale" > < / a >
## getMinScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getMinScale() const
< / pre >
Returns the minimum scaling factor of < a href = "#Matrix" > Matrix< / a > by decomposing the scaling and
skewing elements.
Returns -1 if scale factor overflows or < a href = "#Matrix" > Matrix< / a > contains perspective.
### Return Value
minimum scale factor
### Example
< div > < fiddle-embed name = "1d6f67904c88a806c3731879e9af4ae5" >
#### Example Output
~~~~
matrix.getMinScale() 24
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_getMaxScale" > getMaxScale< / a > < a href = "#SkMatrix_getMinMaxScales" > getMinMaxScales< / a >
---
< a name = "SkMatrix_getMaxScale" > < / a >
## getMaxScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
SkScalar getMaxScale() const
< / pre >
Returns the maximum scaling factor of < a href = "#Matrix" > Matrix< / a > by decomposing the scaling and
skewing elements.
Returns -1 if scale factor overflows or < a href = "#Matrix" > Matrix< / a > contains perspective.
### Return Value
maximum scale factor
### Example
< div > < fiddle-embed name = "3fee4364929899649cf9efc37897e964" >
#### Example Output
~~~~
matrix.getMaxScale() 42
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_getMinScale" > getMinScale< / a > < a href = "#SkMatrix_getMinMaxScales" > getMinMaxScales< / a >
---
< a name = "SkMatrix_getMinMaxScales" > < / a >
## getMinMaxScales
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool SK_WARN_UNUSED_RESULT getMinMaxScales(SkScalar scaleFactors[2]) const
< / pre >
Sets < a href = "#SkMatrix_getMinMaxScales_scaleFactors" > scaleFactors< / a > [0] to the minimum scaling factor, and < a href = "#SkMatrix_getMinMaxScales_scaleFactors" > scaleFactors< / a > [1] to the
maximum scaling factor. Scaling factors are computed by decomposing
the < a href = "#Matrix" > Matrix< / a > scaling and skewing elements.
Returns true if < a href = "#SkMatrix_getMinMaxScales_scaleFactors" > scaleFactors< / a > are found; otherwise, returns false and sets
< a href = "#SkMatrix_getMinMaxScales_scaleFactors" > scaleFactors< / a > to undefined values.
### Parameters
< table > < tr > < td > < a name = "SkMatrix_getMinMaxScales_scaleFactors" > < code > < strong > scaleFactors < / strong > < / code > < / a > < / td > < td >
storage for minimum and maximum scale factors< / td >
< / tr >
< / table >
### Return Value
true if scale factors were computed correctly
### Example
< div > < fiddle-embed name = "cd4dc63d3e04226f0b5861ba8925e223" >
#### Example Output
~~~~
matrix.getMinMaxScales() false 2 2
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_getMinScale" > getMinScale< / a > < a href = "#SkMatrix_getMaxScale" > getMaxScale< / a >
---
< a name = "SkMatrix_decomposeScale" > < / a >
## decomposeScale
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool decomposeScale(SkSize* scale, SkMatrix* remaining = nullptr) const
< / pre >
Decomposes < a href = "#Matrix" > Matrix< / a > into < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > components and whatever remains. Returns false if
< a href = "#Matrix" > Matrix< / a > could not be decomposed.
Sets < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > to portion of < a href = "#Matrix" > Matrix< / a > that scales in x and y. Sets < a href = "#SkMatrix_decomposeScale_remaining" > remaining< / a > to < a href = "#Matrix" > Matrix< / a >
with x and y scaling factored out. < a href = "#SkMatrix_decomposeScale_remaining" > remaining< / a > may be passed as nullptr
to determine if < a href = "#Matrix" > Matrix< / a > can be decomposed without computing remainder.
Returns true if < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > components are found. < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > and < a href = "#SkMatrix_decomposeScale_remaining" > remaining< / a > are
unchanged if < a href = "#Matrix" > Matrix< / a > contains perspective; < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > factors are not finite, or
are nearly zero.
On success< a href = "#Matrix" > Matrix< / a > = < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > * Remaining
### Parameters
< table > < tr > < td > < a name = "SkMatrix_decomposeScale_scale" > < code > < strong > scale < / strong > < / code > < / a > < / td > < td >
x and y scaling factors; may be nullptr< / td >
< / tr > < tr > < td > < a name = "SkMatrix_decomposeScale_remaining" > < code > < strong > remaining < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > without scaling; may be nullptr< / td >
< / tr >
< / table >
### Return Value
true if < a href = "#SkMatrix_decomposeScale_scale" > scale< / a > can be computed
### Example
< div > < fiddle-embed name = "139b874da0a3ede1f3df88119085c0aa" >
#### Example Output
~~~~
[ 0.0000 -0.2500 0.0000][ 0.5000 0.0000 0.0000][ 0.0000 0.0000 1.0000]
success: true scale: 0.5, 0.25
[ 0.0000 -0.5000 0.0000][ 2.0000 0.0000 0.0000][ 0.0000 0.0000 1.0000]
[ 0.0000 -0.2500 0.0000][ 0.5000 0.0000 0.0000][ 0.0000 0.0000 1.0000]
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_MakeScale" > MakeScale< / a >
---
< a name = "SkMatrix_I" > < / a >
## I
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static const SkMatrix& I()
< / pre >
Returns reference to const identity < a href = "#Matrix" > Matrix< / a > . Returned < a href = "#Matrix" > Matrix< / a > is < a href = "#SkMatrix_set" > set< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| 1 0 0 |
| 0 1 0 |
| 0 0 1 |< / pre >
### Return Value
const identity < a href = "#Matrix" > Matrix< / a >
### Example
< div > < fiddle-embed name = "d961d91020f19037204a8c3fd8cb1060" >
#### Example Output
~~~~
m1 == m2
m2 == m3
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_reset" > reset< / a > < a href = "#SkMatrix_setIdentity" > setIdentity< / a >
---
< a name = "SkMatrix_InvalidMatrix" > < / a >
## InvalidMatrix
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static const SkMatrix& InvalidMatrix()
< / pre >
Returns reference to a const < a href = "#Matrix" > Matrix< / a > with invalid values. Returned < a href = "#Matrix" > Matrix< / a > is < a href = "#SkMatrix_set" > set< / a >
to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |
| SK_ScalarMax SK_ScalarMax SK_ScalarMax |< / pre >
### Return Value
const invalid < a href = "#Matrix" > Matrix< / a >
### Example
< div > < fiddle-embed name = "af0b72360c1c7a25b4754bfa47011dd5" >
#### Example Output
~~~~
scaleX 3.40282e+38
~~~~
< / fiddle-embed > < / div >
### See Also
SeeAlso < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_Concat" > < / a >
## Concat
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
static SkMatrix Concat(const SkMatrix& a, const SkMatrix& b)
< / pre >
Returns < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_Concat_a" > a< / a > multiplied by < a href = "#Matrix" > Matrix< / a > < a href = "#SkMatrix_Concat_b" > b< / a > .
Given:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L |
a = | D E F |, b = | M N O |
| G H I | | P Q R |< / pre >
sets < a href = "#Matrix" > Matrix< / a > to:
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| A B C | | J K L | | AJ+BM+CP AK+BN+CQ AL+BO+CR |
a * b = | D E F | * | M N O | = | DJ+EM+FP DK+EN+FQ DL+EO+FR |
| G H I | | P Q R | | GJ+HM+IP GK+HN+IQ GL+HO+IR |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_Concat_a" > < code > < strong > a < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on left side of multiply expression< / td >
< / tr > < tr > < td > < a name = "SkMatrix_Concat_b" > < code > < strong > b < / strong > < / code > < / a > < / td > < td >
< a href = "#Matrix" > Matrix< / a > on right side of multiply expression< / td >
< / tr >
< / table >
### Return Value
< a href = "#Matrix" > Matrix< / a > computed from < a href = "#SkMatrix_Concat_a" > a< / a > times < a href = "#SkMatrix_Concat_b" > b< / a >
### Example
< div > < fiddle-embed name = "6b4562c7052da94f3d5b2412dca41946" > < div > < a href = "#SkMatrix_setPolyToPoly" > setPolyToPoly< / a > creates perspective matrices, one the inverse of the other.
Multiplying the matrix by its inverse turns into an identity matrix.< / div > < / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_preConcat" > preConcat< / a > < a href = "#SkMatrix_postConcat" > postConcat< / a >
---
< a name = "SkMatrix_dirtyMatrixTypeCache" > < / a >
## dirtyMatrixTypeCache
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void dirtyMatrixTypeCache()
< / pre >
Sets internal cache to unknown state. Use to force update after repeated
modifications to < a href = "#Matrix" > Matrix< / a > element reference returned by < a href = "#SkMatrix_subscript_operator_const" > operator[](int index)< / a > .
### Example
< div > < fiddle-embed name = "f4365ef332f51f7fd25040e0771ba9a2" >
#### Example Output
~~~~
with identity matrix: x = 24
after skew x mod: x = 24
after 2nd skew x mod: x = 24
after dirty cache: x = 66
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_subscript_operator_const" > operator[](int index)< / a > < a href = "#SkMatrix_getType" > getType< / a >
---
< a name = "SkMatrix_setScaleTranslate" > < / a >
## setScaleTranslate
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
void setScaleTranslate(SkScalar sx, SkScalar sy, SkScalar tx, SkScalar ty)
< / pre >
Initializes < a href = "#Matrix" > Matrix< / a > with scale and translate elements.
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
| sx 0 tx |
| 0 sy ty |
| 0 0 1 |< / pre >
### Parameters
< table > < tr > < td > < a name = "SkMatrix_setScaleTranslate_sx" > < code > < strong > sx < / strong > < / code > < / a > < / td > < td >
horizontal scale factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScaleTranslate_sy" > < code > < strong > sy < / strong > < / code > < / a > < / td > < td >
vertical scale factor to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScaleTranslate_tx" > < code > < strong > tx < / strong > < / code > < / a > < / td > < td >
horizontal translation to store< / td >
< / tr > < tr > < td > < a name = "SkMatrix_setScaleTranslate_ty" > < code > < strong > ty < / strong > < / code > < / a > < / td > < td >
vertical translation to store< / td >
< / tr >
< / table >
### Example
< div > < fiddle-embed name = "fed43797f13796529cb6731385d6f8f3" >
#### Example Output
~~~~
[ 1.0000 0.0000 3.0000][ 0.0000 2.0000 4.0000][ 0.0000 0.0000 1.0000]
~~~~
< / fiddle-embed > < / div >
### See Also
< a href = "#SkMatrix_setScale" > setScale< / a > < a href = "#SkMatrix_preTranslate" > preTranslate< / a > < a href = "#SkMatrix_postTranslate" > postTranslate< / a >
---
< a name = "SkMatrix_isFinite" > < / a >
## isFinite
< pre style = "padding: 1em 1em 1em 1em;width: 50em; background-color: #f0f0f0 " >
bool isFinite() const
< / pre >
Returns true if all elements of the matrix are finite. Returns false if any
element is infinity, or < a href = "undocumented#NaN" > NaN< / a > .
### Return Value
true if matrix has only finite elements
### Example
< div > < fiddle-embed name = "bc6c6f6a5df770287120d87f81b922eb" >
#### Example Output
~~~~
[ 1.0000 0.0000 nan][ 0.0000 1.0000 0.0000][ 0.0000 0.0000 1.0000]
matrix is finite: false
matrix != matrix
~~~~
< / fiddle-embed > < / div >
### See Also
operator==
---
