path ops near exact

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 "SkOpSegment.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 191 matching lines @@
     setUpWinding(index, endIndex, maxWinding, sumWinding);
     bool from = *maxWinding != 0;
     bool to = *sumWinding  != 0;
     bool result = gUnaryActiveEdge[from][to];
     return result;
 }
 
 void SkOpSegment::addAngle(SkTArray<SkOpAngle, true>* anglesPtr, int start, int end) const {
     SkASSERT(start != end);
     SkOpAngle& angle = anglesPtr->push_back();
-#if DEBUG_ANGLE
+#if 0 && DEBUG_ANGLE // computed pt and actual pt may differ by more than approx eq
     SkTArray<SkOpAngle, true>& angles = *anglesPtr;
     if (angles.count() > 1) {
         const SkOpSegment* aSeg = angles[0].segment();
         int aStart = angles[0].start();
         if (!aSeg->fTs[aStart].fTiny) {
             const SkPoint& angle0Pt = aSeg->xyAtT(aStart);
             SkDPoint newPt = (*CurveDPointAtT[SkPathOpsVerbToPoints(aSeg->fVerb)])(aSeg->fPts,
                     aSeg->fTs[aStart].fT);
 #if ONE_OFF_DEBUG
             SkDebugf("%s t1=%1.9g (%1.9g, %1.9g) (%1.9g, %1.9g)\n", __FUNCTION__,
@@ skipping 850 matching lines @@
         span->fOppValue &= 1;
     }
     if (!span->fWindValue && !span->fOppValue) {
         span->fDone = true;
         ++fDoneSpans;
         return true;
     }
     return false;
 }
 
+// look to see if the curve end intersects an intermediary that intersects the other
+void SkOpSegment::checkEnds() {
+#if 1
+    return;  // FIXME: suspect we will need the code below to make intersections consistent
+#else
+    SkTDArray<SkOpSpan> missingSpans;
+    int count = fTs.count();
+    for (int index = 0; index < count; ++index) {
+        const SkOpSpan& span = fTs[index];
+        const SkOpSegment* other = span.fOther;
+        const SkOpSpan* otherSpan = &other->fTs[span.fOtherIndex];
+        double otherT = otherSpan->fT;
+        if (otherT != 0 && otherT != 1) {
+            continue;
+        }
+        int peekStart = span.fOtherIndex;
+        while (peekStart > 0) {
+            const SkOpSpan* peeker = &other->fTs[peekStart - 1];
+            if (peeker->fT != otherT) {
+                break;
+            }
+            --peekStart;
+        }
+        int otherLast = other->fTs.count() - 1;
+        int peekLast = span.fOtherIndex;
+        while (peekLast < otherLast) {
+            const SkOpSpan* peeker = &other->fTs[peekLast + 1];
+            if (peeker->fT != otherT) {
+                break;
+            }
+            ++peekLast;
+        }
+        if (peekStart == peekLast) {
+            continue;
+        }
+        double t = span.fT;
+        int tStart = index;
+        while (tStart > 0 && t == fTs[tStart - 1].fT) {
+            --tStart;
+        }
+        int tLast = index;
+        int last = count - 1;
+        while (tLast < last && t == fTs[tLast + 1].fT) {
+            ++tLast;
+        }
+        for (int peekIndex = peekStart; peekIndex <= peekLast; ++peekIndex) {
+            if (peekIndex == span.fOtherIndex) {
+                continue;
+            }
+            const SkOpSpan& peekSpan = other->fTs[peekIndex];
+            SkOpSegment* match = peekSpan.fOther;
+            const double matchT = peekSpan.fOtherT;
+            for (int tIndex = tStart; tIndex <= tLast; ++tIndex) {
+                const SkOpSpan& tSpan = fTs[tIndex];
+                if (tSpan.fOther == match && tSpan.fOtherT == matchT) {
+                    goto nextPeeker;
+                }
+            }
+            // this segment is missing a entry that the other contains
+            // remember so we can add the missing one and recompute the indices
+            SkOpSpan* missing = missingSpans.append();
+            missing->fT = t;
+            missing->fOther = match;
+            missing->fOtherT = matchT;
+            missing->fPt = peekSpan.fPt;
+        }
+nextPeeker:
+        ;
+    }
+    int missingCount = missingSpans.count();
+    for (int index = 0; index < missingCount; ++index)  {
+        const SkOpSpan& missing = missingSpans[index];
+        addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt);
+    }
+    if (missingCount > 0) {
+        fixOtherTIndex();
+    }
+#endif
+}
+
 bool SkOpSegment::equalPoints(int greaterTIndex, int lesserTIndex) {
     SkASSERT(greaterTIndex >= lesserTIndex);
     double greaterT = fTs[greaterTIndex].fT;
     double lesserT = fTs[lesserTIndex].fT;
     if (greaterT == lesserT) {
         return true;
     }
     if (!approximately_negative(greaterT - lesserT)) {
         return false;
     }
@@ skipping 1815 matching lines @@
         sum += fTs[i].fWindValue;
         slots[fTs[i].fOther->fID - 1] = as_digit(fTs[i].fWindValue);
         sum += fTs[i].fOppValue;
         slots[slotCount + fTs[i].fOther->fID - 1] = as_digit(fTs[i].fOppValue);
     }
     SkDebugf("%s id=%2d %.*s | %.*s\n", __FUNCTION__, fID, slotCount, slots.begin(), slotCount,
             slots.begin() + slotCount);
     return sum;
 }
 #endif