harden pathops for pathological test

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 284 matching lines @@
     void alignSpanState(int start, int end);
     bool betweenTs(int lesser, double testT, int greater) const;
     void blindCancel(const SkCoincidence& coincidence, SkOpSegment* other);
     void blindCoincident(const SkCoincidence& coincidence, SkOpSegment* other);
     bool calcAngles();
     double calcMissingTEnd(const SkOpSegment* ref, double loEnd, double min, double max,
                            double hiEnd, const SkOpSegment* other, int thisEnd);
     double calcMissingTStart(const SkOpSegment* ref, double loEnd, double min, double max,
                              double hiEnd, const SkOpSegment* other, int thisEnd);
     void checkDuplicates();
-    void checkEnds();
+    bool 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 findOtherT(double t, const SkOpSegment* ) const;
     int findT(double t, const SkPoint& , const SkOpSegment* ) const;
     SkOpSegment* findTop(int* tIndex, int* endIndex, bool* unsortable, bool firstPass);
     void fixOtherTIndex();
+    bool inconsistentAngle(int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding,
+                        const SkOpAngle* angle) const;
     void initWinding(int start, int end, SkOpAngle::IncludeType angleIncludeType);
-    void initWinding(int start, int end, double tHit, int winding, SkScalar hitDx, int oppWind,
+    bool initWinding(int start, int end, double tHit, int winding, SkScalar hitDx, int oppWind,
                      SkScalar hitOppDx);
     bool isMissing(double startT, const SkPoint& pt) const;
     bool isTiny(const SkOpAngle* angle) const;
     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);
+    bool markAndChaseWinding(const SkOpAngle* angle, int winding, int oppWinding,
+                             SkOpSpan** lastPtr);
     SkOpSpan* markAngle(int maxWinding, int sumWinding, int oppMaxWinding, int oppSumWinding,
                         const SkOpAngle* angle);
     void markDone(int index, int winding);
     void markDoneBinary(int index);
+    void markDoneFinal(int index);
     void markDoneUnary(int index);
     bool nextCandidate(int* start, int* end) const;
     int nextSpan(int from, int step) const;
     void pinT(const SkPoint& pt, double* t);
     void setUpWindings(int index, int endIndex, int* sumMiWinding, int* sumSuWinding,
             int* maxWinding, int* sumWinding, int* oppMaxWinding, int* oppSumWinding);
     void sortAngles();
     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);
@@ skipping 46 matching lines @@
     const SkOpAngle* activeAngleOther(int index, int* start, int* end, bool* done,
                                       bool* sortable) const;
     bool activeOp(int xorMiMask, int xorSuMask, int index, int endIndex, SkPathOp op,
                   int* sumMiWinding, int* sumSuWinding);
     bool activeWinding(int index, int endIndex, int* sumWinding);
     void addCancelOutsides(const SkPoint& startPt, const SkPoint& endPt, SkOpSegment* other);
     void addCoinOutsides(const SkPoint& startPt, const SkPoint& endPt, SkOpSegment* other);
     SkOpAngle* addSingletonAngleDown(SkOpSegment** otherPtr, SkOpAngle** );
     SkOpAngle* addSingletonAngleUp(SkOpSegment** otherPtr, SkOpAngle** );
     SkOpAngle* addSingletonAngles(int step);
+    void alignRange(int lower, int upper, const SkOpSegment* other, int oLower, int oUpper);
     void alignSpan(const SkPoint& newPt, double newT, const SkOpSegment* other, double otherT,
                    const SkOpSegment* other2, SkOpSpan* oSpan, SkTDArray<AlignedSpan>* );
     bool betweenPoints(double midT, const SkPoint& pt1, const SkPoint& pt2) const;
     void bumpCoincidentBlind(bool binary, int index, int last);
     bool bumpCoincidentThis(const SkOpSpan& oTest, bool binary, int* index,
-                           SkTArray<SkPoint, true>* outsideTs);
+                            SkTArray<SkPoint, true>* outsideTs);
     void bumpCoincidentOBlind(int index, int last);
-    void bumpCoincidentOther(const SkOpSpan& oTest, int* index,
-                           SkTArray<SkPoint, true>* outsideTs);
+    bool bumpCoincidentOther(const SkOpSpan& oTest, int* index,
+                             SkTArray<SkPoint, true>* outsideTs, const SkPoint& endPt);
     bool bumpSpan(SkOpSpan* span, int windDelta, int oppDelta);
     bool calcLoopSpanCount(const SkOpSpan& thisSpan, int* smallCounts);
     bool checkForSmall(const SkOpSpan* span, const SkPoint& pt, double newT,
                        int* less, int* more) const;
     void checkLinks(const SkOpSpan* ,
                     SkTArray<MissingSpan, true>* missingSpans) const;
     static void CheckOneLink(const SkOpSpan* test, const SkOpSpan* oSpan,
                              const SkOpSpan* oFirst, const SkOpSpan* oLast,
                              const SkOpSpan** missingPtr,
                              SkTArray<MissingSpan, true>* missingSpans);
     int checkSetAngle(int tIndex) const;
     void checkSmallCoincidence(const SkOpSpan& span, SkTArray<MissingSpan, true>* );
     bool coincidentSmall(const SkPoint& pt, double t, const SkOpSegment* other) const;
     bool clockwise(int tStart, int tEnd, bool* swap) const;
     static void ComputeOneSum(const SkOpAngle* baseAngle, SkOpAngle* nextAngle,
                               SkOpAngle::IncludeType );
     static void ComputeOneSumReverse(const SkOpAngle* baseAngle, SkOpAngle* nextAngle,
                                      SkOpAngle::IncludeType );
     bool containsT(double t, const SkOpSegment* other, double otherT) const;
     bool decrementSpan(SkOpSpan* span);
     int findEndSpan(int endIndex) const;
     int findStartSpan(int startIndex) const;
     int firstActive(int tIndex) const;
     const SkOpSpan& firstSpan(const SkOpSpan& thisSpan) const;
     void init(const SkPoint pts[], SkPath::Verb verb, bool operand, bool evenOdd);
     bool inCoincidentSpan(double t, const SkOpSegment* other) const;
+    bool inconsistentWinding(const SkOpAngle* , int maxWinding, int oppMaxWinding) const;
+    bool inconsistentWinding(int min, int maxWinding, int oppMaxWinding) const;
+    bool inconsistentWinding(const char* funName, int tIndex, int winding, int oppWinding) const;
     bool inLoop(const SkOpAngle* baseAngle, int spanCount, int* indexPtr) const;
 #if OLD_CHASE
     bool isSimple(int end) const;
 #else
     SkOpSegment* isSimple(int* end, int* step);
 #endif
     bool isTiny(int index) const;
     const SkOpSpan& lastSpan(const SkOpSpan& thisSpan) const;
     void matchWindingValue(int tIndex, double t, bool borrowWind);
     SkOpSpan* markAndChaseDone(int index, int endIndex, int winding);
     SkOpSpan* markAndChaseDoneBinary(const SkOpAngle* angle, int winding, int oppWinding);
-    SkOpSpan* markAndChaseWinding(const SkOpAngle* angle, int winding);
-    SkOpSpan* markAndChaseWinding(int index, int endIndex, int winding);
-    SkOpSpan* markAndChaseWinding(int index, int endIndex, int winding, int oppWinding);
+    bool markAndChaseWinding(const SkOpAngle* angle, int winding, SkOpSpan** lastPtr);
+    bool markAndChaseWinding(int index, int endIndex, int winding, SkOpSpan** lastPtr);
+    bool markAndChaseWinding(int index, int endIndex, int winding, int oppWinding,
+                             SkOpSpan** lastPtr);
     SkOpSpan* markAngle(int maxWinding, int sumWinding, const SkOpAngle* angle);
     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 markOneDoneFinal(const char* funName, int tIndex);
     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);
+    bool markOneWinding(const char* funName, int tIndex, int winding, SkOpSpan** lastPtr);
+    bool markOneWinding(const char* funName, int tIndex, int winding, int oppWinding,
+                        SkOpSpan** lastPtr);
+    bool markWinding(int index, int winding);
+    bool markWinding(int index, int winding, int oppWinding);
     bool monotonicInY(int tStart, int tEnd) const;
 
     bool multipleEnds() const { return fTs[count() - 2].fT == 1; }
     bool multipleStarts() const { return fTs[1].fT == 0; }
 
-    SkOpSegment* nextChase(int* index, int* step, int* min, SkOpSpan** last);
+    SkOpSegment* nextChase(int* index, int* step, int* min, SkOpSpan** last) const;
     int nextExactSpan(int from, int step) const;
+    void resetSpanFlags();
     bool serpentine(int tStart, int tEnd) const;
     void setCoincidentRange(const SkPoint& startPt, const SkPoint& endPt,  SkOpSegment* other);
     void setFromAngle(int endIndex, SkOpAngle* );
+    void setSpanFlags(const SkPoint& pt, double newT, SkOpSpan* span);
     void setToAngle(int endIndex, SkOpAngle* );
     void setUpWindings(int index, int endIndex, int* sumMiWinding,
             int* maxWinding, int* sumWinding);
     void subDivideBounds(int start, int end, SkPathOpsBounds* bounds) const;
     static void TrackOutsidePair(SkTArray<SkPoint, true>* outsideTs, const SkPoint& endPt,
             const SkPoint& startPt);
     static void TrackOutside(SkTArray<SkPoint, true>* outsideTs, const SkPoint& startPt);
     int updateOppWinding(int index, int endIndex) const;
     int updateOppWinding(const SkOpAngle* angle) const;
     int updateWinding(int index, int endIndex) const;
@@ skipping 34 matching lines @@
         return value < 0 ? '?' : value <= 9 ? '0' + value : '+';
     }
 #endif
     // available to testing only
     void debugConstruct();
     void debugConstructCubic(SkPoint shortQuad[4]);
     void debugConstructLine(SkPoint shortQuad[2]);
     void debugConstructQuad(SkPoint shortQuad[3]);
     void debugReset();
     void dumpDPts() const;
+    void dumpHexPts() const;
     void dumpSpan(int index) const;
 
     const SkPoint* fPts;
     SkPathOpsBounds fBounds;
     // FIXME: can't convert to SkTArray because it uses insert
     SkTDArray<SkOpSpan> fTs;  // 2+ (always includes t=0 t=1) -- at least (number of spans) + 1
     SkOpAngleSet fAngles;  // empty or 2+ -- (number of non-zero spans) * 2
     // OPTIMIZATION: could pack donespans, verb, operand, xor into 1 int-sized value
     int fDoneSpans;  // quick check that segment is finished
     // OPTIMIZATION: force the following to be byte-sized
     SkPath::Verb fVerb;
     bool fLoop;   // set if cubic intersects itself
     bool fMultiples;  // set if curve intersects multiple other curves at one interior point
     bool fOperand;
     bool fXor;  // set if original contour had even-odd fill
     bool fOppXor;  // set if opposite operand had even-odd fill
     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