path ops work in progress

src/pathops/SkDLineIntersection.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 "SkPathOpsLine.h"
 
 /* Determine the intersection point of two lines. This assumes the lines are not parallel,
@@ skipping 17 matching lines @@
 
 int SkIntersections::computePoints(const SkDLine& line, int used) {
     fPt[0] = line.ptAtT(fT[0][0]);
     if ((fUsed = used) == 2) {
         fPt[1] = line.ptAtT(fT[0][1]);
     }
     return fUsed;
 }
 
 int SkIntersections::intersectRay(const SkDLine& a, const SkDLine& b) {
-    double axLen = a[1].fX - a[0].fX;
-    double ayLen = a[1].fY - a[0].fY;
-    double bxLen = b[1].fX - b[0].fX;
-    double byLen = b[1].fY - b[0].fY;
+    SkDVector aLen = a[1] - a[0];
+    SkDVector bLen = b[1] - b[0];
     /* Slopes match when denom goes to zero:
                       axLen / ayLen ==                   bxLen / byLen
     (ayLen * byLen) * axLen / ayLen == (ayLen * byLen) * bxLen / byLen
              byLen  * axLen         ==  ayLen          * bxLen
              byLen  * axLen         -   ayLen          * bxLen == 0 ( == denom )
      */
-    double denom = byLen * axLen - ayLen * bxLen;
-    double ab0y = a[0].fY - b[0].fY;
-    double ab0x = a[0].fX - b[0].fX;
-    double numerA = ab0y * bxLen - byLen * ab0x;
-    double numerB = ab0y * axLen - ayLen * ab0x;
+    double denom = bLen.fY * aLen.fX - aLen.fY * bLen.fX;
+    SkDVector ab0 = a[0] - b[0];
+    double numerA = ab0.fY * bLen.fX - bLen.fY * ab0.fX;
+    double numerB = ab0.fY * aLen.fX - aLen.fY * ab0.fX;
     numerA /= denom;
     numerB /= denom;
     int used;
     if (!approximately_zero(denom)) {
         fT[0][0] = numerA;
         fT[1][0] = numerB;
         used = 1;
     } else {
        /* See if the axis intercepts match:
                   ay - ax * ayLen / axLen  ==          by - bx * ayLen / axLen
          axLen * (ay - ax * ayLen / axLen) == axLen * (by - bx * ayLen / axLen)
          axLen *  ay - ax * ayLen          == axLen *  by - bx * ayLen
         */
-        if (!AlmostEqualUlps(axLen * a[0].fY - ayLen * a[0].fX,
-                axLen * b[0].fY - ayLen * b[0].fX)) {
+        if (!AlmostEqualUlps(aLen.fX * a[0].fY - aLen.fY * a[0].fX,
+                aLen.fX * b[0].fY - aLen.fY * b[0].fX)) {
             return fUsed = 0;
         }
         // there's no great answer for intersection points for coincident rays, but return something
         fT[0][0] = fT[1][0] = 0;
         fT[1][0] = fT[1][1] = 1;
         used = 2;
     }
     return computePoints(a, used);
 }
 
@@ skipping 21 matching lines @@
     /* Slopes match when denom goes to zero:
                       axLen / ayLen ==                   bxLen / byLen
     (ayLen * byLen) * axLen / ayLen == (ayLen * byLen) * bxLen / byLen
              byLen  * axLen         ==  ayLen          * bxLen
              byLen  * axLen         -   ayLen          * bxLen == 0 ( == denom )
      */
     double axByLen = axLen * byLen;
     double ayBxLen = ayLen * bxLen;
     // detect parallel lines the same way here and in SkOpAngle operator <
     // so that non-parallel means they are also sortable
-    bool parallel = AlmostEqualUlps(axByLen, ayBxLen);
-    if (!parallel) {
+    bool unparallel = NotAlmostEqualUlps(axByLen, ayBxLen);
+    if (unparallel) {
         double ab0y = a[0].fY - b[0].fY;
         double ab0x = a[0].fX - b[0].fX;
         double numerA = ab0y * bxLen - byLen * ab0x;
         double numerB = ab0y * axLen - ayLen * ab0x;
         double denom = axByLen - ayBxLen;
         if (between(0, numerA, denom) && between(0, numerB, denom)) {
             fT[0][0] = numerA / denom;
             fT[1][0] = numerB / denom;
             computePoints(a, 1);
         }
     }
-    if (fAllowNear || parallel) {
+    if (fAllowNear || !unparallel) {
         for (int iA = 0; iA < 2; ++iA) {
             if ((t = b.nearPoint(a[iA])) >= 0) {
                 insert(iA, t, a[iA]);
             }
         }
         for (int iB = 0; iB < 2; ++iB) {
             if ((t = a.nearPoint(b[iB])) >= 0) {
                 insert(t, iB, b[iB]);
             }
         }
     }
+    while (fUsed > 2) {
+        removeOne(1);
+    }
+    if (fUsed == 2 && unparallel) {
+        bool startMatch = fT[0][0] == 0 || fT[1][0] == 0 || fT[1][0] == 1;
+        bool endMatch = fT[0][1] == 1 || fT[1][1] == 0 || fT[1][1] == 1;
+        if (!startMatch && !endMatch) {
+            SkASSERT(startMatch || endMatch);
+            removeOne(endMatch);
+        }
+    }
     return fUsed;
 }
 
 static int horizontal_coincident(const SkDLine& line, double y) {
     double min = line[0].fY;
     double max = line[1].fY;
     if (min > max) {
         SkTSwap(min, max);
     }
     if (min > y || max < y) {
@@ skipping 162 matching lines @@
 // 4 subs, 2 muls, 1 cmp
 static bool ccw(const SkDPoint& A, const SkDPoint& B, const SkDPoint& C) {
     return (C.fY - A.fY) * (B.fX - A.fX) > (B.fY - A.fY) * (C.fX - A.fX);
 }
 
 // 16 subs, 8 muls, 6 cmps
 bool SkIntersections::Test(const SkDLine& a, const SkDLine& b) {
     return ccw(a[0], b[0], b[1]) != ccw(a[1], b[0], b[1])
             && ccw(a[0], a[1], b[0]) != ccw(a[0], a[1], b[1]);
 }