pathops coincident work

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 244 matching lines @@
     SkOpPtT* newPtT = this->addT(newT);
     *startOver |= this->globalState()->allocatedOpSpan();
     if (!newPtT) {
         return false;
     }
     newPtT->fPt = this->ptAtT(newT);
     // const cast away to change linked list; pt/t values stays unchanged
     SkOpPtT* oppPrev = test->ptT()->oppPrev(newPtT);
     if (oppPrev) {
         SkOpSpanBase* writableTest = const_cast<SkOpSpanBase*>(test);
+        writableTest->mergeMatches(newPtT->span());
         writableTest->ptT()->addOpp(newPtT, oppPrev);
         writableTest->checkForCollapsedCoincidence();
     }
     return true;
 }
 
 // Please keep this in sync with debugAddT()
 SkOpPtT* SkOpSegment::addT(double t) {
     debugValidate();
     SkPoint pt = this->ptAtT(t);
@@ skipping 73 matching lines @@
 }
 
 // Quads and conics collapse if the end points are the same, because
 // the curve doesn't enclose an area.
 bool SkOpSegment::collapsed() const {
     // FIXME: cubics can have also collapsed -- need to check if the
     // control points are on a line with the end points
     return fVerb < SkPath::kCubic_Verb && fHead.pt() == fTail.pt();
 }
 
+bool SkOpSegment::collapsed(double s, double e) const {
+    const SkOpSpanBase* span = &fHead;
+    do {
+        if (span->collapsed(s, e)) {
+            return true;
+        }
+    } while (span->upCastable() && (span = span->upCast()->next()));
+    return false;
+}
+
 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;
     if (binary) {
         sumSuWinding = baseSegment->updateOppWindingReverse(baseAngle);
         if (baseSegment->operand()) {
             SkTSwap<int>(sumMiWinding, sumSuWinding);
@@ skipping 925 matching lines @@
                     }
                     SkOpPtT* matchPtT = startPtT;
                     do {
                         if (matchPtT->segment() == oppPtTSegment) {
                             goto foundMatch;
                         }
                     } while ((matchPtT = matchPtT->next()) != startPtT);
                     goto tryNextSpan;
             foundMatch:  // merge oppTest and oppSpan
                     oppSegment->debugValidate();
-                    if (oppTest == &oppSegment->fTail || oppTest == &oppSegment->fHead) {
-                        SkASSERT(oppSpan != &oppSegment->fHead); // don't expect collapse
-                        SkASSERT(oppSpan != &oppSegment->fTail);
-                        oppTest->merge(oppSpan->upCast());
-                    } else {
-                        oppSpan->merge(oppTest->upCast());
-                    }
+                    oppTest->mergeMatches(oppSpan);
+                    oppTest->addOpp(oppSpan);
                     oppSegment->debugValidate();
                     goto checkNextSpan;
                 }
         tryNextSpan:
                 ;
             } while (oppTest != oppLast && (oppTest = oppTest->upCast()->next()));
         } while ((testPtT = testPtT->next()) != startPtT);
 checkNextSpan:
         ;
     } while ((test = test->final() ? nullptr : test->upCast()->next()));
     debugValidate();
     return true;
 }
 
 // adjacent spans may have points close by
 bool SkOpSegment::spansNearby(const SkOpSpanBase* refSpan, const SkOpSpanBase* checkSpan) const {
     const SkOpPtT* refHead = refSpan->ptT();
     const SkOpPtT* checkHead = checkSpan->ptT();
 // if the first pt pair from adjacent spans are far apart, assume that all are far enough apart
-    if (!SkDPoint::RoughlyEqual(refHead->fPt, checkHead->fPt)) {
+    if (!SkDPoint::WayRoughlyEqual(refHead->fPt, checkHead->fPt)) {
 #if DEBUG_COINCIDENCE
         // verify that no combination of points are close
         const SkOpPtT* dBugRef = refHead;
         do {
             const SkOpPtT* dBugCheck = checkHead;
             do {
-                SkASSERT(!SkDPoint::ApproximatelyEqual(dBugRef->fPt, dBugCheck->fPt));
+                SkOPASSERT(!SkDPoint::ApproximatelyEqual(dBugRef->fPt, dBugCheck->fPt));
                 dBugCheck = dBugCheck->next();
             } while (dBugCheck != checkHead);
             dBugRef = dBugRef->next();
         } while (dBugRef != refHead);
 #endif
         return false;
     }
     // check only unique points
     SkScalar distSqBest = SK_ScalarMax;
     const SkOpPtT* refBest = nullptr;
@@ skipping 330 matching lines @@
         SkDLine ray = {{{midPt.fX, midPt.fY}, {partMidPt.fX + dxdy.fY, partMidPt.fY - dxdy.fX}}};
         SkDCurve oppPart;
         opp->subDivide(priorPtT->span(), ptT->span(), &oppPart);
         (*CurveDIntersectRay[opp->verb()])(oppPart, ray, &i);
         // measure distance and see if it's small enough to denote coincidence
         for (int index = 0; index < i.used(); ++index) {
             if (!between(0, i[0][index], 1)) {
                 continue;
             }
             SkDPoint oppPt = i.pt(index);
-            if (oppPt.approximatelyEqual(midPt)) {
+            if (oppPt.approximatelyDEqual(midPt)) {
                 // the coincidence can occur at almost any angle
                 coincident = true;
             }
         }
     }
     return coincident;
 }
 
 void SkOpSegment::undoneSpan(SkOpSpanBase** start, SkOpSpanBase** end) {
     SkOpSpan* span = this->head();
@@ skipping 68 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();
 }