Push sigma-based blur interface into our GMs/benches/tests/samplecode

https://codereview.chromium.org/23701006/



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

3 files changed, 35 insertions, 23 deletions

diff --git a/bench/BlurBench.cpp b/bench/BlurBench.cpp
index 5f2f425fbe..67a600b6b4 100644
--- a/bench/BlurBench.cpp
+++ b/bench/BlurBench.cpp
@@ -6,6 +6,7 @@
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
+#include "SkBlurMask.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
@@ -32,12 +33,14 @@ class BlurBench : public SkBenchmark {
     SkString    fName;
 
 public:
-    BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) : INHERITED(param) {
+    BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) 
+        : INHERITED(param) {
         fRadius = rad;
         fStyle = bs;
         fFlags = flags;
         const char* name = rad > 0 ? gStyleName[bs] : "none";
-        const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality" : "low_quality";
+        const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality" 
+                                                                              : "low_quality";
         if (SkScalarFraction(rad) != 0) {
             fName.printf("blur_%.2f_%s_%s", SkScalarToFloat(rad), name, quality);
         } else {
@@ -63,7 +66,9 @@ protected:
             r.offset(fRadius, fRadius);
 
             if (fRadius > 0) {
-                SkMaskFilter* mf = SkBlurMaskFilter::Create(fRadius, fStyle, fFlags);
+                SkMaskFilter* mf = SkBlurMaskFilter::Create(fStyle, 
+                                            SkBlurMask::ConvertRadiusToSigma(fRadius), 
+                                            fFlags);
                 paint.setMaskFilter(mf)->unref();
             }
             canvas->drawOval(r, paint);
diff --git a/bench/BlurRectBench.cpp b/bench/BlurRectBench.cpp
index 1f40780fc2..5c93cd5d1a 100644
--- a/bench/BlurRectBench.cpp
+++ b/bench/BlurRectBench.cpp
@@ -15,7 +15,9 @@
 
 #define SMALL   SkIntToScalar(2)
 #define REAL    SkFloatToScalar(1.5f)
+static const SkScalar kMedium = SkIntToScalar(5);
 #define BIG     SkIntToScalar(10)
+static const SkScalar kMedBig = SkIntToScalar(20);
 #define REALBIG SkFloatToScalar(30.5f)
 
 class BlurRectBench: public SkBenchmark {
@@ -83,12 +85,13 @@ class BlurRectDirectBench: public BlurRectBench {
             name.printf("blurrect_direct_%d", SkScalarRoundToInt(rad));
         }
 
-        setName(name);
+        this->setName(name);
     }
 protected:
     virtual void makeBlurryRect(const SkRect& r) SK_OVERRIDE {
         SkMask mask;
-        SkBlurMask::BlurRect(&mask, r, this->radius(), SkBlurMask::kNormal_Style);
+        SkBlurMask::BlurRect(SkBlurMask::ConvertRadiusToSigma(this->radius()), 
+                             &mask, r, SkBlurMask::kNormal_Style);
         SkMask::FreeImage(mask.fImage);
     }
 private:
@@ -127,12 +130,14 @@ class BlurRectBoxFilterBench: public BlurRectSeparableBench {
 public:
     BlurRectBoxFilterBench(void *param, SkScalar rad) : INHERITED(param, rad) {
         SkString name;
+
         if (SkScalarFraction(rad) != 0) {
             name.printf("blurrect_boxfilter_%.2f", SkScalarToFloat(rad));
         } else {
             name.printf("blurrect_boxfilter_%d", SkScalarRoundToInt(rad));
         }
-        setName(name);
+
+        this->setName(name);
     }
 
 protected:
@@ -140,9 +145,9 @@ protected:
     virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
-        SkBlurMask::Blur(&mask, fSrcMask, this->radius(),
-                         SkBlurMask::kNormal_Style,
-                         SkBlurMask::kHigh_Quality);
+        SkBlurMask::BoxBlur(&mask, fSrcMask, SkBlurMask::ConvertRadiusToSigma(this->radius()),
+                            SkBlurMask::kNormal_Style,
+                            SkBlurMask::kHigh_Quality);
         SkMask::FreeImage(mask.fImage);
     }
 private:
@@ -153,12 +158,14 @@ class BlurRectGaussianBench: public BlurRectSeparableBench {
 public:
     BlurRectGaussianBench(void *param, SkScalar rad) : INHERITED(param, rad) {
         SkString name;
+
         if (SkScalarFraction(rad) != 0) {
             name.printf("blurrect_gaussian_%.2f", SkScalarToFloat(rad));
         } else {
             name.printf("blurrect_gaussian_%d", SkScalarRoundToInt(rad));
         }
-        setName(name);
+ 
+        this->setName(name);
     }
 
 protected:
@@ -166,8 +173,8 @@ protected:
     virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
-        SkBlurMask::BlurGroundTruth(&mask, fSrcMask, this->radius(),
-                                    SkBlurMask::kNormal_Style);
+        SkBlurMask::BlurGroundTruth(SkBlurMask::ConvertRadiusToSigma(this->radius()),
+                                    &mask, fSrcMask, SkBlurMask::kNormal_Style);
         SkMask::FreeImage(mask.fImage);
     }
 private:
@@ -187,11 +194,11 @@ DEF_BENCH(return new BlurRectDirectBench(p, BIG);)
 DEF_BENCH(return new BlurRectDirectBench(p, REALBIG);)
 DEF_BENCH(return new BlurRectDirectBench(p, REAL);)
 
-DEF_BENCH(return new BlurRectDirectBench(p, SkIntToScalar(5));)
-DEF_BENCH(return new BlurRectDirectBench(p, SkIntToScalar(20));)
+DEF_BENCH(return new BlurRectDirectBench(p, kMedium);)
+DEF_BENCH(return new BlurRectDirectBench(p, kMedBig);)
 
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SkIntToScalar(5));)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SkIntToScalar(20));)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedium);)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedBig);)
 
 #if 0
 // disable Gaussian benchmarks; the algorithm works well enough
diff --git a/bench/RectoriBench.cpp b/bench/RectoriBench.cpp
index 80996c9760..1aa9814207 100644
--- a/bench/RectoriBench.cpp
+++ b/bench/RectoriBench.cpp
@@ -28,8 +28,8 @@ protected:
         SkMWCRandom Random;
 
         for (int i = 0; i < N; i++) {
-            SkScalar blurRad = Random.nextRangeScalar(1.5f, 25.0f);
-            SkScalar size = Random.nextRangeScalar(20*blurRad, 50*blurRad);
+            SkScalar blurSigma = Random.nextRangeScalar(1.5f, 25.0f);
+            SkScalar size = Random.nextRangeScalar(20*blurSigma, 50*blurSigma);
 
             SkScalar x = Random.nextRangeScalar(0.0f, W - size);
             SkScalar y = Random.nextRangeScalar(0.0f, H - size);
@@ -38,7 +38,7 @@ protected:
 
             SkRect outer(inner);
             // outer is always outset either 2x or 4x the blur radius (we go with 2x)
-            outer.outset(2*blurRad, 2*blurRad);
+            outer.outset(2*blurSigma, 2*blurSigma);
 
             SkPath p;
 
@@ -51,7 +51,7 @@ protected:
             SkScalar translate = 2.0f * size;
 
             SkPaint paint;
-            paint.setLooper(this->createLooper(-translate, blurRad))->unref();
+            paint.setLooper(this->createLooper(-translate, blurSigma))->unref();
             paint.setColor(0xff000000 | Random.nextU());
             paint.setAntiAlias(true);
 
@@ -72,7 +72,7 @@ private:
 
     enum { N = SkBENCHLOOP(100) };
 
-    SkLayerDrawLooper* createLooper(SkScalar xOff, SkScalar radius) {
+    SkLayerDrawLooper* createLooper(SkScalar xOff, SkScalar sigma) {
         SkLayerDrawLooper* looper = new SkLayerDrawLooper;
 
         //-----------------------------------------------
@@ -88,8 +88,8 @@ private:
 
         SkPaint* paint = looper->addLayer(info);
 
-        SkMaskFilter* mf = SkBlurMaskFilter::Create(radius,
-                                                    SkBlurMaskFilter::kNormal_BlurStyle,
+        SkMaskFilter* mf = SkBlurMaskFilter::Create(SkBlurMaskFilter::kNormal_BlurStyle,
+                                                    sigma,
                                                     SkBlurMaskFilter::kHighQuality_BlurFlag);
         paint->setMaskFilter(mf)->unref();