path ops -- rewrite angle sort

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"
+#include "SkOpSpan.h"
 #include "SkPathOpsBounds.h"
 #include "SkPathOpsCurve.h"
 #include "SkTDArray.h"
 
 class SkPathWriter;
 
 class SkOpSegment {
 public:
     SkOpSegment() {
 #if DEBUG_DUMP
@@ skipping 12 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;
     }
 
+    int count() const {
+        return fTs.count();
+    }
+
     bool done() const {
         SkASSERT(fDoneSpans <= fTs.count());
         return fDoneSpans == fTs.count();
     }
 
     bool done(int min) const {
         return fTs[min].fDone;
     }
 
     bool done(const SkOpAngle* angle) const {
@@ skipping 60 matching lines @@
 
     int oppValue(int tIndex) const {
         return fTs[tIndex].fOppValue;
     }
 
     int oppValue(const SkOpAngle* angle) const {
         int lesser = SkMin32(angle->start(), angle->end());
         return fTs[lesser].fOppValue;
     }
 
+    const SkOpSegment* other(int index) const {
+        return fTs[index].fOther;
+    }
+
     const SkPoint* pts() const {
         return fPts;
     }
 
     void reset() {
         init(NULL, (SkPath::Verb) -1, false, false);
         fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMax, SK_ScalarMax);
         fTs.reset();
     }
 
@@ skipping 122 matching lines @@
     SkOpSegment* findNextXor(int* nextStart, int* nextEnd, bool* unsortable);
     void findTooCloseToCall();
     SkOpSegment* findTop(int* tIndex, int* endIndex, bool* unsortable, bool onlySortable);
     void fixOtherTIndex();
     void initWinding(int start, int end);
     void initWinding(int start, int end, double tHit, int winding, SkScalar hitDx, int oppWind,
             SkScalar hitOppDx);
     bool isLinear(int start, int end) const;
     bool isMissing(double startT) const;
     bool isSimple(int end) const;
+    bool isTiny(const SkOpAngle* angle) const;
+    bool isTiny(int index) const;
     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,
                         bool activeAngle, const SkOpAngle* angle);
     void markDone(int index, int winding);
     void markDoneBinary(int index);
     void markDoneUnary(int index);
     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);
     bool nextCandidate(int* start, int* end) const;
     int nextExactSpan(int from, int step) const;
     int nextSpan(int from, int step) const;
     void setUpWindings(int index, int endIndex, int* sumMiWinding, int* sumSuWinding,
             int* maxWinding, int* sumWinding, int* oppMaxWinding, int* oppSumWinding);
-    static bool SortAngles(const SkTDArray<SkOpAngle>& angles, SkTDArray<SkOpAngle*>* angleList);
-    void subDivide(int start, int end, SkPoint edge[4]) const;
+    enum SortAngleKind {
+        kMustBeOrdered_SortAngleKind, // required for winding calc
+        kMayBeUnordered_SortAngleKind // ok for find top
+    };
+    static bool SortAngles(const SkTDArray<SkOpAngle>& angles, SkTDArray<SkOpAngle*>* angleList,
+                           SortAngleKind );
+    bool subDivide(int start, int end, SkPoint edge[4]) const;
+    bool subDivide(int start, int end, SkDCubic* result) const;
     void undoneSpan(int* start, int* end);
     int updateOppWindingReverse(const SkOpAngle* angle) const;
     int updateWindingReverse(const SkOpAngle* angle) const;
     static bool UseInnerWinding(int outerWinding, int innerWinding);
     int windingAtT(double tHit, int tIndex, bool crossOpp, SkScalar* dx) const;
     int windSum(const SkOpAngle* angle) const;
     int windValue(const SkOpAngle* angle) const;
 
 #if DEBUG_DUMP
     int debugID() const {
@@ skipping 47 matching lines @@
     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);
     void markUnsortable(int start, int end);
     bool monotonicInY(int tStart, int tEnd) const;
     bool multipleSpans(int end) const;
     SkOpSegment* nextChase(int* index, const int step, int* min, SkOpSpan** last);
     bool serpentine(int tStart, int tEnd) const;
     void subDivideBounds(int start, int end, SkPathOpsBounds* bounds) const;
-    bool tiny(const SkOpAngle* angle) const;
     static void TrackOutside(SkTDArray<double>* outsideTs, double end, double start);
     int updateOppWinding(int index, int endIndex) const;
     int updateOppWinding(const SkOpAngle* angle) const;
     int updateWinding(int index, int endIndex) const;
     int updateWinding(const SkOpAngle* angle) const;
     SkOpSpan* verifyOneWinding(const char* funName, int tIndex);
     SkOpSpan* verifyOneWindingU(const char* funName, int tIndex);
     int windValueAt(double t) const;
     void zeroSpan(SkOpSpan* span);
 
@@ skipping 22 matching lines @@
     SkPath::Verb fVerb;
     bool fOperand;
     bool fXor;  // set if original contour had even-odd fill
     bool fOppXor;  // set if opposite operand had even-odd fill
 #if DEBUG_DUMP
     int fID;
 #endif
 };
 
 #endif