| /* |
| * 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* oneOffTests[] = { |
| oneOffTest1, |
| oneOffTest2, |
| oneOffTest3, |
| }; |
| |
| 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__); |
| } |
| |
| 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; |
| } |
| } |