summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
authorBruno de Oliveira Abinader <bruno@mapbox.com>2016-10-06 16:26:11 +0300
committerBruno de Oliveira Abinader <bruno@mapbox.com>2016-10-11 19:36:21 +0300
commit9946e605365f8d4a718dfd85b4e28ca653a787c1 (patch)
treed1c0478475a72e54ec2ab15cadc37973a2a39c66 /test
parent36b3ba56b6394f8d5d0f4f43176e65c24ffba6ea (diff)
downloadqtlocation-mapboxgl-9946e605365f8d4a718dfd85b4e28ca653a787c1.tar.gz
[test] Added TileCoordinate tests
Diffstat (limited to 'test')
-rw-r--r--test/tile/tile_coordinate.test.cpp92
1 files changed, 92 insertions, 0 deletions
diff --git a/test/tile/tile_coordinate.test.cpp b/test/tile/tile_coordinate.test.cpp
new file mode 100644
index 0000000000..f2337c1e7f
--- /dev/null
+++ b/test/tile/tile_coordinate.test.cpp
@@ -0,0 +1,92 @@
+#include <mbgl/test/util.hpp>
+
+#include <mbgl/map/change.hpp>
+#include <mbgl/map/transform.hpp>
+#include <mbgl/map/transform_state.hpp>
+#include <mbgl/tile/tile.hpp>
+#include <mbgl/tile/tile_id.hpp>
+#include <mbgl/util/constants.hpp>
+#include <mbgl/util/geometry.hpp>
+#include <mbgl/util/tile_coordinate.hpp>
+
+
+using namespace mbgl;
+
+TEST(TileCoordinate, FromLatLng) {
+ size_t changeCount = 0;
+ std::vector<MapChange> changes = {
+ MapChangeRegionWillChange,
+ MapChangeRegionDidChange,
+ };
+ auto onMapChange = [&](MapChange change) {
+ ASSERT_EQ(change, changes[changeCount]);
+ ++changeCount;
+ };
+
+ Transform transform(onMapChange);
+
+ const double max = util::tileSize;
+ const std::array<uint16_t, 2> size { { uint16_t(max), uint16_t(max) } };
+ transform.resize(size);
+
+ // Center, top-left, bottom-left, bottom-right, top-right edges.
+ std::vector<std::pair<LatLng, ScreenCoordinate>> edges {
+ { {}, { max / 2.0, max / 2.0 } },
+ { { util::LATITUDE_MAX, -util::LONGITUDE_MAX }, { 0, max } },
+ { { -util::LATITUDE_MAX, -util::LONGITUDE_MAX }, { 0, 0 } },
+ { { -util::LATITUDE_MAX, util::LONGITUDE_MAX }, { max, 0 } },
+ { { util::LATITUDE_MAX, util::LONGITUDE_MAX }, { max, max } },
+ };
+
+ for (const auto& pair : edges) {
+ const auto& latLng = pair.first;
+ const auto& screenCoordinate = pair.second;
+ const auto base = TileCoordinate::fromLatLng(transform.getState(), 0, latLng);
+
+ // 16 is the maximum zoom level where we actually compute placements.
+ for (uint8_t integerZoom = 0; integerZoom <= 16; ++integerZoom) {
+ const double zoom = integerZoom;
+ const double maxTilesPerAxis = std::pow(2.0, zoom);
+ const Point<double> tilePoint = {
+ latLng.longitude == 0 ? 0.5 : latLng.longitude == -util::LONGITUDE_MAX ? 0 : 1.0,
+ latLng.latitude == 0 ? 0.5 : latLng.latitude == -util::LATITUDE_MAX ? 1.0 : 0,
+ };
+
+ const auto fromLatLng = TileCoordinate::fromLatLng(transform.getState(), zoom, latLng);
+ ASSERT_DOUBLE_EQ(fromLatLng.z, zoom);
+ ASSERT_DOUBLE_EQ(fromLatLng.p.x, tilePoint.x * maxTilesPerAxis);
+ ASSERT_NEAR(fromLatLng.p.y, tilePoint.y * maxTilesPerAxis, 1.0e-7);
+
+ const auto fromScreenCoordinate = TileCoordinate::fromScreenCoordinate(transform.getState(), zoom, screenCoordinate);
+ ASSERT_DOUBLE_EQ(fromScreenCoordinate.z, fromLatLng.z);
+ ASSERT_NEAR(fromScreenCoordinate.p.x, fromLatLng.p.x, 0.99);
+ ASSERT_NEAR(fromScreenCoordinate.p.y, fromLatLng.p.y, 0.99);
+
+ const auto zoomed = base.zoomTo(zoom);
+ ASSERT_DOUBLE_EQ(zoomed.z, zoom);
+ ASSERT_DOUBLE_EQ(zoomed.p.x, fromLatLng.p.x);
+ ASSERT_DOUBLE_EQ(zoomed.p.y, fromLatLng.p.y);
+ }
+ }
+}
+
+TEST(TileCoordinate, ToGeometryCoordinate) {
+ std::vector<Point<double>> edges {
+ { 0.5, 0.5 }, { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 }
+ };
+
+ for (uint8_t zoom = 0; zoom <= 16; ++zoom) {
+ uint32_t maxTilesPerAxis = std::pow(2, zoom);
+ for (const auto& edge : edges) {
+ uint32_t tileX = edge.x == 0 ? 0 : edge.x == 1 ? maxTilesPerAxis - 1 : (maxTilesPerAxis / 2.0) - 1;
+ uint32_t tileY = edge.y == 0 ? 0 : edge.y == 1 ? maxTilesPerAxis - 1 : (maxTilesPerAxis / 2.0) - 1;
+ UnwrappedTileID unwrapped(0, CanonicalTileID { zoom, tileX, tileY });
+
+ auto tilePointX = ((edge.x * maxTilesPerAxis) - tileX) * util::EXTENT;
+ auto tilePointY = ((edge.y * maxTilesPerAxis) - tileY) * util::EXTENT;
+ GeometryCoordinate point = TileCoordinate::toGeometryCoordinate(unwrapped, edge);
+ ASSERT_DOUBLE_EQ(point.x, tilePointX);
+ ASSERT_DOUBLE_EQ(point.y, tilePointY);
+ }
+ }
+}