fail early if coincidence can't be resolved

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 "SkIntersections.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 1253 matching lines @@
 
 // FIXME: need to test this case:
 // contourA has two segments that are coincident
 // contourB has two segments that are coincident in the same place
 // each ends up with +2/0 pairs for winding count
 // since logic below doesn't transfer count (only increments/decrements) can this be
 // resolved to +4/0 ?
 
 // set spans from start to end to increment the greater by one and decrement
 // the lesser
-void SkOpSegment::addTCoincident(const SkPoint& startPt, const SkPoint& endPt, double endT,
+bool SkOpSegment::addTCoincident(const SkPoint& startPt, const SkPoint& endPt, double endT,
         SkOpSegment* other) {
     bool binary = fOperand != other->fOperand;
     int index = 0;
     while (startPt != fTs[index].fPt) {
         SkASSERT(index < fTs.count());
         ++index;
     }
     double startT = fTs[index].fT;
     while (index > 0 && precisely_equal(fTs[index - 1].fT, startT)) {
         --index;
@@ skipping 11 matching lines @@
     SkSTArray<kOutsideTrackedTCount, SkPoint, true> oOutsidePts;
     SkOpSpan* test = &fTs[index];
     const SkPoint* testPt = &test->fPt;
     double testT = test->fT;
     SkOpSpan* oTest = &other->fTs[oIndex];
     const SkPoint* oTestPt = &oTest->fPt;
     // paths with extreme data will fail this test and eject out of pathops altogether later on
     // SkASSERT(AlmostEqualUlps(*testPt, *oTestPt));
     do {
         SkASSERT(test->fT < 1);
-        SkASSERT(oTest->fT < 1);
+        if (oTest->fT == 1) {
+            // paths with extreme data may be so mismatched that we fail here
+            return false;
+        }
 
         // consolidate the winding count even if done
         if ((test->fWindValue == 0 && test->fOppValue == 0)
                 || (oTest->fWindValue == 0 && oTest->fOppValue == 0)) {
             SkDEBUGCODE(int firstWind = test->fWindValue);
             SkDEBUGCODE(int firstOpp = test->fOppValue);
             do {
                 SkASSERT(firstWind == fTs[index].fWindValue);
                 SkASSERT(firstOpp == fTs[index].fOppValue);
                 ++index;
@@ skipping 85 matching lines @@
     }
     int outCount = outsidePts.count();
     if (!done() && outCount) {
         addCoinOutsides(outsidePts[0], endPt, other);
     }
     if (!other->done() && oOutsidePts.count()) {
         other->addCoinOutsides(oOutsidePts[0], endPt, this);
     }
     setCoincidentRange(startPt, endPt, other);
     other->setCoincidentRange(startPt, endPt, this);
+    return true;
 }
 
 // FIXME: this doesn't prevent the same span from being added twice
 // fix in caller, SkASSERT here?
 // FIXME: this may erroneously reject adds for cubic loops
 const SkOpSpan* SkOpSegment::addTPair(double t, SkOpSegment* other, double otherT, bool borrowWind,
         const SkPoint& pt, const SkPoint& pt2) {
     int tCount = fTs.count();
     for (int tIndex = 0; tIndex < tCount; ++tIndex) {
         const SkOpSpan& span = fTs[tIndex];
@@ skipping 993 matching lines @@
                 missing.fPt)) {
             continue;
         }
         int otherTIndex = missingOther->findT(missing.fOtherT, missing.fPt, missing.fSegment);
         const SkOpSpan& otherSpan = missingOther->span(otherTIndex);
         if (otherSpan.fSmall) {
             const SkOpSpan* nextSpan = &otherSpan;
             do {
                 ++nextSpan;
             } while (nextSpan->fSmall);
-            missing.fSegment->addTCoincident(missing.fPt, nextSpan->fPt, nextSpan->fT,
-                    missingOther);
+            SkAssertResult(missing.fSegment->addTCoincident(missing.fPt, nextSpan->fPt,
+                    nextSpan->fT, missingOther));
         } else if (otherSpan.fT > 0) {
             const SkOpSpan* priorSpan = &otherSpan;
             do {
                 --priorSpan;
             } while (priorSpan->fT == otherSpan.fT);
             if (priorSpan->fSmall) {
                 missing.fSegment->addTCancel(missing.fPt, priorSpan->fPt, missingOther);
             }
         }
     }
@@ skipping 50 matching lines @@
         }
     }
     // FIXME: again, be overly conservative to avoid breaking existing tests
     const SkOpSpan& oSpan = oStartIndex < oEndIndex ? other->fTs[oStartIndex]
             : other->fTs[oEndIndex];
     if (checkMultiple && !oSpan.fSmall) {
         return;
     }
 //    SkASSERT(oSpan.fSmall);
     if (oStartIndex < oEndIndex) {
-        addTCoincident(span.fPt, next->fPt, next->fT, other);
+        SkAssertResult(addTCoincident(span.fPt, next->fPt, next->fT, other));
     } else {
         addTCancel(span.fPt, next->fPt, other);
     }
     if (!checkMultiple) {
         return;
     }
     // check to see if either segment is coincident with a third segment -- if it is, and if
     // the opposite segment is not already coincident with the third, make it so
     // OPTIMIZE: to make this check easier, add coincident and cancel could set a coincident bit
     if (span.fWindValue != 1 || span.fOppValue != 0) {
@@ skipping 24 matching lines @@
                     SkPoint oMid = other->ptAtT((oTest->fOtherT + tTest->fT) / 2);
                     if (!SkDPoint::ApproximatelyEqual(mid, oMid)) {
                         continue;
                     }
                 }
 #if DEBUG_CONCIDENT
                 SkDebugf("%s coincident found=%d %1.9g %1.9g\n", __FUNCTION__, testOther->fID,
                         oTest->fOtherT, tTest->fT);
 #endif
                 if (tTest->fT < oTest->fOtherT) {
-                    addTCoincident(span.fPt, next->fPt, next->fT, testOther);
+                    SkAssertResult(addTCoincident(span.fPt, next->fPt, next->fT, testOther));
                 } else {
                     addTCancel(span.fPt, next->fPt, testOther);
                 }
                 MissingSpan missing;
                 missing.fSegment = testOther;
                 checkMultiple->push_back(missing);
                 break;
             }
         }
         oTest = &oSpan;
@@ skipping 868 matching lines @@
         if (test->fOther == other || test->fOtherT != 1) {
             continue;
         }
         SkPoint startPt, endPt;
         double endT;
         if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) {
             SkOpSegment* match = test->fOther;
             if (cancel) {
                 match->addTCancel(startPt, endPt, other);
             } else {
-                match->addTCoincident(startPt, endPt, endT, other);
+                SkAssertResult(match->addTCoincident(startPt, endPt, endT, other));
             }
             return true;
         }
     } while (fTs[++tIndex].fT == 0);
     return false;
 }
 
 // this span is excluded by the winding rule -- chase the ends
 // as long as they are unambiguous to mark connections as done
 // and give them the same winding value
@@ skipping 999 matching lines @@
     SkASSERT(span->fWindValue > 0 || span->fOppValue != 0);
     span->fWindValue = 0;
     span->fOppValue = 0;
     if (span->fTiny || span->fSmall) {
         return;
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
     ++fDoneSpans;
 }