add conics to path ops

src/pathops/SkOpAngle.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpAngle.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsCurve.h"
 #include "SkTSort.h"
@@ skipping 171 matching lines @@
         int lineStart = fStart->t() < fEnd->t() ? 0 : 1;
         line = linePts[lineStart ^ 1] - linePts[lineStart];
     } else {
         SkPoint shortPts[2] = { fCurvePart[0].asSkPoint(), fCurvePart[1].asSkPoint() };
         line = shortPts[1] - shortPts[0];
     }
     float crosses[3];
     SkPath::Verb testVerb = test->segment()->verb();
     int iMax = SkPathOpsVerbToPoints(testVerb);
 //    SkASSERT(origin == test.fCurveHalf[0]);
-    const SkDCubic& testCurve = test->fCurvePart;
+    const SkDCurve& testCurve = test->fCurvePart;
     for (int index = 1; index <= iMax; ++index) {
         float xy1 = (float) (line.fX * (testCurve[index].fY - origin.fY));
         float xy2 = (float) (line.fY * (testCurve[index].fX - origin.fX));
         crosses[index - 1] = AlmostEqualUlps(xy1, xy2) ? 0 : xy1 - xy2;
     }
     if (crosses[0] * crosses[1] < 0) {
         return -1;
     }
     if (SkPath::kCubic_Verb == testVerb) {
         if (crosses[0] * crosses[2] < 0 || crosses[1] * crosses[2] < 0) {
@@ skipping 235 matching lines @@
     int lPts = SkPathOpsVerbToPoints(lVerb);
     int rPts = SkPathOpsVerbToPoints(rVerb);
     SkDLine rays[] = {{{this->fCurvePart[0], rh->fCurvePart[rPts]}},
             {{this->fCurvePart[0], this->fCurvePart[lPts]}}};
     if (rays[0][1] == rays[1][1]) {
         return checkParallel(rh);
     }
     double smallTs[2] = {-1, -1};
     bool limited[2] = {false, false};
     for (int index = 0; index < 2; ++index) {
-        int cPts = index ? rPts : lPts;
+        SkPath::Verb cVerb = index ? rVerb : lVerb;
         // if the curve is a line, then the line and the ray intersect only at their crossing
-        if (cPts == 1) { // line
+        if (cVerb == SkPath::kLine_Verb) {
             continue;
         }
         const SkOpSegment& segment = index ? *rh->segment() : *this->segment();
         SkIntersections i;
-        (*CurveIntersectRay[cPts])(segment.pts(), rays[index], &i);
+        (*CurveIntersectRay[cVerb])(segment.pts(), segment.weight(), rays[index], &i);
         double tStart = index ? rh->fStart->t() : this->fStart->t();
         double tEnd = index ? rh->fComputedEnd->t() : this->fComputedEnd->t();
         bool testAscends = tStart < (index ? rh->fComputedEnd->t() : this->fComputedEnd->t());
         double t = testAscends ? 0 : 1;
         for (int idx2 = 0; idx2 < i.used(); ++idx2) {
             double testT = i[0][idx2];
             if (!approximately_between_orderable(tStart, testT, tEnd)) {
                 continue;
             }
             if (approximately_equal_orderable(tStart, testT)) {
@@ skipping 36 matching lines @@
             sRayLonger = rayLonger;
             sCept = cept;
             sCeptT = smallTs[index];
             sIndex = index;
             break;
         }
         double delta = fabs(rayDist - endDist);
         double minX, minY, maxX, maxY;
         minX = minY = SK_ScalarInfinity;
         maxX = maxY = -SK_ScalarInfinity;
-        const SkDCubic& curve = index ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = index ? rh->fCurvePart : this->fCurvePart;
         int ptCount = index ? rPts : lPts;
         for (int idx2 = 0; idx2 <= ptCount; ++idx2) {
             minX = SkTMin(minX, curve[idx2].fX);
             minY = SkTMin(minY, curve[idx2].fY);
             maxX = SkTMax(maxX, curve[idx2].fX);
             maxY = SkTMax(maxY, curve[idx2].fY);
         }
         double maxWidth = SkTMax(maxX - minX, maxY - minY);
         delta /= maxWidth;
         if (delta > 1e-3 && (useIntersect ^= true)) {  // FIXME: move this magic number
             sRayLonger = rayLonger;
             sCept = cept;
             sCeptT = smallTs[index];
             sIndex = index;
         }
     }
     if (useIntersect) {
-        const SkDCubic& curve = sIndex ? rh->fCurvePart : this->fCurvePart;
+        const SkDCurve& curve = sIndex ? rh->fCurvePart : this->fCurvePart;
         const SkOpSegment& segment = sIndex ? *rh->segment() : *this->segment();
         double tStart = sIndex ? rh->fStart->t() : fStart->t();
         SkDVector mid = segment.dPtAtT(tStart + (sCeptT - tStart) / 2) - curve[0];
         double septDir = mid.crossCheck(sCept);
         if (!septDir) {
             return checkParallel(rh);
         }
         return sRayLonger ^ (sIndex == 0) ^ (septDir < 0);
     } else {
         return checkParallel(rh);
     }
 }
 
 bool SkOpAngle::endToSide(const SkOpAngle* rh, bool* inside) const {
     const SkOpSegment* segment = this->segment();
     SkPath::Verb verb = segment->verb();
-    int pts = SkPathOpsVerbToPoints(verb);
     SkDLine rayEnd;
     rayEnd[0].set(this->fEnd->pt());
     rayEnd[1] = rayEnd[0];
-    SkDVector slopeAtEnd = (*CurveDSlopeAtT[pts])(segment->pts(), this->fEnd->t());
+    SkDVector slopeAtEnd = (*CurveDSlopeAtT[verb])(segment->pts(), segment->weight(),
+            this->fEnd->t());
     rayEnd[1].fX += slopeAtEnd.fY;
     rayEnd[1].fY -= slopeAtEnd.fX;
     SkIntersections iEnd;
     const SkOpSegment* oppSegment = rh->segment();
     SkPath::Verb oppVerb = oppSegment->verb();
-    int oppPts = SkPathOpsVerbToPoints(oppVerb);
-    (*CurveIntersectRay[oppPts])(oppSegment->pts(), rayEnd, &iEnd);
+    (*CurveIntersectRay[oppVerb])(oppSegment->pts(), oppSegment->weight(), rayEnd, &iEnd);
     double endDist;
     int closestEnd = iEnd.closestTo(rh->fStart->t(), rh->fEnd->t(), rayEnd[0], &endDist);
     if (closestEnd < 0) {
         return false;
     }
     if (!endDist) {
         return false;
     }
     SkDPoint start;
     start.set(this->fStart->pt());
     // OPTIMIZATION: multiple times in the code we find the max scalar
     double minX, minY, maxX, maxY;
     minX = minY = SK_ScalarInfinity;
     maxX = maxY = -SK_ScalarInfinity;
-    const SkDCubic& curve = rh->fCurvePart;
+    const SkDCurve& curve = rh->fCurvePart;
+    int oppPts = SkPathOpsVerbToPoints(oppVerb);
     for (int idx2 = 0; idx2 <= oppPts; ++idx2) {
         minX = SkTMin(minX, curve[idx2].fX);
         minY = SkTMin(minY, curve[idx2].fY);
         maxX = SkTMax(maxX, curve[idx2].fX);
         maxY = SkTMax(maxY, curve[idx2].fY);
     }
     double maxWidth = SkTMax(maxX - minX, maxY - minY);
     endDist /= maxWidth;
     if (endDist < 5e-11) {  // empirically found
         return false;
@@ skipping 266 matching lines @@
     return true;
 }
 
 double SkOpAngle::midT() const {
     return (fStart->t() + fEnd->t()) / 2;
 }
 
 bool SkOpAngle::midToSide(const SkOpAngle* rh, bool* inside) const {
     const SkOpSegment* segment = this->segment();
     SkPath::Verb verb = segment->verb();
-    int pts = SkPathOpsVerbToPoints(verb);
     const SkPoint& startPt = this->fStart->pt();
     const SkPoint& endPt = this->fEnd->pt();
     SkDPoint dStartPt;
     dStartPt.set(startPt);
     SkDLine rayMid;
     rayMid[0].fX = (startPt.fX + endPt.fX) / 2;
     rayMid[0].fY = (startPt.fY + endPt.fY) / 2;
     rayMid[1].fX = rayMid[0].fX + (endPt.fY - startPt.fY);
     rayMid[1].fY = rayMid[0].fY - (endPt.fX - startPt.fX);
     SkIntersections iMid;
-    (*CurveIntersectRay[pts])(segment->pts(), rayMid, &iMid);
+    (*CurveIntersectRay[verb])(segment->pts(), segment->weight(), rayMid, &iMid);
     int iOutside = iMid.mostOutside(this->fStart->t(), this->fEnd->t(), dStartPt);
     if (iOutside < 0) {
         return false;
     }
     const SkOpSegment* oppSegment = rh->segment();
     SkPath::Verb oppVerb = oppSegment->verb();
-    int oppPts = SkPathOpsVerbToPoints(oppVerb);
     SkIntersections oppMid;
-    (*CurveIntersectRay[oppPts])(oppSegment->pts(), rayMid, &oppMid);
+    (*CurveIntersectRay[oppVerb])(oppSegment->pts(), oppSegment->weight(), rayMid, &oppMid);
     int oppOutside = oppMid.mostOutside(rh->fStart->t(), rh->fEnd->t(), dStartPt);
     if (oppOutside < 0) {
         return false;
     }
     SkDVector iSide = iMid.pt(iOutside) - dStartPt;
     SkDVector oppSide = oppMid.pt(oppOutside) - dStartPt;
     double dir = iSide.crossCheck(oppSide);
     if (!dir) {
         return false;
     }
@@ skipping 68 matching lines @@
 
 void SkOpAngle::set(SkOpSpanBase* start, SkOpSpanBase* end) {
     fStart = start;
     fComputedEnd = fEnd = end;
     SkASSERT(start != end);
     fNext = NULL;
     fComputeSector = fComputedSector = fCheckCoincidence = false;
     fStop = false;
     setSpans();
     setSector();
-    PATH_OPS_DEBUG_CODE(fID = start->globalState()->nextAngleID());
+    SkDEBUGCODE(fID = start->globalState()->nextAngleID());
 }
 
 void SkOpAngle::setCurveHullSweep() {
     fUnorderedSweep = false;
     fSweep[0] = fCurvePart[1] - fCurvePart[0];
     const SkOpSegment* segment = fStart->segment();
     if (SkPath::kLine_Verb == segment->verb()) {
         fSweep[1] = fSweep[0];
         return;
     }
@@ skipping 30 matching lines @@
         fUnorderedSweep = true;
     }
     fSweep[1] = thirdSweep;
 }
 
 void SkOpAngle::setSpans() {
     fUnorderable = false;
     fLastMarked = NULL;
     const SkOpSegment* segment = fStart->segment();
     const SkPoint* pts = segment->pts();
+    SkDEBUGCODE(fCurvePart.fVerb = SkPath::kCubic_Verb);
     SkDEBUGCODE(fCurvePart[2].fX = fCurvePart[2].fY = fCurvePart[3].fX = fCurvePart[3].fY
             = SK_ScalarNaN);
+    SkDEBUGCODE(fCurvePart.fVerb = segment->verb());
     segment->subDivide(fStart, fEnd, &fCurvePart);
     setCurveHullSweep();
     const SkPath::Verb verb = segment->verb();
     if (verb != SkPath::kLine_Verb
             && !(fIsCurve = fSweep[0].crossCheck(fSweep[1]) != 0)) {
         SkDLine lineHalf;
         lineHalf[0].set(fCurvePart[0].asSkPoint());
         lineHalf[1].set(fCurvePart[SkPathOpsVerbToPoints(verb)].asSkPoint());
         fTangentHalf.lineEndPoints(lineHalf);
         fSide = 0;
     }
     switch (verb) {
     case SkPath::kLine_Verb: {
         SkASSERT(fStart != fEnd);
         const SkPoint& cP1 = pts[fStart->t() < fEnd->t()];
         SkDLine lineHalf;
         lineHalf[0].set(fStart->pt());
         lineHalf[1].set(cP1);
         fTangentHalf.lineEndPoints(lineHalf);
         fSide = 0;
         fIsCurve = false;
         } return;
-    case SkPath::kQuad_Verb: {
+    case SkPath::kQuad_Verb:
+    case SkPath::kConic_Verb: {
         SkLineParameters tangentPart;
-        SkDQuad& quad2 = *SkTCast<SkDQuad*>(&fCurvePart);
-        (void) tangentPart.quadEndPoints(quad2);
+        (void) tangentPart.quadEndPoints(fCurvePart.fQuad);
         fSide = -tangentPart.pointDistance(fCurvePart[2]);  // not normalized -- compare sign only
         } break;
     case SkPath::kCubic_Verb: {
         SkLineParameters tangentPart;
-        (void) tangentPart.cubicPart(fCurvePart);
+        (void) tangentPart.cubicPart(fCurvePart.fCubic);
         fSide = -tangentPart.pointDistance(fCurvePart[3]);
         double testTs[4];
         // OPTIMIZATION: keep inflections precomputed with cubic segment?
         int testCount = SkDCubic::FindInflections(pts, testTs);
         double startT = fStart->t();
         double endT = fEnd->t();
         double limitT = endT;
         int index;
         for (index = 0; index < testCount; ++index) {
             if (!::between(startT, testTs[index], limitT)) {
@@ skipping 10 matching lines @@
             ++index;
         }
         index <<= 1;
         for (; index < testCases; ++index) {
             int testIndex = index >> 1;
             double testT = testTs[testIndex];
             if (index & 1) {
                 testT = (testT + testTs[testIndex + 1]) / 2;
             }
             // OPTIMIZE: could avoid call for t == startT, endT
-            SkDPoint pt = dcubic_xy_at_t(pts, testT);
+            SkDPoint pt = dcubic_xy_at_t(pts, segment->weight(), testT);
             SkLineParameters tangentPart;
-            tangentPart.cubicEndPoints(fCurvePart);
+            tangentPart.cubicEndPoints(fCurvePart.fCubic);
             double testSide = tangentPart.pointDistance(pt);
             if (fabs(bestSide) < fabs(testSide)) {
                 bestSide = testSide;
             }
         }
         fSide = -bestSide;  // compare sign only
         } break;
     default:
         SkASSERT(0);
     }
@@ skipping 75 matching lines @@
         return true;
     }
     SkASSERT(s0dt0 != 0);
     double m = s0xt0 / s0dt0;
     double sDist = sweep[0].length() * m;
     double tDist = tweep[0].length() * m;
     bool useS = fabs(sDist) < fabs(tDist);
     double mFactor = fabs(useS ? this->distEndRatio(sDist) : rh->distEndRatio(tDist));
     return mFactor < 5000;  // empirically found limit
 }