test DEMPyramid

3 files changed, 164 insertions, 25 deletions

diff --git a/cmake/test-files.cmake b/cmake/test-files.cmake
index b580ecccc0..2191852b41 100644
--- a/cmake/test-files.cmake
+++ b/cmake/test-files.cmake
@@ -21,6 +21,9 @@ set(MBGL_TEST_FILES
     test/api/recycle_map.cpp
     test/api/zoom_history.cpp
 
+    # geometry
+    test/geometry/dem_pyramid.test.cpp
+
     # gl
     test/gl/bucket.test.cpp
     test/gl/context.test.cpp
diff --git a/src/mbgl/geometry/dem_pyramid.cpp b/src/mbgl/geometry/dem_pyramid.cpp
index 62cc94f27b..d4dbe76698 100644
--- a/src/mbgl/geometry/dem_pyramid.cpp
+++ b/src/mbgl/geometry/dem_pyramid.cpp
@@ -15,34 +15,34 @@ DEMPyramid::DEMPyramid(PremultipliedImage& image):
         }
     }
     
-    //    // in order to avoid flashing seams between tiles, here we are initially populating a 1px border of
-    //    // pixels around the image with the data of the nearest pixel from the image. this data is eventually
-    //    // replaced when the tile's neighboring tiles are loaded and the accurate data can be backfilled using
-    //    // DEMPyramid#backfillBorder
-    //
-    ////    for (int32_t x = 0; x < first.dim; x++) {
-    ////        // left vertical border
-    ////        first.set(-1, x, first.get(0, x));
-    ////
-    ////        // right vertical border
-    ////        first.set(first.dim, x, first.get(first.dim - 1, x));
-    ////
-    ////        //left horizontal border
-    ////        first.set(x, -1, first.get(x, 0));
-    ////
-    ////        // right horizontal border
-    ////        first.set(x, first.dim, first.get(x, first.dim - 1));
-    ////    }
-    ////
-    ////    // corners
-    ////    first.set(-1, -1, first.get(0, 0));
-    ////    first.set(first.dim, -1, first.get(first.dim - 1, 0));
-    ////    first.set( -1, first.dim, first.get(0, first.dim - 1));
-    ////    first.set(first.dim, first.dim, first.get(first.dim - 1, first.dim - 1));
+    // in order to avoid flashing seams between tiles, here we are initially populating a 1px border of
+    // pixels around the image with the data of the nearest pixel from the image. this data is eventually
+    // replaced when the tile's neighboring tiles are loaded and the accurate data can be backfilled using
+    // DEMPyramid#backfillBorder
+
+    for (int32_t x = 0; x < level.dim; x++) {
+        // left vertical border
+        level.set(-1, x, level.get(0, x));
+
+        // right vertical border
+        level.set(level.dim, x, level.get(level.dim - 1, x));
+
+        //left horizontal border
+        level.set(x, -1, level.get(x, 0));
+
+        // right horizontal border
+        level.set(x, level.dim, level.get(x, level.dim - 1));
+    }
+
+    // corners
+    level.set(-1, -1, level.get(0, 0));
+    level.set(level.dim, -1, level.get(level.dim - 1, 0));
+    level.set( -1, level.dim, level.get(0, level.dim - 1));
+    level.set(level.dim, level.dim, level.get(level.dim - 1, level.dim - 1));
     loaded = true;
 }
 
-void DEMPyramid::backfillBorder(mbgl::DEMPyramid &borderTileData, int8_t dx, int8_t dy) {
+void DEMPyramid::backfillBorder(mbgl::DEMPyramid& borderTileData, int8_t dx, int8_t dy) {
     auto& t = level;
     auto& o = borderTileData.level;
     assert(t.dim == o.dim);
diff --git a/test/geometry/dem_pyramid.test.cpp b/test/geometry/dem_pyramid.test.cpp
index c3ff8fd66e..05ad28b994 100644
--- a/test/geometry/dem_pyramid.test.cpp
+++ b/test/geometry/dem_pyramid.test.cpp
@@ -3,5 +3,141 @@
 #include <mbgl/util/image.hpp>
 #include <mbgl/geometry/dem_pyramid.hpp>
 
+using namespace mbgl;
 
+auto fakeImage = [](Size s) {
+    PremultipliedImage img = PremultipliedImage(s);
 
+    for (size_t i = 0; i < img.bytes(); i ++) {
+        img.data[i] = (i+1) % 4 == 0 ? 1 : std::rand() % 255;
+    }
+    return img;
+};
+
+TEST(Level, Constructor) {
+    DEMPyramid::Level level(4, 2);
+    EXPECT_EQ(level.dim, 4);
+    EXPECT_EQ(level.border, 2);
+    EXPECT_EQ(level.stride, 8);
+    EXPECT_EQ(level.image.bytes(), size_t(8*8*4));
+}
+
+TEST(Level, RoundTrip) {
+    DEMPyramid::Level level(4, 2);
+    level.set(0, 0, 255);
+    EXPECT_EQ(level.get(0,0), 255);
+}
+
+TEST(DEMPyramid, Constructor) {
+    PremultipliedImage image = fakeImage({16, 16});
+    DEMPyramid pyramid(image);
+
+    EXPECT_TRUE(pyramid.isLoaded());
+    EXPECT_EQ(pyramid.level.dim, 16);
+    EXPECT_EQ(pyramid.level.border, 8);
+};
+
+TEST(DEMPyramid, InitialBackfill) {
+
+    PremultipliedImage image1 = fakeImage({4, 4});
+    DEMPyramid dem1(image1);
+
+    bool nonempty = true;
+    // checking that a 1 px border around the fake image has been populated
+    // with a non-empty pixel value
+    for (int x = -1; x < 5; x++){
+        for (int y = -1; y < 5; y ++) {
+            if (dem1.level.get(x, y) == -65536) {
+                nonempty = false;
+                break;
+            }
+        }
+    }
+    EXPECT_TRUE(nonempty);
+
+    bool verticalBorderMatch = true;
+    int vertx[] = {-1, 4};
+    for (int x : vertx) {
+        for (int y = 0; y < 4; y++) {
+            if (dem1.level.get(x, y) != dem1.level.get(x < 0 ? x + 1 : x - 1, y)) {
+                verticalBorderMatch = false;
+                break;
+            }
+        }
+    }
+    // vertical border of DEM data is initially equal to next column of data
+    EXPECT_TRUE(verticalBorderMatch);
+
+    // horizontal borders empty
+    bool horizontalBorderMatch = true;
+    int horiz[] = {-1, 4};
+    for (int y : horiz) {
+        for (int x = 0; x < 4; x++) {
+            if (dem1.level.get(x, y) != dem1.level.get(x, y < 0 ? y + 1 : y - 1)) {
+                horizontalBorderMatch = false;
+                break;
+            }
+        }
+    }
+    //horizontal border of DEM data is initially equal to next row of data
+
+    EXPECT_TRUE(horizontalBorderMatch);
+    // -1, 1 corner initially equal to closest corner data
+    EXPECT_TRUE(dem1.level.get(-1, 4) == dem1.level.get(0, 3));
+    // 1, 1 corner initially equal to closest corner data
+    EXPECT_TRUE(dem1.level.get(4, 4) == dem1.level.get(3, 3));
+    // -1, -1 corner initially equal to closest corner data
+    EXPECT_TRUE(dem1.level.get(-1, -1) == dem1.level.get(0, 0));
+    // -1, 1 corner initially equal to closest corner data
+    EXPECT_TRUE(dem1.level.get(4, -1) == dem1.level.get(3, 0));
+};
+
+TEST(DEMPyramid, BackfillNeighbor) {
+    PremultipliedImage image1 = fakeImage({4, 4});
+    DEMPyramid dem0(image1);
+
+    PremultipliedImage image2 = fakeImage({4, 4});
+    DEMPyramid dem1(image2);
+
+    dem0.backfillBorder(dem1, -1, 0);
+    for (int y = 0; y < 4; y++) {
+        // dx = -1, dy = 0, so the left edge of dem1 should equal the right edge of dem0
+        // backfills Left neighbor
+        EXPECT_TRUE(dem0.level.get(-1, y) == dem1.level.get(3, y));
+
+    }
+
+    dem0.backfillBorder(dem1, 0, -1);
+    // backfills TopCenter neighbor
+    for (int x = 0; x < 4; x++) {
+        EXPECT_TRUE(dem0.level.get(x, -1) == dem1.level.get(x, 3));
+    }
+
+    dem0.backfillBorder(dem1, 1, 0);
+    // backfills Right neighb// backfulls TopRight neighboror
+    for (int y = 0; y < 4; y++) {
+        EXPECT_TRUE(dem0.level.get(4, y) == dem1.level.get(0, y));
+    }
+
+    dem0.backfillBorder(dem1, 0, 1);
+    // backfills BottomCenter neighbor
+    for (int x = 0; x < 4; x++) {
+        EXPECT_TRUE(dem0.level.get(x, 4) == dem1.level.get(x, 0));
+    }
+
+    dem0.backfillBorder(dem1, -1, 1);
+    // backfulls TopRight neighbor
+    EXPECT_TRUE(dem0.level.get(-1, 4) == dem1.level.get(3, 0));
+
+    dem0.backfillBorder(dem1, 1, 1);
+    // backfulls BottomRight neighbor
+    EXPECT_TRUE(dem0.level.get(4, 4) == dem1.level.get(0, 0));
+
+    dem0.backfillBorder(dem1, -1, -1);
+    // backfulls TopLeft neighbor
+    EXPECT_TRUE(dem0.level.get(-1, -1) == dem1.level.get(3, 3));
+
+    dem0.backfillBorder(dem1, 1, -1);
+    // backfulls BottomLeft neighbor
+    EXPECT_TRUE(dem0.level.get(4, -1) == dem1.level.get(0, 3));
+};