summaryrefslogtreecommitdiffstats
path: root/chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp')
-rw-r--r--chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp469
1 files changed, 469 insertions, 0 deletions
diff --git a/chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp b/chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp
new file mode 100644
index 00000000000..5f1b7f876be
--- /dev/null
+++ b/chromium/third_party/skia/experimental/Intersection/EdgeWalkerRectangles_Test.cpp
@@ -0,0 +1,469 @@
+/*
+ * 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 "EdgeWalker_Test.h"
+#include "Intersection_Tests.h"
+#include "SkBitmap.h"
+
+static SkBitmap bitmap;
+
+static void testSimplifyCoincidentInner() {
+ SkPath path, out;
+ path.setFillType(SkPath::kWinding_FillType);
+ path.addRect(10, 10, 60, 60, SkPath::kCCW_Direction);
+ path.addRect(20, 20, 50, 50, SkPath::kCW_Direction);
+ path.addRect(20, 30, 40, 40, SkPath::kCW_Direction);
+ testSimplify(path, true, out, bitmap);
+}
+
+static void testSimplifyCoincidentVertical() {
+ SkPath path, out;
+ path.setFillType(SkPath::kWinding_FillType);
+ path.addRect(10, 10, 30, 30);
+ path.addRect(10, 30, 30, 40);
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 30, 40)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyCoincidentHorizontal() {
+ SkPath path, out;
+ path.setFillType(SkPath::kWinding_FillType);
+ path.addRect(10, 10, 30, 30);
+ path.addRect(30, 10, 40, 30);
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 40, 30)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyMulti() {
+ SkPath path, out;
+ path.setFillType(SkPath::kWinding_FillType);
+ path.addRect(10, 10, 30, 30);
+ path.addRect(20, 20, 40, 40);
+ simplify(path, true, out);
+ SkPath expected;
+ expected.setFillType(SkPath::kEvenOdd_FillType);
+ expected.moveTo(10,10); // two cutout corners
+ expected.lineTo(10,30);
+ expected.lineTo(20,30);
+ expected.lineTo(20,40);
+ expected.lineTo(40,40);
+ expected.lineTo(40,20);
+ expected.lineTo(30,20);
+ expected.lineTo(30,10);
+ expected.lineTo(10,10);
+ expected.close();
+ if (out != expected) {
+ SkDebugf("%s expected equal\n", __FUNCTION__);
+ }
+
+ path = out;
+ path.addRect(30, 10, 40, 20);
+ path.addRect(10, 30, 20, 40);
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 40, 40)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+
+ path = out;
+ path.addRect(10, 10, 40, 40, SkPath::kCCW_Direction);
+ simplify(path, true, out);
+ if (!out.isEmpty()) {
+ SkDebugf("%s expected empty\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyAddL() {
+ SkPath path, out;
+ path.moveTo(10,10); // 'L' shape
+ path.lineTo(10,40);
+ path.lineTo(40,40);
+ path.lineTo(40,20);
+ path.lineTo(30,20);
+ path.lineTo(30,10);
+ path.lineTo(10,10);
+ path.close();
+ path.addRect(30, 10, 40, 20); // missing notch of 'L'
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 40, 40)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyCoincidentCCW() {
+ SkPath path, out;
+ path.addRect(10, 10, 40, 40, SkPath::kCCW_Direction);
+ path.addRect(10, 10, 40, 40, SkPath::kCCW_Direction);
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 40, 40)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyCoincidentCW() {
+ SkPath path, out;
+ path.addRect(10, 10, 40, 40, SkPath::kCCW_Direction);
+ path.addRect(10, 10, 40, 40, SkPath::kCW_Direction);
+ simplify(path, true, out);
+ if (!out.isEmpty()) {
+ SkDebugf("%s expected empty\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyCorner() {
+ SkPath path, out;
+ path.addRect(10, 10, 20, 20, SkPath::kCCW_Direction);
+ path.addRect(20, 20, 40, 40, SkPath::kCW_Direction);
+ simplify(path, true, out);
+ SkTDArray<SkRect> boundsArray;
+ contourBounds(out, boundsArray);
+ if (boundsArray.count() != 2) {
+ SkDebugf("%s expected 2 contours\n", __FUNCTION__);
+ return;
+ }
+ SkRect one = SkRect::MakeLTRB(10, 10, 20, 20);
+ SkRect two = SkRect::MakeLTRB(20, 20, 40, 40);
+ if ((boundsArray[0] != one && boundsArray[0] != two)
+ || (boundsArray[1] != one && boundsArray[1] != two)) {
+ SkDebugf("%s expected match\n", __FUNCTION__);
+ }
+}
+
+static void testSimplifyDiagonal() {
+ SkRect rect2 = SkRect::MakeXYWH(10, 10, 10, 10);
+ for (size_t outDir = SkPath::kCW_Direction; outDir <= SkPath::kCCW_Direction; ++outDir) {
+ for (size_t inDir = SkPath::kCW_Direction; inDir <= SkPath::kCCW_Direction; ++inDir) {
+ for (int x = 0; x <= 20; x += 20) {
+ for (int y = 0; y <= 20; y += 20) {
+ SkPath path, out;
+ SkRect rect1 = SkRect::MakeXYWH(x, y, 10, 10);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ SkPath::Iter iter(out, false);
+ SkPoint pts[4], lastLine[2];
+ SkPath::Verb verb;
+ SkRect bounds[2];
+ bounds[0].setEmpty();
+ bounds[1].setEmpty();
+ SkRect* boundsPtr = bounds;
+ int count = 0, segments = 0;
+ bool lastLineSet = false;
+ while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kMove_Verb:
+ if (!boundsPtr->isEmpty()) {
+ SkASSERT(boundsPtr == bounds);
+ ++boundsPtr;
+ }
+ boundsPtr->set(pts[0].fX, pts[0].fY, pts[0].fX, pts[0].fY);
+ count = 0;
+ lastLineSet = false;
+ break;
+ case SkPath::kLine_Verb:
+ if (lastLineSet) {
+ SkASSERT((lastLine[1].fX - lastLine[0].fX) *
+ (pts[1].fY - lastLine[0].fY) !=
+ (lastLine[1].fY - lastLine[0].fY) *
+ (pts[1].fX - lastLine[0].fX));
+ }
+ lastLineSet = true;
+ lastLine[0] = pts[0];
+ lastLine[1] = pts[1];
+ count = 1;
+ ++segments;
+ break;
+ case SkPath::kClose_Verb:
+ count = 0;
+ break;
+ default:
+ SkDEBUGFAIL("bad verb");
+ return;
+ }
+ for (int i = 1; i <= count; ++i) {
+ boundsPtr->growToInclude(pts[i].fX, pts[i].fY);
+ }
+ }
+ if (boundsPtr != bounds) {
+ SkASSERT((bounds[0] == rect1 || bounds[1] == rect1)
+ && (bounds[0] == rect2 || bounds[1] == rect2));
+ } else {
+ SkASSERT(segments == 8);
+ }
+ }
+ }
+ }
+ }
+}
+
+static void assertOneContour(const SkPath& out, bool edge, bool extend) {
+ SkPath::Iter iter(out, false);
+ SkPoint pts[4];
+ SkPath::Verb verb;
+ SkRect bounds;
+ bounds.setEmpty();
+ int count = 0;
+ while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+ switch (verb) {
+ case SkPath::kMove_Verb:
+ SkASSERT(count == 0);
+ break;
+ case SkPath::kLine_Verb:
+ SkASSERT(pts[0].fX == pts[1].fX || pts[0].fY == pts[1].fY);
+ ++count;
+ break;
+ case SkPath::kClose_Verb:
+ break;
+ default:
+ SkDEBUGFAIL("bad verb");
+ return;
+ }
+ }
+ SkASSERT(count == (extend ? 4 : edge ? 6 : 8));
+}
+
+static void testSimplifyCoincident() {
+ // outside to inside, outside to right, outside to outside
+ // left to inside, left to right, left to outside
+ // inside to right, inside to outside
+ // repeat above for left, right, bottom
+ SkScalar start[] = { 0, 10, 20 };
+ size_t startCount = sizeof(start) / sizeof(start[0]);
+ SkScalar stop[] = { 30, 40, 50 };
+ size_t stopCount = sizeof(stop) / sizeof(stop[0]);
+ SkRect rect2 = SkRect::MakeXYWH(10, 10, 30, 30);
+ for (size_t outDir = SkPath::kCW_Direction; outDir <= SkPath::kCCW_Direction; ++outDir) {
+ for (size_t inDir = SkPath::kCW_Direction; inDir <= SkPath::kCCW_Direction; ++inDir) {
+ for (size_t startIndex = 0; startIndex < startCount; ++startIndex) {
+ for (size_t stopIndex = 0; stopIndex < stopCount; ++stopIndex) {
+ bool extend = start[startIndex] == rect2.fLeft && stop[stopIndex] == rect2.fRight;
+ bool edge = start[startIndex] == rect2.fLeft || stop[stopIndex] == rect2.fRight;
+ SkRect rect1 = SkRect::MakeLTRB(start[startIndex], 0, stop[stopIndex], 10);
+ SkPath path, out;
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ assertOneContour(out, edge, extend);
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(start[startIndex], 40, stop[stopIndex], 50);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ assertOneContour(out, edge, extend);
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(0, start[startIndex], 10, stop[stopIndex]);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ assertOneContour(out, edge, extend);
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(40, start[startIndex], 50, stop[stopIndex]);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ assertOneContour(out, edge, extend);
+ }
+ }
+ }
+ }
+}
+
+static void testSimplifyOverlap() {
+ SkScalar start[] = { 0, 10, 20 };
+ size_t startCount = sizeof(start) / sizeof(start[0]);
+ SkScalar stop[] = { 30, 40, 50 };
+ size_t stopCount = sizeof(stop) / sizeof(stop[0]);
+ SkRect rect2 = SkRect::MakeXYWH(10, 10, 30, 30);
+ for (size_t dir = SkPath::kCW_Direction; dir <= SkPath::kCCW_Direction; ++dir) {
+ for (size_t lefty = 0; lefty < startCount; ++lefty) {
+ for (size_t righty = 0; righty < stopCount; ++righty) {
+ for (size_t toppy = 0; toppy < startCount; ++toppy) {
+ for (size_t botty = 0; botty < stopCount; ++botty) {
+ SkRect rect1 = SkRect::MakeLTRB(start[lefty], start[toppy],
+ stop[righty], stop[botty]);
+ SkPath path, out;
+ path.addRect(rect1, static_cast<SkPath::Direction>(dir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(dir));
+ testSimplify(path, true, out, bitmap);
+ }
+ }
+ }
+ }
+ }
+}
+
+static void testSimplifyOverlapTiny() {
+ SkScalar start[] = { 0, 1, 2 };
+ size_t startCount = sizeof(start) / sizeof(start[0]);
+ SkScalar stop[] = { 3, 4, 5 };
+ size_t stopCount = sizeof(stop) / sizeof(stop[0]);
+ SkRect rect2 = SkRect::MakeXYWH(1, 1, 3, 3);
+ for (size_t dir = SkPath::kCW_Direction; dir <= SkPath::kCCW_Direction; ++dir) {
+ for (size_t lefty = 0; lefty < startCount; ++lefty) {
+ for (size_t righty = 0; righty < stopCount; ++righty) {
+ for (size_t toppy = 0; toppy < startCount; ++toppy) {
+ for (size_t botty = 0; botty < stopCount; ++botty) {
+ SkRect rect1 = SkRect::MakeLTRB(start[lefty], start[toppy],
+ stop[righty], stop[botty]);
+ SkPath path, out;
+ path.addRect(rect1, static_cast<SkPath::Direction>(dir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(dir));
+ simplify(path, true, out);
+ comparePathsTiny(path, out);
+ }
+ }
+ }
+ }
+ }
+}
+
+static void testSimplifyDegenerate() {
+ SkScalar start[] = { 0, 10, 20 };
+ size_t startCount = sizeof(start) / sizeof(start[0]);
+ SkScalar stop[] = { 30, 40, 50 };
+ size_t stopCount = sizeof(stop) / sizeof(stop[0]);
+ SkRect rect2 = SkRect::MakeXYWH(10, 10, 30, 30);
+ for (size_t outDir = SkPath::kCW_Direction; outDir <= SkPath::kCCW_Direction; ++outDir) {
+ for (size_t inDir = SkPath::kCW_Direction; inDir <= SkPath::kCCW_Direction; ++inDir) {
+ for (size_t startIndex = 0; startIndex < startCount; ++startIndex) {
+ for (size_t stopIndex = 0; stopIndex < stopCount; ++stopIndex) {
+ SkRect rect1 = SkRect::MakeLTRB(start[startIndex], 0, stop[stopIndex], 0);
+ SkPath path, out;
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s 1 expected rect\n", __FUNCTION__);
+ }
+ if (rect != rect2) {
+ SkDebugf("%s 1 expected union\n", __FUNCTION__);
+ }
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(start[startIndex], 40, stop[stopIndex], 40);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s 2 expected rect\n", __FUNCTION__);
+ }
+ if (rect != rect2) {
+ SkDebugf("%s 2 expected union\n", __FUNCTION__);
+ }
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(0, start[startIndex], 0, stop[stopIndex]);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s 3 expected rect\n", __FUNCTION__);
+ }
+ if (rect != rect2) {
+ SkDebugf("%s 3 expected union\n", __FUNCTION__);
+ }
+
+ path.reset();
+ rect1 = SkRect::MakeLTRB(40, start[startIndex], 40, stop[stopIndex]);
+ path.addRect(rect1, static_cast<SkPath::Direction>(outDir));
+ path.addRect(rect2, static_cast<SkPath::Direction>(inDir));
+ simplify(path, true, out);
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s 4 expected rect\n", __FUNCTION__);
+ }
+ if (rect != rect2) {
+ SkDebugf("%s 4 expected union\n", __FUNCTION__);
+ }
+ }
+ }
+ }
+ }
+}
+
+static void testSimplifyDegenerate1() {
+ SkPath path, out;
+ path.setFillType(SkPath::kWinding_FillType);
+ path.addRect( 0, 0, 0, 30);
+ path.addRect(10, 10, 40, 40);
+ simplify(path, true, out);
+ SkRect rect;
+ if (!out.isRect(&rect)) {
+ SkDebugf("%s expected rect\n", __FUNCTION__);
+ }
+ if (rect != SkRect::MakeLTRB(10, 10, 40, 40)) {
+ SkDebugf("%s expected union\n", __FUNCTION__);
+ }
+}
+
+static void (*simplifyTests[])() = {
+ testSimplifyCoincidentInner,
+ testSimplifyOverlapTiny,
+ testSimplifyDegenerate1,
+ testSimplifyCorner,
+ testSimplifyDegenerate,
+ testSimplifyOverlap,
+ testSimplifyDiagonal,
+ testSimplifyCoincident,
+ testSimplifyCoincidentCW,
+ testSimplifyCoincidentCCW,
+ testSimplifyCoincidentVertical,
+ testSimplifyCoincidentHorizontal,
+ testSimplifyAddL,
+ testSimplifyMulti,
+};
+
+static size_t simplifyTestsCount = sizeof(simplifyTests) / sizeof(simplifyTests[0]);
+
+static void (*firstTest)() = 0;
+
+void SimplifyRectangularPaths_Test() {
+ size_t index = 0;
+ if (firstTest) {
+ while (index < simplifyTestsCount && simplifyTests[index] != firstTest) {
+ ++index;
+ }
+ }
+ for ( ; index < simplifyTestsCount; ++index) {
+ if (simplifyTests[index] == testSimplifyCorner) {
+ // testSimplifyCorner fails because it expects two contours, where
+ // only one is returned. Both results are reasonable, but if two
+ // contours are desirable, or if we provide an option to choose
+ // between longer contours and more contours, turn this back on. For
+ // the moment, testSimplifyDiagonal also checks the test case, and
+ // permits either two rects or one non-crossing poly as valid
+ // unreported results.
+ continue;
+ }
+ (*simplifyTests[index])();
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-08 00:37:27 +0000