682c58da48
- add links to types within methods - add check to see that all references and definitions match - add style to tables to make them easier to read - use https everywhere - remove trailing spaces - move overview inside class - split class and struct in summary tables - add missing #Line - clean up SkImageInfo constant documentation - work on SkColor documentation - allow common phrases to take different parameters - add more flexibility to generated tables - tighten token parent requirements - generalize deprecated and example interfaces - detect inner constructors R=caryclark@google.com Docs-Preview: https://skia.org/?cl=121799 Bug: skia:6898 Change-Id: Ia75a23740b80259460916890b310e2a9f024962a Reviewed-on: https://skia-review.googlesource.com/121799 Commit-Queue: Cary Clark <caryclark@skia.org> Auto-Submit: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
1277 lines
36 KiB
Plaintext
1277 lines
36 KiB
Plaintext
#Topic Point
|
|
#Alias Points
|
|
#Alias Point_Reference
|
|
|
|
#Struct SkPoint
|
|
|
|
SkPoint holds two 32-bit floating point coordinates.
|
|
|
|
#Subtopic Overview
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Related_Function
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Member_Function
|
|
#Populate
|
|
##
|
|
|
|
#Subtopic Member
|
|
#Populate
|
|
|
|
#Member SkScalar fX
|
|
#Line # x-axis value ##
|
|
x-axis value used by both Point and Vector. May contain any value, including
|
|
infinities and NaN.
|
|
##
|
|
|
|
#Member SkScalar fY
|
|
#Line # y-axis value ##
|
|
y-axis value used by both Point and Vector. May contain any value, including
|
|
infinities and NaN.
|
|
##
|
|
|
|
#Subtopic Member ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Constructor
|
|
#Populate
|
|
##
|
|
|
|
#Method static constexpr SkPoint Make(SkScalar x, SkScalar y)
|
|
#In Constructor
|
|
#Line # constructs from SkScalar inputs ##
|
|
Sets fX to x, fY to y. Used both to set Point and Vector.
|
|
|
|
#Param x SkScalar x-axis value of constructed Point or Vector ##
|
|
#Param y SkScalar y-axis value of constructed Point or Vector ##
|
|
|
|
#Return Point (x, y) ##
|
|
|
|
#Example
|
|
SkPoint pt1 = {45, 66};
|
|
SkPoint pt2 = SkPoint::Make(45, 66);
|
|
SkVector v1 = {45, 66};
|
|
SkVector v2 = SkPoint::Make(45, 66);
|
|
SkDebugf("all %s" "equal\n", pt1 == pt2 && pt2 == v1 && v1 == v2 ? "" : "not ");
|
|
#StdOut
|
|
all equal
|
|
##
|
|
##
|
|
|
|
#SeeAlso set() iset() SkIPoint::Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Property
|
|
#Line # member values ##
|
|
#Populate
|
|
##
|
|
|
|
#Method SkScalar x() const
|
|
#In Property
|
|
#Line # returns fX ##
|
|
Returns x-axis value of Point or Vector.
|
|
|
|
#Return fX ##
|
|
|
|
#Example
|
|
SkPoint pt1 = {45, 66};
|
|
SkDebugf("pt1.fX %c= pt1.x()\n", pt1.fX == pt1.x() ? '=' : '!');
|
|
#StdOut
|
|
pt1.fX == pt1.x()
|
|
##
|
|
##
|
|
|
|
#SeeAlso y() SkIPoint::x()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar y() const
|
|
#In Property
|
|
#Line # returns fY ##
|
|
Returns y-axis value of Point or Vector.
|
|
|
|
#Return fY ##
|
|
|
|
#Example
|
|
SkPoint pt1 = {45, 66};
|
|
SkDebugf("pt1.fY %c= pt1.y()\n", pt1.fY == pt1.y() ? '=' : '!');
|
|
#StdOut
|
|
pt1.fY == pt1.y()
|
|
##
|
|
##
|
|
|
|
#SeeAlso x() SkIPoint::y()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool isZero() const
|
|
#In Property
|
|
#Line # returns true if both members equal zero ##
|
|
Returns true if fX and fY are both zero.
|
|
|
|
#Return true if fX is zero and fY is zero ##
|
|
|
|
#Example
|
|
SkPoint pt = { 0.f, -0.f};
|
|
SkDebugf("pt.fX=%c%g pt.fY=%c%g\n", std::signbit(pt.fX) ? '-' : '+', fabsf(pt.fX),
|
|
std::signbit(pt.fY) ? '-' : '+', fabsf(pt.fY));
|
|
SkDebugf("pt.isZero() == %s\n", pt.isZero() ? "true" : "false");
|
|
#StdOut
|
|
pt.fX=+0 pt.fY=-0
|
|
pt.isZero() == true
|
|
##
|
|
##
|
|
|
|
#SeeAlso isFinite SkIPoint::isZero
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Set
|
|
#Populate
|
|
#Line # replaces all values ##
|
|
##
|
|
|
|
#Method void set(SkScalar x, SkScalar y)
|
|
#In Set
|
|
#Line # sets to SkScalar input ##
|
|
Sets fX to x and fY to y.
|
|
|
|
#Param x new value for fX ##
|
|
#Param y new value for fY ##
|
|
|
|
#Example
|
|
SkPoint pt1, pt2 = { SK_ScalarPI, SK_ScalarSqrt2 };
|
|
pt1.set(SK_ScalarPI, SK_ScalarSqrt2);
|
|
SkDebugf("pt1 %c= pt2\n", pt1 == pt2 ? '=' : '!');
|
|
#StdOut
|
|
pt1 == pt2
|
|
##
|
|
##
|
|
|
|
#SeeAlso iset() Make
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void iset(int32_t x, int32_t y)
|
|
#In Set
|
|
#Line # sets to integer input ##
|
|
Sets fX to x and fY to y, promoting integers to SkScalar values.
|
|
|
|
Assigning a large integer value directly to fX or fY may cause a compiler
|
|
error, triggered by narrowing conversion of int to SkScalar. This safely
|
|
casts x and y to avoid the error.
|
|
|
|
#Param x new value for fX ##
|
|
#Param y new value for fY ##
|
|
|
|
#Example
|
|
SkPoint pt1, pt2 = { SK_MinS16, SK_MaxS16 };
|
|
pt1.iset(SK_MinS16, SK_MaxS16);
|
|
SkDebugf("pt1 %c= pt2\n", pt1 == pt2 ? '=' : '!');
|
|
##
|
|
|
|
#SeeAlso set Make SkIPoint::set
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void iset(const SkIPoint& p)
|
|
|
|
Sets fX to p.fX and fY to p.fY, promoting integers to SkScalar values.
|
|
|
|
Assigning an IPoint containing a large integer value directly to fX or fY may
|
|
cause a compiler error, triggered by narrowing conversion of int to SkScalar.
|
|
This safely casts p.fX and p.fY to avoid the error.
|
|
|
|
#Param p IPoint members promoted to SkScalar ##
|
|
|
|
#Example
|
|
SkIPoint iPt = { SK_MinS32, SK_MaxS32 };
|
|
SkPoint fPt;
|
|
fPt.iset(iPt);
|
|
SkDebugf("iPt: %d, %d\n", iPt.fX, iPt.fY);
|
|
SkDebugf("fPt: %g, %g\n", fPt.fX, fPt.fY);
|
|
#StdOut
|
|
iPt: -2147483647, 2147483647
|
|
fPt: -2.14748e+09, 2.14748e+09
|
|
##
|
|
##
|
|
|
|
#SeeAlso set Make SkIPoint::set
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void setAbs(const SkPoint& pt)
|
|
#In Set
|
|
#Line # sets sign of both members to positive ##
|
|
Sets fX to absolute value of pt.fX; and fY to absolute value of pt.fY.
|
|
|
|
#Param pt members providing magnitude for fX and fY ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0.f, -0.f}, {-1, -2},
|
|
{ SK_ScalarInfinity, SK_ScalarNegativeInfinity },
|
|
{ SK_ScalarNaN, -SK_ScalarNaN } };
|
|
for (const SkPoint& pt : test) {
|
|
SkPoint absPt;
|
|
absPt.setAbs(pt);
|
|
SkDebugf("pt: %g, %g abs: %g, %g\n", pt.fX, pt.fY, absPt.fX, absPt.fY);
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 abs: 0, 0
|
|
pt: -1, -2 abs: 1, 2
|
|
pt: inf, -inf abs: inf, inf
|
|
pt: nan, -nan abs: nan, nan
|
|
##
|
|
##
|
|
|
|
#SeeAlso set Make negate
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Offset
|
|
#Line # moves sides ##
|
|
#Populate
|
|
##
|
|
|
|
#Method static void Offset(SkPoint points[], int count, const SkVector& offset)
|
|
#In Offset
|
|
#Line # translates Point array ##
|
|
Adds offset to each Point in points array with count entries.
|
|
|
|
#Param points Point array ##
|
|
#Param count entries in array ##
|
|
#Param offset Vector added to points ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
SkPoint::Offset(points, SK_ARRAY_COUNT(points), { 1, 9 } );
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso offset operator+=(const SkVector& v)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static void Offset(SkPoint points[], int count, SkScalar dx, SkScalar dy)
|
|
|
|
Adds offset (dx, dy) to each Point in points array of length count.
|
|
|
|
#Param points Point array ##
|
|
#Param count entries in array ##
|
|
#Param dx added to fX in points ##
|
|
#Param dy added to fY in points ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
SkPoint::Offset(points, SK_ARRAY_COUNT(points), 1, 9);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso offset operator+=(const SkVector& v)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void offset(SkScalar dx, SkScalar dy)
|
|
#In Offset
|
|
#Line # translates Point ##
|
|
Adds offset (dx, dy) to Point.
|
|
|
|
#Param dx added to fX ##
|
|
#Param dy added to fY ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
points[1].offset(1, 1);
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso Offset operator+=(const SkVector& v)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar length() const
|
|
#In Property
|
|
#Line # returns straight-line distance to origin ##
|
|
Returns the Euclidean_Distance from origin, computed as:
|
|
#Code
|
|
#Literal
|
|
sqrt(fX * fX + fY * fY)
|
|
##
|
|
.
|
|
|
|
#Return straight-line distance to origin ##
|
|
|
|
#Example
|
|
#Height 192
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 90, 30 }, { 120, 150 }, { 150, 30 }, { 210, 90 } };
|
|
const SkPoint origin = {30, 140};
|
|
for (auto point : points) {
|
|
canvas->drawLine(origin, point, paint);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
SkScalar angle = SkScalarATan2((point.fY - origin.fY), point.fX - origin.fX);
|
|
canvas->rotate(angle * 180 / SK_ScalarPI, origin.fX, origin.fY);
|
|
SkString length("length = ");
|
|
length.appendScalar(point.length());
|
|
canvas->drawString(length, origin.fX + 25, origin.fY - 4, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso distanceToOrigin Length setLength Distance
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar distanceToOrigin() const
|
|
#In Property
|
|
#Line # returns straight-line distance to origin ##
|
|
Returns the Euclidean_Distance from origin, computed as:
|
|
#Code
|
|
#Literal
|
|
sqrt(fX * fX + fY * fY)
|
|
##
|
|
.
|
|
|
|
#Return straight-line distance to origin ##
|
|
|
|
#Example
|
|
#Height 192
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 60, -110 }, { 90, 10 }, { 120, -110 }, { 180, -50 } };
|
|
const SkPoint origin = {0, 0};
|
|
canvas->translate(30, 140);
|
|
for (auto point : points) {
|
|
canvas->drawLine(origin, point, paint);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
SkScalar angle = SkScalarATan2((point.fY - origin.fY), point.fX - origin.fX);
|
|
canvas->rotate(angle * 180 / SK_ScalarPI, origin.fX, origin.fY);
|
|
SkString distance("distance = ");
|
|
distance.appendScalar(point.distanceToOrigin());
|
|
canvas->drawString(distance, origin.fX + 25, origin.fY - 4, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso length Length setLength Distance
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool normalize()
|
|
#In Set
|
|
#Line # sets length to one, preserving direction ##
|
|
Scales (fX, fY) so that length() returns one, while preserving ratio of fX to fY,
|
|
if possible. If prior length is nearly zero, sets Vector to (0, 0) and returns
|
|
false; otherwise returns true.
|
|
|
|
#Return true if former length is not zero or nearly zero ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint lines[][2] = { {{ 30, 110 }, { 190, 30 }},
|
|
{{ 120, 140 }, { 30, 220 }}};
|
|
for (auto line : lines) {
|
|
canvas->drawLine(line[0], line[1], paint);
|
|
SkVector vector = line[1] - line[0];
|
|
if (vector.normalize()) {
|
|
SkVector rotate90 = { -vector.fY, vector.fX };
|
|
rotate90 *= 10.f;
|
|
canvas->drawLine(line[0] - rotate90, line[0] + rotate90, paint);
|
|
canvas->drawLine(line[1] - rotate90, line[1] + rotate90, paint);
|
|
}
|
|
}
|
|
##
|
|
|
|
#SeeAlso Normalize setLength length Length
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool setNormalize(SkScalar x, SkScalar y)
|
|
#In Set
|
|
#Line # sets length to one, in direction of (x, y) ##
|
|
Sets Vector to (x, y) scaled so length() returns one, and so that
|
|
(fX, fY) is proportional to (x, y). If (x, y) length is nearly zero,
|
|
sets Vector to (0, 0) and returns false; otherwise returns true.
|
|
|
|
#Param x proportional value for fX ##
|
|
#Param y proportional value for fY ##
|
|
|
|
#Return true if (x, y) length is not zero or nearly zero ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 60, -110 }, { 90, 10 }, { 120, -110 }, { 180, -50 } };
|
|
const SkPoint origin = {0, 0};
|
|
canvas->translate(30, 140);
|
|
for (auto point : points) {
|
|
paint.setStrokeWidth(1);
|
|
paint.setColor(SK_ColorBLACK);
|
|
canvas->drawLine(origin, point, paint);
|
|
SkVector normal;
|
|
normal.setNormalize(point.fX, point.fY);
|
|
normal *= 100;
|
|
paint.setStrokeWidth(10);
|
|
paint.setColor(0x3f4512bf);
|
|
canvas->drawLine(origin, normal, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso normalize setLength
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool setLength(SkScalar length)
|
|
#In Set
|
|
#Line # sets straight-line distance to origin ##
|
|
Scales Vector so that distanceToOrigin returns length, if possible. If former
|
|
length is nearly zero, sets Vector to (0, 0) and return false; otherwise returns
|
|
true.
|
|
|
|
#Param length straight-line distance to origin ##
|
|
|
|
#Return true if former length is not zero or nearly zero ##
|
|
|
|
#Example
|
|
#Height 160
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 60, -110 }, { 90, 10 }, { 120, -110 }, { 180, -50 } };
|
|
const SkPoint origin = {0, 0};
|
|
canvas->translate(30, 140);
|
|
for (auto point : points) {
|
|
paint.setStrokeWidth(1);
|
|
paint.setColor(SK_ColorBLACK);
|
|
canvas->drawLine(origin, point, paint);
|
|
SkVector normal = point;
|
|
normal.setLength(100);
|
|
paint.setStrokeWidth(10);
|
|
paint.setColor(0x3f45bf12);
|
|
canvas->drawLine(origin, normal, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso length Length setNormalize setAbs
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool setLength(SkScalar x, SkScalar y, SkScalar length)
|
|
|
|
Sets Vector to (x, y) scaled to length, if possible. If former
|
|
length is nearly zero, sets Vector to (0, 0) and return false; otherwise returns
|
|
true.
|
|
|
|
#Param x proportional value for fX ##
|
|
#Param y proportional value for fY ##
|
|
#Param length straight-line distance to origin ##
|
|
|
|
#Return true if (x, y) length is not zero or nearly zero ##
|
|
|
|
#Example
|
|
#Height 160
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 60, -110 }, { 90, 10 }, { 120, -110 }, { 180, -50 } };
|
|
const SkPoint origin = {0, 0};
|
|
canvas->translate(30, 140);
|
|
for (auto point : points) {
|
|
paint.setStrokeWidth(1);
|
|
paint.setColor(SK_ColorBLACK);
|
|
canvas->drawLine(origin, point, paint);
|
|
SkVector normal;
|
|
normal.setLength(point.fX, point.fY, 100);
|
|
paint.setStrokeWidth(10);
|
|
paint.setColor(0x3fbf4512);
|
|
canvas->drawLine(origin, normal, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso length Length setNormalize setAbs
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Operator
|
|
#Populate
|
|
##
|
|
|
|
#Method void scale(SkScalar scale, SkPoint* dst) const
|
|
#In Offset
|
|
#In Operator
|
|
#Line # multiplies Point by scale factor ##
|
|
Sets dst to Point times scale. dst may be Point to modify Point in place.
|
|
|
|
#Param scale factor to multiply Point by ##
|
|
#Param dst storage for scaled Point ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint point = {40, -15}, scaled;
|
|
SkPoint origin = {30, 110};
|
|
for (auto scale : {1, 2, 3, 5}) {
|
|
paint.setStrokeWidth(scale * 5);
|
|
paint.setARGB(0x7f, 0x9f, 0xbf, 0x33 * scale);
|
|
point.scale(scale, &scaled);
|
|
canvas->drawLine(origin, origin + scaled, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso operator*(SkScalar scale)_const operator*=(SkScalar scale) setLength
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void scale(SkScalar value)
|
|
|
|
Scales Point in place by scale.
|
|
|
|
#Param value factor to multiply Point by ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint point = {40, -15};
|
|
SkPoint origin = {30, 110};
|
|
for (auto scale : {1, 2, 3, 5}) {
|
|
paint.setStrokeWidth(scale * 5);
|
|
paint.setARGB(0x7f, 0x9f, 0xbf, 0x33 * scale);
|
|
point.scale(scale);
|
|
canvas->drawLine(origin, origin + point, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso operator*(SkScalar scale)_const operator*=(SkScalar scale) setLength
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void negate()
|
|
#In Operator
|
|
#Line # reverses the sign of both members ##
|
|
Changes the sign of fX and fY.
|
|
|
|
#Example
|
|
SkPoint test[] = { {0.f, -0.f}, {-1, -2},
|
|
{ SK_ScalarInfinity, SK_ScalarNegativeInfinity },
|
|
{ SK_ScalarNaN, -SK_ScalarNaN } };
|
|
for (const SkPoint& pt : test) {
|
|
SkPoint negPt = pt;
|
|
negPt.negate();
|
|
SkDebugf("pt: %g, %g negate: %g, %g\n", pt.fX, pt.fY, negPt.fX, negPt.fY);
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 negate: -0, 0
|
|
pt: -1, -2 negate: 1, 2
|
|
pt: inf, -inf negate: -inf, inf
|
|
pt: nan, -nan negate: -nan, nan
|
|
##
|
|
##
|
|
|
|
#SeeAlso operator-()_const setAbs
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPoint operator-()_const
|
|
|
|
#Line # reverses sign of Point ##
|
|
Returns Point changing the signs of fX and fY.
|
|
|
|
#Return Point as (-fX, -fY) ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0.f, -0.f}, {-1, -2},
|
|
{ SK_ScalarInfinity, SK_ScalarNegativeInfinity },
|
|
{ SK_ScalarNaN, -SK_ScalarNaN } };
|
|
for (const SkPoint& pt : test) {
|
|
SkPoint negPt = -pt;
|
|
SkDebugf("pt: %g, %g negate: %g, %g\n", pt.fX, pt.fY, negPt.fX, negPt.fY);
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 negate: -0, 0
|
|
pt: -1, -2 negate: 1, 2
|
|
pt: inf, -inf negate: -inf, inf
|
|
pt: nan, -nan negate: -nan, nan
|
|
##
|
|
##
|
|
|
|
#SeeAlso negate operator-(const SkPoint& a, const SkPoint& b) operator-=(const SkVector& v) SkIPoint::operator-()_const
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void operator+=(const SkVector& v)
|
|
|
|
#Line # adds Vector to Point ##
|
|
Adds Vector v to Point. Sets Point to:
|
|
#Formula
|
|
(fX + v.fX, fY + v.fY)
|
|
##
|
|
.
|
|
|
|
#Param v Vector to add ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
points[1] += {1, 1};
|
|
points[2] += {-1, -1};
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso offset() operator+(const SkPoint& a, const SkVector& b) SkIPoint::operator+=(const SkIVector& v)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method void operator-=(const SkVector& v)
|
|
|
|
#Line # subtracts Vector from Point ##
|
|
Subtracts Vector v from Point. Sets Point to:
|
|
#Formula
|
|
(fX - v.fX, fY - v.fY)
|
|
##
|
|
.
|
|
|
|
#Param v Vector to subtract ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
points[1] -= {1, 1};
|
|
points[2] -= {-1, -1};
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso offset() operator-(const SkPoint& a, const SkPoint& b) SkIPoint::operator-=(const SkIVector& v)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPoint operator*(SkScalar scale)_const
|
|
|
|
#Line # returns Point multiplied by scale ##
|
|
Returns Point multiplied by scale.
|
|
|
|
#Param scale Scalar to multiply by ##
|
|
|
|
#Return Point as (fX * scale, fY * scale) ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(15, 10);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
for (auto& point : points) {
|
|
point = point * 1.5f;
|
|
}
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso operator*=(SkScalar scale) scale() setLength setNormalize
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPoint& operator*=(SkScalar scale)
|
|
|
|
#Line # multiplies Point by scale factor ##
|
|
Multiplies Point by scale. Sets Point to:
|
|
#Formula
|
|
(fX * scale, fY * scale)
|
|
##
|
|
|
|
#Param scale Scalar to multiply by ##
|
|
|
|
#Return reference to Point ##
|
|
|
|
#Example
|
|
#Height 128
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(15, 10);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
for (auto& point : points) {
|
|
point *= 2;
|
|
}
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso operator*(SkScalar scale)_const scale() setLength setNormalize
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool isFinite() const
|
|
#In Property
|
|
#Line # returns true if no member is infinite or NaN ##
|
|
Returns true if both fX and fY are measurable values.
|
|
|
|
#Return true for values other than infinities and NaN ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0, -0.f}, {-1, -2}, {SK_ScalarInfinity, 1}, {SK_ScalarNaN, -1} };
|
|
for (const SkPoint& pt : test) {
|
|
SkDebugf("pt: %g, %g finite: %s\n", pt.fX, pt.fY, pt.isFinite() ? "true" : "false");
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 finite: true
|
|
pt: -1, -2 finite: true
|
|
pt: inf, 1 finite: false
|
|
pt: nan, -1 finite: false
|
|
##
|
|
##
|
|
|
|
#SeeAlso SkRect::isFinite SkPath::isFinite
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool equals(SkScalar x, SkScalar y) const
|
|
#In Operator
|
|
#Line # returns true if Points are equal ##
|
|
Returns true if Point is equivalent to Point constructed from (x, y).
|
|
|
|
#Param x value compared with fX ##
|
|
#Param y value compared with fY ##
|
|
|
|
#Return true if Point equals (x, y) ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0, -0.f}, {-1, -2}, {SK_ScalarInfinity, 1}, {SK_ScalarNaN, -1} };
|
|
for (const SkPoint& pt : test) {
|
|
SkDebugf("pt: %g, %g %c= pt\n", pt.fX, pt.fY, pt.equals(pt.fX, pt.fY) ? '=' : '!');
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 == pt
|
|
pt: -1, -2 == pt
|
|
pt: inf, 1 == pt
|
|
pt: nan, -1 != pt
|
|
##
|
|
##
|
|
|
|
#SeeAlso operator==(const SkPoint& a, const SkPoint& b)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool operator==(const SkPoint& a, const SkPoint& b)
|
|
|
|
#Line # returns true if Point are equal ##
|
|
Returns true if a is equivalent to b.
|
|
|
|
#Param a Point to compare ##
|
|
#Param b Point to compare ##
|
|
|
|
#Return true if a.fX == b.fX and a.fY == b.fY ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0, -0.f}, {-1, -2}, {SK_ScalarInfinity, 1}, {SK_ScalarNaN, -1} };
|
|
for (const SkPoint& pt : test) {
|
|
SkDebugf("pt: %g, %g %c= pt\n", pt.fX, pt.fY, pt == pt ? '=' : '!');
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 == pt
|
|
pt: -1, -2 == pt
|
|
pt: inf, 1 == pt
|
|
pt: nan, -1 != pt
|
|
##
|
|
##
|
|
|
|
#SeeAlso equals() operator!=(const SkPoint& a, const SkPoint& b)
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method bool operator!=(const SkPoint& a, const SkPoint& b)
|
|
|
|
#Line # returns true if Point are unequal ##
|
|
Returns true if a is not equivalent to b.
|
|
|
|
#Param a Point to compare ##
|
|
#Param b Point to compare ##
|
|
|
|
#Return true if a.fX != b.fX or a.fY != b.fY ##
|
|
|
|
#Example
|
|
SkPoint test[] = { {0, -0.f}, {-1, -2}, {SK_ScalarInfinity, 1}, {SK_ScalarNaN, -1} };
|
|
for (const SkPoint& pt : test) {
|
|
SkDebugf("pt: %g, %g %c= pt\n", pt.fX, pt.fY, pt != pt ? '!' : '=');
|
|
}
|
|
#StdOut
|
|
pt: 0, -0 == pt
|
|
pt: -1, -2 == pt
|
|
pt: inf, 1 == pt
|
|
pt: nan, -1 != pt
|
|
##
|
|
##
|
|
|
|
#SeeAlso operator==(const SkPoint& a, const SkPoint& b) equals()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkVector operator-(const SkPoint& a, const SkPoint& b)
|
|
|
|
#Line # returns Vector between Points ##
|
|
Returns Vector from b to a, computed as
|
|
#Formula
|
|
(a.fX - b.fX, a.fY - b.fY)
|
|
##
|
|
.
|
|
|
|
Can also be used to subtract Vector from Point, returning Point.
|
|
Can also be used to subtract Vector from Vector, returning Vector.
|
|
|
|
#Param a Point to subtract from ##
|
|
#Param b Point to subtract ##
|
|
|
|
#Return Vector from b to a ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
points[1] += points[0] - points[2];
|
|
points[2] -= points[3] - points[5];
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso operator-=(const SkVector& v) offset()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkPoint operator+(const SkPoint& a, const SkVector& b)
|
|
|
|
#Line # returns Point offset by Vector ##
|
|
Returns Point resulting from Point a offset by Vector b, computed as:
|
|
#Formula
|
|
(a.fX + b.fX, a.fY + b.fY)
|
|
##
|
|
.
|
|
|
|
Can also be used to offset Point b by Vector a, returning Point.
|
|
Can also be used to add Vector to Vector, returning Vector.
|
|
|
|
#Param a Point or Vector to add to ##
|
|
#Param b Point or Vector to add ##
|
|
|
|
#Return Point equal to a offset by b ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkPoint points[] = { { 3, 1 }, { 4, 2 }, { 5, 1 }, { 7, 3 },
|
|
{ 6, 4 }, { 7, 5 }, { 5, 7 },
|
|
{ 4, 6 }, { 3, 7 }, { 1, 5 },
|
|
{ 2, 4 }, { 1, 3 }, { 3, 1 } };
|
|
canvas->scale(30, 15);
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
SkVector mod = {1, 1};
|
|
for (auto& point : points) {
|
|
point = point + mod;
|
|
mod.fX *= 1.1f;
|
|
mod.fY += .2f;
|
|
}
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawPoints(SkCanvas::kPolygon_PointMode, SK_ARRAY_COUNT(points), points, paint);
|
|
##
|
|
|
|
#SeeAlso operator+=(const SkVector& v) offset()
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkScalar Length(SkScalar x, SkScalar y)
|
|
#In Property
|
|
#Line # returns straight-line distance to origin ##
|
|
Returns the Euclidean_Distance from origin, computed as:
|
|
#Code
|
|
#Literal
|
|
sqrt(x * x + y * y)
|
|
##
|
|
.
|
|
|
|
#Param x component of length ##
|
|
#Param y component of length ##
|
|
|
|
#Return straight-line distance to origin ##
|
|
|
|
#Example
|
|
#Height 192
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint points[] = { { 90, 30 }, { 120, 150 }, { 150, 30 }, { 210, 90 } };
|
|
const SkPoint origin = {30, 140};
|
|
for (auto point : points) {
|
|
canvas->drawLine(origin, point, paint);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
SkScalar angle = SkScalarATan2((point.fY - origin.fY), point.fX - origin.fX);
|
|
canvas->rotate(angle * 180 / SK_ScalarPI, origin.fX, origin.fY);
|
|
SkString length("length = ");
|
|
length.appendScalar(SkPoint::Length(point.fX, point.fY));
|
|
canvas->drawString(length, origin.fX + 25, origin.fY - 4, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso length() Distance setLength
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkScalar Normalize(SkVector* vec)
|
|
#In Offset
|
|
#Line # sets length to one, and returns prior length ##
|
|
Scales (vec->fX, vec->fY) so that length() returns one, while preserving ratio of vec->fX to vec->fY,
|
|
if possible. If original length is nearly zero, sets vec to (0, 0) and returns zero;
|
|
otherwise, returns length of vec before vec is scaled.
|
|
|
|
Returned prior length may be SK_ScalarInfinity if it can not be represented by SkScalar.
|
|
|
|
Note that normalize() is faster if prior length is not required.
|
|
|
|
#Param vec normalized to unit length ##
|
|
|
|
#Return original vec length ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint lines[][2] = { {{ 30, 110 }, { 190, 30 }},
|
|
{{ 30, 220 }, { 120, 140 }}};
|
|
for (auto line : lines) {
|
|
canvas->drawLine(line[0], line[1], paint);
|
|
SkVector vector = line[1] - line[0];
|
|
SkScalar priorLength = SkPoint::Normalize(&vector);
|
|
SkVector rotate90 = { -vector.fY, vector.fX };
|
|
rotate90 *= 10.f;
|
|
canvas->drawLine(line[0] - rotate90, line[0] + rotate90, paint);
|
|
canvas->drawLine(line[1] - rotate90, line[1] + rotate90, paint);
|
|
SkString length("length = ");
|
|
length.appendScalar(priorLength);
|
|
canvas->drawString(length, line[0].fX + 25, line[0].fY - 4, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso normalize() setLength Length
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkScalar Distance(const SkPoint& a, const SkPoint& b)
|
|
#In Property
|
|
#Line # returns straight-line distance between points ##
|
|
Returns the Euclidean_Distance between a and b.
|
|
|
|
#Param a line end point ##
|
|
#Param b line end point ##
|
|
|
|
#Return straight-line distance from a to b ##
|
|
|
|
#Example
|
|
#Height 192
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
const SkPoint lines[][2] = {{{-10, -10}, {90, 30}}, {{0, 0}, {150, 30}}, {{10, 25}, {120, 150}}};
|
|
const SkPoint origin = {30, 160};
|
|
for (auto line : lines) {
|
|
SkPoint a = origin + line[0];
|
|
const SkPoint& b = line[1];
|
|
canvas->drawLine(a, b, paint);
|
|
SkAutoCanvasRestore acr(canvas, true);
|
|
SkScalar angle = SkScalarATan2((b.fY - a.fY), b.fX - a.fX);
|
|
canvas->rotate(angle * 180 / SK_ScalarPI, a.fX, a.fY);
|
|
SkString distance("distance = ");
|
|
distance.appendScalar(SkPoint::Distance(a, b));
|
|
canvas->drawString(distance, a.fX + 25, a.fY - 4, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso length() setLength
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkScalar DotProduct(const SkVector& a, const SkVector& b)
|
|
#In Operator
|
|
#Line # returns dot product ##
|
|
Returns the dot product of Vector a and Vector b.
|
|
|
|
#Param a left side of dot product ##
|
|
#Param b right side of dot product ##
|
|
|
|
#Return product of input magnitudes and cosine of the angle between them ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkVector vectors[][2] = {{{50, 2}, {-14, 20}}, {{0, 50}, {-50, 0}}, {{-20, 25}, {25, -20}},
|
|
{{-20, -24}, {-24, -20}}};
|
|
SkPoint center[] = {{32, 32}, {160, 32}, {32, 160}, {160, 160}};
|
|
paint.setStrokeWidth(2);
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
canvas->drawLine(center[i], center[i] + vectors[i][0], paint);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][1], paint);
|
|
SkString str;
|
|
str.printf("dot = %g", SkPoint::DotProduct(vectors[i][0], vectors[i][1]));
|
|
canvas->drawString(str, center[i].fX, center[i].fY, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso dot CrossProduct
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method static SkScalar CrossProduct(const SkVector& a, const SkVector& b)
|
|
#In Operator
|
|
#Line # returns cross product ##
|
|
Returns the cross product of Vector a and Vector b.
|
|
|
|
a and b form three-dimensional vectors with z-axis value equal to zero. The
|
|
cross product is a three-dimensional vector with x-axis and y-axis values equal
|
|
to zero. The cross product z-axis component is returned.
|
|
|
|
#Param a left side of cross product ##
|
|
#Param b right side of cross product ##
|
|
|
|
#Return area spanned by Vectors signed by angle direction ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkVector vectors[][2] = {{{50, 2}, {-14, 20}}, {{0, 50}, {-50, 0}}, {{-20, 25}, {25, -20}},
|
|
{{-20, -24}, {-24, -20}}};
|
|
SkPoint center[] = {{32, 32}, {160, 32}, {32, 160}, {160, 160}};
|
|
paint.setStrokeWidth(2);
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][0], paint);
|
|
paint.setColor(SK_ColorBLUE);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][1], paint);
|
|
SkString str;
|
|
SkScalar cross = SkPoint::CrossProduct(vectors[i][1], vectors[i][0]);
|
|
str.printf("cross = %g", cross);
|
|
paint.setColor(cross >= 0 ? SK_ColorRED : SK_ColorBLUE);
|
|
canvas->drawString(str, center[i].fX, center[i].fY, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso cross DotProduct
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar cross(const SkVector& vec) const
|
|
#In Operator
|
|
#Line # returns cross product ##
|
|
Returns the cross product of Vector and vec.
|
|
|
|
Vector and vec form three-dimensional vectors with z-axis value equal to zero.
|
|
The cross product is a three-dimensional vector with x-axis and y-axis values
|
|
equal to zero. The cross product z-axis component is returned.
|
|
|
|
#Param vec right side of cross product ##
|
|
|
|
#Return area spanned by Vectors signed by angle direction ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkVector vectors[][2] = {{{50, 2}, {-14, 20}}, {{0, 50}, {-50, 0}}, {{-20, 25}, {25, -20}},
|
|
{{-20, -24}, {-24, -20}}};
|
|
SkPoint center[] = {{32, 32}, {160, 32}, {32, 160}, {160, 160}};
|
|
paint.setStrokeWidth(2);
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
paint.setColor(SK_ColorRED);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][0], paint);
|
|
paint.setColor(SK_ColorBLUE);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][1], paint);
|
|
SkString str;
|
|
SkScalar cross = vectors[i][0].cross(vectors[i][1]);
|
|
str.printf("cross = %g", cross);
|
|
paint.setColor(cross >= 0 ? SK_ColorRED : SK_ColorBLUE);
|
|
canvas->drawString(str, center[i].fX, center[i].fY, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso CrossProduct dot
|
|
|
|
#Method ##
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Method SkScalar dot(const SkVector& vec) const
|
|
#In Operator
|
|
#Line # returns dot product ##
|
|
Returns the dot product of Vector and Vector vec.
|
|
|
|
#Param vec right side of dot product ##
|
|
|
|
#Return product of input magnitudes and cosine of the angle between them ##
|
|
|
|
#Example
|
|
SkPaint paint;
|
|
paint.setAntiAlias(true);
|
|
SkVector vectors[][2] = {{{50, 2}, {-14, 20}}, {{0, 50}, {-50, 0}}, {{-20, 25}, {25, -20}},
|
|
{{-20, -24}, {-24, -20}}};
|
|
SkPoint center[] = {{32, 32}, {160, 32}, {32, 160}, {160, 160}};
|
|
paint.setStrokeWidth(2);
|
|
for (size_t i = 0; i < 4; ++i) {
|
|
canvas->drawLine(center[i], center[i] + vectors[i][0], paint);
|
|
canvas->drawLine(center[i], center[i] + vectors[i][1], paint);
|
|
SkString str;
|
|
str.printf("dot = %g", vectors[i][0].dot(vectors[i][1]));
|
|
canvas->drawString(str, center[i].fX, center[i].fY, paint);
|
|
}
|
|
##
|
|
|
|
#SeeAlso DotProduct cross
|
|
|
|
#Method ##
|
|
|
|
#Struct SkPoint ##
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
#Subtopic Vector
|
|
#Line # alias for Point ##
|
|
#Alias Vector
|
|
#Alias Vectors
|
|
#Typedef SkPoint SkVector
|
|
#Line # alias for Point ##
|
|
#Code
|
|
typedef SkPoint SkVector;
|
|
##
|
|
SkVector provides an alternative name for SkPoint. SkVector and SkPoint can
|
|
be used interchangably for all purposes.
|
|
#Typedef ##
|
|
##
|
|
|
|
#Topic Point ##
|