200 lines
7.9 KiB
C++
200 lines
7.9 KiB
C++
#include "catch.hpp"
|
|
#include "geometry_equal.hpp"
|
|
|
|
#include <mapnik/geometry.hpp>
|
|
#include <mapnik/projection.hpp>
|
|
#include <mapnik/proj_transform.hpp>
|
|
#include <mapnik/view_transform.hpp>
|
|
#include <mapnik/geometry_transform.hpp>
|
|
#include <mapnik/geometry_strategy.hpp>
|
|
#include <mapnik/proj_strategy.hpp>
|
|
#include <mapnik/view_strategy.hpp>
|
|
#include <mapnik/vector_tile_strategy.hpp>
|
|
|
|
TEST_CASE("geometry strategy tests") {
|
|
|
|
SECTION("proj and view strategy") {
|
|
using namespace mapnik::geometry;
|
|
mapnik::box2d<double> e(-20037508.342789,-20037508.342789,20037508.342789,20037508.342789);
|
|
mapnik::view_transform vt(256, 256, e);
|
|
mapnik::view_strategy vs(vt);
|
|
mapnik::unview_strategy uvs(vt);
|
|
mapnik::projection source("+init=epsg:4326");
|
|
mapnik::projection dest("+init=epsg:3857");
|
|
mapnik::proj_transform proj_trans(source, dest);
|
|
mapnik::proj_transform proj_trans_rev(dest, source);
|
|
mapnik::proj_strategy ps(proj_trans);
|
|
mapnik::proj_strategy ps_rev(proj_trans_rev);
|
|
{
|
|
// Test first that proj strategy works properly
|
|
point<double> p1(-97.553098,35.523105);
|
|
point<double> r1(-1.08596e+07, 4.2352e+06);
|
|
point<double> p3 = transform<double>(p1, ps);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test next that view_strategy works
|
|
point<double> p1(-1.08596e+07, 4.2352e+06);
|
|
point<double> r1(58.6287 , 100.945);
|
|
point<double> p3 = transform<double>(p1, vs);
|
|
assert_g_equal(r1, p3);
|
|
|
|
}
|
|
{
|
|
// Test next that view_strategy works as single process in strategy group
|
|
point<double> p1(-1.08596e+07, 4.2352e+06);
|
|
point<double> r1(58.6287 , 100.945);
|
|
using sg_type = strategy_group<mapnik::view_strategy>;
|
|
sg_type sg(vs);
|
|
point<double> p3 = transform<double>(p1, sg);
|
|
assert_g_equal(r1, p3);
|
|
|
|
}
|
|
{
|
|
// Test that both work grouped together in strategy group
|
|
using sg_type = strategy_group<mapnik::proj_strategy, mapnik::view_strategy >;
|
|
sg_type sg(ps, vs);
|
|
point<double> p1(-97.553098,35.523105);
|
|
point<double> r1(58.6287 , 100.945);
|
|
point<double> p3 = transform<double>(p1, sg);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test that both work grouped together passing in geometry
|
|
using sg_type = strategy_group<mapnik::proj_strategy, mapnik::view_strategy >;
|
|
sg_type sg(ps, vs);
|
|
geometry<double> p1(std::move(point<double>(-97.553098,35.523105)));
|
|
point<double> r1(58.6287 , 100.945);
|
|
geometry<double> p2 = transform<double>(p1, sg);
|
|
REQUIRE(p2.is<point<double> >());
|
|
point<double> p3 = mapnik::util::get<point<double> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test that it works pulling back int
|
|
using sg_type = strategy_group<mapnik::proj_strategy, mapnik::view_strategy >;
|
|
sg_type sg(ps, vs);
|
|
geometry<double> p1(std::move(point<double>(-97.553098,35.523105)));
|
|
point<std::int64_t> r1(58 , 100);
|
|
geometry<std::int64_t> p2 = transform<std::int64_t>(p1, sg);
|
|
REQUIRE(p2.is<point<std::int64_t> >());
|
|
point<std::int64_t> p3 = mapnik::util::get<point<std::int64_t> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test with scaling as well. This would be like projection from 4326 to a vector tile.
|
|
mapnik::geometry::scale_rounding_strategy ss(16);
|
|
using sg_type = strategy_group<mapnik::proj_strategy, mapnik::view_strategy, mapnik::geometry::scale_rounding_strategy >;
|
|
sg_type sg(ps, vs, ss);
|
|
geometry<double> p1(std::move(point<double>(-97.553098,35.523105)));
|
|
point<std::int64_t> r1(938 , 1615);
|
|
geometry<std::int64_t> p2 = transform<std::int64_t>(p1, sg);
|
|
REQUIRE(p2.is<point<std::int64_t> >());
|
|
point<std::int64_t> p3 = mapnik::util::get<point<std::int64_t> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test vector tile strategy
|
|
mapnik::geometry::vector_tile_strategy vs(proj_trans_rev, vt, 16);
|
|
geometry<double> p1(std::move(point<double>(-97.553098,35.523105)));
|
|
point<std::int64_t> r1(938 , 1615);
|
|
geometry<std::int64_t> p2 = transform<std::int64_t>(p1, vs);
|
|
REQUIRE(p2.is<point<std::int64_t> >());
|
|
point<std::int64_t> p3 = mapnik::util::get<point<std::int64_t> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test the entire process in reverse! This would be like converting a vector tile coordinate to 4326.
|
|
mapnik::geometry::scale_strategy ss(1.0/16.0);
|
|
using sg_type = strategy_group_first<mapnik::geometry::scale_strategy, mapnik::unview_strategy, mapnik::proj_strategy >;
|
|
sg_type sg(ss, uvs, ps_rev);
|
|
geometry<std::int64_t> p1(std::move(point<std::int64_t>(938 , 1615)));
|
|
point<double> r1(-97.5586 , 35.5322);
|
|
geometry<double> p2 = transform<double>(p1, sg);
|
|
REQUIRE(p2.is<point<double> >());
|
|
point<double> p3 = mapnik::util::get<point<double> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test with scaling + offset as well. This would be like projection from 4326 to a vector tile.
|
|
mapnik::geometry::scale_rounding_strategy ss(16, 20);
|
|
using sg_type = strategy_group<mapnik::proj_strategy, mapnik::view_strategy, mapnik::geometry::scale_rounding_strategy >;
|
|
sg_type sg(ps, vs, ss);
|
|
geometry<double> p1(std::move(point<double>(-97.553098,35.523105)));
|
|
point<std::int64_t> r1(958 , 1635);
|
|
geometry<std::int64_t> p2 = transform<std::int64_t>(p1, sg);
|
|
REQUIRE(p2.is<point<std::int64_t> >());
|
|
point<std::int64_t> p3 = mapnik::util::get<point<std::int64_t> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
{
|
|
// Test the entire scaling plus offset in reverse process in reverse! This would be like converting a vector tile coordinate to 4326.
|
|
mapnik::geometry::scale_strategy ss(1.0/16.0, -20.0/16.0);
|
|
using sg_type = strategy_group_first<mapnik::geometry::scale_strategy, mapnik::unview_strategy, mapnik::proj_strategy >;
|
|
sg_type sg(ss, uvs, ps_rev);
|
|
geometry<std::int64_t> p1(std::move(point<std::int64_t>(958 , 1635)));
|
|
point<double> r1(-97.5586 , 35.5322);
|
|
geometry<double> p2 = transform<double>(p1, sg);
|
|
REQUIRE(p2.is<point<double> >());
|
|
point<double> p3 = mapnik::util::get<point<double> >(p2);
|
|
assert_g_equal(r1, p3);
|
|
}
|
|
|
|
} // END SECTION
|
|
|
|
SECTION("scaling strategies - double to double") {
|
|
using namespace mapnik::geometry;
|
|
|
|
{
|
|
scale_strategy ss(10.0);
|
|
point<double> p(-90.3, 35.5);
|
|
point<double> r(-903.0, 355.0);
|
|
point<double> o = transform<double>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
{
|
|
scale_strategy ss(0.5, -2.0);
|
|
point<double> p(-90.3, 35.5);
|
|
point<double> r(-47.15, 15.75);
|
|
point<double> o = transform<double>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
{
|
|
scale_rounding_strategy ss(0.5, -2.0);
|
|
point<double> p(-90.3, 35.5);
|
|
point<double> r(-47.0, 16.0);
|
|
point<double> o = transform<double>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
|
|
} // END SECTION
|
|
|
|
SECTION("scaling strategies - double to int64") {
|
|
using namespace mapnik::geometry;
|
|
|
|
{
|
|
scale_strategy ss(10.0);
|
|
point<double> p(-90.31, 35.58);
|
|
point<std::int64_t> r(-903, 355);
|
|
point<std::int64_t> o = transform<std::int64_t>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
{
|
|
scale_strategy ss(0.5, -2.0);
|
|
point<double> p(-90.3, 35.5);
|
|
point<std::int64_t> r(-47, 15);
|
|
point<std::int64_t> o = transform<std::int64_t>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
{
|
|
scale_rounding_strategy ss(0.5, -2.0);
|
|
point<double> p(-90.3, 35.5);
|
|
point<std::int64_t> r(-47, 16);
|
|
point<std::int64_t> o = transform<std::int64_t>(p, ss);
|
|
assert_g_equal(r, o);
|
|
}
|
|
} // END SECTION
|
|
|
|
} // END TEST CASE
|
|
|
|
|