path ops work in progress

src/pathops/SkDCubicLineIntersection.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 "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 
@@ skipping 68 matching lines @@
     enum PinTPoint {
         kPointUninitialized,
         kPointInitialized
     };
 
     LineCubicIntersections(const SkDCubic& c, const SkDLine& l, SkIntersections* i)
         : fCubic(c)
         , fLine(l)
         , fIntersections(i)
         , fAllowNear(true) {
+        i->setMax(3);
     }
 
     void allowNear(bool allow) {
         fAllowNear = allow;
     }
 
     // see parallel routine in line quadratic intersections
     int intersectRay(double roots[3]) {
         double adj = fLine[1].fX - fLine[0].fX;
         double opp = fLine[1].fY - fLine[0].fY;
@@ skipping 16 matching lines @@
         for (int index = 0; index < roots; ++index) {
             double cubicT = rootVals[index];
             double lineT = findLineT(cubicT);
             SkDPoint pt;
             if (pinTs(&cubicT, &lineT, &pt, kPointUninitialized)) {
     #if ONE_OFF_DEBUG
                 SkDPoint cPt = fCubic.ptAtT(cubicT);
                 SkDebugf("%s pt=(%1.9g,%1.9g) cPt=(%1.9g,%1.9g)\n", __FUNCTION__, pt.fX, pt.fY,
                         cPt.fX, cPt.fY);
     #endif
+                for (int inner = 0; inner < fIntersections->used(); ++inner) {
+                    if (fIntersections->pt(inner) != pt) {
+                        continue;
+                    }
+                    double existingCubicT = (*fIntersections)[0][inner];
+                    if (cubicT == existingCubicT) {
+                        goto skipInsert;
+                    }
+                    // check if midway on cubic is also same point. If so, discard this
+                    double cubicMidT = (existingCubicT + cubicT) / 2;
+                    SkDPoint cubicMidPt = fCubic.ptAtT(cubicMidT);
+                    if (cubicMidPt.approximatelyEqual(pt)) {
+                        goto skipInsert;
+                    }
+                }
                 fIntersections->insert(cubicT, lineT, pt);
+        skipInsert:
+                ;
             }
         }
         return fIntersections->used();
     }
 
     int horizontalIntersect(double axisIntercept, double roots[3]) {
         double A, B, C, D;
         SkDCubic::Coefficients(&fCubic[0].fY, &A, &B, &C, &D);
         D -= axisIntercept;
         return SkDCubic::RootsValidT(A, B, C, D, roots);
@@ skipping 193 matching lines @@
 }
 
 int SkIntersections::intersectRay(const SkDCubic& cubic, const SkDLine& line) {
     LineCubicIntersections c(cubic, line, this);
     fUsed = c.intersectRay(fT[0]);
     for (int index = 0; index < fUsed; ++index) {
         fPt[index] = cubic.ptAtT(fT[0][index]);
     }
     return fUsed;
 }