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

bench/BlurBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkString.h"
 #include "SkBlurMaskFilter.h"
 
-#define SMALL   SkIntToScalar(2)
-#define REAL    SkFloatToScalar(1.5f)
-#define BIG     SkIntToScalar(10)
-#define REALBIG SkFloatToScalar(100.5f)
+#define SMALL   SkFloatToScalar(1.6547f)

[bsalomon, 2013/09/05 13:09:10]

This looks really weird, as though someone chose this particular float for some
reason. Could we have a static inline in SkBlurMaskFilter that converts?
Something like

SkMaskFilter* mf = SkBlurMaskFilter::Create(fStyle,
SkBlurMaskRadius::LegacyRadiusToSigma(fRadius), fFlags);

Also below we have the raiduses again as constructor params called offset. It's
obvious at all what their relationship is.

[robertphillips, 2013/09/05 14:00:14]

I considered doing that (using a conversion method) but felt it wasn't really in
the spirit of the new API. If we did switch to a conversion method I would
prefer that it be in the testing/bench/GM code rather then in core Skia. I hope
to completely remove the deprecated entry points and the
SkBlurMask::ConvertRadiusToSigma function that currently does the conversion, so
having SkBlurMaskFilter::LegacyRadiusToSigma would keep that 0.57735 constant in
play.

The weird offset thing is to make the images consistent before and after this
change. Since this is bench it might not be important to preserve going forward,
but it was a useful check during the conversion process.

[bsalomon, 2013/09/05 14:10:55]

It just seems like a future editor of this file (and BlurRectBench.cpp) will be
confused about the radius/offset correspondences such as the one between #define
REAL SkFloatToScalar(1.366025f) and 1.5. It's not obvious how they're related.

+#define REAL    SkFloatToScalar(1.366025f)
+#define BIG     SkFloatToScalar(6.2735f)
+#define REALBIG SkFloatToScalar(58.523675f)
 
 static const char* gStyleName[] = {
     "normal",
     "solid",
     "outer",
     "inner"
 };
 
 class BlurBench : public SkBenchmark {
-    SkScalar    fRadius;
+    SkScalar    fSigma;
+    SkScalar    fOffset;
     SkBlurMaskFilter::BlurStyle fStyle;
     uint32_t                    fFlags;
     SkString    fName;
 
 public:
-    BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) : INHERITED(param) {
-        fRadius = rad;
+    BlurBench(void* param, SkScalar sigma, SkScalar offset, SkBlurMaskFilter::BlurStyle bs, 
+              const char* size, uint32_t flags = 0) : INHERITED(param) {
+        fSigma = sigma;
+        fOffset = offset;
         fStyle = bs;
         fFlags = flags;
-        const char* name = rad > 0 ? gStyleName[bs] : "none";
-        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 {
-            fName.printf("blur_%d_%s_%s", SkScalarRound(rad), name, quality);
-        }
+        const char* name = fSigma > 0 ? gStyleName[bs] : "none";
+        const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality" 
+                                                                              : "low_quality";
+        fName.printf("blur_%s_%s_%s", size, name, quality);
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         SkPaint paint;
         this->setupPaint(&paint);
 
         paint.setAntiAlias(true);
 
         SkRandom rand;
         for (int i = 0; i < SkBENCHLOOP(10); i++) {
             SkRect r = SkRect::MakeWH(rand.nextUScalar1() * 400,
                                       rand.nextUScalar1() * 400);
-            r.offset(fRadius, fRadius);
+            r.offset(fOffset, fOffset);
 
-            if (fRadius > 0) {
-                SkMaskFilter* mf = SkBlurMaskFilter::Create(fRadius, fStyle, fFlags);
+            if (fSigma > 0) {
+                SkMaskFilter* mf = SkBlurMaskFilter::Create(fStyle, fSigma, fFlags);
                 paint.setMaskFilter(mf)->unref();
             }
             canvas->drawOval(r, paint);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(p, SMALL, 2, SkBlurMaskFilter::kNormal_BlurStyle, "2");)
+DEF_BENCH(return new BlurBench(p, SMALL, 2, SkBlurMaskFilter::kSolid_BlurStyle, "2");)
+DEF_BENCH(return new BlurBench(p, SMALL, 2, SkBlurMaskFilter::kOuter_BlurStyle, "2");)
+DEF_BENCH(return new BlurBench(p, SMALL, 2, SkBlurMaskFilter::kInner_BlurStyle, "2");)
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(p, BIG, 10, SkBlurMaskFilter::kNormal_BlurStyle, "10");)
+DEF_BENCH(return new BlurBench(p, BIG, 10, SkBlurMaskFilter::kSolid_BlurStyle, "10");)
+DEF_BENCH(return new BlurBench(p, BIG, 10, SkBlurMaskFilter::kOuter_BlurStyle, "10");)
+DEF_BENCH(return new BlurBench(p, BIG, 10, SkBlurMaskFilter::kInner_BlurStyle, "10");)
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(p, REALBIG, 100.5f, SkBlurMaskFilter::kNormal_BlurStyle, "100.50");)
+DEF_BENCH(return new BlurBench(p, REALBIG, 100.5f, SkBlurMaskFilter::kSolid_BlurStyle, "100.50");)
+DEF_BENCH(return new BlurBench(p, REALBIG, 100.5f, SkBlurMaskFilter::kOuter_BlurStyle, "100.50");)
+DEF_BENCH(return new BlurBench(p, REALBIG, 100.5f, SkBlurMaskFilter::kInner_BlurStyle, "100.50");)
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kInner_BlurStyle);)
+DEF_BENCH(return new BlurBench(p, REAL, 1.5f, SkBlurMaskFilter::kNormal_BlurStyle, "1.50");)
+DEF_BENCH(return new BlurBench(p, REAL, 1.5f, SkBlurMaskFilter::kSolid_BlurStyle, "1.50");)
+DEF_BENCH(return new BlurBench(p, REAL, 1.5f, SkBlurMaskFilter::kOuter_BlurStyle, "1.50");)
+DEF_BENCH(return new BlurBench(p, REAL, 1.5f, SkBlurMaskFilter::kInner_BlurStyle, "1.50");)
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(p, SMALL, 2, SkBlurMaskFilter::kNormal_BlurStyle, "2", SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(p, BIG, 10, SkBlurMaskFilter::kNormal_BlurStyle, "10", SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(p, REALBIG, 100.5f, SkBlurMaskFilter::kNormal_BlurStyle, "100.50", SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+DEF_BENCH(return new BlurBench(p, REAL, 1.5f, SkBlurMaskFilter::kNormal_BlurStyle, "1.50", SkBlurMaskFilter::kHighQuality_BlurFlag);)
 
-DEF_BENCH(return new BlurBench(p, 0, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurBench(p, 0, 0, SkBlurMaskFilter::kNormal_BlurStyle, "0");)