fix minor skp-found bugs

src/pathops/SkOpSegment.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpSegment_DEFINE
 #define SkOpSegment_DEFINE
 
 #include "SkOpAngle.h"
@@ skipping 30 matching lines @@
     // OPTIMIZE
     // when the edges are initially walked, they don't automatically get the prior and next
     // edges assigned to positions t=0 and t=1. Doing that would remove the need for this check,
     // and would additionally remove the need for similar checks in condition edges. It would
     // also allow intersection code to assume end of segment intersections (maybe?)
     bool complete() const {
         int count = fTs.count();
         return count > 1 && fTs[0].fT == 0 && fTs[--count].fT == 1;
     }
 
-    void constructLine(SkPoint shortLine[2]);
-
     int count() const {
         return fTs.count();
     }
 
     bool done() const {
         SkASSERT(fDoneSpans <= fTs.count());
         return fDoneSpans == fTs.count();
     }
 
     bool done(int min) const {
@@ skipping 123 matching lines @@
         int index = tStart < tEnd ? span.fToAngleIndex : span.fFromAngleIndex;
         return index >= 0 ? &angle(index) : NULL;
     }
 
     // FIXME: create some sort of macro or template that avoids casting
     SkOpAngle* spanToAngle(int tStart, int tEnd) {
         const SkOpAngle* cAngle = (const_cast<const SkOpSegment*>(this))->spanToAngle(tStart, tEnd);
         return const_cast<SkOpAngle*>(cAngle);
     }
 
-    // OPTIMIZATION: mark as debugging only if used solely by tests
-    const SkTDArray<SkOpSpan>& spans() const {
-        return fTs;
-    }
-
     int spanSign(const SkOpAngle* angle) const {
         SkASSERT(angle->segment() == this);
         return spanSign(angle->start(), angle->end());
     }
 
     int spanSign(int startIndex, int endIndex) const {
         int result = startIndex < endIndex ? -fTs[startIndex].fWindValue : fTs[endIndex].fWindValue;
 #if DEBUG_WIND_BUMP
         SkDebugf("%s spanSign=%d\n", __FUNCTION__, result);
 #endif
         return result;
     }
 
     double t(int tIndex) const {
         return fTs[tIndex].fT;
     }
 
     double tAtMid(int start, int end, double mid) const {
         return fTs[start].fT * (1 - mid) + fTs[end].fT * mid;
     }
 
-    bool unsortable(int index) const {
-        return fTs[index].fUnsortableStart || fTs[index].fUnsortableEnd;
-    }
-
     void updatePts(const SkPoint pts[]) {
         fPts = pts;
     }
 
     SkPath::Verb verb() const {
         return fVerb;
     }
 
     int windSum(int tIndex) const {
         return fTs[tIndex].fWindSum;
@@ skipping 24 matching lines @@
     }
 
 #if defined(SK_DEBUG) || DEBUG_WINDING
     SkScalar yAtT(int index) const {
         return yAtT(&fTs[index]);
     }
 #endif
 
     const SkOpAngle* activeAngle(int index, int* start, int* end, bool* done,
                                  bool* sortable) const;
-    SkPoint activeLeftTop(bool onlySortable, int* firstT) const;
+    SkPoint activeLeftTop(int* firstT) const;
     bool activeOp(int index, int endIndex, int xorMiMask, int xorSuMask, SkPathOp op);
     bool activeWinding(int index, int endIndex);
     void addCubic(const SkPoint pts[4], bool operand, bool evenOdd);
     void addCurveTo(int start, int end, SkPathWriter* path, bool active) const;
     void addEndSpan(int endIndex);
     void addLine(const SkPoint pts[2], bool operand, bool evenOdd);
     void addOtherT(int index, double otherT, int otherIndex);
     void addQuad(const SkPoint pts[3], bool operand, bool evenOdd);
     void addSimpleAngle(int endIndex);
     int addSelfT(const SkPoint& pt, double newT);
     void addStartSpan(int endIndex);
     int addT(SkOpSegment* other, const SkPoint& pt, double newT);
     void addTCancel(const SkPoint& startPt, const SkPoint& endPt, SkOpSegment* other);
     void addTCoincident(const SkPoint& startPt, const SkPoint& endPt, double endT,
                         SkOpSegment* other);
     const SkOpSpan* addTPair(double t, SkOpSegment* other, double otherT, bool borrowWind,
                              const SkPoint& pt);
     bool alignSpan(int index, double thisT, const SkPoint& thisPt);
     void alignSpanState(int start, int end);
     const SkOpAngle& angle(int index) const;
     bool betweenTs(int lesser, double testT, int greater) const;
     bool calcAngles();
     void checkDuplicates();
     void checkEnds();
     void checkMultiples();
     void checkSmall();
     bool checkSmall(int index) const;
     void checkTiny();
     int computeSum(int startIndex, int endIndex, SkOpAngle::IncludeType includeType);
+    bool containsPt(const SkPoint& , int index, int endIndex) const;
     int crossedSpanY(const SkPoint& basePt, SkScalar* bestY, double* hitT, bool* hitSomething,
                      double mid, bool opp, bool current) const;
     bool findCoincidentMatch(const SkOpSpan* span, const SkOpSegment* other, int oStart, int oEnd,
                              int step, SkPoint* startPt, SkPoint* endPt, double* endT) const;
     SkOpSegment* findNextOp(SkTDArray<SkOpSpan*>* chase, int* nextStart, int* nextEnd,
                             bool* unsortable, SkPathOp op, int xorMiMask, int xorSuMask);
     SkOpSegment* findNextWinding(SkTDArray<SkOpSpan*>* chase, int* nextStart, int* nextEnd,
                                  bool* unsortable);
     SkOpSegment* findNextXor(int* nextStart, int* nextEnd, bool* unsortable);
     int findExactT(double t, const SkOpSegment* ) const;
-    int findT(double t, const SkOpSegment* ) const;
-    SkOpSegment* findTop(int* tIndex, int* endIndex, bool* unsortable);
+    int findT(double t, const SkPoint& , const SkOpSegment* ) const;
+    SkOpSegment* findTop(int* tIndex, int* endIndex, bool* unsortable, bool firstPass);
     void fixOtherTIndex();
     void initWinding(int start, int end, SkOpAngle::IncludeType angleIncludeType);
     void initWinding(int start, int end, double tHit, int winding, SkScalar hitDx, int oppWind,
                      SkScalar hitOppDx);
     bool isMissing(double startT, const SkPoint& pt) const;
-    bool isSmall(const SkOpAngle* angle) const;
     bool isTiny(const SkOpAngle* angle) const;
-    bool joinCoincidence(SkOpSegment* other, double otherT, int step, bool cancel);
+    bool joinCoincidence(SkOpSegment* other, double otherT, const SkPoint& otherPt, int step,
+                         bool cancel);
     SkOpSpan* markAndChaseDoneBinary(int index, int endIndex);
     SkOpSpan* markAndChaseDoneUnary(int index, int endIndex);
     SkOpSpan* markAndChaseWinding(const SkOpAngle* angle, int winding, int oppWinding);
     SkOpSpan* markAngle(int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding,
                         const SkOpAngle* angle);
     void markDone(int index, int winding);
     void markDoneBinary(int index);
     void markDoneUnary(int index);
     bool nextCandidate(int* start, int* end) const;
     int nextSpan(int from, int step) const;
@@ skipping 24 matching lines @@
 #endif
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
     void debugShowActiveSpans() const;
 #endif
 #if DEBUG_CONCIDENT
     void debugShowTs(const char* prefix) const;
 #endif
 #if DEBUG_SHOW_WINDING
     int debugShowWindingValues(int slotCount, int ofInterest) const;
 #endif
+    const SkTDArray<SkOpSpan>& debugSpans() const;
     void debugValidate() const;
     // available to testing only
     void dumpAngles() const;
     void dumpContour(int firstID, int lastID) const;
     void dumpPts() const;
     void dumpSpans() const;
 
 private:
     struct MissingSpan  {
         double fT;
@@ skipping 58 matching lines @@
     void markDoneBinary(int index, int winding, int oppWinding);
     SkOpSpan* markAndChaseDoneUnary(const SkOpAngle* angle, int winding);
     void markOneDone(const char* funName, int tIndex, int winding);
     void markOneDoneBinary(const char* funName, int tIndex);
     void markOneDoneBinary(const char* funName, int tIndex, int winding, int oppWinding);
     void markOneDoneUnary(const char* funName, int tIndex);
     SkOpSpan* markOneWinding(const char* funName, int tIndex, int winding);
     SkOpSpan* markOneWinding(const char* funName, int tIndex, int winding, int oppWinding);
     void markWinding(int index, int winding);
     void markWinding(int index, int winding, int oppWinding);
-    void markUnsortable(int start, int end);
     bool monotonicInY(int tStart, int tEnd) const;
 
     bool multipleEnds() const {
         return fTs[count() - 2].fT == 1;
     }
 
     bool multipleStarts() const {
         return fTs[1].fT == 0;
     }
 
@@ skipping 30 matching lines @@
 #if DEBUG_SWAP_TOP
     bool controlsContainedByEnds(int tStart, int tEnd) const;
 #endif
     void debugAddAngle(int start, int end);
 #if DEBUG_CONCIDENT
     void debugAddTPair(double t, const SkOpSegment& other, double otherT) const;
 #endif
 #if DEBUG_ANGLE
     void debugCheckPointsEqualish(int tStart, int tEnd) const;
 #endif
+#if DEBUG_SWAP_TOP
+    int debugInflections(int index, int endIndex) const;
+#endif
 #if DEBUG_MARK_DONE || DEBUG_UNSORTABLE
     void debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding);
     void debugShowNewWinding(const char* fun, const SkOpSpan& span, int winding, int oppWinding);
 #endif
 #if DEBUG_WINDING
     static char as_digit(int value) {
         return value < 0 ? '?' : value <= 9 ? '0' + value : '+';
     }
 #endif
     // available to testing only
@@ skipping 23 matching lines @@
     bool fSmall;  // set if some span is small
     bool fTiny;  // set if some span is tiny
 #if defined(SK_DEBUG) || !FORCE_RELEASE
     int fID;
 #endif
 
     friend class PathOpsSegmentTester;
 };
 
 #endif