SkDPoint Struct Reference

#include <SkPathOpsPoint.h>

Public Member Functions
void	set (const SkPoint &pt)
void	operator= (const SkPoint &pt)
void	operator+= (const SkDVector &v)
void	operator-= (const SkDVector &v)
SkDPoint	operator+ (const SkDVector &v)
SkDPoint	operator- (const SkDVector &v)
bool	approximatelyDEqual (const SkDPoint &a) const
bool	approximatelyDEqual (const SkPoint &a) const
bool	approximatelyEqual (const SkDPoint &a) const
bool	approximatelyEqual (const SkPoint &a) const
bool	approximatelyZero () const
SkPoint	asSkPoint () const
double	distance (const SkDPoint &a) const
double	distanceSquared (const SkDPoint &a) const
bool	roughlyEqual (const SkDPoint &a) const
void	dump () const

Static Public Member Functions
static bool	ApproximatelyEqual (const SkPoint &a, const SkPoint &b)
static SkDPoint	Mid (const SkDPoint &a, const SkDPoint &b)
static bool	RoughlyEqual (const SkPoint &a, const SkPoint &b)
static bool	WayRoughlyEqual (const SkPoint &a, const SkPoint &b)
static void	Dump (const SkPoint &pt)
static void	DumpHex (const SkPoint &pt)

Public Attributes
double	fX
double	fY

Friends
SkDVector	operator- (const SkDPoint &a, const SkDPoint &b)
bool	operator== (const SkDPoint &a, const SkDPoint &b)
bool	operator!= (const SkDPoint &a, const SkDPoint &b)

Detailed Description

Definition at line 102 of file SkPathOpsPoint.h.

Member Function Documentation

approximatelyDEqual() [1/2]

bool SkDPoint::approximatelyDEqual ( const SkDPoint &  a ) const

inline

Definition at line 157 of file SkPathOpsPoint.h.

                                                      {
        if (approximately_equal(fX, a.fX) && approximately_equal(fY, a.fY)) {
            return true;
        }
        if (!RoughlyEqualUlps(fX, a.fX) || !RoughlyEqualUlps(fY, a.fY)) {
            return false;
        }
        double dist = distance(a);  // OPTIMIZATION: can we compare against distSq instead ?
        double tiniest = std::min(std::min(std::min(fX, a.fX), fY), a.fY);
        double largest = std::max(std::max(std::max(fX, a.fX), fY), a.fY);
        largest = std::max(largest, -tiniest);
        return AlmostDequalUlps(largest, largest + dist); // is the dist within ULPS tolerance?
    }

approximatelyDEqual() [2/2]

bool SkDPoint::approximatelyDEqual ( const SkPoint &  a ) const

inline

Definition at line 171 of file SkPathOpsPoint.h.

                                                     {
        SkDPoint dA;
        dA.set(a);
        return approximatelyDEqual(dA);
    }

approximatelyEqual() [1/2]

bool SkDPoint::approximatelyEqual ( const SkDPoint &  a ) const

inline

Definition at line 177 of file SkPathOpsPoint.h.

                                                     {
        if (approximately_equal(fX, a.fX) && approximately_equal(fY, a.fY)) {
            return true;
        }
        if (!RoughlyEqualUlps(fX, a.fX) || !RoughlyEqualUlps(fY, a.fY)) {
            return false;
        }
        double dist = distance(a);  // OPTIMIZATION: can we compare against distSq instead ?
        double tiniest = std::min(std::min(std::min(fX, a.fX), fY), a.fY);
        double largest = std::max(std::max(std::max(fX, a.fX), fY), a.fY);
        largest = std::max(largest, -tiniest);
        return AlmostPequalUlps(largest, largest + dist); // is the dist within ULPS tolerance?
    }

approximatelyEqual() [2/2]

bool SkDPoint::approximatelyEqual ( const SkPoint &  a ) const

inline

Definition at line 191 of file SkPathOpsPoint.h.

                                                    {
        SkDPoint dA;
        dA.set(a);
        return approximatelyEqual(dA);
    }

ApproximatelyEqual()

static bool SkDPoint::ApproximatelyEqual ( const SkPoint &  a, const SkPoint &  b  )

inlinestatic

Definition at line 197 of file SkPathOpsPoint.h.

                                                                       {
        if (approximately_equal(a.fX, b.fX) && approximately_equal(a.fY, b.fY)) {
            return true;
        }
        if (!RoughlyEqualUlps(a.fX, b.fX) || !RoughlyEqualUlps(a.fY, b.fY)) {
            return false;
        }
        SkDPoint dA, dB;
        dA.set(a);
        dB.set(b);
        double dist = dA.distance(dB);  // OPTIMIZATION: can we compare against distSq instead ?
        float tiniest = std::min(std::min(std::min(a.fX, b.fX), a.fY), b.fY);
        float largest = std::max(std::max(std::max(a.fX, b.fX), a.fY), b.fY);
        largest = std::max(largest, -tiniest);
        return AlmostDequalUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
    }

approximatelyZero()

bool SkDPoint::approximatelyZero ( ) const

inline

Definition at line 215 of file SkPathOpsPoint.h.

                                   {
        return approximately_zero(fX) && approximately_zero(fY);
    }

asSkPoint()

SkPoint SkDPoint::asSkPoint ( ) const

inline

Definition at line 219 of file SkPathOpsPoint.h.

                              {
        SkPoint pt = {SkDoubleToScalar(fX), SkDoubleToScalar(fY)};
        return pt;
    }

distance()

double SkDPoint::distance ( const SkDPoint &  a ) const

inline

Definition at line 224 of file SkPathOpsPoint.h.

                                             {
        SkDVector temp = *this - a;
        return temp.length();
    }

distanceSquared()

double SkDPoint::distanceSquared ( const SkDPoint &  a ) const

inline

Definition at line 229 of file SkPathOpsPoint.h.

                                                    {
        SkDVector temp = *this - a;
        return temp.lengthSquared();
    }

dump()

void SkDPoint::dump

(

)

const

Definition at line 181 of file PathOpsDebug.cpp.

                          {
    SkDebugf("{");
    DebugDumpDouble(fX);
    SkDebugf(", ");
    DebugDumpDouble(fY);
    SkDebugf("}");
}

Dump()

void SkDPoint::Dump ( const SkPoint &  pt )

static

Definition at line 189 of file PathOpsDebug.cpp.

                                     {
    SkDebugf("{");
    DebugDumpFloat(pt.fX);
    SkDebugf(", ");
    DebugDumpFloat(pt.fY);
    SkDebugf("}");
}

DumpHex()

void SkDPoint::DumpHex ( const SkPoint &  pt )

static

Definition at line 197 of file PathOpsDebug.cpp.

                                        {
    SkDebugf("{");
    DebugDumpHexFloat(pt.fX);
    SkDebugf(", ");
    DebugDumpHexFloat(pt.fY);
    SkDebugf("}");
}

Mid()

static SkDPoint SkDPoint::Mid ( const SkDPoint &  a, const SkDPoint &  b  )

inlinestatic

Definition at line 234 of file SkPathOpsPoint.h.

                                                              {
        SkDPoint result;
        result.fX = (a.fX + b.fX) / 2;
        result.fY = (a.fY + b.fY) / 2;
        return result;
    }

operator+()

SkDPoint SkDPoint::operator+ ( const SkDVector &  v )

inline

Definition at line 141 of file SkPathOpsPoint.h.

                                           {
        SkDPoint result = *this;
        result += v;
        return result;
    }

operator+=()

void SkDPoint::operator+= ( const SkDVector &  v )

inline

Definition at line 129 of file SkPathOpsPoint.h.

                                        {
        fX += v.fX;
        fY += v.fY;
    }

operator-()

SkDPoint SkDPoint::operator- ( const SkDVector &  v )

inline

Definition at line 148 of file SkPathOpsPoint.h.

                                           {
        SkDPoint result = *this;
        result -= v;
        return result;
    }

operator-=()

void SkDPoint::operator-= ( const SkDVector &  v )

inline

Definition at line 135 of file SkPathOpsPoint.h.

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

operator=()

void SkDPoint::operator= ( const SkPoint &  pt )

inline

Definition at line 123 of file SkPathOpsPoint.h.

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

roughlyEqual()

bool SkDPoint::roughlyEqual ( const SkDPoint &  a ) const

inline

Definition at line 241 of file SkPathOpsPoint.h.

                                               {
        if (roughly_equal(fX, a.fX) && roughly_equal(fY, a.fY)) {
            return true;
        }
        double dist = distance(a);  // OPTIMIZATION: can we compare against distSq instead ?
        double tiniest = std::min(std::min(std::min(fX, a.fX), fY), a.fY);
        double largest = std::max(std::max(std::max(fX, a.fX), fY), a.fY);
        largest = std::max(largest, -tiniest);
        return RoughlyEqualUlps(largest, largest + dist); // is the dist within ULPS tolerance?
    }

RoughlyEqual()

static bool SkDPoint::RoughlyEqual ( const SkPoint &  a, const SkPoint &  b  )

inlinestatic

Definition at line 252 of file SkPathOpsPoint.h.

                                                                 {
        if (!RoughlyEqualUlps(a.fX, b.fX) && !RoughlyEqualUlps(a.fY, b.fY)) {
            return false;
        }
        SkDPoint dA, dB;
        dA.set(a);
        dB.set(b);
        double dist = dA.distance(dB);  // OPTIMIZATION: can we compare against distSq instead ?
        float tiniest = std::min(std::min(std::min(a.fX, b.fX), a.fY), b.fY);
        float largest = std::max(std::max(std::max(a.fX, b.fX), a.fY), b.fY);
        largest = std::max(largest, -tiniest);
        return RoughlyEqualUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
    }

set()

void SkDPoint::set ( const SkPoint &  pt )

inline

Definition at line 106 of file SkPathOpsPoint.h.

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

WayRoughlyEqual()

static bool SkDPoint::WayRoughlyEqual ( const SkPoint &  a, const SkPoint &  b  )

inlinestatic

Definition at line 267 of file SkPathOpsPoint.h.

                                                                    {
        float largestNumber = std::max(SkTAbs(a.fX), std::max(SkTAbs(a.fY),
                std::max(SkTAbs(b.fX), SkTAbs(b.fY))));
        SkVector diffs = a - b;
        float largestDiff = std::max(diffs.fX, diffs.fY);
        return roughly_zero_when_compared_to(largestDiff, largestNumber);
    }

Friends And Related Function Documentation

operator!=

bool operator!= ( const SkDPoint &  a, const SkDPoint &  b  )

friend

Definition at line 119 of file SkPathOpsPoint.h.

                                                                 {
        return a.fX != b.fX || a.fY != b.fY;
    }

operator-

SkDVector operator- ( const SkDPoint &  a, const SkDPoint &  b  )

friend

Definition at line 111 of file SkPathOpsPoint.h.

                                                                     {
        return { a.fX - b.fX, a.fY - b.fY };
    }

operator==

bool operator== ( const SkDPoint &  a, const SkDPoint &  b  )

friend

Definition at line 115 of file SkPathOpsPoint.h.

                                                                 {
        return a.fX == b.fX && a.fY == b.fY;
    }

Member Data Documentation

fX

double SkDPoint::fX

Definition at line 103 of file SkPathOpsPoint.h.

fY

double SkDPoint::fY

Definition at line 104 of file SkPathOpsPoint.h.

---

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

• third_party/skia/src/pathops/SkPathOpsPoint.h
• third_party/skia/tests/PathOpsDebug.cpp