more general GM setup for testing image filtering -- now with checkerboards, images, and text.

gm/filterbitmap.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 "gm.h"
 #include "SkGradientShader.h"
 
 #include "SkTypeface.h"
 #include "SkImageDecoder.h"
 
+#include "lena_bytes.h"
+
 static void setTypeface(SkPaint* paint, const char name[], SkTypeface::Style style) {
     SkSafeUnref(paint->setTypeface(SkTypeface::CreateFromName(name, style)));
 }
 
-static void load_bm(SkBitmap* bm) {
-//    SkImageDecoder::DecodeFile("/skia/trunk/books.jpg", bm);
-
-    bm->setConfig(SkBitmap::kARGB_8888_Config, 160, 120);
-    bm->allocPixels();
-    SkCanvas canvas(*bm);
-    canvas.drawColor(SK_ColorWHITE);
-
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    paint.setSubpixelText(true);
-    paint.setTextSize(17);
-
-    setTypeface(&paint, "Times", SkTypeface::kNormal);
-    canvas.drawText("Hamburgefons", 12, 10, 25, paint);
-    setTypeface(&paint, "Times", SkTypeface::kBold);
-    canvas.drawText("Hamburgefons", 12, 10, 50, paint);
-    setTypeface(&paint, "Times", SkTypeface::kItalic);
-    canvas.drawText("Hamburgefons", 12, 10, 75, paint);
-    setTypeface(&paint, "Times", SkTypeface::kBoldItalic);
-    canvas.drawText("Hamburgefons", 12, 10, 100, paint);
-}
-
 static SkSize computeSize(const SkBitmap& bm, const SkMatrix& mat) {
     SkRect bounds = SkRect::MakeWH(SkIntToScalar(bm.width()),
                                    SkIntToScalar(bm.height()));
     mat.mapRect(&bounds);
     return SkSize::Make(bounds.width(), bounds.height());
 }
 
 static void draw_col(SkCanvas* canvas, const SkBitmap& bm, const SkMatrix& mat,
                      SkScalar dx) {
     SkPaint paint;
@@ skipping 11 matching lines @@
     canvas->drawBitmapMatrix(bm, mat, &paint);
 }
 
 class FilterBitmapGM : public skiagm::GM {
     bool fOnce;
     void init() {
         if (fOnce) {
             return;
         }
         fOnce = true;
-        load_bm(&fBM);
-
+        
+        make_bitmap();
+        
         SkScalar cx = SkScalarHalf(fBM.width());
         SkScalar cy = SkScalarHalf(fBM.height());
-        SkScalar scale = 1.6f;
+        SkScalar scale = get_scale();
+        
 
         fMatrix[0].setScale(scale, scale);
         fMatrix[1].setRotate(30, cx, cy); fMatrix[1].postScale(scale, scale);
     }
 
 public:
     SkBitmap    fBM;
     SkMatrix    fMatrix[2];
+    SkString    fName;
+    
+    FilterBitmapGM(): 
+        fOnce(false) {
+        this->setBGColor(0xFFDDDDDD);
+    }
 
-    FilterBitmapGM() : fOnce(false) {
-        this->setBGColor(0xFFDDDDDD);
+    void setName( const char name[] ) {
+        fName = SkString(name);

[reed1, 2013/05/29 19:26:04]

alternative (slightly more efficient) : fName.set(name);

     }
 
 protected:
     virtual SkString onShortName() SK_OVERRIDE {
-        return SkString("filterbitmap");
+        return fName;
     }
 
     virtual SkISize onISize() SK_OVERRIDE {
         return SkISize::Make(920, 480);
     }
-
+    
+    virtual void make_bitmap() = 0;
+    virtual SkScalar get_scale() = 0;
+    
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         this->init();
 
         canvas->translate(10, 10);
         for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrix); ++i) {
             SkSize size = computeSize(fBM, fMatrix[i]);
             size.fWidth += 20;
             size.fHeight += 20;
 
             draw_col(canvas, fBM, fMatrix[i], size.fWidth);
             canvas->translate(0, size.fHeight);
         }
     }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 
+class FilterBitmapTextGM: public FilterBitmapGM {
+  public:
+      FilterBitmapTextGM( float textSize )
+      : fTextSize( textSize )
+        {
+            char name[1024];
+            sprintf( name, "filterbitmap_text_%.2fpt", fTextSize );
+            setName( name );
+        }
+        
+  protected:
+      float fTextSize;
+      
+      SkScalar get_scale() SK_OVERRIDE {
+          return 32.f/fTextSize;
+      }
+      
+      void make_bitmap() SK_OVERRIDE {
+          fBM.setConfig(SkBitmap::kARGB_8888_Config, fTextSize * 8, fTextSize * 6);
+          fBM.allocPixels();
+          SkCanvas canvas(fBM);
+          canvas.drawColor(SK_ColorWHITE);
+
+          SkPaint paint;
+          paint.setAntiAlias(true);
+          paint.setSubpixelText(true);
+          paint.setTextSize(fTextSize);
+
+          setTypeface(&paint, "Times", SkTypeface::kNormal);
+          canvas.drawText("Hamburgefons", 12, fTextSize/2, 1.2*fTextSize, paint);
+          setTypeface(&paint, "Times", SkTypeface::kBold);
+          canvas.drawText("Hamburgefons", 12, fTextSize/2, 2.4*fTextSize, paint);
+          setTypeface(&paint, "Times", SkTypeface::kItalic);
+          canvas.drawText("Hamburgefons", 12, fTextSize/2, 3.6*fTextSize, paint);
+          setTypeface(&paint, "Times", SkTypeface::kBoldItalic);
+          canvas.drawText("Hamburgefons", 12, fTextSize/2, 4.8*fTextSize, paint);
+      }
+  private:     
+      typedef FilterBitmapGM INHERITED;
+};
+
+class FilterBitmapCheckerboardGM: public FilterBitmapGM {
+  public:
+      FilterBitmapCheckerboardGM( int size, int num_checks )
+      : fSize( size ), fNumChecks( num_checks )
+        {
+            char name[1024];
+            sprintf( name, "filterbitmap_checkerboard_%d_%d", fSize, fNumChecks );
+            setName( name );
+        }
+        
+  protected:
+      int fSize;
+      int fNumChecks;
+      
+      SkScalar get_scale() SK_OVERRIDE {
+          return 192.f/fSize;
+      }
+      
+      void make_bitmap() SK_OVERRIDE {
+          fBM.setConfig(SkBitmap::kARGB_8888_Config, fSize, fSize);
+          fBM.allocPixels();
+          SkAutoLockPixels lock(fBM);
+          for (int y = 0; y < fSize; y ++) {
+              for (int x = 0; x < fSize; x ++) {
+                  SkPMColor* s = fBM.getAddr32(x, y);
+                  int cx = (x * fNumChecks) / fSize;
+                  int cy = (y * fNumChecks) / fSize;
+                  if ((cx+cy)%2) {
+                      *s = 0xFFFFFFFF;                      
+                  } else {                      
+                      *s = 0xFF000000;
+                  }
+              }
+          }
+      }
+  private:     
+      typedef FilterBitmapGM INHERITED;
+};
+
+class FilterBitmapImageGM: public FilterBitmapGM {
+  public:
+      FilterBitmapImageGM( int size )
+      : fSize( size )
+        {
+            char name[1024];
+            sprintf( name, "filterbitmap_image_%d", fSize );
+            setName( name );
+        }
+        
+  protected:
+      int fSize;
+      int fNumChecks;
+      
+      SkScalar get_scale() SK_OVERRIDE {
+          return 192.f/fSize;
+      }
+      
+      void make_bitmap() SK_OVERRIDE {
+          fBM.setConfig(SkBitmap::kARGB_8888_Config, fSize, fSize);
+          fBM.allocPixels();
+          
+          unsigned char *lena;
+          switch( fSize ) {
+              case 16:
+                  lena = lena_16;
+                  break;
+              case 32:
+                  lena = lena_32;
+                  break;
+              case 64:
+                  lena = lena_64;
+                  break;
+              case 128:
+                  lena = lena_128;
+                  break;
+              default:
+                  lena = NULL;
+                  break;
+          }
+          SkAutoLockPixels lock(fBM);
+          for (int y = 0; y < fSize; y ++) {
+              for (int x = 0; x < fSize; x ++) {
+                  SkPMColor* s = fBM.getAddr32(x, y);
+                  unsigned char *src = lena + 4*(y*fSize + x);
+                  *s = SkPreMultiplyARGB(src[3], src[0], src[1], src[2]);
+              }
+          }
+      }
+  private:     
+      typedef FilterBitmapGM INHERITED;
+};
+
 //////////////////////////////////////////////////////////////////////////////
 
-DEF_GM( return new FilterBitmapGM; )
+DEF_GM( return new FilterBitmapTextGM(3); )
+DEF_GM( return new FilterBitmapTextGM(7); )
+DEF_GM( return new FilterBitmapTextGM(10); )
+DEF_GM( return new FilterBitmapCheckerboardGM(4,4); )
+DEF_GM( return new FilterBitmapCheckerboardGM(32,32); )
+DEF_GM( return new FilterBitmapCheckerboardGM(32,8); )
+DEF_GM( return new FilterBitmapCheckerboardGM(32,2); )
+DEF_GM( return new FilterBitmapCheckerboardGM(192,192); )
+DEF_GM( return new FilterBitmapImageGM(16); )
+DEF_GM( return new FilterBitmapImageGM(32); )
+DEF_GM( return new FilterBitmapImageGM(64); )
+DEF_GM( return new FilterBitmapImageGM(128); )