SkPointPriv Class Reference

#include <SkPointPriv.h>

Public Types
enum	Side { kLeft_Side = -1 , kOn_Side = 0 , kRight_Side = 1 }

Static Public Member Functions
static bool	AreFinite (const SkPoint array[], int count)
static const SkScalar *	AsScalars (const SkPoint &pt)
static bool	CanNormalize (SkScalar dx, SkScalar dy)
static SkScalar	DistanceToLineBetweenSqd (const SkPoint &pt, const SkPoint &a, const SkPoint &b, Side *side=nullptr)
static SkScalar	DistanceToLineBetween (const SkPoint &pt, const SkPoint &a, const SkPoint &b, Side *side=nullptr)
static SkScalar	DistanceToLineSegmentBetweenSqd (const SkPoint &pt, const SkPoint &a, const SkPoint &b)
static SkScalar	DistanceToLineSegmentBetween (const SkPoint &pt, const SkPoint &a, const SkPoint &b)
static SkScalar	DistanceToSqd (const SkPoint &pt, const SkPoint &a)
static bool	EqualsWithinTolerance (const SkPoint &p1, const SkPoint &p2)
static bool	EqualsWithinTolerance (const SkPoint &pt, const SkPoint &p, SkScalar tol)
static SkScalar	LengthSqd (const SkPoint &pt)
static void	Negate (SkIPoint &pt)
static void	RotateCCW (const SkPoint &src, SkPoint *dst)
static void	RotateCCW (SkPoint *pt)
static void	RotateCW (const SkPoint &src, SkPoint *dst)
static void	RotateCW (SkPoint *pt)
static bool	SetLengthFast (SkPoint *pt, float length)
static SkPoint	MakeOrthog (const SkPoint &vec, Side side=kLeft_Side)
static void	SetRectFan (SkPoint v[], SkScalar l, SkScalar t, SkScalar r, SkScalar b, size_t stride)
static void	SetRectTriStrip (SkPoint v[], SkScalar l, SkScalar t, SkScalar r, SkScalar b, size_t stride)
static void	SetRectTriStrip (SkPoint v[], const SkRect &rect, size_t stride)

Detailed Description

Definition at line 14 of file SkPointPriv.h.

Member Enumeration Documentation

Side

enum SkPointPriv::Side

Enumerator
kLeft_Side
kOn_Side
kRight_Side

Definition at line 16 of file SkPointPriv.h.

              {
        kLeft_Side  = -1,
        kOn_Side    =  0,
        kRight_Side =  1,
    };

Member Function Documentation

AreFinite()

static bool SkPointPriv::AreFinite ( const SkPoint  array[], int  count  )

inlinestatic

Definition at line 22 of file SkPointPriv.h.

                                                            {
        return SkIsFinite(&array[0].fX, count << 1);
    }

AsScalars()

static const SkScalar * SkPointPriv::AsScalars ( const SkPoint &  pt )

inlinestatic

Definition at line 26 of file SkPointPriv.h.

{ return &pt.fX; }

CanNormalize()

static bool SkPointPriv::CanNormalize ( SkScalar  dx, SkScalar  dy  )

inlinestatic

Definition at line 28 of file SkPointPriv.h.

                                                       {
        return SkIsFinite(dx, dy) && (dx || dy);
    }

DistanceToLineBetween()

static SkScalar SkPointPriv::DistanceToLineBetween ( const SkPoint &  pt, const SkPoint &  a, const SkPoint &  b, Side *  side = nullptr  )

inlinestatic

Definition at line 35 of file SkPointPriv.h.

                                                                                  {
        return SkScalarSqrt(DistanceToLineBetweenSqd(pt, a, b, side));
    }

DistanceToLineBetweenSqd()

float SkPointPriv::DistanceToLineBetweenSqd ( const SkPoint &  pt, const SkPoint &  a, const SkPoint &  b, Side *  side = nullptr  )

static

Definition at line 101 of file SkPoint.cpp.

                                                           {
 
    SkVector u = b - a;
    SkVector v = pt - a;
 
    float uLengthSqd = LengthSqd(u);
    float det = u.cross(v);
    if (side) {
        SkASSERT(-1 == kLeft_Side &&
                  0 == kOn_Side &&
                  1 == kRight_Side);
        *side = (Side)sk_float_sgn(det);
    }
    float temp = sk_ieee_float_divide(det, uLengthSqd);
    temp *= det;
    // It's possible we have a degenerate line vector, or we're so far away it looks degenerate
    // In this case, return squared distance to point A.
    if (!SkIsFinite(temp)) {
        return LengthSqd(v);
    }
    return temp;
}

DistanceToLineSegmentBetween()

static SkScalar SkPointPriv::DistanceToLineSegmentBetween ( const SkPoint &  pt, const SkPoint &  a, const SkPoint &  b  )

inlinestatic

Definition at line 43 of file SkPointPriv.h.

                                                                   {
        return SkScalarSqrt(DistanceToLineSegmentBetweenSqd(pt, a, b));
    }

DistanceToLineSegmentBetweenSqd()

float SkPointPriv::DistanceToLineSegmentBetweenSqd ( const SkPoint &  pt, const SkPoint &  a, const SkPoint &  b  )

static

Definition at line 126 of file SkPoint.cpp.

                                                                        {
    // See comments to distanceToLineBetweenSqd. If the projection of c onto
    // u is between a and b then this returns the same result as that
    // function. Otherwise, it returns the distance to the closest of a and
    // b. Let the projection of v onto u be v'.  There are three cases:
    //    1. v' points opposite to u. c is not between a and b and is closer
    //       to a than b.
    //    2. v' points along u and has magnitude less than y. c is between
    //       a and b and the distance to the segment is the same as distance
    //       to the line ab.
    //    3. v' points along u and has greater magnitude than u. c is not
    //       between a and b and is closer to b than a.
    // v' = (u dot v) * u / |u|. So if (u dot v)/|u| is less than zero we're
    // in case 1. If (u dot v)/|u| is > |u| we are in case 3. Otherwise,
    // we're in case 2. We actually compare (u dot v) to 0 and |u|^2 to
    // avoid a sqrt to compute |u|.
 
    SkVector u = b - a;
    SkVector v = pt - a;
 
    float uLengthSqd = LengthSqd(u);
    float uDotV = SkPoint::DotProduct(u, v);
 
    // closest point is point A
    if (uDotV <= 0) {
        return LengthSqd(v);
    // closest point is point B
    } else if (uDotV > uLengthSqd) {
        return DistanceToSqd(b, pt);
    // closest point is inside segment
    } else {
        float det = u.cross(v);
        float temp = sk_ieee_float_divide(det, uLengthSqd);
        temp *= det;
        // It's possible we have a degenerate segment, or we're so far away it looks degenerate
        // In this case, return squared distance to point A.
        if (!SkIsFinite(temp)) {
            return LengthSqd(v);
        }
        return temp;
    }
}

DistanceToSqd()

static SkScalar SkPointPriv::DistanceToSqd ( const SkPoint &  pt, const SkPoint &  a  )

inlinestatic

Definition at line 48 of file SkPointPriv.h.

                                                                       {
        SkScalar dx = pt.fX - a.fX;
        SkScalar dy = pt.fY - a.fY;
        return dx * dx + dy * dy;
    }

EqualsWithinTolerance() [1/2]

static bool SkPointPriv::EqualsWithinTolerance ( const SkPoint &  p1, const SkPoint &  p2  )

inlinestatic

Definition at line 54 of file SkPointPriv.h.

                                                                            {
        return !CanNormalize(p1.fX - p2.fX, p1.fY - p2.fY);
    }

EqualsWithinTolerance() [2/2]

static bool SkPointPriv::EqualsWithinTolerance ( const SkPoint &  pt, const SkPoint &  p, SkScalar  tol  )

inlinestatic

Definition at line 58 of file SkPointPriv.h.

                                                                                         {
        return SkScalarNearlyZero(pt.fX - p.fX, tol)
               && SkScalarNearlyZero(pt.fY - p.fY, tol);
    }

LengthSqd()

static SkScalar SkPointPriv::LengthSqd ( const SkPoint &  pt )

inlinestatic

Definition at line 63 of file SkPointPriv.h.

                                                 {
        return SkPoint::DotProduct(pt, pt);
    }

MakeOrthog()

static SkPoint SkPointPriv::MakeOrthog ( const SkPoint &  vec, Side  side = kLeft_Side  )

inlinestatic

Definition at line 96 of file SkPointPriv.h.

                                                                          {
        SkASSERT(side == kRight_Side || side == kLeft_Side);
        return (side == kRight_Side) ? SkPoint{-vec.fY, vec.fX} : SkPoint{vec.fY, -vec.fX};
    }

Negate()

static void SkPointPriv::Negate ( SkIPoint &  pt )

inlinestatic

Definition at line 67 of file SkPointPriv.h.

                                     {
        pt.fX = -pt.fX;
        pt.fY = -pt.fY;
    }

RotateCCW() [1/2]

static void SkPointPriv::RotateCCW ( const SkPoint &  src, SkPoint *  dst  )

inlinestatic

Definition at line 72 of file SkPointPriv.h.

                                                            {
        // use a tmp in case src == dst
        SkScalar tmp = src.fX;
        dst->fX = src.fY;
        dst->fY = -tmp;
    }

RotateCCW() [2/2]

static void SkPointPriv::RotateCCW ( SkPoint *  pt )

inlinestatic

Definition at line 79 of file SkPointPriv.h.

                                       {
        RotateCCW(*pt, pt);
    }

RotateCW() [1/2]

static void SkPointPriv::RotateCW ( const SkPoint &  src, SkPoint *  dst  )

inlinestatic

Definition at line 83 of file SkPointPriv.h.

                                                           {
        // use a tmp in case src == dst
        SkScalar tmp = src.fX;
        dst->fX = -src.fY;
        dst->fY = tmp;
    }

RotateCW() [2/2]

static void SkPointPriv::RotateCW ( SkPoint *  pt )

inlinestatic

Definition at line 90 of file SkPointPriv.h.

                                      {
        RotateCW(*pt, pt);
    }

SetLengthFast()

bool SkPointPriv::SetLengthFast ( SkPoint *  pt, float  length  )

static

Definition at line 94 of file SkPoint.cpp.

                                                         {
    return set_point_length<true>(pt, pt->fX, pt->fY, length);
}

SetRectFan()

static void SkPointPriv::SetRectFan ( SkPoint  v[], SkScalar  l, SkScalar  t, SkScalar  r, SkScalar  b, size_t  stride  )

inlinestatic

Definition at line 102 of file SkPointPriv.h.

                           {
        SkASSERT(stride >= sizeof(SkPoint));
 
        ((SkPoint*)((intptr_t)v + 0 * stride))->set(l, t);
        ((SkPoint*)((intptr_t)v + 1 * stride))->set(l, b);
        ((SkPoint*)((intptr_t)v + 2 * stride))->set(r, b);
        ((SkPoint*)((intptr_t)v + 3 * stride))->set(r, t);
    }

SetRectTriStrip() [1/2]

static void SkPointPriv::SetRectTriStrip ( SkPoint  v[], const SkRect &  rect, size_t  stride  )

inlinestatic

Definition at line 122 of file SkPointPriv.h.

                                                                                {
        SetRectTriStrip(v, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, stride);
    }

SetRectTriStrip() [2/2]

static void SkPointPriv::SetRectTriStrip ( SkPoint  v[], SkScalar  l, SkScalar  t, SkScalar  r, SkScalar  b, size_t  stride  )

inlinestatic

Definition at line 113 of file SkPointPriv.h.

                           {
        SkASSERT(stride >= sizeof(SkPoint));
 
        ((SkPoint*)((intptr_t)v + 0 * stride))->set(l, t);
        ((SkPoint*)((intptr_t)v + 1 * stride))->set(l, b);
        ((SkPoint*)((intptr_t)v + 2 * stride))->set(r, t);
        ((SkPoint*)((intptr_t)v + 3 * stride))->set(r, b);
    }

---

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

• third_party/skia/src/core/SkPointPriv.h
• third_party/skia/src/core/SkPoint.cpp