compute initial winding from projected rays

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"
 
 void SkIntersections::cleanUpParallelLines(bool parallel) {
@@ skipping 170 matching lines @@
     }
     if (min > y || max < y) {
         return 0;
     }
     if (AlmostEqualUlps(min, max) && max - min < fabs(line[0].fX - line[1].fX)) {
         return 2;
     }
     return 1;
 }
 
-static double horizontal_intercept(const SkDLine& line, double y) {
+double SkIntersections::HorizontalIntercept(const SkDLine& line, double y) {
      return SkPinT((y - line[0].fY) / (line[1].fY - line[0].fY));
 }
 
 int SkIntersections::horizontal(const SkDLine& line, double left, double right,
                                 double y, bool flipped) {
     fMax = 3;  // clean up parallel at the end will limit the result to 2 at the most
     // see if end points intersect the opposite line
     double t;
     const SkDPoint leftPt = { left, y };
     if ((t = line.exactPoint(leftPt)) >= 0) {
         insert(t, (double) flipped, leftPt);
     }
     if (left != right) {
         const SkDPoint rightPt = { right, y };
         if ((t = line.exactPoint(rightPt)) >= 0) {
             insert(t, (double) !flipped, rightPt);
         }
         for (int index = 0; index < 2; ++index) {
             if ((t = SkDLine::ExactPointH(line[index], left, right, y)) >= 0) {
                 insert((double) index, flipped ? 1 - t : t, line[index]);
             }
         }
     }
     int result = horizontal_coincident(line, y);
     if (result == 1 && fUsed == 0) {
-        fT[0][0] = horizontal_intercept(line, y);
+        fT[0][0] = HorizontalIntercept(line, y);
         double xIntercept = line[0].fX + fT[0][0] * (line[1].fX - line[0].fX);
         if (between(left, xIntercept, right)) {
             fT[1][0] = (xIntercept - left) / (right - left);
             if (flipped) {
                 // OPTIMIZATION: ? instead of swapping, pass original line, use [1].fX - [0].fX
                 for (int index = 0; index < result; ++index) {
                     fT[1][index] = 1 - fT[1][index];
                 }
             }
             fPt[0].fX = xIntercept;
@@ skipping 29 matching lines @@
     }
     if (!precisely_between(min, x, max)) {
         return 0;
     }
     if (AlmostEqualUlps(min, max)) {
         return 2;
     }
     return 1;
 }
 
-static double vertical_intercept(const SkDLine& line, double x) {
+double SkIntersections::VerticalIntercept(const SkDLine& line, double x) {
     return SkPinT((x - line[0].fX) / (line[1].fX - line[0].fX));
 }
 
 int SkIntersections::vertical(const SkDLine& line, double top, double bottom,
                               double x, bool flipped) {
     fMax = 3;  // cleanup parallel lines will bring this back line
     // see if end points intersect the opposite line
     double t;
     SkDPoint topPt = { x, top };
     if ((t = line.exactPoint(topPt)) >= 0) {
         insert(t, (double) flipped, topPt);
     }
     if (top != bottom) {
         SkDPoint bottomPt = { x, bottom };
         if ((t = line.exactPoint(bottomPt)) >= 0) {
             insert(t, (double) !flipped, bottomPt);
         }
         for (int index = 0; index < 2; ++index) {
             if ((t = SkDLine::ExactPointV(line[index], top, bottom, x)) >= 0) {
                 insert((double) index, flipped ? 1 - t : t, line[index]);
             }
         }
     }
     int result = vertical_coincident(line, x);
     if (result == 1 && fUsed == 0) {
-        fT[0][0] = vertical_intercept(line, x);
+        fT[0][0] = VerticalIntercept(line, x);
         double yIntercept = line[0].fY + fT[0][0] * (line[1].fY - line[0].fY);
         if (between(top, yIntercept, bottom)) {
             fT[1][0] = (yIntercept - top) / (bottom - top);
             if (flipped) {
                 // OPTIMIZATION: instead of swapping, pass original line, use [1].fY - [0].fY
                 for (int index = 0; index < result; ++index) {
                     fT[1][index] = 1 - fT[1][index];
                 }
             }
             fPt[0].fX = x;
@@ skipping 15 matching lines @@
                     insert((double) index, flipped ? 1 - t : t, line[index]);
                 }
             }
         }
     }
     cleanUpParallelLines(result == 2);
     SkASSERT(fUsed <= 2);
     return fUsed;
 }