path ops near exact

src/pathops/SkIntersections.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 SkIntersections_DEFINE
 #define SkIntersections_DEFINE
 
 #include "SkPathOpsCubic.h"
@@ skipping 27 matching lines @@
 
     void set(const SkIntersections& i) {
         memcpy(fPt, i.fPt, sizeof(fPt));
         memcpy(fT, i.fT, sizeof(fT));
         memcpy(fIsCoincident, i.fIsCoincident, sizeof(fIsCoincident));
         fUsed = i.fUsed;
         fSwap = i.fSwap;
         SkDEBUGCODE(fDepth = i.fDepth);
     }
 
+    void allowNear(bool nearAllowed) {
+        fAllowNear = nearAllowed;
+    }
+
     int cubic(const SkPoint a[4]) {
         SkDCubic cubic;
         cubic.set(a);
         return intersect(cubic);
     }
 
     int cubicCubic(const SkPoint a[4], const SkPoint b[4]) {
         SkDCubic aCubic;
         aCubic.set(a);
         SkDCubic bCubic;
@@ skipping 23 matching lines @@
     }
 
     int cubicQuad(const SkPoint a[4], const SkPoint b[3]) {
         SkDCubic cubic;
         cubic.set(a);
         SkDQuad quad;
         quad.set(b);
         return intersect(cubic, quad);
     }
 
+    bool hasT(double t) const {
+        SkASSERT(t == 0 || t == 1);
+        return fUsed > 0 && (t == 0 ? fT[0][0] == 0 : fT[0][fUsed - 1] == 1);
+    }
+
     int insertSwap(double one, double two, const SkDPoint& pt) {
         if (fSwap) {
             return insert(two, one, pt);
         } else {
             return insert(one, two, pt);
         }
     }
 
-    int insertSwap(double one, double two, double x, double y) {
-        if (fSwap) {
-            return insert(two, one, x, y);
-        } else {
-            return insert(one, two, x, y);
-        }
-    }
-
     bool isCoincident(int index) {
         return (fIsCoincident[0] & 1 << index) != 0;
     }
 
     int lineHorizontal(const SkPoint a[2], SkScalar left, SkScalar right, SkScalar y,
                        bool flipped) {
         SkDLine line;
         line.set(a);
         return horizontal(line, left, right, y, flipped);
     }
@@ skipping 42 matching lines @@
         SkDQuad bQuad;
         bQuad.set(b);
         return intersect(aQuad, bQuad);
     }
 
     int quadRay(const SkPoint pts[3], const SkDLine& line);
     void removeOne(int index);
 
     // leaves flip, swap alone
     void reset() {
+        fAllowNear = true;
         fUsed = 0;
     }
 
     void swap() {
         fSwap ^= true;
     }
 
     void swapPts();
 
     bool swapped() const {
@@ skipping 18 matching lines @@
     void flip();
     int horizontal(const SkDLine&, double y);
     int horizontal(const SkDLine&, double left, double right, double y, bool flipped);
     int horizontal(const SkDQuad&, double left, double right, double y, bool flipped);
     int horizontal(const SkDQuad&, double left, double right, double y, double tRange[2]);
     int horizontal(const SkDCubic&, double y, double tRange[3]);
     int horizontal(const SkDCubic&, double left, double right, double y, bool flipped);
     int horizontal(const SkDCubic&, double left, double right, double y, double tRange[3]);
     // FIXME : does not respect swap
     int insert(double one, double two, const SkDPoint& pt);
-    int insert(double one, double two, double x, double y);
     // start if index == 0 : end if index == 1
     void insertCoincident(double one, double two, const SkDPoint& pt);
     void insertCoincidentPair(double s1, double e1, double s2, double e2,
             const SkDPoint& startPt, const SkDPoint& endPt);
     int intersect(const SkDLine&, const SkDLine&);
     int intersect(const SkDQuad&, const SkDLine&);
     int intersect(const SkDQuad&, const SkDQuad&);
     int intersect(const SkDCubic&);  // return true if cubic self-intersects
     int intersect(const SkDCubic&, const SkDLine&);
     int intersect(const SkDCubic&, const SkDQuad&);
@@ skipping 23 matching lines @@
 
 private:
     int computePoints(const SkDLine& line, int used);
     // used by addCoincident to remove ordinary intersections in range
  //   void remove(double one, double two, const SkDPoint& startPt, const SkDPoint& endPt);
 
     SkDPoint fPt[9];
     double fT[2][9];
     uint16_t fIsCoincident[2];  // bit arrays, one bit set for each coincident T
     unsigned char fUsed;
+    bool fAllowNear;
     bool fSwap;
 #ifdef SK_DEBUG
     int fDepth;
 #endif
 };
 
 extern int (SkIntersections::*CurveRay[])(const SkPoint[], const SkDLine& );
 extern int (SkIntersections::*CurveVertical[])(const SkPoint[], SkScalar top, SkScalar bottom,
             SkScalar x, bool flipped);
 
 #endif