| #Topic Point |
| #Alias Points ## |
| #Alias Point_Reference ## |
| |
| #Struct SkPoint |
| |
| #Code |
| #Populate |
| ## |
| |
| SkPoint holds two 32-bit floating point coordinates. |
| |
| #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. |
| ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method static constexpr SkPoint Make(SkScalar x, SkScalar y) |
| #In Constructors |
| #Line # constructs from SkScalar inputs ## |
| #Populate |
| |
| #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 ## |
| ## |
| |
| #Method SkScalar x() const |
| #In Property |
| #Line # returns fX ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 |
| #Line # replaces all values ## |
| ## |
| |
| #Method void set(SkScalar x, SkScalar y) |
| #In Set |
| #Line # sets to SkScalar input ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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) |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| ## |
| |
| #Method static void Offset(SkPoint points[], int count, const SkVector& offset) |
| #In Offset |
| #Line # translates Point array ## |
| #Populate |
| |
| #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) |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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) ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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) |
| #Populate |
| |
| #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 ## |
| |
| # ------------------------------------------------------------------------------ |
| |
| #Method void scale(SkScalar scale, SkPoint* dst) const |
| #In Offset |
| #In Operators |
| #Line # multiplies Point by scale factor ## |
| #Populate |
| |
| #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) |
| #Populate |
| |
| #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 Operators |
| #Line # reverses the sign of both members ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 Operators |
| #Line # returns true if Points are equal ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 ## |
| #Populate |
| |
| #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 Operators |
| #Line # returns dot product ## |
| #Populate |
| |
| #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 Operators |
| #Line # returns cross product ## |
| #Populate |
| |
| #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 Operators |
| #Line # returns cross product ## |
| #Populate |
| |
| #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 Operators |
| #Line # returns dot product ## |
| #Populate |
| |
| #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 interchangeably for all purposes. |
| #Typedef ## |
| ## |
| |
| #Topic Point ## |
