SkDQuad Struct Reference

#include <SkPathOpsQuad.h>

Public Member Functions
bool	collapsed () const
bool	controlsInside () const
void	debugInit ()
void	debugSet (const SkDPoint *pts)
SkDQuad	flip () const
const SkDQuad &	set (const SkPoint pts[kPointCount] SkDEBUGPARAMS(SkOpGlobalState *state=nullptr))
const SkDPoint &	operator[] (int n) const
SkDPoint &	operator[] (int n)
void	align (int endIndex, SkDPoint *dstPt) const
SkDQuadPair	chopAt (double t) const
SkDVector	dxdyAtT (double t) const
int	horizontalIntersect (double yIntercept, double roots[2]) const
bool	hullIntersects (const SkDQuad &, bool *isLinear) const
bool	hullIntersects (const SkDConic &, bool *isLinear) const
bool	hullIntersects (const SkDCubic &, bool *isLinear) const
bool	isLinear (int startIndex, int endIndex) const
bool	monotonicInX () const
bool	monotonicInY () const
void	otherPts (int oddMan, const SkDPoint *endPt[2]) const
SkDPoint	ptAtT (double t) const
SkDQuad	subDivide (double t1, double t2) const
void	subDivide (double t1, double t2, SkDQuad *quad) const
SkDPoint	subDivide (const SkDPoint &a, const SkDPoint &c, double t1, double t2) const
int	verticalIntersect (double xIntercept, double roots[2]) const
SkDCubic	debugToCubic () const
void	dump () const
void	dumpID (int id) const
void	dumpInner () const

Static Public Member Functions
static bool	IsConic ()
static int	AddValidTs (double s[], int realRoots, double *t)
static int	FindExtrema (const double src[], double tValue[1])
static int	maxIntersections ()
static int	pointCount ()
static int	pointLast ()
static int	RootsReal (double A, double B, double C, double t[2])
static int	RootsValidT (const double A, const double B, const double C, double s[2])
static void	SetABC (const double *quad, double *a, double *b, double *c)
static SkDQuad	SubDivide (const SkPoint a[kPointCount], double t1, double t2)
static SkDPoint	SubDivide (const SkPoint pts[kPointCount], const SkDPoint &a, const SkDPoint &c, double t1, double t2)

Public Attributes
SkDPoint	fPts [kPointCount]

Static Public Attributes
static const int	kPointCount = 3
static const int	kPointLast = kPointCount - 1
static const int	kMaxIntersections = 4

Detailed Description

Definition at line 34 of file SkPathOpsQuad.h.

Member Function Documentation

AddValidTs()

int SkDQuad::AddValidTs ( double  s[], int  realRoots, double *  t  )

static

Definition at line 116 of file SkPathOpsQuad.cpp.

                                                            {
    int foundRoots = 0;
    for (int index = 0; index < realRoots; ++index) {
        double tValue = s[index];
        if (approximately_zero_or_more(tValue) && approximately_one_or_less(tValue)) {
            if (approximately_less_than_zero(tValue)) {
                tValue = 0;
            } else if (approximately_greater_than_one(tValue)) {
                tValue = 1;
            }
            for (int idx2 = 0; idx2 < foundRoots; ++idx2) {
                if (approximately_equal(t[idx2], tValue)) {
                    goto nextRoot;
                }
            }
            t[foundRoots++] = tValue;
        }
nextRoot:
        {}
    }
    return foundRoots;
}

align()

void SkDQuad::align	(	int	endIndex,
		SkDPoint *	dstPt
	)		const

Definition at line 301 of file SkPathOpsQuad.cpp.

                                                       {
    if (fPts[endIndex].fX == fPts[1].fX) {
        dstPt->fX = fPts[endIndex].fX;
    }
    if (fPts[endIndex].fY == fPts[1].fY) {
        dstPt->fY = fPts[endIndex].fY;
    }
}

chopAt()

SkDQuadPair SkDQuad::chopAt

(

double

t

)

const

Definition at line 354 of file SkPathOpsQuad.cpp.

{
    SkDQuadPair dst;
    interp_quad_coords(&fPts[0].fX, &dst.pts[0].fX, t);
    interp_quad_coords(&fPts[0].fY, &dst.pts[0].fY, t);
    return dst;
}

collapsed()

bool SkDQuad::collapsed ( ) const

inline

Definition at line 41 of file SkPathOpsQuad.h.

                           {
        return fPts[0].approximatelyEqual(fPts[1]) && fPts[0].approximatelyEqual(fPts[2]);
    }

controlsInside()

bool SkDQuad::controlsInside ( ) const

inline

Definition at line 45 of file SkPathOpsQuad.h.

                                {
        SkDVector v01 = fPts[0] - fPts[1];
        SkDVector v02 = fPts[0] - fPts[2];
        SkDVector v12 = fPts[1] - fPts[2];
        return v02.dot(v01) > 0 && v02.dot(v12) > 0;
    }

debugInit()

void SkDQuad::debugInit ( )

inline

Definition at line 52 of file SkPathOpsQuad.h.

                     {
        sk_bzero(fPts, sizeof(fPts));
    }

debugSet()

void SkDQuad::debugSet

(

const SkDPoint *

pts

)

Definition at line 707 of file SkPathOpsDebug.cpp.

                                          {
    memcpy(fPts, pts, sizeof(fPts));
    SkDEBUGCODE(fDebugGlobalState = nullptr);
}

debugToCubic()

SkDCubic SkDQuad::debugToCubic

(

)

const

Definition at line 695 of file SkPathOpsDebug.cpp.

                                     {
    SkDCubic cubic;
    cubic[0] = fPts[0];
    cubic[2] = fPts[1];
    cubic[3] = fPts[2];
    cubic[1].fX = (cubic[0].fX + cubic[2].fX * 2) / 3;
    cubic[1].fY = (cubic[0].fY + cubic[2].fY * 2) / 3;
    cubic[2].fX = (cubic[3].fX + cubic[2].fX * 2) / 3;
    cubic[2].fY = (cubic[3].fY + cubic[2].fY * 2) / 3;
    return cubic;
}

dump()

void SkDQuad::dump

(

)

const

Definition at line 205 of file PathOpsDebug.cpp.

                         {
    dumpInner();
    SkDebugf("}},\n");
}

dumpID()

void SkDQuad::dumpID

(

int

id

)

const

Definition at line 210 of file PathOpsDebug.cpp.

                                 {
    dumpInner();
    SkDebugf("}");
    DumpID(id);
}

dumpInner()

void SkDQuad::dumpInner

(

)

const

Definition at line 216 of file PathOpsDebug.cpp.

                              {
    SkDebugf("{{");
    int index = 0;
    do {
        fPts[index].dump();
        SkDebugf(", ");
    } while (++index < 2);
    fPts[index].dump();
}

dxdyAtT()

SkDVector SkDQuad::dxdyAtT

(

double

t

)

const

Definition at line 206 of file SkPathOpsQuad.cpp.

                                         {
    double a = t - 1;
    double b = 1 - 2 * t;
    double c = t;
    SkDVector result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
            a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
    if (result.fX == 0 && result.fY == 0) {
        if (zero_or_one(t)) {
            result = fPts[2] - fPts[0];
        } else {
            // incomplete
            SkDebugf("!q");
        }
    }
    return result;
}

FindExtrema()

int SkDQuad::FindExtrema ( const double  src[], double  tValue[1]  )

static

Quad'(t) = At + B, where A = 2(a - 2b + c) B = 2(b - a) Solve for t, only if it fits between 0 < t < 1

Definition at line 384 of file SkPathOpsQuad.cpp.

                                                             {
    /*  At + B == 0
        t = -B / A
    */
    double a = src[0];
    double b = src[2];
    double c = src[4];
    return valid_unit_divide(a - b, a - b - b + c, tValue);
}

flip()

SkDQuad SkDQuad::flip ( ) const

inline

Definition at line 58 of file SkPathOpsQuad.h.

                         {
        SkDQuad result = {{fPts[2], fPts[1], fPts[0]}  SkDEBUGPARAMS(fDebugGlobalState) };
        return result;
    }

horizontalIntersect()

int SkDQuad::horizontalIntersect	(	double	yIntercept,
		double	roots[2]
	)		const

Return the number of valid roots (0 < root < 1) for this cubic intersecting the specified horizontal line.

Definition at line 472 of file SkDQuadLineIntersection.cpp.

                                                                         {
    return SkIntersections::HorizontalIntercept(*this, yIntercept, roots);
}

hullIntersects() [1/3]

bool SkDQuad::hullIntersects	(	const SkDConic &	conic,
		bool *	isLinear
	)		const

Definition at line 91 of file SkPathOpsQuad.cpp.

                                                                        {
    return conic.hullIntersects(*this, isLinear);
}

hullIntersects() [2/3]

bool SkDQuad::hullIntersects	(	const SkDCubic &	cubic,
		bool *	isLinear
	)		const

Definition at line 95 of file SkPathOpsQuad.cpp.

                                                                        {
    return cubic.hullIntersects(*this, isLinear);
}

hullIntersects() [3/3]

bool SkDQuad::hullIntersects	(	const SkDQuad &	q2,
		bool *	isLinear
	)		const

Definition at line 53 of file SkPathOpsQuad.cpp.

                                                                    {
    bool linear = true;
    for (int oddMan = 0; oddMan < kPointCount; ++oddMan) {
        const SkDPoint* endPt[2];
        this->otherPts(oddMan, endPt);
        double origX = endPt[0]->fX;
        double origY = endPt[0]->fY;
        double adj = endPt[1]->fX - origX;
        double opp = endPt[1]->fY - origY;
        double sign = (fPts[oddMan].fY - origY) * adj - (fPts[oddMan].fX - origX) * opp;
        if (approximately_zero(sign)) {
            continue;
        }
        linear = false;
        bool foundOutlier = false;
        for (int n = 0; n < kPointCount; ++n) {
            double test = (q2[n].fY - origY) * adj - (q2[n].fX - origX) * opp;
            if (test * sign > 0 && !precisely_zero(test)) {
                foundOutlier = true;
                break;
            }
        }
        if (!foundOutlier) {
            return false;
        }
    }
    if (linear && !matchesEnd(fPts, q2.fPts[0]) && !matchesEnd(fPts, q2.fPts[2])) {
        // if the end point of the opposite quad is inside the hull that is nearly a line,
        // then representing the quad as a line may cause the intersection to be missed.
        // Check to see if the endpoint is in the triangle.
        if (pointInTriangle(fPts, q2.fPts[0]) || pointInTriangle(fPts, q2.fPts[2])) {
            linear = false;
        }
    }
    *isLinear = linear;
    return true;
}

IsConic()

static bool SkDQuad::IsConic ( )

inlinestatic

Definition at line 63 of file SkPathOpsQuad.h.

{ return false; }

isLinear()

bool SkDQuad::isLinear	(	int	startIndex,
		int	endIndex
	)		const

Definition at line 192 of file SkPathOpsQuad.cpp.

                                                         {
    SkLineParameters lineParameters;
    lineParameters.quadEndPoints(*this, startIndex, endIndex);
    // FIXME: maybe it's possible to avoid this and compare non-normalized
    lineParameters.normalize();
    double distance = lineParameters.controlPtDistance(*this);
    double tiniest = std::min(std::min(std::min(std::min(std::min(fPts[0].fX, fPts[0].fY),
            fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY);
    double largest = std::max(std::max(std::max(std::max(std::max(fPts[0].fX, fPts[0].fY),
            fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY);
    largest = std::max(largest, -tiniest);
    return approximately_zero_when_compared_to(distance, largest);
}

maxIntersections()

static int SkDQuad::maxIntersections ( )

inlinestatic

Definition at line 97 of file SkPathOpsQuad.h.

{ return kMaxIntersections; }

monotonicInX()

bool SkDQuad::monotonicInX

(

)

const

Definition at line 253 of file SkPathOpsQuad.cpp.

                                 {
    return between(fPts[0].fX, fPts[1].fX, fPts[2].fX);
}

monotonicInY()

bool SkDQuad::monotonicInY

(

)

const

Definition at line 257 of file SkPathOpsQuad.cpp.

                                 {
    return between(fPts[0].fY, fPts[1].fY, fPts[2].fY);
}

operator[]() [1/2]

SkDPoint & SkDQuad::operator[] ( int  n )

inline

Definition at line 75 of file SkPathOpsQuad.h.

{ SkASSERT(n >= 0 && n < kPointCount); return fPts[n]; }

operator[]() [2/2]

const SkDPoint & SkDQuad::operator[] ( int  n ) const

inline

Definition at line 74 of file SkPathOpsQuad.h.

{ SkASSERT(n >= 0 && n < kPointCount); return fPts[n]; }

otherPts()

void SkDQuad::otherPts	(	int	oddMan,
		const SkDPoint *	endPt[2]
	)		const

Definition at line 108 of file SkPathOpsQuad.cpp.

                                                                 {
    for (int opp = 1; opp < kPointCount; ++opp) {
        int end = (oddMan ^ opp) - oddMan;  // choose a value not equal to oddMan
        end &= ~(end >> 2);  // if the value went negative, set it to zero
        endPt[opp - 1] = &fPts[end];
    }
}

pointCount()

static int SkDQuad::pointCount ( )

inlinestatic

Definition at line 101 of file SkPathOpsQuad.h.

{ return kPointCount; }

pointLast()

static int SkDQuad::pointLast ( )

inlinestatic

Definition at line 102 of file SkPathOpsQuad.h.

{ return kPointLast; }

ptAtT()

SkDPoint SkDQuad::ptAtT

(

double

t

)

const

Definition at line 224 of file SkPathOpsQuad.cpp.

                                      {
    if (0 == t) {
        return fPts[0];
    }
    if (1 == t) {
        return fPts[2];
    }
    double one_t = 1 - t;
    double a = one_t * one_t;
    double b = 2 * one_t * t;
    double c = t * t;
    SkDPoint result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
            a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
    return result;
}

RootsReal()

int SkDQuad::RootsReal ( double  A, double  B, double  C, double  t[2]  )

static

Definition at line 169 of file SkPathOpsQuad.cpp.

                                                                                  {
    if (!A) {
        return handle_zero(B, C, s);
    }
    const double p = B / (2 * A);
    const double q = C / A;
    if (approximately_zero(A) && (approximately_zero_inverse(p) || approximately_zero_inverse(q))) {
        return handle_zero(B, C, s);
    }
    /* normal form: x^2 + px + q = 0 */
    const double p2 = p * p;
    if (!AlmostDequalUlps(p2, q) && p2 < q) {
        return 0;
    }
    double sqrt_D = 0;
    if (p2 > q) {
        sqrt_D = sqrt(p2 - q);
    }
    s[0] = sqrt_D - p;
    s[1] = -sqrt_D - p;
    return 1 + !AlmostDequalUlps(s[0], s[1]);
}

RootsValidT()

int SkDQuad::RootsValidT ( const double  A, const double  B, const double  C, double  s[2]  )

static

Definition at line 144 of file SkPathOpsQuad.cpp.

                                                                  {
    double s[2];
    int realRoots = RootsReal(A, B, C, s);
    int foundRoots = AddValidTs(s, realRoots, t);
    return foundRoots;
}

set()

const SkDQuad & SkDQuad::set ( const SkPoint pts   SkDEBUGPARAMS(SkOpGlobalState *state=nullptr)[kPointCount] )

inline

Definition at line 65 of file SkPathOpsQuad.h.

                                                             {
        fPts[0] = pts[0];
        fPts[1] = pts[1];
        fPts[2] = pts[2];
        SkDEBUGCODE(fDebugGlobalState = state);
        return *this;
    }

SetABC()

void SkDQuad::SetABC ( const double *  quad, double *  a, double *  b, double *  c  )

static

Definition at line 400 of file SkPathOpsQuad.cpp.

                                                                        {
    *a = quad[0];      // a = A
    *b = 2 * quad[2];  // b =     2*B
    *c = quad[4];      // c =             C
    *b -= *c;          // b =     2*B -   C
    *a -= *b;          // a = A - 2*B +   C
    *b -= *c;          // b =     2*B - 2*C
}

subDivide() [1/3]

SkDPoint SkDQuad::subDivide	(	const SkDPoint &	a,
		const SkDPoint &	c,
		double	t1,
		double	t2
	)		const

Definition at line 310 of file SkPathOpsQuad.cpp.

                                                                                            {
    SkASSERT(t1 != t2);
    SkDPoint b;
    SkDQuad sub = subDivide(t1, t2);
    SkDLine b0 = {{a, sub[1] + (a - sub[0])}};
    SkDLine b1 = {{c, sub[1] + (c - sub[2])}};
    SkIntersections i;
    i.intersectRay(b0, b1);
    if (i.used() == 1 && i[0][0] >= 0 && i[1][0] >= 0) {
        b = i.pt(0);
    } else {
        SkASSERT(i.used() <= 2);
        return SkDPoint::Mid(b0[1], b1[1]);
    }
    if (t1 == 0 || t2 == 0) {
        align(0, &b);
    }
    if (t1 == 1 || t2 == 1) {
        align(2, &b);
    }
    if (AlmostBequalUlps(b.fX, a.fX)) {
        b.fX = a.fX;
    } else if (AlmostBequalUlps(b.fX, c.fX)) {
        b.fX = c.fX;
    }
    if (AlmostBequalUlps(b.fY, a.fY)) {
        b.fY = a.fY;
    } else if (AlmostBequalUlps(b.fY, c.fY)) {
        b.fY = c.fY;
    }
    return b;
}

SubDivide() [1/2]

static SkDQuad SkDQuad::SubDivide ( const SkPoint  a[kPointCount], double  t1, double  t2  )

inlinestatic

Definition at line 110 of file SkPathOpsQuad.h.

                                                                                 {
        SkDQuad quad;
        quad.set(a);
        return quad.subDivide(t1, t2);
    }

SubDivide() [2/2]

static SkDPoint SkDQuad::SubDivide ( const SkPoint  pts[kPointCount], const SkDPoint &  a, const SkDPoint &  c, double  t1, double  t2  )

inlinestatic

Definition at line 116 of file SkPathOpsQuad.h.

                                                    {
        SkDQuad quad;
        quad.set(pts);
        return quad.subDivide(a, c, t1, t2);
    }

subDivide() [2/3]

SkDQuad SkDQuad::subDivide	(	double	t1,
		double	t2
	)		const

Definition at line 285 of file SkPathOpsQuad.cpp.

                                                     {
    if (0 == t1 && 1 == t2) {
        return *this;
    }
    SkDQuad dst;
    double ax = dst[0].fX = interp_quad_coords(&fPts[0].fX, t1);
    double ay = dst[0].fY = interp_quad_coords(&fPts[0].fY, t1);
    double dx = interp_quad_coords(&fPts[0].fX, (t1 + t2) / 2);
    double dy = interp_quad_coords(&fPts[0].fY, (t1 + t2) / 2);
    double cx = dst[2].fX = interp_quad_coords(&fPts[0].fX, t2);
    double cy = dst[2].fY = interp_quad_coords(&fPts[0].fY, t2);
    /* bx = */ dst[1].fX = 2 * dx - (ax + cx) / 2;
    /* by = */ dst[1].fY = 2 * dy - (ay + cy) / 2;
    return dst;
}

subDivide() [3/3]

void SkDQuad::subDivide ( double  t1, double  t2, SkDQuad *  quad  ) const

inline

Definition at line 108 of file SkPathOpsQuad.h.

{ *quad = this->subDivide(t1, t2); }

verticalIntersect()

int SkDQuad::verticalIntersect	(	double	xIntercept,
		double	roots[2]
	)		const

Return the number of valid roots (0 < root < 1) for this cubic intersecting the specified vertical line.

Definition at line 476 of file SkDQuadLineIntersection.cpp.

                                                                       {
    return SkIntersections::VerticalIntercept(*this, xIntercept, roots);
}

Member Data Documentation

fPts

SkDPoint SkDQuad::fPts[kPointCount]

Definition at line 39 of file SkPathOpsQuad.h.

kMaxIntersections

const int SkDQuad::kMaxIntersections = 4

static

Definition at line 37 of file SkPathOpsQuad.h.

kPointCount

const int SkDQuad::kPointCount = 3

static

Definition at line 35 of file SkPathOpsQuad.h.

kPointLast

const int SkDQuad::kPointLast = kPointCount - 1

static

Definition at line 36 of file SkPathOpsQuad.h.

---

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

• third_party/skia/src/pathops/SkPathOpsQuad.h
• third_party/skia/src/pathops/SkDQuadLineIntersection.cpp
• third_party/skia/src/pathops/SkPathOpsDebug.cpp
• third_party/skia/src/pathops/SkPathOpsQuad.cpp
• third_party/skia/tests/PathOpsDebug.cpp