remove prototype pathops code

experimental/Intersection/SimplifyAngle_Test.cpp

Index: experimental/Intersection/SimplifyAngle_Test.cpp
diff --git a/experimental/Intersection/SimplifyAngle_Test.cpp b/experimental/Intersection/SimplifyAngle_Test.cpp
deleted file mode 100644
index e83a52f650f5aae92cc9215a7f58a8ca083186cc..0000000000000000000000000000000000000000
--- a/experimental/Intersection/SimplifyAngle_Test.cpp
+++ /dev/null
@@ -1,342 +0,0 @@
-/*
- * 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 "Simplify.h"
-
-namespace SimplifyAngleTest {
-
-#include "Simplify.cpp"
-
-} // end of SimplifyAngleTest namespace
-
-#include "Intersection_Tests.h"
-
-static const SkPoint lines[][2] = {
-    { { 10,  10}, { 10,  20} },
-    { { 10,  10}, { 20,  10} },
-    { { 10,  10}, {-20,  10} },
-    { { 10,  10}, { 10, -20} },
-    { { 10,  10}, { 20,  20} },
-    { { 10,  10}, {-20, -20} },
-    { { 10,  10}, {-20,  40} },
-    { { 10,  10}, { 40, -20} }
-};
-
-static const size_t lineCount = sizeof(lines) / sizeof(lines[0]);
-
-static const SkPoint quads[][3] = {
-    {{ 1,  1}, { 2,  2}, { 1,  3}}, // 0
-    {{ 1,  1}, { 3,  3}, { 1,  5}}, // 1
-    {{ 1,  1}, { 4,  4}, { 1,  7}}, // 2
-    {{ 1,  1}, { 5,  5}, { 9,  9}}, // 3
-    {{ 1,  1}, { 4,  4}, { 7,  1}}, // 4
-    {{ 1,  1}, { 3,  3}, { 5,  1}}, // 5
-    {{ 1,  1}, { 2,  2}, { 3,  1}}, // 6
-};
-
-static const size_t quadCount = sizeof(quads) / sizeof(quads[0]);
-
-static const SkPoint cubics[][4] = {
-    {{ 1,  1}, { 2,  2}, { 2,  3}, { 1,  4}},
-    {{ 1,  1}, { 3,  3}, { 3,  5}, { 1,  7}},
-    {{ 1,  1}, { 4,  4}, { 4,  7}, { 1,  10}},
-    {{ 1,  1}, { 5,  5}, { 8,  8}, { 9,  9}},
-    {{ 1,  1}, { 4,  4}, { 7,  4}, { 10, 1}},
-    {{ 1,  1}, { 3,  3}, { 5,  3}, { 7,  1}},
-    {{ 1,  1}, { 2,  2}, { 3,  2}, { 4,  1}},
-};
-
-static const size_t cubicCount = sizeof(cubics) / sizeof(cubics[0]);
-
-struct segment {
-    SkPath::Verb verb;
-    SkPoint pts[4];
-};
-
-static const segment segmentTest1[] = {
-    {SkPath::kLine_Verb, {{2, 1}, {1, 0}        }},
-    {SkPath::kQuad_Verb, {{2, 1}, {1, 0}, {0, 0}}},
-    {SkPath::kQuad_Verb, {{2, 1}, {3, 2}, {2, 3}}},
-    {SkPath::kLine_Verb, {{2, 1}, {3, 2}        }},
-    {SkPath::kMove_Verb                          }
-};
-
-static const segment segmentTest2[] = {
-    {SkPath::kLine_Verb, {{1, 0}, {0, 0}        }},
-    {SkPath::kQuad_Verb, {{1, 0}, {1.89897954f, 0.898979485f}, {2.39387703f, 1.59591794f}}},
-    {SkPath::kLine_Verb, {{1, 0}, {3, 2}        }},
-    {SkPath::kMove_Verb                          }
-};
-
-static const segment segmentTest3[] = {
-    {SkPath::kQuad_Verb, {{0, 0}, {2, 0}, {0, 1}}},
-    {SkPath::kQuad_Verb, {{0, 0}, {1, 0}, {0, 1}}},
-    {SkPath::kMove_Verb                          }
-};
-
-static const segment* segmentTests[] = {
-    segmentTest3,
-    segmentTest2,
-    segmentTest1,
-};
-
-static const size_t segmentTestCount = sizeof(segmentTests) / sizeof(segmentTests[0]);
-
-static void testSegments(bool testFlat) {
-    for (size_t testIndex = 0; testIndex < segmentTestCount; ++testIndex) {
-        const segment* segPtr = segmentTests[testIndex];
-        SimplifyAngleTest::Angle lesser, greater;
-        int index = 0;
-        do {
-            int next = index + 1;
-            SkTDArray<SimplifyAngleTest::Span> dummy;
-            lesser.set(segPtr[index].pts, segPtr[index].verb, NULL, index, next, dummy);
-            if (segPtr[next].verb == SkPath::kMove_Verb) {
-                break;
-            }
-            greater.set(segPtr[next].pts, segPtr[next].verb, NULL, index, next, dummy);
-            bool result = lesser < greater;
-            SkASSERT(result);
-            index = next;
-        } while (true);
-    }
-}
-
-static void testLines(bool testFlat) {
-    // create angles in a circle
-    SkTDArray<SimplifyAngleTest::Angle> angles;
-    SkTDArray<SimplifyAngleTest::Angle* > angleList;
-    SkTDArray<double> arcTans;
-    size_t x;
-    for (x = 0; x < lineCount; ++x) {
-        SimplifyAngleTest::Angle* angle = angles.append();
-        SkTDArray<SimplifyAngleTest::Span> dummy;
-        angle->set(lines[x], SkPath::kLine_Verb, 0, x, x + 1, dummy);
-        double arcTan = atan2(lines[x][0].fX - lines[x][1].fX,
-                lines[x][0].fY - lines[x][1].fY);
-        arcTans.push(arcTan);
-    }
-    for (x = 0; x < lineCount; ++x) {
-        angleList.push(&angles[x]);
-    }
-    QSort<SimplifyAngleTest::Angle>(angleList.begin(), angleList.end() - 1);
-    bool first = true;
-    bool wrap = false;
-    double base, last;
-    for (size_t x = 0; x < lineCount; ++x) {
-        const SimplifyAngleTest::Angle* angle = angleList[x];
-        int span = angle->start();
-//        SkDebugf("%s [%d] %1.9g (%1.9g,%1.9g %1.9g,%1.9g)\n", __FUNCTION__,
-//                span, arcTans[span], lines[span][0].fX, lines[span][0].fY,
-//                lines[span][1].fX, lines[span][1].fY);
-        if (first) {
-            base = last = arcTans[span];
-            first = false;
-            continue;
-        }
-        if (last < arcTans[span]) {
-            last = arcTans[span];
-            continue;
-        }
-        if (!wrap) {
-            if (base < arcTans[span]) {
-                SkDebugf("%s !wrap [%d] %g\n", __FUNCTION__, span, arcTans[span]);
-                SkASSERT(0);
-            }
-            last = arcTans[span];
-            wrap = true;
-            continue;
-        }
-        SkDebugf("%s wrap [%d] %g\n", __FUNCTION__, span, arcTans[span]);
-        SkASSERT(0);
-    }
-}
-
-static void testQuads(bool testFlat) {
-    SkTDArray<SimplifyAngleTest::Angle> angles;
-    SkTDArray<SimplifyAngleTest::Angle* > angleList;
-    size_t x;
-    for (x = 0; x < quadCount; ++x) {
-        SimplifyAngleTest::Angle* angle = angles.append();
-        SkTDArray<SimplifyAngleTest::Span> dummy;
-        angle->set(quads[x], SkPath::kQuad_Verb, 0, x, x + 1, dummy);
-   }
-    for (x = 0; x < quadCount; ++x) {
-        angleList.push(&angles[x]);
-    }
-    QSort<SimplifyAngleTest::Angle>(angleList.begin(), angleList.end() - 1);
-    for (size_t x = 0; x < quadCount; ++x) {
-        *angleList[x] < *angleList[x + 1];
-        SkASSERT(x == quadCount - 1 || *angleList[x] < *angleList[x + 1]);
-        const SimplifyAngleTest::Angle* angle = angleList[x];
-        if ((int) x != angle->start()) {
-            SkDebugf("%s [%d] [%d]\n", __FUNCTION__, x, angle->start());
-            SkASSERT(0);
-        }
-    }
-}
-
-static void testCubics(bool testFlat) {
-    SkTDArray<SimplifyAngleTest::Angle> angles;
-    SkTDArray<SimplifyAngleTest::Angle* > angleList;
-    for (size_t x = 0; x < cubicCount; ++x) {
-        SimplifyAngleTest::Angle* angle = angles.append();
-            SkTDArray<SimplifyAngleTest::Span> dummy;
-        angle->set(cubics[x], SkPath::kCubic_Verb, 0, x, x + 1, dummy);
-        angleList.push(angle);
-    }
-    QSort<SimplifyAngleTest::Angle>(angleList.begin(), angleList.end() - 1);
-    for (size_t x = 0; x < cubicCount; ++x) {
-        const SimplifyAngleTest::Angle* angle = angleList[x];
-        if ((int) x != angle->start()) {
-            SkDebugf("%s [%d] [%d]\n", __FUNCTION__, x, angle->start());
-            SkASSERT(0);
-        }
-    }
-}
-
-struct segmentWithT {
-    SkPath::Verb verb;
-    SkPoint pts[4];
-    double ts[2];
-};
-
-
-static const segmentWithT oneOffTest1[] = {
-    {SkPath::kQuad_Verb, {{391.653534f, 183.286819f}, {391.653534f, 157.724487f}, {405.469604f, 141.372879f}},
-        {0.62346946335026932, 0.62344389027237135}},
-    {SkPath::kQuad_Verb, {{399.365234f, 171.695801f}, {399.365234f, 140.337967f}, {375.976227f, 140.337967f}},
-        {0.31638302676995866, 0.31637992418411398}},
-    {SkPath::kMove_Verb }
-};
-
-static const segmentWithT oneOffTest2[] = {
-    {SkPath::kQuad_Verb, {{399.070374f, 151.722f}, {391.101532f, 163.002533f}, {391.101532f, 182.665863f}},
-        {0.13793711854916513, 0.13790171160614006}},
-    {SkPath::kQuad_Verb, {{391.653534f, 183.286819f}, {391.653534f, 157.724487f}, {405.469604f, 141.372879f}},
-        {0.62344389027237135, 0.62346946335026932}},
-    {SkPath::kMove_Verb }
-};
-
-static const segmentWithT oneOffTest3[] = {
-    {SkPath::kQuad_Verb, {{399.365234f, 171.695801f}, {399.365234f, 140.337967f}, {375.976227f, 140.337967f}},
-        {0.31637992418411398, 0.31638302676995866, }},
-    {SkPath::kQuad_Verb, {{399.070374f, 151.722f}, {391.101532f, 163.002533f}, {391.101532f, 182.665863f}},
-        {0.13790171160614006, 0.13793711854916513}},
-    {SkPath::kMove_Verb }
-};
-
-static const segmentWithT oneOffTest4[] = {
-    {SkPath::kCubic_Verb, {{1,2}, {1,3}, {1,0}, {5,3}}, {0.134792, 0}},
-    {SkPath::kCubic_Verb, {{0,1}, {3,5}, {2,1}, {3,1}}, {0.134792094, 0}},
-    {SkPath::kCubic_Verb, {{0,1}, {3,5}, {2,1}, {3,1}}, {0.134792094, 0.551812363}},
-    {SkPath::kCubic_Verb, {{1,2}, {1,3}, {1,0}, {5,3}}, {0.134792, 0.333333333}},
-    {SkPath::kMove_Verb }
-};
-
-static const segmentWithT* oneOffTests[] = {
-    oneOffTest1,
-    oneOffTest2,
-    oneOffTest3,
-    oneOffTest4,
-};
-
-static const size_t oneOffTestCount = sizeof(oneOffTests) / sizeof(oneOffTests[0]);
-
-static void oneOffTest(bool testFlat) {
-    for (size_t testIndex = 0; testIndex < oneOffTestCount; ++testIndex) {
-        const segmentWithT* segPtr = oneOffTests[testIndex];
-        SimplifyAngleTest::Angle lesser, greater;
-        int index = 0;
-        do {
-            int next = index + 1;
-            SkTDArray<SimplifyAngleTest::Span> dummy; // FIXME
-            lesser.set(segPtr[index].pts, segPtr[index].verb, 0, index, next, dummy); // FIXME: segPtr[index].ts[0], segPtr[index].ts[1]);
-            if (segPtr[next].verb == SkPath::kMove_Verb) {
-                break;
-            }
-            greater.set(segPtr[next].pts, segPtr[next].verb, 0, index, next, dummy); // FIXME: segPtr[next].ts[0], segPtr[next].ts[1]);
-            bool result = lesser < greater;
-            SkASSERT(result);
-            index = next;
-        } while (true);
-    }
-    SkDebugf("%s finished\n", __FUNCTION__);
-}
-
-#if 0 // seems too complicated for this to be useful (didn't finish writing/debugging this)
-// this (trys to) take a pair of curves, construct segments/spans, and verify that they sort correctly
-static void oneOffTestNew() {
-    const segmentWithT* segPtr = oneOffTest4;
-    SimplifyAngleTest::Segment segOne, segTwo;
-    segOne.init(segPtr[0].pts, segPtr[0].verb, false, false);
-    segTwo.init(segPtr[1].pts, segPtr[1].verb, false, false);
-    int index = 0;
-    do {
-        int next = index + 1;
-        if (segPtr[index].verb == SkPath::kMove_Verb) {
-            break;
-        }
-        SkPoint sub[4];
-        (*SegmentSubDivide[segPtr[index].verb])(segPtr[index].pts, segPtr[index].ts[0],
-                segPtr[index].ts[1], sub);
-        if (memcmp(segPtr[index].pts, segPtr[0].pts, sizeof(SkPoint) * (segPtr[index].verb + 1) == 0) {
-            segOne.addT(&segTwo, sub[0], segPtr[index].ts[0]);
-            segOne.addT(&segTwo, sub[segPtr[index].verb], segPtr[index].ts[1]);
-        } else {
-            segTwo.addT(&segOne, sub[0], segPtr[index].ts[0]);
-            segTwo.addT(&v, sub[segPtr[index].verb], segPtr[index].ts[1]);
-        }
-    } while (true);
-    SimplifyAngleTest::Angle lesser, greater;
-    do {
-        int next = index + 1;
-        if (segPtr[next].verb == SkPath::kMove_Verb) {
-            break;
-        }
-        SkPoint one[4], two[4];
-        bool use1 = memcmp(segPtr[index].pts, segPtr[0].pts, sizeof(SkPoint) * (segPtr[index].verb + 1) == 0;
-        lesser.set(segPtr[index].pts, segPtr[index].verb, use1 ? &segOne : &segTwo, index, next, dummy);
-        use1 = memcmp(segPtr[next].pts, segPtr[0].pts, sizeof(SkPoint) * (segPtr[next].verb + 1) == 0;
-        greater.set(segPtr[next].pts, segPtr[next].verb, use1 ? &segOne : &segTwo, index, next, dummy);
-        bool result = lesser < greater;
-        SkASSERT(result);
-        index = next;
-    } while (true);
-    SkDebugf("%s finished\n", __FUNCTION__);
-}
-#endif
-
-static void (*tests[])(bool) = {
-    oneOffTest,
-    testSegments,
-    testLines,
-    testQuads,
-    testCubics
-};
-
-static const size_t testCount = sizeof(tests) / sizeof(tests[0]);
-
-static void (*firstTest)(bool) = 0;
-static bool skipAll = false;
-
-void SimplifyAngle_Test() {
-    if (skipAll) {
-        return;
-    }
-    size_t index = 0;
-    if (firstTest) {
-        while (index < testCount && tests[index] != firstTest) {
-            ++index;
-        }
-    }
-    bool firstTestComplete = false;
-    for ( ; index < testCount; ++index) {
-        (*tests[index])(false); // set to true to exercise setFlat
-        firstTestComplete = true;
-    }
-}