fix minor skp-found bugs

src/pathops/SkOpAngle.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 "SkOpAngle.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsCurve.h"
@@ skipping 303 matching lines @@
             }
             goto recomputeSector;
         }
         checkEnd += step;
     } while (checkEnd != limit);
 recomputeSector:
     if (checkEnd == fEnd || checkEnd - step == fEnd) {
         fUnorderable = true;
         return false;
     }
+    int saveEnd = fEnd;
     fEnd = checkEnd - step;
     setSpans();
     setSector();
+    fEnd = saveEnd;
     return !fUnorderable;
 }
 
 // returns -1 if overlaps   0 if no overlap cw    1 if no overlap ccw
 int SkOpAngle::convexHullOverlaps(const SkOpAngle& rh) const {
     const SkDVector* sweep = fSweep;
     const SkDVector* tweep = rh.fSweep;
     double s0xs1 = sweep[0].crossCheck(sweep[1]);
     double s0xt0 = sweep[0].crossCheck(tweep[0]);
     double s1xt0 = sweep[1].crossCheck(tweep[0]);
@@ skipping 314 matching lines @@
             angle->insert(this);
         }
         return;
     }
     bool singleton = NULL == fNext;
     if (singleton) {
         fNext = this;
     }
     SkOpAngle* next = fNext;
     if (next->fNext == this) {
+        if (angle->overlap(*this)) {
+            return;
+        }
         if (singleton || angle->after(this)) {
             this->fNext = angle;
             angle->fNext = next;
         } else {
             next->fNext = angle;
             angle->fNext = this;
         }
         debugValidateNext();
         return;
     }
     SkOpAngle* last = this;
     do {
         SkASSERT(last->fNext == next);
+        if (angle->overlap(*last) || angle->overlap(*next)) {
+            return;
+        }
         if (angle->after(last)) {
             last->fNext = angle;
             angle->fNext = next;
             debugValidateNext();
             return;
         }
         last = next;
         next = next->fNext;
         if (last == this && next->fUnorderable) {
             fUnorderable = true;
@@ skipping 10 matching lines @@
 SkOpSpan* SkOpAngle::lastMarked() const {
     if (fLastMarked) {
         if (fLastMarked->fChased) {
             return NULL;
         }
         fLastMarked->fChased = true;
     }
     return fLastMarked;
 }
 
+bool SkOpAngle::loopContains(const SkOpAngle& test) const {
+    if (!fNext) {
+        return false;
+    }
+    const SkOpAngle* first = this;
+    const SkOpAngle* loop = this;
+    const SkOpSegment* tSegment = test.fSegment;
+    double tStart = tSegment->span(test.fStart).fT;
+    double tEnd = tSegment->span(test.fEnd).fT;
+    do {
+        const SkOpSegment* lSegment = loop->fSegment;
+        // FIXME : use precisely_equal ? or compare points exactly ?
+        if (lSegment != tSegment) {
+            continue;
+        }
+        double lStart = lSegment->span(loop->fStart).fT;
+        if (lStart != tEnd) {
+            continue;
+        }
+        double lEnd = lSegment->span(loop->fEnd).fT;
+        if (lEnd == tStart) {
+            return true;
+        }
+    } while ((loop = loop->fNext) != first);
+    return false;
+}
+
 int SkOpAngle::loopCount() const {
     int count = 0;
     const SkOpAngle* first = this;
     const SkOpAngle* next = this;
     do {
         next = next->fNext;
         ++count;
     } while (next && next != first);
     return count;
 }
@@ skipping 92 matching lines @@
     if ((result = convexHullOverlaps(rh)) >= 0) {
         return result;
     }
     return endsIntersect(rh);
 unorderable:
     fUnorderable = true;
     rh.fUnorderable = true;
     return true;
 }
 
+bool SkOpAngle::overlap(const SkOpAngle& other) const {
+    int min = SkTMin(fStart, fEnd);
+    const SkOpSpan& span = fSegment->span(min);
+    const SkOpSegment* oSeg = other.fSegment;
+    int oMin = SkTMin(other.fStart, other.fEnd);
+    const SkOpSpan& oSpan = oSeg->span(oMin);
+    if (!span.fSmall && !oSpan.fSmall) {
+        return false;
+    }
+    if (fSegment->span(fStart).fPt != oSeg->span(other.fStart).fPt) {
+        return false;
+    }
+    // see if small span is contained by opposite span
+    return span.fSmall ? oSeg->containsPt(fSegment->span(fEnd).fPt, other.fEnd, other.fStart)
+            : fSegment->containsPt(oSeg->span(other.fEnd).fPt, fEnd, fStart);
+}
+
 // OPTIMIZE: if this shows up in a profile, add a previous pointer
 // as is, this should be rarely called
 SkOpAngle* SkOpAngle::previous() const {
     SkOpAngle* last = fNext;
     do {
         SkOpAngle* next = last->fNext;
         if (next == this) {
             return last;
         }
         last = next;
@@ skipping 212 matching lines @@
         return true;
     }
     SkASSERT(s0dt0 != 0);
     double m = s0xt0 / s0dt0;
     double sDist = sweep[0].length() * m;
     double tDist = tweep[0].length() * m;
     bool useS = fabs(sDist) < fabs(tDist);
     double mFactor = fabs(useS ? distEndRatio(sDist) : rh.distEndRatio(tDist));
     return mFactor < 5000;  // empirically found limit
 }