LineConicIntersections Class Reference

Public Types
enum	PinTPoint { kPointUninitialized , kPointInitialized }

Public Member Functions
	LineConicIntersections (const SkDConic &c, const SkDLine &l, SkIntersections *i)
	LineConicIntersections (const SkDConic &c)
void	allowNear (bool allow)
void	checkCoincident ()
int	horizontalIntersect (double axisIntercept, double roots[2])
int	horizontalIntersect (double axisIntercept, double left, double right, bool flipped)
int	intersect ()
int	intersectRay (double roots[2])
int	validT (double r[3], double axisIntercept, double roots[2])
int	verticalIntersect (double axisIntercept, double roots[2])
int	verticalIntersect (double axisIntercept, double top, double bottom, bool flipped)

Protected Member Functions
void	addExactEndPoints ()
void	addNearEndPoints ()
void	addLineNearEndPoints ()
void	addExactHorizontalEndPoints (double left, double right, double y)
void	addNearHorizontalEndPoints (double left, double right, double y)
void	addExactVerticalEndPoints (double top, double bottom, double x)
void	addNearVerticalEndPoints (double top, double bottom, double x)
double	findLineT (double t)
bool	pinTs (double *conicT, double *lineT, SkDPoint *pt, PinTPoint ptSet)
bool	uniqueAnswer (double conicT, const SkDPoint &pt)

Detailed Description

Definition at line 24 of file SkDConicLineIntersection.cpp.

Member Enumeration Documentation

PinTPoint

enum LineConicIntersections::PinTPoint

Enumerator
kPointUninitialized
kPointInitialized

Definition at line 26 of file SkDConicLineIntersection.cpp.

                   {
        kPointUninitialized,
        kPointInitialized
    };

Constructor & Destructor Documentation

LineConicIntersections() [1/2]

LineConicIntersections::LineConicIntersections ( const SkDConic &  c, const SkDLine &  l, SkIntersections *  i  )

inline

Definition at line 31 of file SkDConicLineIntersection.cpp.

        : fConic(c)
        , fLine(&l)
        , fIntersections(i)
        , fAllowNear(true) {
        i->setMax(4);  // allow short partial coincidence plus discrete intersection
    }

LineConicIntersections() [2/2]

LineConicIntersections::LineConicIntersections ( const SkDConic &  c )

inline

Definition at line 39 of file SkDConicLineIntersection.cpp.

        : fConic(c)
        SkDEBUGPARAMS(fLine(nullptr))
        SkDEBUGPARAMS(fIntersections(nullptr))
        SkDEBUGPARAMS(fAllowNear(false)) {
    }

Member Function Documentation

addExactEndPoints()

void LineConicIntersections::addExactEndPoints ( )

inlineprotected

Definition at line 190 of file SkDConicLineIntersection.cpp.

                             {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double lineT = fLine->exactPoint(fConic[cIndex]);
            if (lineT < 0) {
                continue;
            }
            double conicT = (double) (cIndex >> 1);
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
    }

addExactHorizontalEndPoints()

void LineConicIntersections::addExactHorizontalEndPoints ( double  left, double  right, double  y  )

inlineprotected

Definition at line 231 of file SkDConicLineIntersection.cpp.

                                                                          {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double lineT = SkDLine::ExactPointH(fConic[cIndex], left, right, y);
            if (lineT < 0) {
                continue;
            }
            double conicT = (double) (cIndex >> 1);
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
    }

addExactVerticalEndPoints()

void LineConicIntersections::addExactVerticalEndPoints ( double  top, double  bottom, double  x  )

inlineprotected

Definition at line 257 of file SkDConicLineIntersection.cpp.

                                                                        {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double lineT = SkDLine::ExactPointV(fConic[cIndex], top, bottom, x);
            if (lineT < 0) {
                continue;
            }
            double conicT = (double) (cIndex >> 1);
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
    }

addLineNearEndPoints()

void LineConicIntersections::addLineNearEndPoints ( )

inlineprotected

Definition at line 216 of file SkDConicLineIntersection.cpp.

                                {
        for (int lIndex = 0; lIndex < 2; ++lIndex) {
            double lineT = (double) lIndex;
            if (fIntersections->hasOppT(lineT)) {
                continue;
            }
            double conicT = ((const SkDCurve*) &fConic)->nearPoint(SkPath::kConic_Verb,
                (*fLine)[lIndex], (*fLine)[!lIndex]);
            if (conicT < 0) {
                continue;
            }
            fIntersections->insert(conicT, lineT, (*fLine)[lIndex]);
        }
    }

addNearEndPoints()

void LineConicIntersections::addNearEndPoints ( )

inlineprotected

Definition at line 201 of file SkDConicLineIntersection.cpp.

                            {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double conicT = (double) (cIndex >> 1);
            if (fIntersections->hasT(conicT)) {
                continue;
            }
            double lineT = fLine->nearPoint(fConic[cIndex], nullptr);
            if (lineT < 0) {
                continue;
            }
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
        this->addLineNearEndPoints();
    }

addNearHorizontalEndPoints()

void LineConicIntersections::addNearHorizontalEndPoints ( double  left, double  right, double  y  )

inlineprotected

Definition at line 242 of file SkDConicLineIntersection.cpp.

                                                                         {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double conicT = (double) (cIndex >> 1);
            if (fIntersections->hasT(conicT)) {
                continue;
            }
            double lineT = SkDLine::NearPointH(fConic[cIndex], left, right, y);
            if (lineT < 0) {
                continue;
            }
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
        this->addLineNearEndPoints();
    }

addNearVerticalEndPoints()

void LineConicIntersections::addNearVerticalEndPoints ( double  top, double  bottom, double  x  )

inlineprotected

Definition at line 268 of file SkDConicLineIntersection.cpp.

                                                                       {
        for (int cIndex = 0; cIndex < SkDConic::kPointCount; cIndex += SkDConic::kPointLast) {
            double conicT = (double) (cIndex >> 1);
            if (fIntersections->hasT(conicT)) {
                continue;
            }
            double lineT = SkDLine::NearPointV(fConic[cIndex], top, bottom, x);
            if (lineT < 0) {
                continue;
            }
            fIntersections->insert(conicT, lineT, fConic[cIndex]);
        }
        this->addLineNearEndPoints();
    }

allowNear()

void LineConicIntersections::allowNear ( bool  allow )

inline

Definition at line 46 of file SkDConicLineIntersection.cpp.

                               {
        fAllowNear = allow;
    }

checkCoincident()

void LineConicIntersections::checkCoincident ( )

inline

Definition at line 50 of file SkDConicLineIntersection.cpp.

                           {
        int last = fIntersections->used() - 1;
        for (int index = 0; index < last; ) {
            double conicMidT = ((*fIntersections)[0][index] + (*fIntersections)[0][index + 1]) / 2;
            SkDPoint conicMidPt = fConic.ptAtT(conicMidT);
            double t = fLine->nearPoint(conicMidPt, nullptr);
            if (t < 0) {
                ++index;
                continue;
            }
            if (fIntersections->isCoincident(index)) {
                fIntersections->removeOne(index);
                --last;
            } else if (fIntersections->isCoincident(index + 1)) {
                fIntersections->removeOne(index + 1);
                --last;
            } else {
                fIntersections->setCoincident(index++);
            }
            fIntersections->setCoincident(index);
        }
    }

findLineT()

double LineConicIntersections::findLineT ( double  t )

inlineprotected

Definition at line 283 of file SkDConicLineIntersection.cpp.

                               {
        SkDPoint xy = fConic.ptAtT(t);
        double dx = (*fLine)[1].fX - (*fLine)[0].fX;
        double dy = (*fLine)[1].fY - (*fLine)[0].fY;
        if (fabs(dx) > fabs(dy)) {
            return (xy.fX - (*fLine)[0].fX) / dx;
        }
        return (xy.fY - (*fLine)[0].fY) / dy;
    }

horizontalIntersect() [1/2]

int LineConicIntersections::horizontalIntersect ( double  axisIntercept, double  left, double  right, bool  flipped  )

inline

Definition at line 84 of file SkDConicLineIntersection.cpp.

                                                                                           {
        this->addExactHorizontalEndPoints(left, right, axisIntercept);
        if (fAllowNear) {
            this->addNearHorizontalEndPoints(left, right, axisIntercept);
        }
        double roots[2];
        int count = this->horizontalIntersect(axisIntercept, roots);
        for (int index = 0; index < count; ++index) {
            double conicT = roots[index];
            SkDPoint pt = fConic.ptAtT(conicT);
            SkDEBUGCODE(double conicVals[] = { fConic[0].fY, fConic[1].fY, fConic[2].fY });
            SkOPOBJASSERT(fIntersections, close_to(pt.fY, axisIntercept, conicVals));
            double lineT = (pt.fX - left) / (right - left);
            if (this->pinTs(&conicT, &lineT, &pt, kPointInitialized)
                    && this->uniqueAnswer(conicT, pt)) {
                fIntersections->insert(conicT, lineT, pt);
            }
        }
        if (flipped) {
            fIntersections->flip();
        }
        this->checkCoincident();
        return fIntersections->used();
    }

horizontalIntersect() [2/2]

int LineConicIntersections::horizontalIntersect ( double  axisIntercept, double  roots[2]  )

inline

Definition at line 79 of file SkDConicLineIntersection.cpp.

                                                                   {
        double conicVals[] = { fConic[0].fY, fConic[1].fY, fConic[2].fY };
        return this->validT(conicVals, axisIntercept, roots);
    }

intersect()

int LineConicIntersections::intersect ( )

inline

Definition at line 109 of file SkDConicLineIntersection.cpp.

                    {
        this->addExactEndPoints();
        if (fAllowNear) {
            this->addNearEndPoints();
        }
        double rootVals[2];
        int roots = this->intersectRay(rootVals);
        for (int index = 0; index < roots; ++index) {
            double conicT = rootVals[index];
            double lineT = this->findLineT(conicT);
#ifdef SK_DEBUG
            if (!fIntersections->globalState()
                    || !fIntersections->globalState()->debugSkipAssert()) {
                SkDEBUGCODE(SkDPoint conicPt = fConic.ptAtT(conicT));
                SkDEBUGCODE(SkDPoint linePt = fLine->ptAtT(lineT));
                SkASSERT(conicPt.approximatelyDEqual(linePt));
            }
#endif
            SkDPoint pt;
            if (this->pinTs(&conicT, &lineT, &pt, kPointUninitialized)
                    && this->uniqueAnswer(conicT, pt)) {
                fIntersections->insert(conicT, lineT, pt);
            }
        }
        this->checkCoincident();
        return fIntersections->used();
    }

intersectRay()

int LineConicIntersections::intersectRay ( double  roots[2] )

inline

Definition at line 137 of file SkDConicLineIntersection.cpp.

                                      {
        double adj = (*fLine)[1].fX - (*fLine)[0].fX;
        double opp = (*fLine)[1].fY - (*fLine)[0].fY;
        double r[3];
        for (int n = 0; n < 3; ++n) {
            r[n] = (fConic[n].fY - (*fLine)[0].fY) * adj - (fConic[n].fX - (*fLine)[0].fX) * opp;
        }
        return this->validT(r, 0, roots);
    }

pinTs()

bool LineConicIntersections::pinTs ( double *  conicT, double *  lineT, SkDPoint *  pt, PinTPoint  ptSet  )

inlineprotected

Definition at line 293 of file SkDConicLineIntersection.cpp.

                                                                             {
        if (!approximately_one_or_less_double(*lineT)) {
            return false;
        }
        if (!approximately_zero_or_more_double(*lineT)) {
            return false;
        }
        double qT = *conicT = SkPinT(*conicT);
        double lT = *lineT = SkPinT(*lineT);
        if (lT == 0 || lT == 1 || (ptSet == kPointUninitialized && qT != 0 && qT != 1)) {
            *pt = (*fLine).ptAtT(lT);
        } else if (ptSet == kPointUninitialized) {
            *pt = fConic.ptAtT(qT);
        }
        SkPoint gridPt = pt->asSkPoint();
        if (SkDPoint::ApproximatelyEqual(gridPt, (*fLine)[0].asSkPoint())) {
            *pt = (*fLine)[0];
            *lineT = 0;
        } else if (SkDPoint::ApproximatelyEqual(gridPt, (*fLine)[1].asSkPoint())) {
            *pt = (*fLine)[1];
            *lineT = 1;
        }
        if (fIntersections->used() > 0 && approximately_equal((*fIntersections)[1][0], *lineT)) {
            return false;
        }
        if (gridPt == fConic[0].asSkPoint()) {
            *pt = fConic[0];
            *conicT = 0;
        } else if (gridPt == fConic[2].asSkPoint()) {
            *pt = fConic[2];
            *conicT = 1;
        }
        return true;
    }

uniqueAnswer()

bool LineConicIntersections::uniqueAnswer ( double  conicT, const SkDPoint &  pt  )

inlineprotected

Definition at line 328 of file SkDConicLineIntersection.cpp.

                                                         {
        for (int inner = 0; inner < fIntersections->used(); ++inner) {
            if (fIntersections->pt(inner) != pt) {
                continue;
            }
            double existingConicT = (*fIntersections)[0][inner];
            if (conicT == existingConicT) {
                return false;
            }
            // check if midway on conic is also same point. If so, discard this
            double conicMidT = (existingConicT + conicT) / 2;
            SkDPoint conicMidPt = fConic.ptAtT(conicMidT);
            if (conicMidPt.approximatelyEqual(pt)) {
                return false;
            }
        }
#if ONE_OFF_DEBUG
        SkDPoint qPt = fConic.ptAtT(conicT);
        SkDebugf("%s pt=(%1.9g,%1.9g) cPt=(%1.9g,%1.9g)\n", __FUNCTION__, pt.fX, pt.fY,
                qPt.fX, qPt.fY);
#endif
        return true;
    }

validT()

int LineConicIntersections::validT ( double  r[3], double  axisIntercept, double  roots[2]  )

inline

Definition at line 147 of file SkDConicLineIntersection.cpp.

                                                                   {
        double A = r[2];
        double B = r[1] * fConic.fWeight - axisIntercept * fConic.fWeight + axisIntercept;
        double C = r[0];
        A += C - 2 * B;  // A = a + c - 2*(b*w - xCept*w + xCept)
        B -= C;  // B = b*w - w * xCept + xCept - a
        C -= axisIntercept;
        return SkDQuad::RootsValidT(A, 2 * B, C, roots);
    }

verticalIntersect() [1/2]

int LineConicIntersections::verticalIntersect ( double  axisIntercept, double  roots[2]  )

inline

Definition at line 157 of file SkDConicLineIntersection.cpp.

                                                                 {
        double conicVals[] = { fConic[0].fX, fConic[1].fX, fConic[2].fX };
        return this->validT(conicVals, axisIntercept, roots);
    }

verticalIntersect() [2/2]

int LineConicIntersections::verticalIntersect ( double  axisIntercept, double  top, double  bottom, bool  flipped  )

inline

Definition at line 162 of file SkDConicLineIntersection.cpp.

                                                                                         {
        this->addExactVerticalEndPoints(top, bottom, axisIntercept);
        if (fAllowNear) {
            this->addNearVerticalEndPoints(top, bottom, axisIntercept);
        }
        double roots[2];
        int count = this->verticalIntersect(axisIntercept, roots);
        for (int index = 0; index < count; ++index) {
            double conicT = roots[index];
            SkDPoint pt = fConic.ptAtT(conicT);
            SkDEBUGCODE(double conicVals[] = { fConic[0].fX, fConic[1].fX, fConic[2].fX });
            SkOPOBJASSERT(fIntersections, close_to(pt.fX, axisIntercept, conicVals));
            double lineT = (pt.fY - top) / (bottom - top);
            if (this->pinTs(&conicT, &lineT, &pt, kPointInitialized)
                    && this->uniqueAnswer(conicT, pt)) {
                fIntersections->insert(conicT, lineT, pt);
            }
        }
        if (flipped) {
            fIntersections->flip();
        }
        this->checkCoincident();
        return fIntersections->used();
    }

---

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

• third_party/skia/src/pathops/SkDConicLineIntersection.cpp