fix some pathops bugs found in 1M skps

src/pathops/SkOpSegment.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 "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 415 matching lines @@
         }
         activePrior = active;
         prior = span;
         spanBase = next;
     }
     if (activePrior && !fTail.simple()) {
         addEndSpan(allocator);
     }
 }
 
-void SkOpSegment::checkAngleCoin(SkOpCoincidence* coincidences, SkChunkAlloc* allocator) {
-    SkOpSpanBase* base = &fHead;
-    SkOpSpan* span;
-    do {
-        SkOpAngle* angle = base->fromAngle();
-        if (angle && angle->fCheckCoincidence) {
-            angle->checkNearCoincidence();
-        }
-        if (base->final()) {
-             break;
-        }
-        span = base->upCast();
-        angle = span->toAngle();
-        if (angle && angle->fCheckCoincidence) {
-            angle->checkNearCoincidence();
-        }
-    } while ((base = span->next()));
-}
-
 bool SkOpSegment::collapsed() const {
     return fVerb == SkPath::kLine_Verb && fHead.pt() == fTail.pt();
 }
 
 void SkOpSegment::ComputeOneSum(const SkOpAngle* baseAngle, SkOpAngle* nextAngle,
         SkOpAngle::IncludeType includeType) {
     SkOpSegment* baseSegment = baseAngle->segment();
     int sumMiWinding = baseSegment->updateWindingReverse(baseAngle);
     int sumSuWinding;
     bool binary = includeType >= SkOpAngle::kBinarySingle;
@@ skipping 121 matching lines @@
 }
 
 void SkOpSegment::detach(const SkOpSpan* span) {
     if (span->done()) {
         --fDoneCount;
     }
     --fCount;
     SkASSERT(fCount >= fDoneCount);
 }
 
-double SkOpSegment::distSq(double t, SkOpAngle* oppAngle) {
+double SkOpSegment::distSq(double t, const SkOpAngle* oppAngle) const {
     SkDPoint testPt = this->dPtAtT(t);
     SkDLine testPerp = {{ testPt, testPt }};
     SkDVector slope = this->dSlopeAtT(t);
     testPerp[1].fX += slope.fY;
     testPerp[1].fY -= slope.fX;
     SkIntersections i;
-    SkOpSegment* oppSegment = oppAngle->segment();
+    const SkOpSegment* oppSegment = oppAngle->segment();
     (*CurveIntersectRay[oppSegment->verb()])(oppSegment->pts(), oppSegment->weight(), testPerp, &i);
     double closestDistSq = SK_ScalarInfinity;
     for (int index = 0; index < i.used(); ++index) {
         if (!between(oppAngle->start()->t(), i[0][index], oppAngle->end()->t())) {
             continue;
         }
         double testDistSq = testPt.distanceSquared(i.pt(index));
         if (closestDistSq > testDistSq) {
             closestDistSq = testDistSq;
         }
@@ skipping 599 matching lines @@
     SkOpSpan* prior = nullptr;
     SkOpSpanBase* spanBase = &fHead;
     do {
         SkOpPtT* ptT = spanBase->ptT(), * spanStopPtT = ptT;
         SkASSERT(ptT->span() == spanBase);
         while ((ptT = ptT->next()) != spanStopPtT) {
             if (ptT->deleted()) {
                 continue;
             }
             SkOpSegment* opp = ptT->span()->segment();
-            if (opp->verb() == SkPath::kLine_Verb) {
-                continue;
-            }
+//            if (opp->verb() == SkPath::kLine_Verb) {
+//                continue;
+//            }
             if (opp->done()) {
                 continue;
             }
             // when opp is encounted the 1st time, continue; on 2nd encounter, look for coincidence
             if (!opp->visited()) {
                 continue;
             }
             if (spanBase == &fHead) {
                 continue;
             }
             SkOpSpan* span = spanBase->upCastable();
             // FIXME?: this assumes that if the opposite segment is coincident then no more
             // coincidence needs to be detected. This may not be true.
             if (span && span->containsCoincidence(opp)) { 
                 continue;
             }
+            if (spanBase->segment() == opp) {
+                continue;
+            }
             if (spanBase->containsCoinEnd(opp)) {
                 continue;
             } 
             SkOpPtT* priorPtT = nullptr, * priorStopPtT;
             // find prior span containing opp segment
             SkOpSegment* priorOpp = nullptr;
             SkOpSpan* priorTest = spanBase->prev();
             while (!priorOpp && priorTest) {
                 priorStopPtT = priorPtT = priorTest->ptT();
                 while ((priorPtT = priorPtT->next()) != priorStopPtT) {
                     if (priorPtT->deleted()) {
                         continue;
                     }
                     SkOpSegment* segment = priorPtT->span()->segment();
                     if (segment == opp) {
                         prior = priorTest;
                         priorOpp = opp;
                         break;
                     }
                 }
                 priorTest = priorTest->prev();
             }
             if (!priorOpp) {
                 continue;
             }
+            if (priorPtT == ptT) {
+                continue;
+            }
             SkOpPtT* oppStart = prior->ptT();
             SkOpPtT* oppEnd = spanBase->ptT();
             bool swapped = priorPtT->fT > ptT->fT;
             if (swapped) {
                 SkTSwap(priorPtT, ptT);
                 SkTSwap(oppStart, oppEnd);
             }
             bool flipped = oppStart->fT > oppEnd->fT;
-            bool coincident;
+            bool coincident = false;
             if (coincidences->contains(priorPtT, ptT, oppStart, oppEnd, flipped)) {
                 goto swapBack;
             }
-            coincident = testForCoincidence(priorPtT, ptT, prior, spanBase, opp, 5000);
+            if (opp->verb() == SkPath::kLine_Verb) {
+                coincident = (SkDPoint::ApproximatelyEqual(priorPtT->fPt, oppStart->fPt) ||
+                        SkDPoint::ApproximatelyEqual(priorPtT->fPt, oppEnd->fPt)) &&
+                        (SkDPoint::ApproximatelyEqual(ptT->fPt, oppStart->fPt) ||
+                        SkDPoint::ApproximatelyEqual(ptT->fPt, oppEnd->fPt));
+            }
+            if (!coincident) {
+                coincident = testForCoincidence(priorPtT, ptT, prior, spanBase, opp, 5000);
+            }
             if (coincident) {
             // mark coincidence
                 if (!coincidences->extend(priorPtT, ptT, oppStart, oppEnd)
                         && !coincidences->extend(oppStart, oppEnd, priorPtT, ptT)) {
                     coincidences->add(priorPtT, ptT, oppStart, oppEnd, allocator);
                 }
                 clear_visited(&fHead);
                 return true;
             }
     swapBack:
@@ skipping 484 matching lines @@
     int absOut = SkTAbs(outerWinding);
     int absIn = SkTAbs(innerWinding);
     bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
     return result;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }