remove unused SkXRay functions

src/core/SkGeometry.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGeometry.h"
 #include "SkMatrix.h"
 
-bool SkXRayCrossesLine(const SkXRay& pt,
-                       const SkPoint pts[2],
-                       bool* ambiguous) {
-    if (ambiguous) {
-        *ambiguous = false;
-    }
-    // Determine quick discards.
-    // Consider query line going exactly through point 0 to not
-    // intersect, for symmetry with SkXRayCrossesMonotonicCubic.
-    if (pt.fY == pts[0].fY) {
-        if (ambiguous) {
-            *ambiguous = true;
-        }
-        return false;
-    }
-    if (pt.fY < pts[0].fY && pt.fY < pts[1].fY)
-        return false;
-    if (pt.fY > pts[0].fY && pt.fY > pts[1].fY)
-        return false;
-    if (pt.fX > pts[0].fX && pt.fX > pts[1].fX)
-        return false;
-    // Determine degenerate cases
-    if (SkScalarNearlyZero(pts[0].fY - pts[1].fY))
-        return false;
-    if (SkScalarNearlyZero(pts[0].fX - pts[1].fX)) {
-        // We've already determined the query point lies within the
-        // vertical range of the line segment.
-        if (pt.fX <= pts[0].fX) {
-            if (ambiguous) {
-                *ambiguous = (pt.fY == pts[1].fY);
-            }
-            return true;
-        }
-        return false;
-    }
-    // Ambiguity check
-    if (pt.fY == pts[1].fY) {
-        if (pt.fX <= pts[1].fX) {
-            if (ambiguous) {
-                *ambiguous = true;
-            }
-            return true;
-        }
-        return false;
-    }
-    // Full line segment evaluation
-    SkScalar delta_y = pts[1].fY - pts[0].fY;
-    SkScalar delta_x = pts[1].fX - pts[0].fX;
-    SkScalar slope = SkScalarDiv(delta_y, delta_x);
-    SkScalar b = pts[0].fY - SkScalarMul(slope, pts[0].fX);
-    // Solve for x coordinate at y = pt.fY
-    SkScalar x = SkScalarDiv(pt.fY - b, slope);
-    return pt.fX <= x;
-}
-
 /** If defined, this makes eval_quad and eval_cubic do more setup (sometimes
     involving integer multiplies by 2 or 3, but fewer calls to SkScalarMul.
     May also introduce overflow of fixed when we compute our setup.
 */
 //    #define DIRECT_EVAL_OF_POLYNOMIALS
 
 ////////////////////////////////////////////////////////////////////////
 
 static int is_not_monotonic(SkScalar a, SkScalar b, SkScalar c) {
     SkScalar ab = a - b;
@@ skipping 866 matching lines @@
     if (dst) {
         if (count == 0) {
             memcpy(dst, src, 4 * sizeof(SkPoint));
         } else {
             SkChopCubicAt(src, dst, tValues, count);
         }
     }
     return count + 1;
 }
 
-bool SkXRayCrossesMonotonicCubic(const SkXRay& pt, const SkPoint cubic[4],
-                                 bool* ambiguous) {
-    if (ambiguous) {
-        *ambiguous = false;
-    }
-
-    // Find the minimum and maximum y of the extrema, which are the
-    // first and last points since this cubic is monotonic
-    SkScalar min_y = SkMinScalar(cubic[0].fY, cubic[3].fY);
-    SkScalar max_y = SkMaxScalar(cubic[0].fY, cubic[3].fY);
-
-    if (pt.fY == cubic[0].fY
-        || pt.fY < min_y
-        || pt.fY > max_y) {
-        // The query line definitely does not cross the curve
-        if (ambiguous) {
-            *ambiguous = (pt.fY == cubic[0].fY);
-        }
-        return false;
-    }
-
-    bool pt_at_extremum = (pt.fY == cubic[3].fY);
-
-    SkScalar min_x =
-        SkMinScalar(
-            SkMinScalar(
-                SkMinScalar(cubic[0].fX, cubic[1].fX),
-                cubic[2].fX),
-            cubic[3].fX);
-    if (pt.fX < min_x) {
-        // The query line definitely crosses the curve
-        if (ambiguous) {
-            *ambiguous = pt_at_extremum;
-        }
-        return true;
-    }
-
-    SkScalar max_x =
-        SkMaxScalar(
-            SkMaxScalar(
-                SkMaxScalar(cubic[0].fX, cubic[1].fX),
-                cubic[2].fX),
-            cubic[3].fX);
-    if (pt.fX > max_x) {
-        // The query line definitely does not cross the curve
-        return false;
-    }
-
-    // Do a binary search to find the parameter value which makes y as
-    // close as possible to the query point. See whether the query
-    // line's origin is to the left of the associated x coordinate.
-
-    // kMaxIter is chosen as the number of mantissa bits for a float,
-    // since there's no way we are going to get more precision by
-    // iterating more times than that.
-    const int kMaxIter = 23;
-    SkPoint eval;
-    int iter = 0;
-    SkScalar upper_t;
-    SkScalar lower_t;
-    // Need to invert direction of t parameter if cubic goes up
-    // instead of down
-    if (cubic[3].fY > cubic[0].fY) {
-        upper_t = SK_Scalar1;
-        lower_t = 0;
-    } else {
-        upper_t = 0;
-        lower_t = SK_Scalar1;
-    }
-    do {
-        SkScalar t = SkScalarAve(upper_t, lower_t);
-        SkEvalCubicAt(cubic, t, &eval, NULL, NULL);
-        if (pt.fY > eval.fY) {
-            lower_t = t;
-        } else {
-            upper_t = t;
-        }
-    } while (++iter < kMaxIter
-             && !SkScalarNearlyZero(eval.fY - pt.fY));
-    if (pt.fX <= eval.fX) {
-        if (ambiguous) {
-            *ambiguous = pt_at_extremum;
-        }
-        return true;
-    }
-    return false;
-}
-
-int SkNumXRayCrossingsForCubic(const SkXRay& pt,
-                               const SkPoint cubic[4],
-                               bool* ambiguous) {
-    int num_crossings = 0;
-    SkPoint monotonic_cubics[10];
-    int num_monotonic_cubics = SkChopCubicAtYExtrema(cubic, monotonic_cubics);
-    if (ambiguous) {
-        *ambiguous = false;
-    }
-    bool locally_ambiguous;
-    if (SkXRayCrossesMonotonicCubic(pt,
-                                    &monotonic_cubics[0],
-                                    &locally_ambiguous))
-        ++num_crossings;
-    if (ambiguous) {
-        *ambiguous |= locally_ambiguous;
-    }
-    if (num_monotonic_cubics > 0)
-        if (SkXRayCrossesMonotonicCubic(pt,
-                                        &monotonic_cubics[3],
-                                        &locally_ambiguous))
-            ++num_crossings;
-    if (ambiguous) {
-        *ambiguous |= locally_ambiguous;
-    }
-    if (num_monotonic_cubics > 1)
-        if (SkXRayCrossesMonotonicCubic(pt,
-                                        &monotonic_cubics[6],
-                                        &locally_ambiguous))
-            ++num_crossings;
-    if (ambiguous) {
-        *ambiguous |= locally_ambiguous;
-    }
-    return num_crossings;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /*  Find t value for quadratic [a, b, c] = d.
     Return 0 if there is no solution within [0, 1)
 */
 static SkScalar quad_solve(SkScalar a, SkScalar b, SkScalar c, SkScalar d) {
     // At^2 + Bt + C = d
     SkScalar A = a - 2 * b + c;
     SkScalar B = 2 * (b - a);
     SkScalar C = a - d;
@@ skipping 575 matching lines @@
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     for (int i = 0; i < conicCount; ++i) {
         matrix.mapPoints(dst[i].fPts, 3);
     }
     return conicCount;
 }