Reduce size of filter mask.

http://codereview.appspot.com/4965057/

Reduce the size of filter masks, fix HQ blur when clipped, and add tests.


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

1 files changed, 133 insertions, 16 deletions

diff --git a/tests/BlurTest.cpp b/tests/BlurTest.cpp
index 76a987161c..61fff63c6b 100644
--- a/tests/BlurTest.cpp
+++ b/tests/BlurTest.cpp
@@ -7,34 +7,151 @@
  */
 #include "Test.h"
 #include "SkBlurMaskFilter.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
 #include "SkRandom.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define ILLEGAL_MODE    ((SkXfermode::Mode)-1)
 
+static const int outset = 100;
+static const SkColor bgColor = SK_ColorWHITE;
+static const int strokeWidth = 4;
+
+static void create(SkBitmap* bm, SkIRect bound, SkBitmap::Config config) {
+    bm->setConfig(config, bound.width(), bound.height());
+    bm->allocPixels();
+}
+
+static void drawBG(SkCanvas* canvas) {
+    canvas->drawColor(bgColor);
+}
+
+
+struct BlurTest {
+    void (*addPath)(SkPath*);
+    int viewLen;
+    SkIRect views[9];
+};
+
+//Path Draw Procs
+//Beware that paths themselves my draw differently depending on the clip.
+static void draw50x50Rect(SkPath* path) {
+    path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50));
+}
+
+//Tests
+static BlurTest tests[] = {
+    { draw50x50Rect, 3, {
+        //inner half of blur
+        { 0, 0, 50, 50 },
+        //blur, but no path.
+        { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 },
+        //just an edge
+        { 40, strokeWidth, 60, 50 - strokeWidth },
+    }},
+};
+
+/** Assumes that the ref draw was completely inside ref canvas --
+    implies that everything outside is "bgColor".
+    Checks that all overlap is the same and that all non-overlap on the
+    ref is "bgColor".
+ */
+static bool compare(const SkBitmap& ref, const SkIRect& iref,
+                    const SkBitmap& test, const SkIRect& itest)
+{
+    const int xOff = itest.fLeft - iref.fLeft;
+    const int yOff = itest.fTop - iref.fTop;
+
+    SkAutoLockPixels alpRef(ref);
+    SkAutoLockPixels alpTest(test);
+
+    for (int y = 0; y < test.height(); ++y) {
+        for (int x = 0; x < test.width(); ++x) {
+            SkColor testColor = test.getColor(x, y);
+            int refX = x + xOff;
+            int refY = y + yOff;
+            SkColor refColor;
+            if (refX >= 0 && refX < ref.width() &&
+                refY >= 0 && refY < ref.height())
+            {
+                refColor = ref.getColor(refX, refY);
+            } else {
+                refColor = bgColor;
+            }
+            if (refColor != testColor) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 static void test_blur(skiatest::Reporter* reporter) {
-    SkScalar radius = SkIntToScalar(2);
 
-    for (int i = 0; i < SkBlurMaskFilter::kBlurStyleCount; ++i) {
-        SkMaskFilter* filter;
-        SkMaskFilter::BlurInfo info;
+    SkPaint paint;
+    paint.setColor(SK_ColorGRAY);
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setStrokeWidth(SkIntToScalar(strokeWidth));
+
+    SkScalar radius = SkIntToScalar(5);
+    for (int style = 0; style < SkBlurMaskFilter::kBlurStyleCount; ++style) {
+        SkBlurMaskFilter::BlurStyle blurStyle =
+            static_cast<SkBlurMaskFilter::BlurStyle>(style);
+
+        const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
+        for (uint32_t flags = 0; flags < flagPermutations; ++flags) {
+            SkMaskFilter* filter;
+            filter = SkBlurMaskFilter::Create(radius, blurStyle, flags);
+
+            SkMaskFilter::BlurInfo info;
+            sk_bzero(&info, sizeof(info));
+            SkMaskFilter::BlurType type = filter->asABlur(&info);
+
+            REPORTER_ASSERT(reporter, type ==
+                static_cast<SkMaskFilter::BlurType>(style + 1));
+            REPORTER_ASSERT(reporter, info.fRadius == radius);
+            REPORTER_ASSERT(reporter, info.fIgnoreTransform ==
+                SkToBool(flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag));
+            REPORTER_ASSERT(reporter, info.fHighQuality ==
+                SkToBool(flags & SkBlurMaskFilter::kHighQuality_BlurFlag));
+
+            paint.setMaskFilter(filter);
+            filter->unref();
+
+            for (int test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
+                SkPath path;
+                tests[test].addPath(&path);
+                SkRect refBound = path.getBounds();
+                refBound.outset(outset, outset);
+                SkIRect iref;
+                refBound.roundOut(&iref);
+                SkBitmap refBitmap;
+                create(&refBitmap, iref, SkBitmap::kARGB_8888_Config);
 
-        uint32_t flags = i & 3;
+                SkCanvas refCanvas(refBitmap);
+                refCanvas.translate(SkIntToScalar(-iref.fLeft),
+                                    SkIntToScalar(-iref.fTop));
+                drawBG(&refCanvas);
+                refCanvas.drawPath(path, paint);
 
-        filter = SkBlurMaskFilter::Create(radius, (SkBlurMaskFilter::BlurStyle)i,
-                                          flags);
+                for (int view = 0; view < tests[test].viewLen; ++view) {
+                    SkIRect itest = tests[test].views[view];
+                    SkBitmap testBitmap;
+                    create(&testBitmap, itest, SkBitmap::kARGB_8888_Config);
 
-        sk_bzero(&info, sizeof(info));
-        SkMaskFilter::BlurType type = filter->asABlur(&info);
-        REPORTER_ASSERT(reporter, type == (SkMaskFilter::BlurType)(i + 1));
-        REPORTER_ASSERT(reporter, info.fRadius == radius);
-        REPORTER_ASSERT(reporter, info.fIgnoreTransform ==
-                        SkToBool(flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag));
-        REPORTER_ASSERT(reporter, info.fHighQuality ==
-                        SkToBool(flags & SkBlurMaskFilter::kHighQuality_BlurFlag));
+                    SkCanvas testCanvas(testBitmap);
+                    testCanvas.translate(SkIntToScalar(-itest.fLeft),
+                                         SkIntToScalar(-itest.fTop));
+                    drawBG(&testCanvas);
+                    testCanvas.drawPath(path, paint);
 
-        filter->unref();
+                    REPORTER_ASSERT(reporter,
+                        compare(refBitmap, iref, testBitmap, itest));
+                }
+            }
+        }
     }
 }