shape op work in progress

git-svn-id: http://skia.googlecode.com/svn/trunk@6450 2bbb7eff-a529-9590-31e7-b0007b416f81

diff --git a/experimental/Intersection/EdgeWalker_Test.h b/experimental/Intersection/EdgeWalker_Test.h
index 30c8ace..d5c38cf 100644 (file)
--- a/experimental/Intersection/EdgeWalker_Test.h
+++ b/experimental/Intersection/EdgeWalker_Test.h
@@ -48,6 +48,9 @@ void createThread(State4* statePtr, void* (*test)(void* ));
 int dispatchTest4(void* (*testFun)(void* ), int a, int b, int c, int d);
 void initializeTests(const char* testName, size_t testNameSize);
 void outputProgress(const State4& state, const char* pathStr, SkPath::FillType );
-void outputToStream(const State4& state, const char* pathStr, SkPath::FillType, SkWStream& outFile);
+void outputProgress(const State4& state, const char* pathStr, ShapeOp op);
+void outputToStream(const State4& state, const char* pathStr, const char* pathPrefix,
+                    const char* nameSuffix,
+                    const char* testFunction, SkWStream& outFile);
 bool runNextTestSet(State4& state);
 int waitForCompletion();

diff --git a/experimental/Intersection/EdgeWalker_TestUtility.cpp b/experimental/Intersection/EdgeWalker_TestUtility.cpp
index 7887b54..e3ea52e 100644 (file)
--- a/experimental/Intersection/EdgeWalker_TestUtility.cpp
+++ b/experimental/Intersection/EdgeWalker_TestUtility.cpp
@@ -268,7 +268,14 @@ bool testSimplifyx(SkPath& path, bool useXor, SkPath& out, State4& state,
         char temp[8192];
         bzero(temp, sizeof(temp));
         SkMemoryWStream stream(temp, sizeof(temp));
-        outputToStream(state, pathStr, fillType, stream);
+        const char* pathPrefix = NULL;
+        const char* nameSuffix = NULL;
+        if (fillType == SkPath::kEvenOdd_FillType) {
+            pathPrefix = "    path.setFillType(SkPath::kEvenOdd_FillType);\n";
+            nameSuffix = "x";
+        }
+        const char testFunction[] = "testSimplifyx(path);";
+        outputToStream(state, pathStr, pathPrefix, nameSuffix, testFunction, stream);
         SkDebugf(temp);
         SkASSERT(0);
     }
@@ -440,52 +447,100 @@ void outputProgress(const State4& state, const char* pathStr, SkPath::FillType p
         }
         SkDebugf("%s\n", pathStr);
     }
+    const char testFunction[] = "testSimplifyx(path);";
+    const char* pathPrefix = NULL;
+    const char* nameSuffix = NULL;
+    if (pathFillType == SkPath::kEvenOdd_FillType) {
+        pathPrefix = "    path.setFillType(SkPath::kEvenOdd_FillType);\n";
+        nameSuffix = "x";
+    }
     if (gUsePhysicalFiles) {
         SkFILEWStream outFile(state.filename);
         if (!outFile.isValid()) {
             SkASSERT(0);
             return;
         }
-        outputToStream(state, pathStr, pathFillType, outFile);
+        outputToStream(state, pathStr, pathPrefix, nameSuffix, testFunction, outFile);
         return;
     }
     SkFILEWStream outRam(state.filename);
-    outputToStream(state, pathStr, pathFillType, outRam);
+    outputToStream(state, pathStr, pathPrefix, nameSuffix, testFunction, outRam);
 }
 
-static void writeTestName(SkPath::FillType pathFillType, SkWStream& outFile) {
+static const char* opStrs[] = {
+    "kDifference_Op",
+    "kIntersect_Op",
+    "kUnion_Op",
+    "kXor_Op",
+};
+
+static const char* opSuffixes[] = {
+    "d",
+    "i",
+    "u",
+    "x",
+};
+
+void outputProgress(const State4& state, const char* pathStr, ShapeOp op) {
+    SkString testFunc("testShapeOp(path, pathB, ");
+    testFunc += opStrs[op];
+    testFunc += ");";
+    const char* testFunction = testFunc.c_str();
+    if (gRunTestsInOneThread && gShowOutputProgress) {
+        SkDebugf("%s\n", pathStr);
+        SkDebugf("    %s\n", testFunction);
+    }
+    const char* nameSuffix = opSuffixes[op];
+    if (gUsePhysicalFiles) {
+        SkFILEWStream outFile(state.filename);
+        if (!outFile.isValid()) {
+            SkASSERT(0);
+            return;
+        }
+        outputToStream(state, pathStr, NULL, nameSuffix, testFunction, outFile);
+        return;
+    }
+    SkFILEWStream outRam(state.filename);
+    outputToStream(state, pathStr, NULL, nameSuffix, testFunction, outRam);
+}
+
+static void writeTestName(const char* nameSuffix, SkWStream& outFile) {
     outFile.writeText(testName);
     outFile.writeDecAsText(testNumber);
-    if (pathFillType == SkPath::kEvenOdd_FillType) {
-        outFile.writeText("x");
+    if (nameSuffix) {
+        outFile.writeText(nameSuffix);
     }
 }
 
-void outputToStream(const State4& state, const char* pathStr, SkPath::FillType pathFillType, SkWStream& outFile) {
+void outputToStream(const State4& state, const char* pathStr, const char* pathPrefix,
+        const char* nameSuffix,
+        const char* testFunction, SkWStream& outFile) {
     outFile.writeText("<div id=\"");
-    writeTestName(pathFillType, outFile);
+    writeTestName(nameSuffix, outFile);
     outFile.writeText("\">\n");
-    if (pathFillType == SkPath::kEvenOdd_FillType) {
-        outFile.writeText("    path.setFillType(SkPath::kEvenOdd_FillType);\n");
+    if (pathPrefix) {
+        outFile.writeText(pathPrefix);
     }
     outFile.writeText(pathStr);
     outFile.writeText("</div>\n\n");
 
     outFile.writeText(marker);
     outFile.writeText("    ");
-    writeTestName(pathFillType, outFile);
+    writeTestName(nameSuffix, outFile);
     outFile.writeText(",\n\n\n");
 
     outFile.writeText("static void ");
-    writeTestName(pathFillType, outFile);
-    outFile.writeText("() {\n    SkPath path;\n");
-    if (pathFillType == SkPath::kEvenOdd_FillType) {
-        outFile.writeText("    path.setFillType(SkPath::kEvenOdd_FillType);\n");
+    writeTestName(nameSuffix, outFile);
+    outFile.writeText("() {\n    SkPath path, pathB;\n");
+    if (pathPrefix) {
+        outFile.writeText(pathPrefix);
     }
     outFile.writeText(pathStr);
-    outFile.writeText("    testSimplifyx(path);\n}\n\n");
+    outFile.writeText("    ");
+    outFile.writeText(testFunction);
+    outFile.writeText("\n}\n\n");
     outFile.writeText("static void (*firstTest)() = ");
-    writeTestName(pathFillType, outFile);
+    writeTestName(nameSuffix, outFile);
     outFile.writeText(";\n\n");
 
     outFile.writeText("static struct {\n");
@@ -493,7 +548,7 @@ void outputToStream(const State4& state, const char* pathStr, SkPath::FillType p
     outFile.writeText("    const char* str;\n");
     outFile.writeText("} tests[] = {\n");
     outFile.writeText("    TEST(");
-    writeTestName(pathFillType, outFile);
+    writeTestName(pathPrefix, outFile);
     outFile.writeText("),\n");
     outFile.flush();
 }

diff --git a/experimental/Intersection/Intersection_Tests.cpp b/experimental/Intersection/Intersection_Tests.cpp
index eae004c..23ce5be 100644 (file)
--- a/experimental/Intersection/Intersection_Tests.cpp
+++ b/experimental/Intersection/Intersection_Tests.cpp
@@ -15,6 +15,7 @@ void cubecode_test(int test);
 void Intersection_Tests() {
     int testsRun = 0;
     SimplifyNew_Test();
+    ShapeOps4x4RectsThreaded_Test(testsRun);
     QuadraticIntersection_Test();
     LineQuadraticIntersection_Test();
     MiniSimplify_Test();

diff --git a/experimental/Intersection/Intersection_Tests.h b/experimental/Intersection/Intersection_Tests.h
index 094e844..46e6b7b 100644 (file)
--- a/experimental/Intersection/Intersection_Tests.h
+++ b/experimental/Intersection/Intersection_Tests.h
@@ -37,6 +37,7 @@ void Simplify4x4QuadralateralsThreaded_Test(int& );
 void Simplify4x4QuadraticsThreaded_Test(int& );
 void Simplify4x4RectsThreaded_Test(int& );
 void SimplifyRectangularPaths_Test();
+void ShapeOps4x4RectsThreaded_Test(int& );
 void QuadLineIntersectThreaded_Test(int& );
 void QuadraticBezierClip_Test();
 void QuadraticCoincidence_Test();

diff --git a/experimental/Intersection/ShapeOpRect4x4_Test.cpp b/experimental/Intersection/ShapeOpRect4x4_Test.cpp
new file mode 100644 (file)
index 0000000..6eeb441
--- /dev/null
+++ b/experimental/Intersection/ShapeOpRect4x4_Test.cpp
@@ -0,0 +1,99 @@
+/*
+ * 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 "ShapeOps.h"
+
+// four rects, of four sizes
+// for 3 smaller sizes, tall, wide
+    // top upper mid lower bottom aligned (3 bits, 5 values)
+    // same with x (3 bits, 5 values)
+// not included, square, tall, wide (2 bits)
+// cw or ccw (1 bit)
+
+static void* testShapeOps4x4RectsMain(void* data)
+{
+    SkASSERT(data);
+    State4& state = *(State4*) data;
+    char pathStr[1024]; // gdb: set print elements 400
+    bzero(pathStr, sizeof(pathStr));
+    do {
+        for (int a = 0 ; a < 6; ++a) {
+        for (int b = a + 1 ; a < 7; ++b)  {
+        for (int c = 0 ; c < 6; ++c)          {
+        for (int d = c + 1 ; d < 7; ++d)           {
+        for (int op = 0 ; op < kShapeOp_Count; ++op)    {
+        for (int e = 0 ; e <= SkPath::kEvenOdd_FillType; ++e) {
+        for (int f = 0 ; f <= SkPath::kEvenOdd_FillType; ++f)   {
+            SkPath pathA, pathB;
+            char* str = pathStr;
+            pathA.setFillType((SkPath::FillType) e);
+            str += sprintf(str, "    path.setFillType((SkPath::FillType) %d);\n", e);
+            pathA.addRect(state.a, state.a, state.b, state.b, (SkPath::Direction) 0);
+            str += sprintf(str, "    path.addRect(%d, %d, %d, %d,"
+                    " (SkPath::Direction) %d);\n", state.a, state.a, state.b, state.b, 0);
+            pathA.addRect(state.c, state.c, state.d, state.d, (SkPath::Direction) 0);
+            str += sprintf(str, "    path.addRect(%d, %d, %d, %d,"
+                    " (SkPath::Direction) %d);\n", state.c, state.c, state.d, state.d, 0);
+            pathA.close();
+            pathB.setFillType((SkPath::FillType) f);
+            str += sprintf(str, "    pathB.setFillType((SkPath::FillType) %d);\n", f);
+            pathB.addRect(a, a, b, b, (SkPath::Direction) 0);
+            str += sprintf(str, "    pathB.addRect(%d, %d, %d, %d,"
+                    " (SkPath::Direction) %d);\n", a, a, b, b, 0);
+            pathB.addRect(c, c, d, d, (SkPath::Direction) 0);
+            str += sprintf(str, "    pathB.addRect(%d, %d, %d, %d,"
+                    " (SkPath::Direction) %d);\n", c, c, d, d, 0);
+            pathB.close();
+            outputProgress(state, pathStr, kDifference_Op);
+            testShapeOp(pathA, pathB, kDifference_Op);
+            state.testsRun++;
+            outputProgress(state, pathStr, kIntersect_Op);
+            testShapeOp(pathA, pathB, kIntersect_Op);
+            state.testsRun++;
+            outputProgress(state, pathStr, kUnion_Op);
+            testShapeOp(pathA, pathB, kUnion_Op);
+            state.testsRun++;
+            outputProgress(state, pathStr, kXor_Op);
+            testShapeOp(pathA, pathB, kXor_Op);
+            state.testsRun++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+    } while (runNextTestSet(state));
+    return NULL;
+}
+
+void ShapeOps4x4RectsThreaded_Test(int& testsRun)
+{
+    SkDebugf("%s\n", __FUNCTION__);
+#ifdef SK_DEBUG
+    gDebugMaxWindSum = 4;
+    gDebugMaxWindValue = 4;
+#endif
+    const char testLineStr[] = "testOp";
+    initializeTests(testLineStr, sizeof(testLineStr));
+    int testsStart = testsRun;
+    for (int a = 0; a < 6; ++a) { // outermost
+        for (int b = a + 1; b < 7; ++b) {
+            for (int c = 0 ; c < 6; ++c) {
+                for (int d = c + 1; d < 7; ++d) {
+                    testsRun += dispatchTest4(testShapeOps4x4RectsMain, a, b, c, d);
+                }
+                if (!gRunTestsInOneThread) SkDebugf(".");
+            }
+            if (!gRunTestsInOneThread) SkDebugf("%d", b);
+        }
+        if (!gRunTestsInOneThread) SkDebugf("\n%d", a);
+    }
+    testsRun += waitForCompletion();
+    SkDebugf("%s tests=%d total=%d\n", __FUNCTION__, testsRun - testsStart, testsRun);
+}

diff --git a/experimental/Intersection/SimplifyNew_Test.cpp b/experimental/Intersection/SimplifyNew_Test.cpp
index f190ec1..eb000d6 100644 (file)
--- a/experimental/Intersection/SimplifyNew_Test.cpp
+++ b/experimental/Intersection/SimplifyNew_Test.cpp
@@ -2607,6 +2607,17 @@ static void testXor2() {
     testShapeOp(one, two, kXor_Op);
 }
 
+static void testOp1d() {
+    SkPath path, pathB;
+    path.setFillType((SkPath::FillType) 0);
+    path.addRect(0, 0, 1, 1, (SkPath::Direction) 0);
+    path.addRect(0, 0, 2, 2, (SkPath::Direction) 0);
+    pathB.setFillType((SkPath::FillType) 0);
+    pathB.addRect(0, 0, 1, 1, (SkPath::Direction) 0);
+    pathB.addRect(0, 0, 1, 1, (SkPath::Direction) 0);
+    testShapeOp(path, pathB, kDifference_Op);
+}
+
 static void testQuadratic22() {
     SkPath path;
     path.moveTo(0, 0);
@@ -3219,11 +3230,12 @@ static struct {
     TEST(testIntersect2),
     TEST(testUnion2),
     TEST(testXor2),
+    TEST(testOp1d),
 };
 
 static const size_t subTestCount = sizeof(subTests) / sizeof(subTests[0]);
 
-static void (*firstBinaryTest)() = testUnion2;
+static void (*firstBinaryTest)() = testOp1d;
 
 static bool skipAll = false;
 static bool runBinaryTestsFirst = true;