src/third_party/skia/tests/TileGridTest.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkCanvas.h"
   9 #include "SkPictureRecorder.h"
  10 #include "SkTileGrid.h"
  11 #include "Test.h"
  12
  13 enum Tile {
  14     kTopLeft_Tile = 0x1,
  15     kTopRight_Tile = 0x2,
  16     kBottomLeft_Tile = 0x4,
  17     kBottomRight_Tile = 0x8,
  18
  19     kAll_Tile = kTopLeft_Tile | kTopRight_Tile | kBottomLeft_Tile | kBottomRight_Tile,
  20 };
  21
  22 class MockCanvas : public SkCanvas {
  23 public:
  24     MockCanvas(const SkBitmap& bm) : SkCanvas(bm) {}
  25
  26     virtual void drawRect(const SkRect& rect, const SkPaint&) {
  27         // This capture occurs before quick reject.
  28         fRects.push(rect);
  29     }
  30
  31     SkTDArray<SkRect> fRects;
  32 };
  33
  34 static void verifyTileHits(skiatest::Reporter* reporter, SkIRect rect,
  35                            uint32_t tileMask, int borderPixels = 0) {
  36     SkTileGridFactory::TileGridInfo info;
  37     info.fMargin.set(borderPixels, borderPixels);
  38     info.fOffset.setZero();
  39     info.fTileInterval.set(10 - 2 * borderPixels, 10 - 2 * borderPixels);
  40     SkTileGrid grid(2, 2, info);
  41     grid.insert(NULL, rect, false);
  42     REPORTER_ASSERT(reporter, grid.tileCount(0, 0) ==
  43                     ((tileMask & kTopLeft_Tile)? 1 : 0));
  44     REPORTER_ASSERT(reporter, grid.tileCount(1, 0) ==
  45                     ((tileMask & kTopRight_Tile)? 1 : 0));
  46     REPORTER_ASSERT(reporter, grid.tileCount(0, 1) ==
  47                     ((tileMask & kBottomLeft_Tile)? 1 : 0));
  48     REPORTER_ASSERT(reporter, grid.tileCount(1, 1) ==
  49                     ((tileMask & kBottomRight_Tile)? 1 : 0));
  50 }
  51
  52 DEF_TEST(TileGrid_UnalignedQuery, reporter) {
  53     // Use SkTileGridPicture to generate a SkTileGrid with a helper
  54     SkTileGridFactory::TileGridInfo info;
  55     info.fMargin.setEmpty();
  56     info.fOffset.setZero();
  57     info.fTileInterval.set(10, 10);
  58     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
  59                                     SkIntToScalar(8), SkIntToScalar(8));
  60     SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(11), SkIntToScalar(11),
  61                                     SkIntToScalar(1), SkIntToScalar(1));
  62     SkTileGridFactory factory(info);
  63     SkPictureRecorder recorder;
  64     SkCanvas* canvas = recorder.beginRecording(20, 20, &factory, 0);
  65     SkPaint paint;
  66     canvas->drawRect(rect1, paint);
  67     canvas->drawRect(rect2, paint);
  68     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
  69
  70     SkBitmap store;
  71     store.allocN32Pixels(1, 1);
  72
  73     // Test parts of top-left tile
  74     {
  75         MockCanvas mockCanvas(store);
  76         picture->draw(&mockCanvas);
  77         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
  78         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
  79     }
  80     {
  81         MockCanvas mockCanvas(store);
  82         mockCanvas.translate(-7.99f, -7.99f);
  83         picture->draw(&mockCanvas);
  84         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
  85         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
  86     }
  87     // Corner overlap
  88     {
  89         MockCanvas mockCanvas(store);
  90         mockCanvas.translate(-9.5f, -9.5f);
  91         picture->draw(&mockCanvas);
  92         REPORTER_ASSERT(reporter, 2 == mockCanvas.fRects.count());
  93         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
  94         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[1]);
  95     }
  96     // Intersect bottom right tile, but does not overlap rect 2
  97     {
  98         MockCanvas mockCanvas(store);
  99         mockCanvas.translate(-16.0f, -16.0f);
 100         picture->draw(&mockCanvas);
 101         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 102         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
 103     }
 104     // Out of bounds queries, snap to border tiles
 105     {
 106         MockCanvas mockCanvas(store);
 107         mockCanvas.translate(2.0f, 0.0f);
 108         picture->draw(&mockCanvas);
 109         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 110         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
 111     }
 112     {
 113         MockCanvas mockCanvas(store);
 114         mockCanvas.translate(0.0f, 2.0f);
 115         picture->draw(&mockCanvas);
 116         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 117         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
 118     }
 119     {
 120         MockCanvas mockCanvas(store);
 121         mockCanvas.translate(-22.0f, -16.0f);
 122         picture->draw(&mockCanvas);
 123         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 124         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
 125     }
 126     {
 127         MockCanvas mockCanvas(store);
 128         mockCanvas.translate(-16.0f, -22.0f);
 129         picture->draw(&mockCanvas);
 130         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 131         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
 132     }
 133 }
 134
 135 DEF_TEST(TileGrid_OverlapOffsetQueryAlignment, reporter) {
 136     // Use SkTileGridPicture to generate a SkTileGrid with a helper
 137     SkTileGridFactory::TileGridInfo info;
 138     info.fMargin.set(1, 1);
 139     info.fOffset.set(-1, -1);
 140     info.fTileInterval.set(8, 8);
 141
 142     // rect landing entirely in top left tile
 143     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
 144                                     SkIntToScalar(1), SkIntToScalar(1));
 145     // rect landing entirely in center tile
 146     SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(12), SkIntToScalar(12),
 147                                     SkIntToScalar(1), SkIntToScalar(1));
 148     // rect landing entirely in bottomright tile
 149     SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(19), SkIntToScalar(19),
 150                                     SkIntToScalar(1), SkIntToScalar(1));
 151     SkTileGridFactory factory(info);
 152     SkPictureRecorder recorder;
 153     SkCanvas* canvas = recorder.beginRecording(20, 20, &factory, 0);
 154     SkPaint paint;
 155     canvas->drawRect(rect1, paint);
 156     canvas->drawRect(rect2, paint);
 157     canvas->drawRect(rect3, paint);
 158     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 159
 160     SkBitmap tileBitmap;
 161     tileBitmap.allocN32Pixels(10, 10);
 162     SkBitmap moreThanATileBitmap;
 163     moreThanATileBitmap.allocN32Pixels(11, 11);
 164     SkBitmap tinyBitmap;
 165     tinyBitmap.allocN32Pixels(2, 2);
 166     // Test parts of top-left tile
 167     {
 168         // The offset should cancel the top and left borders of the top left tile
 169         // So a look-up at interval 0-10 should be grid aligned,
 170         MockCanvas mockCanvas(tileBitmap);
 171         picture->draw(&mockCanvas);
 172         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 173         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
 174     }
 175     {
 176         // Encroaching border by one pixel
 177         MockCanvas mockCanvas(moreThanATileBitmap);
 178         picture->draw(&mockCanvas);
 179         REPORTER_ASSERT(reporter, 2 == mockCanvas.fRects.count());
 180         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
 181         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[1]);
 182     }
 183     {
 184         // Tile stride is 8 (tileWidth - 2 * border pixels
 185         // so translating by 8, should make query grid-aligned
 186         // with middle tile.
 187         MockCanvas mockCanvas(tileBitmap);
 188         mockCanvas.translate(SkIntToScalar(-8), SkIntToScalar(-8));
 189         picture->draw(&mockCanvas);
 190         REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
 191         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
 192     }
 193     {
 194         MockCanvas mockCanvas(tileBitmap);
 195         mockCanvas.translate(-7.9f, -7.9f);
 196         picture->draw(&mockCanvas);
 197         REPORTER_ASSERT(reporter, 2 == mockCanvas.fRects.count());
 198         REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
 199         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[1]);
 200     }
 201     {
 202         MockCanvas mockCanvas(tileBitmap);
 203         mockCanvas.translate(-8.1f, -8.1f);
 204         picture->draw(&mockCanvas);
 205         REPORTER_ASSERT(reporter, 2 == mockCanvas.fRects.count());
 206         REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
 207         REPORTER_ASSERT(reporter, rect3 == mockCanvas.fRects[1]);
 208     }
 209     {
 210         // Regression test for crbug.com/234688
 211         // Once the 2x2 device region is inset by margin, it yields an empty
 212         // adjusted region, sitting right on top of the tile boundary.
 213         MockCanvas mockCanvas(tinyBitmap);
 214         mockCanvas.translate(-8.0f, -8.0f);
 215         picture->draw(&mockCanvas);
 216         // This test passes by not asserting. We do not validate the rects recorded
 217         // because the result is numerically unstable (floating point equality).
 218         // The content of any one of the four tiles of the tilegrid would be a valid
 219         // result since any bbox that covers the center point of the canvas will be
 220         // recorded in all four tiles.
 221     }
 222 }
 223
 224 DEF_TEST(TileGrid, reporter) {
 225     // Out of bounds
 226     verifyTileHits(reporter, SkIRect::MakeXYWH(30, 0, 1, 1),  0);
 227     verifyTileHits(reporter, SkIRect::MakeXYWH(0, 30, 1, 1),  0);
 228     verifyTileHits(reporter, SkIRect::MakeXYWH(-10, 0, 1, 1),  0);
 229     verifyTileHits(reporter, SkIRect::MakeXYWH(0, -10, 1, 1),  0);
 230
 231     // Dilation for AA consideration
 232     verifyTileHits(reporter, SkIRect::MakeXYWH(0, 0, 9, 9),  kTopLeft_Tile);
 233     verifyTileHits(reporter, SkIRect::MakeXYWH(0, 0, 10, 10),  kAll_Tile);
 234     verifyTileHits(reporter, SkIRect::MakeXYWH(9, 9, 1, 1),  kAll_Tile);
 235     verifyTileHits(reporter, SkIRect::MakeXYWH(10, 10, 1, 1),  kAll_Tile);
 236     verifyTileHits(reporter, SkIRect::MakeXYWH(11, 11, 1, 1),  kBottomRight_Tile);
 237
 238     // BorderPixels
 239     verifyTileHits(reporter, SkIRect::MakeXYWH(0, 0, 6, 6),  kTopLeft_Tile, 1);
 240     verifyTileHits(reporter, SkIRect::MakeXYWH(0, 0, 7, 7),  kAll_Tile, 1);
 241     verifyTileHits(reporter, SkIRect::MakeXYWH(9, 9, 1, 1),  kAll_Tile, 1);
 242     verifyTileHits(reporter, SkIRect::MakeXYWH(10, 10, 1, 1),  kBottomRight_Tile, 1);
 243     verifyTileHits(reporter, SkIRect::MakeXYWH(17, 17, 1, 1),  kBottomRight_Tile, 1);
 244
 245     // BBoxes that overlap tiles
 246     verifyTileHits(reporter, SkIRect::MakeXYWH(5, 5, 10, 1),  kTopLeft_Tile | kTopRight_Tile);
 247     verifyTileHits(reporter, SkIRect::MakeXYWH(5, 5, 1, 10),  kTopLeft_Tile |
 248                    kBottomLeft_Tile);
 249     verifyTileHits(reporter, SkIRect::MakeXYWH(5, 5, 10, 10),  kAll_Tile);
 250     verifyTileHits(reporter, SkIRect::MakeXYWH(-10, -10, 40, 40),  kAll_Tile);
 251 }