diff --git a/SConstruct b/SConstruct index ce9ac2eab..67f647272 100644 --- a/SConstruct +++ b/SConstruct @@ -1,6 +1,6 @@ # This file is part of Mapnik (c++ mapping toolkit) # -# Copyright (C) 2017 Artem Pavlenko +# Copyright (C) 2021 Artem Pavlenko # # Mapnik is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -66,7 +66,8 @@ SCONF_TEMP_DIR = '.sconf_temp' BOOST_SEARCH_PREFIXES = ['/usr/local','/opt/local','/sw','/usr',] BOOST_MIN_VERSION = '1.61' #CAIRO_MIN_VERSION = '1.8.0' - +PROJ_MIN_VERSION = (7, 2, 0) +PROJ_MIN_VERSION_STRING = "%s.%s.%s" % PROJ_MIN_VERSION HARFBUZZ_MIN_VERSION = (0, 9, 34) HARFBUZZ_MIN_VERSION_STRING = "%s.%s.%s" % HARFBUZZ_MIN_VERSION @@ -80,6 +81,7 @@ pretty_dep_names = { 'ogr':'OGR-enabled GDAL C++ Library | configured using gdal-config program | try setting GDAL_CONFIG SCons option | more info: https://github.com/mapnik/mapnik/wiki/OGR', 'cairo':'Cairo C library | configured using pkg-config | try setting PKG_CONFIG_PATH SCons option', 'proj':'Proj C Projections library | configure with PROJ_LIBS & PROJ_INCLUDES | more info: http://trac.osgeo.org/proj/', + 'proj-min-version':'libproj >=%s required' % PROJ_MIN_VERSION_STRING, 'pg':'Postgres C Library required for PostGIS plugin | configure with pg_config program or configure with PG_LIBS & PG_INCLUDES | more info: https://github.com/mapnik/mapnik/wiki/PostGIS', 'sqlite3':'SQLite3 C Library | configure with SQLITE_LIBS & SQLITE_INCLUDES | more info: https://github.com/mapnik/mapnik/wiki/SQLite', 'jpeg':'JPEG C library | configure with JPEG_LIBS & JPEG_INCLUDES', @@ -103,7 +105,7 @@ pretty_dep_names = { 'boost_regex_icu':'libboost_regex built with optional ICU unicode support is needed for unicode regex support in mapnik.', 'sqlite_rtree':'The SQLite plugin requires libsqlite3 built with RTREE support (-DSQLITE_ENABLE_RTREE=1)', 'pgsql2sqlite_rtree':'The pgsql2sqlite program requires libsqlite3 built with RTREE support (-DSQLITE_ENABLE_RTREE=1)', - 'PROJ_LIB':'The directory where proj4 stores its data files. Must exist for proj4 to work correctly', + 'PROJ_LIB':'The directory where proj stores its data files. Must exist for proj to work correctly', 'GDAL_DATA':'The directory where GDAL stores its data files. Must exist for GDAL to work correctly', 'ICU_DATA':'The directory where icu stores its data files. If ICU reports a path, it must exist. ICU can also be built without .dat files and in that case this path is empty' } @@ -407,7 +409,7 @@ opts.AddVariables( BoolVariable('WEBP', 'Build Mapnik with WEBP read', 'True'), PathVariable('WEBP_INCLUDES', 'Search path for libwebp include files', '/usr/include', PathVariable.PathAccept), PathVariable('WEBP_LIBS','Search path for libwebp library files','/usr/' + LIBDIR_SCHEMA_DEFAULT, PathVariable.PathAccept), - BoolVariable('PROJ', 'Build Mapnik with proj4 support to enable transformations between many different projections', 'True'), + BoolVariable('PROJ', 'Build Mapnik with proj support to enable transformations between many different projections', 'True'), PathVariable('PROJ_INCLUDES', 'Search path for PROJ.4 include files', '/usr/include', PathVariable.PathAccept), PathVariable('PROJ_LIBS', 'Search path for PROJ.4 library files', '/usr/' + LIBDIR_SCHEMA_DEFAULT, PathVariable.PathAccept), ('PG_INCLUDES', 'Search path for libpq (postgres client) include files', ''), @@ -918,6 +920,31 @@ def CheckGdalData(context, silent=False): context.Result('Failed to detect (mapnik-config will have null value)') return value +def proj_version(context): + context.Message('Checking for Proj version >=%s...' % PROJ_MIN_VERSION_STRING) + ret, out = context.TryRun(""" +#include "proj.h" +#include +#define PROJ_VERSION_ATLEAST(major,minor,micro) \ + ((major)*10000+(minor)*100+(micro) <= \ + PROJ_VERSION_MAJOR*10000+PROJ_VERSION_MINOR*100+PROJ_VERSION_PATCH) +int main() +{ + printf("%d;%d.%d.%d", PROJ_VERSION_ATLEAST{min-version}, PROJ_VERSION_MAJOR, PROJ_VERSION_MINOR, PROJ_VERSION_PATCH); + return 0; +} +""".replace("{min-version}", str(PROJ_MIN_VERSION)),'.c') + if not ret: + context.Result('error (could not get version from proj.h)') + else: + ok_str, found_version_str = out.strip().split(';', 1) + major,minor,patch = found_version_str.split('.') + ret = int(ok_str), int(major)*10000+int(minor)*100+int(patch) + if ret: + context.Result('yes (found Proj %s)' % found_version_str) + else: + context.Result('no (found Proj %s)' % found_version_str) + return ret def CheckProjData(context, silent=False): @@ -925,51 +952,40 @@ def CheckProjData(context, silent=False): context.Message('Checking for PROJ_LIB directory...') ret, out = context.TryRun(""" -// This is narly, could eventually be replaced using https://github.com/OSGeo/proj.4/pull/551] -#include +#include #include -#include +#include +#include +#include +#include -static void my_proj4_logger(void * user_data, int /*level*/, const char * msg) +std::vector split_searchpath(std::string const& paths) { - std::string* posMsg = static_cast(user_data); - *posMsg += msg; + std::vector output; + std::stringstream ss(paths); + std::string path; + + for( std::string path;std::getline(ss, path, ':');) + { + output.push_back(path); + } + return output; } -// https://github.com/OSGeo/gdal/blob/ddbf6d39aa4b005a77ca4f27c2d61a3214f336f8/gdal/alg/gdalapplyverticalshiftgrid.cpp#L616-L633 - -std::string find_proj_path(const char * pszFilename) { - std::string osMsg; - std::string osFilename; - projCtx ctx = pj_ctx_alloc(); - pj_ctx_set_app_data(ctx, &osMsg); - pj_ctx_set_debug(ctx, PJ_LOG_DEBUG_MAJOR); - pj_ctx_set_logger(ctx, my_proj4_logger); - PAFile f = pj_open_lib(ctx, pszFilename, "rb"); - if( f ) +int main() +{ + PJ_INFO info = proj_info(); + std::string result = info.searchpath; + for (auto path : split_searchpath(result)) { - pj_ctx_fclose(ctx, f); + std::ifstream file(path + "/proj.db"); + if (file) + { + std::cout << path; + return 0; + } } - size_t nPos = osMsg.find("fopen("); - if( nPos != std::string::npos ) - { - osFilename = osMsg.substr(nPos + strlen("fopen(")); - nPos = osFilename.find(")"); - if( nPos != std::string::npos ) - osFilename = osFilename.substr(0, nPos); - } - pj_ctx_free(ctx); - return osFilename; -} - - -int main() { - std::string result = find_proj_path(" "); - std::cout << result; - if (result.empty()) { - return -1; - } - return 0; + return -1; } """, '.cpp') @@ -977,7 +993,7 @@ int main() { if silent: context.did_show_result=1 if ret: - context.Result('pj_open_lib returned %s' % value) + context.Result('proj_info.searchpath returned %s' % value) else: context.Result('Failed to detect (mapnik-config will have null value)') return value @@ -1215,7 +1231,7 @@ int main() context.Result(ret) return ret -__cplusplus = {'14':'201402L', '17':'201703L'} +__cplusplus = {'14':'201402L', '17':'201703L', '20':'202002L'} def supports_cxx_std (context, silent=False): cplusplus_string = __cplusplus[env['CXX_STD']] @@ -1245,6 +1261,7 @@ conf_tests = { 'prioritize_paths' : prioritize_paths, 'FindBoost' : FindBoost, 'CheckBoost' : CheckBoost, 'CheckIcuData' : CheckIcuData, + 'proj_version' : proj_version, 'CheckProjData' : CheckProjData, 'CheckGdalData' : CheckGdalData, 'CheckCairoHasFreetype' : CheckCairoHasFreetype, @@ -1545,7 +1562,7 @@ if not preconfigured: env['SKIPPED_DEPS'].append('jpeg') if env['PROJ']: - OPTIONAL_LIBSHEADERS.append(['proj', 'proj_api.h', False,'C','-DMAPNIK_USE_PROJ4']) + OPTIONAL_LIBSHEADERS.append(['proj', 'proj.h', False,'C','-DMAPNIK_USE_PROJ']) inc_path = env['%s_INCLUDES' % 'PROJ'] lib_path = env['%s_LIBS' % 'PROJ'] env.AppendUnique(CPPPATH = fix_path(inc_path)) @@ -1697,6 +1714,13 @@ if not preconfigured: else: color_print(4, 'Could not find optional header or shared library for %s' % libname) env['SKIPPED_DEPS'].append(libname) + elif libname == 'proj': + result, version = conf.proj_version() + if not result: + env['SKIPPED_DEPS'].append('proj-min-version') + else: + env.Append(CPPDEFINES = define) + env.Append(CPPDEFINES = "-DMAPNIK_PROJ_VERSION=%d" % version) else: env.Append(CPPDEFINES = define) else: diff --git a/benchmark/build.py b/benchmark/build.py index b08724d8d..7f77e49b1 100644 --- a/benchmark/build.py +++ b/benchmark/build.py @@ -9,6 +9,7 @@ test_env = env.Clone() test_env['LIBS'] = [env['MAPNIK_NAME']] test_env.AppendUnique(LIBS=copy(env['LIBMAPNIK_LIBS'])) test_env.AppendUnique(LIBS='mapnik-wkt') +test_env.AppendUnique(LIBS='sqlite3') if env['PLATFORM'] == 'Linux': test_env.AppendUnique(LIBS='dl') test_env.AppendUnique(LIBS='rt') diff --git a/benchmark/data/gdal-wgs.xml b/benchmark/data/gdal-wgs.xml index aa5866532..7a0ca6012 100644 --- a/benchmark/data/gdal-wgs.xml +++ b/benchmark/data/gdal-wgs.xml @@ -1,7 +1,7 @@ + srs="epsg:4326"> style ./valid.geotiff.tif diff --git a/benchmark/data/raster-wgs.xml b/benchmark/data/raster-wgs.xml index 3ee054d2d..d879f4fc8 100644 --- a/benchmark/data/raster-wgs.xml +++ b/benchmark/data/raster-wgs.xml @@ -1,7 +1,7 @@ + srs="epsg:4326"> style ./valid.geotiff.tif diff --git a/benchmark/src/test_noop_rendering.cpp b/benchmark/src/test_noop_rendering.cpp index 03d2e675c..55c09e34c 100644 --- a/benchmark/src/test_noop_rendering.cpp +++ b/benchmark/src/test_noop_rendering.cpp @@ -11,7 +11,7 @@ #include #include - + class test : public benchmark::test_case { public: @@ -24,7 +24,7 @@ public: } bool operator()() const { - mapnik::Map m(256,256,"+init=epsg:3857"); + mapnik::Map m(256,256,"epsg:3857"); mapnik::parameters params; params["type"]="memory"; diff --git a/benchmark/src/test_polygon_clipping.cpp b/benchmark/src/test_polygon_clipping.cpp index aed74fe33..e27300423 100644 --- a/benchmark/src/test_polygon_clipping.cpp +++ b/benchmark/src/test_polygon_clipping.cpp @@ -51,7 +51,7 @@ void render(mapnik::geometry::multi_polygon const& geom, agg::pixfmt_rgba32_plain pixf(buf); ren_base renb(pixf); renderer ren(renb); - mapnik::proj_transform prj_trans(mapnik::projection("+init=epsg:4326"),mapnik::projection("+init=epsg:4326")); + mapnik::proj_transform prj_trans(mapnik::projection("epsg:4326"),mapnik::projection("epsg:4326")); ren.color(agg::rgba8(127,127,127,255)); agg::rasterizer_scanline_aa<> ras; for (auto const& poly : geom) diff --git a/benchmark/src/test_proj_transform1.cpp b/benchmark/src/test_proj_transform1.cpp index fa050da12..be85685d8 100644 --- a/benchmark/src/test_proj_transform1.cpp +++ b/benchmark/src/test_proj_transform1.cpp @@ -9,7 +9,7 @@ class test : public benchmark::test_case std::string dest_; mapnik::box2d from_; mapnik::box2d to_; - bool defer_proj4_init_; + bool defer_proj_init_; public: test(mapnik::parameters const& params, std::string const& src, @@ -22,11 +22,11 @@ public: dest_(dest), from_(from), to_(to), - defer_proj4_init_(defer_proj) {} + defer_proj_init_(defer_proj) {} bool validate() const { - mapnik::projection src(src_,defer_proj4_init_); - mapnik::projection dest(dest_,defer_proj4_init_); + mapnik::projection src(src_,defer_proj_init_); + mapnik::projection dest(dest_,defer_proj_init_); mapnik::proj_transform tr(src,dest); mapnik::box2d bbox = from_; if (!tr.forward(bbox)) return false; @@ -38,15 +38,15 @@ public: } bool operator()() const { + mapnik::projection src(src_,defer_proj_init_); + mapnik::projection dest(dest_,defer_proj_init_); + mapnik::proj_transform tr(src,dest); for (std::size_t i=0;i box(j,k,j,k); if (!tr.forward(box)) throw std::runtime_error("could not transform coords"); } @@ -56,19 +56,19 @@ public: } }; -// echo -180 -60 | cs2cs -f "%.10f" +init=epsg:4326 +to +init=epsg:3857 +// echo -180 -60 | cs2cs -f "%.10f" epsg:4326 +to epsg:3857 int main(int argc, char** argv) { mapnik::box2d from(-180,-80,180,80); mapnik::box2d to(-20037508.3427892476,-15538711.0963092316,20037508.3427892476,15538711.0963092316); - std::string from_str("+init=epsg:4326"); - std::string to_str("+init=epsg:3857"); + std::string from_str("epsg:4326"); + std::string to_str("epsg:3857"); std::string from_str2("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"); std::string to_str2("+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over"); return benchmark::sequencer(argc, argv) - .run("lonlat->merc epsg", from_str, to_str, from, to, true) - .run("lonlat->merc literal", from_str2, to_str2, from, to, true) - .run("merc->lonlat epsg", to_str, from_str, to, from, true) - .run("merc->lonlat literal", to_str2, from_str2, to, from, true) + .run("lonlat->merc epsg (internal)", from_str, to_str, from, to, true) + .run("lonlat->merc literal (libproj)", from_str2, to_str2, from, to, true) + .run("merc->lonlat epsg (internal)", to_str, from_str, to, from, true) + .run("merc->lonlat literal (libproj)", to_str2, from_str2, to, from, true) .done(); } diff --git a/bootstrap.sh b/bootstrap.sh index 9187badd6..7480c8202 100755 --- a/bootstrap.sh +++ b/bootstrap.sh @@ -8,7 +8,7 @@ todo - shrink icu data ' -MASON_VERSION="edb620c7" +MASON_VERSION="485514d8" function setup_mason() { if [[ ! -d ./.mason ]]; then @@ -49,17 +49,17 @@ BOOST_VERSION="1.75.0" function install_mason_deps() { install ccache 3.3.1 install zlib 1.2.8 - install jpeg_turbo 1.5.1 libjpeg - install libpng 1.6.28 libpng - install libtiff 4.0.7 libtiff - install libpq 9.6.2 - install sqlite 3.17.0 libsqlite3 + install jpeg_turbo 1.5.2 libjpeg + install libpng 1.6.32 libpng + install libtiff 4.0.8 libtiff + install libpq 9.6.5 + install sqlite 3.34.0 libsqlite3 install icu ${ICU_VERSION} - install proj 4.9.3 libproj + install proj 7.2.1 libproj install pixman 0.34.0 libpixman-1 install cairo 1.14.8 libcairo install webp 0.6.0 libwebp - install libgdal 2.1.3 libgdal + install libgdal 2.2.3 libgdal install boost ${BOOST_VERSION} install boost_libsystem ${BOOST_VERSION} install boost_libfilesystem ${BOOST_VERSION} diff --git a/demo/c++/build.py b/demo/c++/build.py index c059b05da..d2d2bc5fa 100644 --- a/demo/c++/build.py +++ b/demo/c++/build.py @@ -41,7 +41,7 @@ if env['HAS_CAIRO']: demo_env.Append(CPPDEFINES = '-DHAVE_CAIRO') libraries = [env['MAPNIK_NAME']] -libraries.extend(copy(env['LIBMAPNIK_LIBS'])) +libraries.extend([copy(env['LIBMAPNIK_LIBS']), 'sqlite3', 'pthread']) rundemo = demo_env.Program('rundemo', source, LIBS=libraries) Depends(rundemo, env.subst('../../src/%s' % env['MAPNIK_LIB_NAME'])) diff --git a/demo/viewer/mainwindow.cpp b/demo/viewer/mainwindow.cpp index cdfd43471..338180f66 100644 --- a/demo/viewer/mainwindow.cpp +++ b/demo/viewer/mainwindow.cpp @@ -421,11 +421,11 @@ void MainWindow::set_default_extent(double x0,double y0, double x1, double y1) if (map_ptr) { mapnik::projection prj(map_ptr->srs()); - prj.forward(x0,y0); - prj.forward(x1,y1); - default_extent_=mapnik::box2d(x0,y0,x1,y1); + prj.forward(x0, y0); + prj.forward(x1, y1); + default_extent_=mapnik::box2d(x0, y0, x1, y1); mapWidget_->zoomToBox(default_extent_); - std::cout << "SET DEFAULT EXT\n"; + std::cout << "SET DEFAULT EXT:" << default_extent_ << std::endl; } } catch (...) {} diff --git a/demo/viewer/mapwidget.cpp b/demo/viewer/mapwidget.cpp index de4523059..b1ea939b0 100644 --- a/demo/viewer/mapwidget.cpp +++ b/demo/viewer/mapwidget.cpp @@ -23,7 +23,7 @@ #include #include #include -#include +#include #include #include #include @@ -156,7 +156,7 @@ void MapWidget::mousePressEvent(QMouseEvent* e) { QVector > info; - projection map_proj(map_->srs()); // map projection + projection map_proj(map_->srs(), true); // map projection double scale_denom = scale_denominator(map_->scale(),map_proj.is_geographic()); view_transform t(map_->width(),map_->height(),map_->get_current_extent()); @@ -170,7 +170,7 @@ void MapWidget::mousePressEvent(QMouseEvent* e) double x = e->x(); double y = e->y(); std::cout << "query at " << x << "," << y << "\n"; - projection layer_proj(layer.srs()); + projection layer_proj(layer.srs(), true); mapnik::proj_transform prj_trans(map_proj,layer_proj); //std::auto_ptr data(new mapnik::memory_datasource); mapnik::featureset_ptr fs = map_->query_map_point(index,x,y); @@ -586,38 +586,43 @@ void MapWidget::updateMap() try { - projection prj(map_->srs()); // map projection - box2d ext = map_->get_current_extent(); - double x0 = ext.minx(); - double y0 = ext.miny(); - double x1 = ext.maxx(); - double y1 = ext.maxy(); - prj.inverse(x0,y0); - prj.inverse(x1,y1); - std::cout << "BBOX (WGS84): " << x0 << "," << y0 << "," << x1 << "," << y1 << "\n"; - update(); - // emit signal to interested widgets - emit mapViewChanged(); - } - catch (...) - { - std::cerr << "Unknown exception caught!\n"; - } + projection prj(map_->srs(), true); // map projection + box2d ext = map_->get_current_extent(); + double x0 = ext.minx(); + double y0 = ext.miny(); + double x1 = ext.maxx(); + double y1 = ext.maxy(); + double z = 0; + std::string dest_srs = {"epsg:4326"}; + mapnik::proj_transform proj_tr(map_->srs(), dest_srs); + + proj_tr.forward(x0, y0, z); + proj_tr.forward(x1, y1, z); + std::cout << "MAP SIZE:" << map_->width() << "," << map_->height() << std::endl; + std::cout << "BBOX (WGS84): " << x0 << "," << y0 << "," << x1 << "," << y1 << "\n"; + update(); + // emit signal to interested widgets + emit mapViewChanged(); + } + catch (...) + { + std::cerr << "Unknown exception caught!\n"; + } } } std::shared_ptr MapWidget::getMap() { - return map_; + return map_; } void MapWidget::setMap(std::shared_ptr map) { - map_ = map; + map_ = map; } void MapWidget::layerSelected(int index) { - selectedLayer_ = index; + selectedLayer_ = index; } diff --git a/include/mapnik/feature_style_processor_impl.hpp b/include/mapnik/feature_style_processor_impl.hpp index b0a5fe9b7..96c4da3d1 100644 --- a/include/mapnik/feature_style_processor_impl.hpp +++ b/include/mapnik/feature_style_processor_impl.hpp @@ -41,7 +41,7 @@ #include #include #include -#include +#include #include #include #include @@ -66,10 +66,9 @@ struct layer_rendering_material std::vector materials_; layer_rendering_material(layer const& lay, projection const& dest) - : - lay_(lay), - proj0_(dest), - proj1_(lay.srs(),true) {} + : lay_(lay), + proj0_(dest), + proj1_(lay.srs(), true) {} layer_rendering_material(layer_rendering_material && rhs) = default; }; @@ -255,8 +254,7 @@ void feature_style_processor::prepare_layer(layer_rendering_material } processor_context_ptr current_ctx = ds->get_context(ctx_map); - proj_transform prj_trans(mat.proj0_,mat.proj1_); - + proj_transform const* proj_trans_ptr = m_.get_proj_transform(mat.proj0_.params(), mat.proj1_.params()); box2d query_ext = extent; // unbuffered box2d buffered_query_ext(query_ext); // buffered @@ -286,22 +284,22 @@ void feature_style_processor::prepare_layer(layer_rendering_material bool early_return = false; // first, try intersection of map extent forward projected into layer srs - if (prj_trans.forward(buffered_query_ext, PROJ_ENVELOPE_POINTS) && buffered_query_ext.intersects(layer_ext)) + if (proj_trans_ptr->forward(buffered_query_ext, PROJ_ENVELOPE_POINTS) && buffered_query_ext.intersects(layer_ext)) { fw_success = true; layer_ext.clip(buffered_query_ext); } // if no intersection and projections are also equal, early return - else if (prj_trans.equal()) + else if (proj_trans_ptr->equal()) { early_return = true; } // next try intersection of layer extent back projected into map srs - else if (prj_trans.backward(layer_ext, PROJ_ENVELOPE_POINTS) && buffered_query_ext_map_srs.intersects(layer_ext)) + else if (proj_trans_ptr->backward(layer_ext, PROJ_ENVELOPE_POINTS) && buffered_query_ext_map_srs.intersects(layer_ext)) { layer_ext.clip(buffered_query_ext_map_srs); // forward project layer extent back into native projection - if (! prj_trans.forward(layer_ext, PROJ_ENVELOPE_POINTS)) + if (! proj_trans_ptr->forward(layer_ext, PROJ_ENVELOPE_POINTS)) { MAPNIK_LOG_ERROR(feature_style_processor) << "feature_style_processor: Layer=" << lay.name() @@ -353,17 +351,17 @@ void feature_style_processor::prepare_layer(layer_rendering_material layer_ext2 = lay.envelope(); if (fw_success) { - if (prj_trans.forward(query_ext, PROJ_ENVELOPE_POINTS)) + if (proj_trans_ptr->forward(query_ext, PROJ_ENVELOPE_POINTS)) { layer_ext2.clip(query_ext); } } else { - if (prj_trans.backward(layer_ext2, PROJ_ENVELOPE_POINTS)) + if (proj_trans_ptr->backward(layer_ext2, PROJ_ENVELOPE_POINTS)) { layer_ext2.clip(query_ext); - prj_trans.forward(layer_ext2, PROJ_ENVELOPE_POINTS); + proj_trans_ptr->forward(layer_ext2, PROJ_ENVELOPE_POINTS); } } @@ -495,9 +493,7 @@ void feature_style_processor::render_material(layer_rendering_materia layer const& lay = mat.lay_; std::vector const & rule_caches = mat.rule_caches_; - - proj_transform prj_trans(mat.proj0_,mat.proj1_); - + proj_transform const* proj_trans_ptr = m_.get_proj_transform(mat.proj0_.params(), mat.proj1_.params()); bool cache_features = lay.cache_features() && active_styles.size() > 1; datasource_ptr ds = lay.datasource(); @@ -525,10 +521,9 @@ void feature_style_processor::render_material(layer_rendering_materia cache->prepare(); render_style(p, style, - rule_caches[i], + rule_caches[i++], cache, - prj_trans); - ++i; + *proj_trans_ptr); } cache->clear(); } @@ -540,8 +535,7 @@ void feature_style_processor::render_material(layer_rendering_materia for (feature_type_style const* style : active_styles) { cache->prepare(); - render_style(p, style, rule_caches[i], cache, prj_trans); - ++i; + render_style(p, style, rule_caches[i++], cache, *proj_trans_ptr); } cache->clear(); } @@ -565,9 +559,8 @@ void feature_style_processor::render_material(layer_rendering_materia { cache->prepare(); render_style(p, style, - rule_caches[i], - cache, prj_trans); - ++i; + rule_caches[i++], + cache, *proj_trans_ptr); } } // We only have a single style and no grouping. @@ -579,10 +572,9 @@ void feature_style_processor::render_material(layer_rendering_materia { featureset_ptr features = *featuresets++; render_style(p, style, - rule_caches[i], + rule_caches[i++], features, - prj_trans); - ++i; + *proj_trans_ptr); } } } diff --git a/include/mapnik/layer.hpp b/include/mapnik/layer.hpp index 81f8bf534..dd28057d5 100644 --- a/include/mapnik/layer.hpp +++ b/include/mapnik/layer.hpp @@ -42,7 +42,7 @@ using datasource_ptr = std::shared_ptr; * @brief A Mapnik map layer. * * Create a layer with a named string and, optionally, an srs string either - * with a Proj.4 epsg code ('+init=epsg:') or with a Proj.4 literal + * with a Proj.4 epsg code ('epsg:') or with a Proj.4 literal * ('+proj='). If no srs is specified it will default to * '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs' */ @@ -50,7 +50,7 @@ class MAPNIK_DECL layer { public: layer(std::string const& name, - std::string const& srs=MAPNIK_LONGLAT_PROJ); + std::string const& srs = MAPNIK_GEOGRAPHIC_PROJ); // copy layer(layer const& l); // move diff --git a/include/mapnik/map.hpp b/include/mapnik/map.hpp index e62f966b7..7b0c155c5 100644 --- a/include/mapnik/map.hpp +++ b/include/mapnik/map.hpp @@ -33,7 +33,7 @@ #include #include #include - +#include #include MAPNIK_DISABLE_WARNING_PUSH #include @@ -41,7 +41,6 @@ MAPNIK_DISABLE_WARNING_PUSH MAPNIK_DISABLE_WARNING_POP // stl -#include #include #include #include @@ -54,11 +53,11 @@ using featureset_ptr = std::shared_ptr; class feature_type_style; class view_transform; class layer; +struct proj_transform_cache; class MAPNIK_DECL Map : boost::equality_comparable { public: - enum aspect_fix_mode { // grow the width or height of the specified geo bbox to fill the map size. default behaviour. @@ -83,8 +82,8 @@ public: }; private: - static const unsigned MIN_MAPSIZE=16; - static const unsigned MAX_MAPSIZE=MIN_MAPSIZE<<10; + static const unsigned MIN_MAPSIZE = 16; + static const unsigned MAX_MAPSIZE = MIN_MAPSIZE << 10; unsigned width_; unsigned height_; std::string srs_; @@ -104,9 +103,8 @@ private: boost::optional font_directory_; freetype_engine::font_file_mapping_type font_file_mapping_; freetype_engine::font_memory_cache_type font_memory_cache_; - + std::unique_ptr proj_cache_ = {}; public: - using const_style_iterator = std::map::const_iterator; using style_iterator = std::map::iterator; using const_fontset_iterator = std::map::const_iterator; @@ -126,7 +124,7 @@ public: * @param height Initial map height. * @param srs Initial map projection. */ - Map(int width, int height, std::string const& srs = MAPNIK_LONGLAT_PROJ); + Map(int width, int height, std::string const& srs = MAPNIK_GEOGRAPHIC_PROJ); /*! \brief Copy Constructor. * @@ -503,9 +501,13 @@ public: return font_memory_cache_; } + proj_transform const* get_proj_transform(std::string const& source, std::string const& dest) const; + private: friend void swap(Map & rhs, Map & lhs); void fixAspectRatio(); + void init_proj_transform(std::string const& source, std::string const& dest); + void init_proj_transforms(); }; DEFINE_ENUM(aspect_fix_mode_e,Map::aspect_fix_mode); diff --git a/include/mapnik/proj_transform.hpp b/include/mapnik/proj_transform.hpp index 588a048eb..2287ef74f 100644 --- a/include/mapnik/proj_transform.hpp +++ b/include/mapnik/proj_transform.hpp @@ -27,40 +27,37 @@ #include #include #include +#include // stl #include namespace mapnik { -class projection; template class box2d; class MAPNIK_DECL proj_transform : private util::noncopyable { public: - proj_transform(projection const& source, - projection const& dest); - + proj_transform(projection const& source, projection const& dest); + ~proj_transform(); bool equal() const; bool is_known() const; bool forward (double& x, double& y , double& z) const; bool backward (double& x, double& y , double& z) const; - bool forward (double *x, double *y , double *z, int point_count, int offset = 1) const; - bool backward (double *x, double *y , double *z, int point_count, int offset = 1) const; + bool forward (double *x, double *y , double *z, std::size_t point_count, std::size_t offset = 1) const; + bool backward (double *x, double *y , double *z, std::size_t point_count, std::size_t offset = 1) const; bool forward (geometry::point & p) const; bool backward (geometry::point & p) const; unsigned int forward (std::vector> & ls) const; unsigned int backward (std::vector> & ls) const; bool forward (box2d & box) const; bool backward (box2d & box) const; - bool forward (box2d & box, int points) const; - bool backward (box2d & box, int points) const; - mapnik::projection const& source() const; - mapnik::projection const& dest() const; - + bool forward (box2d & box, std::size_t points) const; + bool backward (box2d & box, std::size_t points) const; + std::string definition() const; private: - projection const& source_; - projection const& dest_; + PJ_CONTEXT* ctx_ = nullptr; + PJ* transform_ = nullptr; bool is_source_longlat_; bool is_dest_longlat_; bool is_source_equal_dest_; diff --git a/include/mapnik/proj_transform_cache.hpp b/include/mapnik/proj_transform_cache.hpp new file mode 100644 index 000000000..b080081aa --- /dev/null +++ b/include/mapnik/proj_transform_cache.hpp @@ -0,0 +1,76 @@ +/***************************************************************************** + * + * This file is part of Mapnik (c++ mapping toolkit) + * + * Copyright (C) 2021 Artem Pavlenko + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + *****************************************************************************/ + + +#ifndef MAPNIK_PROJ_TRANSFORM_CACHE_HPP +#define MAPNIK_PROJ_TRANSFORM_CACHE_HPP + +#include +#include + +MAPNIK_DISABLE_WARNING_PUSH +#include +#include +#include +#include +MAPNIK_DISABLE_WARNING_POP + +namespace mapnik { + +struct proj_transform_cache : util::noncopyable +{ + using key_type = std::pair; + using compatible_key_type = std::pair; + + struct compatible_hash + { + template + std::size_t operator() (KeyType const& key) const + { + using hash_type = boost::hash; + std::size_t seed = hash_type{}(key.first); + seed ^= hash_type{}(key.second) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + return seed; + } + }; + + struct compatible_predicate + { + bool operator()(compatible_key_type const& k1, + compatible_key_type const& k2) const + { + return k1 == k2; + } + }; + + using cache_type = boost::unordered_map, compatible_hash>; + + proj_transform_cache() = default; + + thread_local static cache_type cache_; + void init(std::string const& source, std::string const& dest) const; + proj_transform const* get(std::string const& source, std::string const& dest) const; +}; + +} + +#endif // MAPNIK_PROJ_TRANSFORM_CACHE_HPP diff --git a/include/mapnik/projection.hpp b/include/mapnik/projection.hpp index cba5f7110..0f0918456 100644 --- a/include/mapnik/projection.hpp +++ b/include/mapnik/projection.hpp @@ -37,6 +37,18 @@ MAPNIK_DISABLE_WARNING_POP #include #include + +// fwd decl +#if MAPNIK_PROJ_VERSION >= 80000 +struct pj_ctx; +using PJ_CONTEXT = struct pj_ctx; +#else +struct projCtx_t; +using PJ_CONTEXT = struct projCtx_t; +#endif +struct PJconsts; +using PJ = struct PJconsts; + namespace mapnik { class proj_init_error : public std::runtime_error @@ -52,7 +64,7 @@ class MAPNIK_DECL projection public: projection(std::string const& params, - bool defer_proj_init = false); + bool defer_proj_init = false); projection(projection const& rhs); ~projection(); @@ -66,7 +78,7 @@ public: void forward(double & x, double & y) const; void inverse(double & x,double & y) const; std::string expanded() const; - void init_proj4() const; + void init_proj() const; private: void swap (projection& rhs); @@ -75,8 +87,8 @@ private: std::string params_; bool defer_proj_init_; mutable bool is_geographic_; - mutable void * proj_; - mutable void * proj_ctx_; + mutable PJ * proj_; + mutable PJ_CONTEXT * proj_ctx_; }; template diff --git a/include/mapnik/util/math.hpp b/include/mapnik/util/math.hpp index d2f1f6ef7..7e163ba57 100644 --- a/include/mapnik/util/math.hpp +++ b/include/mapnik/util/math.hpp @@ -27,8 +27,8 @@ namespace mapnik { namespace util { -constexpr double pi = 3.1415926535897932384626433832795; -constexpr double tau = 6.283185307179586476925286766559; +constexpr double pi = 3.14159265358979323846; +constexpr double tau = 2.0 * pi; template constexpr T const& clamp(T const& v, T const& lo, T const& hi) @@ -38,12 +38,12 @@ constexpr T const& clamp(T const& v, T const& lo, T const& hi) constexpr double degrees(double rad) { - return rad * (360 / tau); + return rad * (180.0 / pi); } constexpr double radians(double deg) { - return deg * (tau / 360); + return deg * (pi / 180); } MAPNIK_DECL double normalize_angle(double angle); diff --git a/include/mapnik/well_known_srs.hpp b/include/mapnik/well_known_srs.hpp index a2154a8e5..29ad18c05 100644 --- a/include/mapnik/well_known_srs.hpp +++ b/include/mapnik/well_known_srs.hpp @@ -41,7 +41,7 @@ namespace mapnik { enum well_known_srs_enum : std::uint8_t { WGS_84, - G_MERC, + WEB_MERC, well_known_srs_enum_MAX }; @@ -53,8 +53,8 @@ constexpr double MERC_MAX_EXTENT = EARTH_RADIUS * util::pi; constexpr double MERC_MAX_LATITUDE = 85.0511287798065923778; // MERC_MAX_LATITUDE = degrees(2 * atan(exp(pi)) - pi / 2) -extern MAPNIK_DECL std::string const MAPNIK_LONGLAT_PROJ; -extern MAPNIK_DECL std::string const MAPNIK_GMERC_PROJ; +extern MAPNIK_DECL std::string const MAPNIK_GEOGRAPHIC_PROJ; +extern MAPNIK_DECL std::string const MAPNIK_WEBMERCATOR_PROJ; MAPNIK_DECL boost::optional is_known_geographic(std::string const& srs); MAPNIK_DECL boost::optional is_well_known_srs(std::string const& srs); diff --git a/src/build.py b/src/build.py index 3231a0085..9227c1089 100644 --- a/src/build.py +++ b/src/build.py @@ -76,8 +76,9 @@ if '-DHAVE_PNG' in env['CPPDEFINES']: lib_env['LIBS'].append('png') enabled_imaging_libraries.append('png_reader.cpp') -if '-DMAPNIK_USE_PROJ4' in env['CPPDEFINES']: +if '-DMAPNIK_USE_PROJ' in env['CPPDEFINES']: lib_env['LIBS'].append('proj') + lib_env['LIBS'].append('sqlite3') if '-DHAVE_TIFF' in env['CPPDEFINES']: lib_env['LIBS'].append('tiff') @@ -213,6 +214,7 @@ source = Split( twkb.cpp projection.cpp proj_transform.cpp + proj_transform_cache.cpp scale_denominator.cpp simplify.cpp parse_transform.cpp diff --git a/src/map.cpp b/src/map.cpp index 9d6eabfcf..8d20225ca 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -31,7 +31,7 @@ #include #include #include -#include +#include #include #include #include @@ -63,10 +63,11 @@ static const char * aspect_fix_mode_strings[] = { IMPLEMENT_ENUM( aspect_fix_mode_e, aspect_fix_mode_strings ) + Map::Map() -: width_(400), +: width_(400), height_(400), - srs_(MAPNIK_LONGLAT_PROJ), + srs_(MAPNIK_GEOGRAPHIC_PROJ), buffer_size_(0), background_image_comp_op_(src_over), background_image_opacity_(1.0), @@ -110,8 +111,11 @@ Map::Map(Map const& rhs) extra_params_(rhs.extra_params_), font_directory_(rhs.font_directory_), font_file_mapping_(rhs.font_file_mapping_), - // on copy discard memory cache - font_memory_cache_() {} + // on copy discard memory caches + font_memory_cache_() +{ + init_proj_transforms(); +} Map::Map(Map && rhs) @@ -133,13 +137,16 @@ Map::Map(Map && rhs) extra_params_(std::move(rhs.extra_params_)), font_directory_(std::move(rhs.font_directory_)), font_file_mapping_(std::move(rhs.font_file_mapping_)), - font_memory_cache_(std::move(rhs.font_memory_cache_)) {} + font_memory_cache_(std::move(rhs.font_memory_cache_)), + proj_cache_(std::move(rhs.proj_cache_)) {} Map::~Map() {} + Map& Map::operator=(Map rhs) { swap(*this, rhs); + init_proj_transforms(); return *this; } @@ -164,7 +171,7 @@ void swap (Map & lhs, Map & rhs) std::swap(lhs.extra_params_, rhs.extra_params_); std::swap(lhs.font_directory_,rhs.font_directory_); std::swap(lhs.font_file_mapping_,rhs.font_file_mapping_); - // on assignment discard memory cache + // on assignment discard memory caches //std::swap(lhs.font_memory_cache_,rhs.font_memory_cache_); } @@ -323,11 +330,13 @@ size_t Map::layer_count() const void Map::add_layer(layer const& l) { + init_proj_transform(srs_, l.srs()); layers_.emplace_back(l); } void Map::add_layer(layer && l) { + init_proj_transform(srs_, l.srs()); layers_.push_back(std::move(l)); } @@ -419,7 +428,9 @@ std::string const& Map::srs() const void Map::set_srs(std::string const& _srs) { + if (srs_ != _srs) init_proj_transforms(); srs_ = _srs; + } void Map::set_buffer_size(int _buffer_size) @@ -517,7 +528,6 @@ void Map::zoom_all() { return; } - projection proj0(srs_); box2d ext; bool success = false; bool first = true; @@ -526,10 +536,9 @@ void Map::zoom_all() if (layer.active()) { std::string const& layer_srs = layer.srs(); - projection proj1(layer_srs); - proj_transform prj_trans(proj0,proj1); + proj_transform const* proj_trans_ptr = proj_cache_->get(srs_, layer_srs);; box2d layer_ext = layer.envelope(); - if (prj_trans.backward(layer_ext, PROJ_ENVELOPE_POINTS)) + if (proj_trans_ptr->backward(layer_ext, PROJ_ENVELOPE_POINTS)) { success = true; MAPNIK_LOG_DEBUG(map) << "map: Layer " << layer.name() << " original ext=" << layer.envelope(); @@ -707,11 +716,9 @@ featureset_ptr Map::query_point(unsigned index, double x, double y) const mapnik::datasource_ptr ds = layer.datasource(); if (ds) { - mapnik::projection dest(srs_); - mapnik::projection source(layer.srs()); - proj_transform prj_trans(source,dest); + proj_transform const* proj_trans_ptr = proj_cache_->get(layer.srs(), srs_); double z = 0; - if (!prj_trans.equal() && !prj_trans.backward(x,y,z)) + if (!proj_trans_ptr->equal() && !proj_trans_ptr->backward(x,y,z)) { throw std::runtime_error("query_point: could not project x,y into layer srs"); } @@ -721,7 +728,7 @@ featureset_ptr Map::query_point(unsigned index, double x, double y) const { map_ex.clip(*maximum_extent_); } - if (!prj_trans.backward(map_ex,PROJ_ENVELOPE_POINTS)) + if (!proj_trans_ptr->backward(map_ex,PROJ_ENVELOPE_POINTS)) { std::ostringstream s; s << "query_point: could not project map extent '" << map_ex @@ -772,4 +779,24 @@ void Map::set_extra_parameters(parameters& params) extra_params_ = params; } +mapnik::proj_transform const* Map::get_proj_transform(std::string const& source, std::string const& dest) const +{ + return proj_cache_->get(source, dest); +} + +void Map::init_proj_transform(std::string const& source, std::string const& dest) +{ + proj_cache_->init(source, dest); +} + +void Map::init_proj_transforms() +{ + std::for_each(layers_.begin(), + layers_.end(), + [this] (auto const& l) + { + init_proj_transform(srs_, l.srs()); + }); +} + } diff --git a/src/proj_transform.cpp b/src/proj_transform.cpp index ed0563837..4571cdad9 100644 --- a/src/proj_transform.cpp +++ b/src/proj_transform.cpp @@ -28,13 +28,13 @@ #include #include #include - +#include // boost #include -#ifdef MAPNIK_USE_PROJ4 -// proj4 -#include +#ifdef MAPNIK_USE_PROJ +// proj +#include #endif // stl @@ -95,30 +95,28 @@ auto envelope_points(box2d const& env, std::size_t num_points) proj_transform::proj_transform(projection const& source, projection const& dest) - : source_(source), - dest_(dest), - is_source_longlat_(false), + : is_source_longlat_(false), is_dest_longlat_(false), is_source_equal_dest_(false), wgs84_to_merc_(false), merc_to_wgs84_(false) { - is_source_equal_dest_ = (source_ == dest_); + is_source_equal_dest_ = (source == dest); if (!is_source_equal_dest_) { - is_source_longlat_ = source_.is_geographic(); - is_dest_longlat_ = dest_.is_geographic(); + is_source_longlat_ = source.is_geographic(); + is_dest_longlat_ = dest.is_geographic(); boost::optional src_k = source.well_known(); boost::optional dest_k = dest.well_known(); bool known_trans = false; if (src_k && dest_k) { - if (*src_k == WGS_84 && *dest_k == G_MERC) + if (*src_k == WGS_84 && *dest_k == WEB_MERC) { wgs84_to_merc_ = true; known_trans = true; } - else if (*src_k == G_MERC && *dest_k == WGS_84) + else if (*src_k == WEB_MERC && *dest_k == WGS_84) { merc_to_wgs84_ = true; known_trans = true; @@ -126,16 +124,45 @@ proj_transform::proj_transform(projection const& source, } if (!known_trans) { -#ifdef MAPNIK_USE_PROJ4 - source_.init_proj4(); - dest_.init_proj4(); +#ifdef MAPNIK_USE_PROJ + ctx_ = proj_context_create(); + transform_ = proj_create_crs_to_crs(ctx_, + source.params().c_str(), + dest.params().c_str(), nullptr); + if (transform_ == nullptr) + { + throw std::runtime_error(std::string("Cannot initialize proj_transform for given projections: '") + source.params() + "'->'" + dest.params() + "'"); + } + PJ* transform_gis = proj_normalize_for_visualization(ctx_, transform_); + if (transform_gis == nullptr) + { + throw std::runtime_error(std::string("Cannot initialize proj_transform for given projections: '") + source.params() + "'->'" + dest.params() + "'"); + } + proj_destroy(transform_); + transform_ = transform_gis; #else - throw std::runtime_error(std::string("Cannot initialize proj_transform for given projections without proj4 support (-DMAPNIK_USE_PROJ4): '") + source_.params() + "'->'" + dest_.params() + "'"); + throw std::runtime_error(std::string("Cannot initialize proj_transform for given projections without proj support (-DMAPNIK_USE_PROJ): '") + source.params() + "'->'" + dest.params() + "'"); #endif } } } +proj_transform::~proj_transform() +{ +#ifdef MAPNIK_USE_PROJ + if (transform_) + { + proj_destroy(transform_); + transform_ = nullptr; + } + if (ctx_) + { + proj_context_destroy(ctx_); + ctx_ = nullptr; + } +#endif +} + bool proj_transform::equal() const { return is_source_equal_dest_; @@ -187,9 +214,8 @@ unsigned int proj_transform::forward (std::vector> & ls) return 0; } -bool proj_transform::forward (double * x, double * y , double * z, int point_count, int offset) const +bool proj_transform::forward (double * x, double * y , double * z, std::size_t point_count, std::size_t offset) const { - if (is_source_equal_dest_) return true; @@ -202,42 +228,19 @@ bool proj_transform::forward (double * x, double * y , double * z, int point_cou return merc2lonlat(x, y, point_count, offset); } -#ifdef MAPNIK_USE_PROJ4 - if (is_source_longlat_) - { - int i; - for(i=0; i & box) const // Alternative is to provide proper clipping box // in the target srs by setting map 'maximum-extent' -bool proj_transform::backward(box2d& env, int points) const +bool proj_transform::backward(box2d& env, std::size_t points) const { if (is_source_equal_dest_) return true; @@ -433,7 +411,7 @@ bool proj_transform::backward(box2d& env, int points) const return true; } -bool proj_transform::forward(box2d& env, int points) const +bool proj_transform::forward(box2d& env, std::size_t points) const { if (is_source_equal_dest_) return true; @@ -473,13 +451,25 @@ bool proj_transform::forward(box2d& env, int points) const return true; } -mapnik::projection const& proj_transform::source() const +std::string proj_transform::definition() const { - return source_; -} -mapnik::projection const& proj_transform::dest() const -{ - return dest_; -} +#ifdef MAPNIK_USE_PROJ + if (transform_) + { + PJ_PROJ_INFO info = proj_pj_info(transform_); + return mapnik::util::trim_copy(info.definition); + } + else +#endif + if (wgs84_to_merc_) + { + return "wgs84 => merc"; + } + else if (merc_to_wgs84_) + { + return "merc => wgs84"; + } + return "unknown"; + } } diff --git a/src/proj_transform_cache.cpp b/src/proj_transform_cache.cpp new file mode 100644 index 000000000..1e051bd8a --- /dev/null +++ b/src/proj_transform_cache.cpp @@ -0,0 +1,58 @@ +/***************************************************************************** + * + * This file is part of Mapnik (c++ mapping toolkit) + * + * Copyright (C) 2021 Artem Pavlenko + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + *****************************************************************************/ + +#include + +namespace mapnik { + +thread_local proj_transform_cache::cache_type proj_transform_cache::cache_ = cache_type(); + +void proj_transform_cache::init(std::string const& source, std::string const& dest) const +{ + compatible_key_type key = std::make_pair(source, dest); + auto itr = cache_.find(key, compatible_hash{}, compatible_predicate{}); + if (itr == cache_.end()) + { + mapnik::projection p0(source, true); + mapnik::projection p1(dest, true); + cache_.emplace(std::make_pair(source, dest), + std::make_unique(p0, p1)); + } +} + +proj_transform const* proj_transform_cache::get(std::string const& source, std::string const& dest) const +{ + + compatible_key_type key = std::make_pair(source, dest); + auto itr = cache_.find(key, compatible_hash{}, compatible_predicate{}); + if (itr == cache_.end()) + { + mapnik::projection srs1(source, true); + mapnik::projection srs2(dest, true); + return cache_.emplace(std::make_pair(source, dest), + std::make_unique(srs1, srs2)).first->second.get(); + } + return itr->second.get(); +} + + +} // namespace mapnik diff --git a/src/projection.cpp b/src/projection.cpp index b8c2f5b71..302ff418e 100644 --- a/src/projection.cpp +++ b/src/projection.cpp @@ -28,23 +28,14 @@ // stl #include -#ifdef MAPNIK_USE_PROJ4 -// proj4 -#include - #if defined(MAPNIK_THREADSAFE) && PJ_VERSION < 480 - #include - static std::mutex mutex_; - #ifdef _MSC_VER - #pragma NOTE(mapnik is building against < proj 4.8, reprojection will be faster if you use >= 4.8) - #else - #warning mapnik is building against < proj 4.8, reprojection will be faster if you use >= 4.8 - #endif - #endif +#ifdef MAPNIK_USE_PROJ +// proj +#include +#include // HUGE_VAL #endif namespace mapnik { - projection::projection(std::string const& params, bool defer_proj_init) : params_(params), defer_proj_init_(defer_proj_init), @@ -58,13 +49,13 @@ projection::projection(std::string const& params, bool defer_proj_init) } else { -#ifdef MAPNIK_USE_PROJ4 - init_proj4(); +#ifdef MAPNIK_USE_PROJ + init_proj(); #else - throw std::runtime_error(std::string("Cannot initialize projection '") + params_ + " ' without proj4 support (-DMAPNIK_USE_PROJ4)"); + throw std::runtime_error(std::string("Cannot initialize projection '") + params_ + " ' without proj support (-DMAPNIK_USE_PROJ)"); #endif } - if (!defer_proj_init_) init_proj4(); + if (!defer_proj_init_) init_proj(); } projection::projection(projection const& rhs) @@ -74,7 +65,7 @@ projection::projection(projection const& rhs) proj_(nullptr), proj_ctx_(nullptr) { - if (!defer_proj_init_) init_proj4(); + if (!defer_proj_init_) init_proj(); } projection& projection::operator=(projection const& rhs) @@ -83,7 +74,7 @@ projection& projection::operator=(projection const& rhs) swap(tmp); proj_ctx_ = nullptr; proj_ = nullptr; - if (!defer_proj_init_) init_proj4(); + if (!defer_proj_init_) init_proj(); return *this; } @@ -97,34 +88,29 @@ bool projection::operator!=(const projection& other) const return !(*this == other); } -void projection::init_proj4() const +void projection::init_proj() const { -#ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ if (!proj_) { -#if PJ_VERSION >= 480 - proj_ctx_ = pj_ctx_alloc(); - proj_ = pj_init_plus_ctx(proj_ctx_, params_.c_str()); + proj_ctx_ = proj_context_create(); + proj_ = proj_create(proj_ctx_, params_.c_str()); if (!proj_ || !proj_ctx_) { if (proj_ctx_) { - pj_ctx_free(proj_ctx_); + proj_context_destroy(proj_ctx_); proj_ctx_ = nullptr; } if (proj_) { - pj_free(proj_); + proj_destroy(proj_); proj_ = nullptr; } throw proj_init_error(params_); } -#else - #if defined(MAPNIK_THREADSAFE) - std::lock_guard lock(mutex_); - #endif - proj_ = pj_init_plus(params_.c_str()); - if (!proj_) throw proj_init_error(params_); -#endif - is_geographic_ = pj_is_latlong(proj_) ? true : false; + PJ_TYPE type = proj_get_type(proj_); + is_geographic_ = (type == PJ_TYPE_GEOGRAPHIC_2D_CRS + || + type == PJ_TYPE_GEOGRAPHIC_3D_CRS) ? true : false; } #endif } @@ -151,82 +137,68 @@ std::string const& projection::params() const void projection::forward(double & x, double &y ) const { -#ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ if (!proj_) { - throw std::runtime_error("projection::forward not supported unless proj4 is initialized"); - } - #if defined(MAPNIK_THREADSAFE) && PJ_VERSION < 480 - std::lock_guard lock(mutex_); - #endif - projUV p; - p.u = x * DEG_TO_RAD; - p.v = y * DEG_TO_RAD; - p = pj_fwd(p,proj_); - x = p.u; - y = p.v; - if (is_geographic_) - { - x *=RAD_TO_DEG; - y *=RAD_TO_DEG; + throw std::runtime_error("projection::forward not supported unless proj is initialized"); } + PJ_COORD coord; + coord.lpzt.z = 0.0; + coord.lpzt.t = HUGE_VAL; + coord.lpzt.lam = x; + coord.lpzt.phi = y; + PJ_COORD coord_out = proj_trans(proj_, PJ_FWD, coord); + x = coord_out.xy.x; + y = coord_out.xy.y; #else - throw std::runtime_error("projection::forward not supported without proj4 support (-DMAPNIK_USE_PROJ4)"); + throw std::runtime_error("projection::forward not supported without proj support (-DMAPNIK_USE_PROJ)"); #endif } void projection::inverse(double & x,double & y) const { -#ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ if (!proj_) { - throw std::runtime_error("projection::inverse not supported unless proj4 is initialized"); + throw std::runtime_error("projection::forward not supported unless proj is initialized"); } - - #if defined(MAPNIK_THREADSAFE) && PJ_VERSION < 480 - std::lock_guard lock(mutex_); - #endif - if (is_geographic_) - { - x *=DEG_TO_RAD; - y *=DEG_TO_RAD; - } - projUV p; - p.u = x; - p.v = y; - p = pj_inv(p,proj_); - x = RAD_TO_DEG * p.u; - y = RAD_TO_DEG * p.v; + PJ_COORD coord; + coord.xyzt.z = 0.0; + coord.xyzt.t = HUGE_VAL; + coord.xyzt.x = x; + coord.xyzt.y = y; + PJ_COORD coord_out = proj_trans(proj_, PJ_INV, coord); + x = coord_out.xy.x; + y = coord_out.xy.y; #else - throw std::runtime_error("projection::inverse not supported without proj4 support (-DMAPNIK_USE_PROJ4)"); + throw std::runtime_error("projection::inverse not supported without proj support (-DMAPNIK_USE_PROJ)"); #endif } projection::~projection() { -#ifdef MAPNIK_USE_PROJ4 - #if defined(MAPNIK_THREADSAFE) && PJ_VERSION < 480 - std::lock_guard lock(mutex_); - #endif +#ifdef MAPNIK_USE_PROJ if (proj_) { - pj_free(proj_); + proj_destroy(proj_); proj_ = nullptr; } - #if PJ_VERSION >= 480 if (proj_ctx_) { - pj_ctx_free(proj_ctx_); + proj_context_destroy(proj_ctx_); proj_ctx_ = nullptr; } - #endif #endif } std::string projection::expanded() const { -#ifdef MAPNIK_USE_PROJ4 - if (proj_) return mapnik::util::trim_copy(pj_get_def( proj_, 0 )); +#ifdef MAPNIK_USE_PROJ + if (proj_) + { + PJ_PROJ_INFO info = proj_pj_info(proj_); + return mapnik::util::trim_copy(info.definition); + } #endif return params_; } diff --git a/src/text/symbolizer_helpers.cpp b/src/text/symbolizer_helpers.cpp index 996b807cb..d85c998d3 100644 --- a/src/text/symbolizer_helpers.cpp +++ b/src/text/symbolizer_helpers.cpp @@ -326,10 +326,9 @@ void base_symbolizer_helper::initialize_points() const else if (type == geometry::geometry_types::Polygon) { auto const& poly = util::get>(geom); - proj_transform backwart_transform(prj_trans_.dest(), prj_trans_.source()); view_strategy vs(t_); - proj_strategy ps(backwart_transform); - using transform_group_type = geometry::strategy_group; + proj_backward_strategy ps(prj_trans_); + using transform_group_type = geometry::strategy_group; transform_group_type transform_group(ps, vs); geometry::polygon tranformed_poly(geometry::transform(poly, transform_group)); if (how_placed == INTERIOR_PLACEMENT) diff --git a/src/well_known_srs.cpp b/src/well_known_srs.cpp index 93fd6815e..96086ee43 100644 --- a/src/well_known_srs.cpp +++ b/src/well_known_srs.cpp @@ -36,28 +36,27 @@ MAPNIK_DISABLE_WARNING_POP namespace mapnik { -extern std::string const MAPNIK_LONGLAT_PROJ = - "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"; +extern std::string const MAPNIK_GEOGRAPHIC_PROJ = + "epsg:4326"; //wgs84 -extern std::string const MAPNIK_GMERC_PROJ = - "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0" - " +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over"; +extern std::string const MAPNIK_WEBMERCATOR_PROJ = + "epsg:3857"; // webmercator static const char * well_known_srs_strings[] = { - "mapnik-longlat", - "mapnik-gmerc", + MAPNIK_GEOGRAPHIC_PROJ.c_str(), + MAPNIK_WEBMERCATOR_PROJ.c_str(), "" }; boost::optional is_well_known_srs(std::string const& srs) { - if (srs == "+init=epsg:4326" || srs == MAPNIK_LONGLAT_PROJ) + if (srs == MAPNIK_GEOGRAPHIC_PROJ) { return boost::optional(mapnik::WGS_84); } - else if (srs == "+init=epsg:3857" || srs == MAPNIK_GMERC_PROJ) + else if (srs == MAPNIK_WEBMERCATOR_PROJ) { - return boost::optional(mapnik::G_MERC); + return boost::optional(mapnik::WEB_MERC); } return boost::optional(); } @@ -65,28 +64,13 @@ boost::optional is_well_known_srs(std::string const& srs) boost::optional is_known_geographic(std::string const& srs) { std::string trimmed = util::trim_copy(srs); - if (trimmed == "+init=epsg:3857") - { - return boost::optional(false); - } - else if (trimmed == "+init=epsg:4326") + if (trimmed == MAPNIK_GEOGRAPHIC_PROJ) { return boost::optional(true); } - else if (srs.find("+proj=") != std::string::npos) + else if (trimmed == MAPNIK_WEBMERCATOR_PROJ) { - if ((srs.find("+proj=longlat") != std::string::npos) || - (srs.find("+proj=latlong") != std::string::npos) || - (srs.find("+proj=lonlat") != std::string::npos) || - (srs.find("+proj=latlon") != std::string::npos) - ) - { - return boost::optional(true); - } - else - { - return boost::optional(false); - } + return boost::optional(false); } return boost::optional(); } @@ -99,7 +83,7 @@ bool lonlat2merc(double & x, double & y) auto dx = clamp(x, -180.0, 180.0); auto dy = clamp(y, -MERC_MAX_LATITUDE, MERC_MAX_LATITUDE); x = EARTH_RADIUS * radians(dx); - y = EARTH_RADIUS * std::log(std::tan(radians(90 + dy) / 2)); + y = EARTH_RADIUS * std::log(std::tan(radians(90.0 + dy) / 2.0)); return true; } @@ -127,7 +111,7 @@ bool merc2lonlat(double & x, double & y) auto rx = clamp(x / EARTH_RADIUS, -pi, pi); auto ry = clamp(y / EARTH_RADIUS, -pi, pi); x = degrees(rx); - y = degrees(2 * std::atan(std::exp(ry)) - pi / 2); + y = degrees(2.0 * std::atan(std::exp(ry)) - pi / 2.0); return true; } diff --git a/test/cleanup.hpp b/test/cleanup.hpp index f9f993047..a8b8457ba 100644 --- a/test/cleanup.hpp +++ b/test/cleanup.hpp @@ -16,9 +16,6 @@ MAPNIK_DISABLE_WARNING_PUSH #endif #include -#ifdef MAPNIK_USE_PROJ4 -#include -#endif MAPNIK_DISABLE_WARNING_POP @@ -47,15 +44,6 @@ inline void run_cleanup() // http://icu-project.org/apiref/icu4c/uclean_8h.html#a93f27d0ddc7c196a1da864763f2d8920 u_cleanup(); - -#ifdef MAPNIK_USE_PROJ4 - // http://trac.osgeo.org/proj/ticket/149 - #if PJ_VERSION >= 480 - pj_clear_initcache(); - #endif - // https://trac.osgeo.org/proj/wiki/ProjAPI#EnvironmentFunctions - pj_deallocate_grids(); -#endif } } diff --git a/test/data b/test/data index c67cf1185..dd0c41c3f 160000 --- a/test/data +++ b/test/data @@ -1 +1 @@ -Subproject commit c67cf11850d65e963e6103b6141f1eca67667aa2 +Subproject commit dd0c41c3f9f5dc98291a727af00bb42734d2a8c0 diff --git a/test/data-visual b/test/data-visual index bacfd251d..1f20cf257 160000 --- a/test/data-visual +++ b/test/data-visual @@ -1 +1 @@ -Subproject commit bacfd251da550fa82ea56f6710dc6f85431480c2 +Subproject commit 1f20cf257f35224d3c139a6015b1cf70814b0d24 diff --git a/test/unit/core/exceptions_test.cpp b/test/unit/core/exceptions_test.cpp index 16ed51974..2c6f14999 100644 --- a/test/unit/core/exceptions_test.cpp +++ b/test/unit/core/exceptions_test.cpp @@ -1,4 +1,3 @@ - #include "catch.hpp" #include @@ -25,7 +24,7 @@ TEST_CASE("exceptions") { SECTION("handling") { try { - mapnik::projection srs("foo"); + mapnik::projection srs("FAIL"); // to avoid unused variable warning srs.params(); REQUIRE(false); @@ -35,11 +34,11 @@ SECTION("handling") { // https://github.com/mapnik/mapnik/issues/2170 try { - mapnik::projection srs("+proj=longlat foo",true); + mapnik::projection srs("epsg:4326 foo",true); REQUIRE(srs.is_geographic()); REQUIRE(true); - srs.init_proj4(); - // oddly init_proj4 does not throw with old proj/ubuntu precise + srs.init_proj(); + // oddly init_proj does not throw with old proj/ubuntu precise //REQUIRE(false); } catch (...) { REQUIRE(true); diff --git a/test/unit/geometry/geometry_equal.hpp b/test/unit/geometry/geometry_equal.hpp index c0819aed1..e7e7b13e5 100644 --- a/test/unit/geometry/geometry_equal.hpp +++ b/test/unit/geometry/geometry_equal.hpp @@ -128,7 +128,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for(auto const& p : zip_crange(ls1, ls2)) + for (auto const p : zip_crange(ls1, ls2)) { REQUIRE(p.template get<0>().x == Approx(p.template get<1>().x)); REQUIRE(p.template get<0>().y == Approx(p.template get<1>().y)); @@ -143,7 +143,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for (auto const& p : zip_crange(p1, p2)) + for (auto const p : zip_crange(p1, p2)) { (*this)(static_cast> const&>(p.template get<0>()), static_cast> const&>(p.template get<1>())); @@ -173,7 +173,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for (auto const& ls : zip_crange(mls1, mls2)) + for (auto const ls : zip_crange(mls1, mls2)) { (*this)(ls.template get<0>(),ls.template get<1>()); } @@ -187,7 +187,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for (auto const& poly : zip_crange(mpoly1, mpoly2)) + for (auto const poly : zip_crange(mpoly1, mpoly2)) { (*this)(poly.template get<0>(),poly.template get<1>()); } @@ -203,7 +203,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for (auto const& g : zip_crange(c1, c2)) + for (auto const g : zip_crange(c1, c2)) { assert_g_equal(g.template get<0>(),g.template get<1>()); } @@ -217,7 +217,7 @@ struct geometry_equal_visitor REQUIRE(false); } - for (auto const& g : zip_crange(c1, c2)) + for (auto const g : zip_crange(c1, c2)) { assert_g_equal(g.template get<0>(),g.template get<1>()); } diff --git a/test/unit/geometry/geometry_reprojection.cpp b/test/unit/geometry/geometry_reprojection.cpp index dd82ac5aa..589a8c361 100644 --- a/test/unit/geometry/geometry_reprojection.cpp +++ b/test/unit/geometry/geometry_reprojection.cpp @@ -11,8 +11,8 @@ TEST_CASE("geometry reprojection") { SECTION("test_projection_4326_3857 - Empty Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans(source, dest); { geometry_empty geom; @@ -37,8 +37,8 @@ SECTION("test_projection_4326_3857 - Empty Geometry Object") { SECTION("test_projection_4326_3857 - Empty Geometry in Geometry Variant") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans(source, dest); { geometry geom = geometry_empty(); @@ -66,8 +66,8 @@ SECTION("test_projection_4326_3857 - Empty Geometry in Geometry Variant") { SECTION("test_projection_4326_3857 - Point Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); point geom1(-97.552175, 35.522895); @@ -119,8 +119,8 @@ SECTION("test_projection_4326_3857 - Point Geometry Object") { SECTION("test_projection_4326_3857 - Point Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); double x1 = -97.552175; @@ -176,8 +176,8 @@ SECTION("test_projection_4326_3857 - Point Geometry Variant Object") { SECTION("test_projection_4326_3857 - Line_String Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); line_string geom1; @@ -241,8 +241,8 @@ SECTION("test_projection_4326_3857 - Line_String Geometry Object") { SECTION("test_projection_4326_3857 - Line_String Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); line_string geom1_; @@ -316,8 +316,8 @@ SECTION("test_projection_4326_3857 - Line_String Geometry Variant Object") { SECTION("test_projection_4326_3857 - Polygon Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1; @@ -411,8 +411,8 @@ SECTION("test_projection_4326_3857 - Polygon Geometry Object") { SECTION("test_projection_4326_3857 - Polygon Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1_; @@ -503,8 +503,8 @@ SECTION("test_projection_4326_3857 - Polygon Geometry Variant Object") { SECTION("test_projection_4326_3857 - Multi_Point Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); multi_point geom1; @@ -568,8 +568,8 @@ SECTION("test_projection_4326_3857 - Multi_Point Geometry Object") { SECTION("test_projection_4326_3857 - Multi_Point Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); multi_point geom1_; @@ -643,8 +643,8 @@ SECTION("test_projection_4326_3857 - Multi_Point Geometry Variant Object") { SECTION("test_projection_4326_3857 - Multi_Line_String Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); line_string geom1a; @@ -720,8 +720,8 @@ SECTION("test_projection_4326_3857 - Multi_Line_String Geometry Object") { SECTION("test_projection_4326_3857 - Multi_Line_String Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); line_string geom1a_; @@ -799,8 +799,8 @@ SECTION("test_projection_4326_3857 - Multi_Line_String Geometry Variant Object") SECTION("test_projection_4326_3857 - Multi_Polygon Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1a; @@ -898,8 +898,8 @@ SECTION("test_projection_4326_3857 - Multi_Polygon Geometry Object") { SECTION("test_projection_4326_3857 - Multi_Polygon Geometry Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1a_; @@ -993,8 +993,8 @@ SECTION("test_projection_4326_3857 - Multi_Polygon Geometry Variant Object") { SECTION("test_projection_4326_3857 - Geometry Collection Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1a; @@ -1092,8 +1092,8 @@ SECTION("test_projection_4326_3857 - Geometry Collection Object") { SECTION("test_projection_4326_3857 - Geometry Collection Variant Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4326"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); polygon geom1a_; @@ -1185,11 +1185,11 @@ SECTION("test_projection_4326_3857 - Geometry Collection Variant Object") { } } // END SECTION -#ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ SECTION("test_projection_4269_3857 - Line_String Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4269"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4269"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); line_string geom1; @@ -1254,8 +1254,8 @@ SECTION("test_projection_4269_3857 - Line_String Geometry Object") { SECTION("test_projection_4269_3857 - Point Geometry Object") { using namespace mapnik::geometry; - mapnik::projection source("+init=epsg:4269"); - mapnik::projection dest("+init=epsg:3857"); + mapnik::projection source("epsg:4269"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans1(source, dest); mapnik::proj_transform proj_trans2(dest, source); point geom1(-97.552175, 35.522895); @@ -1305,6 +1305,6 @@ SECTION("test_projection_4269_3857 - Point Geometry Object") { } } // End Section -#endif // MAPNIK_USE_PROJ4 +#endif // MAPNIK_USE_PROJ } // End Testcase diff --git a/test/unit/geometry/geometry_strategy_test.cpp b/test/unit/geometry/geometry_strategy_test.cpp index d052f9edf..b8add9a81 100644 --- a/test/unit/geometry/geometry_strategy_test.cpp +++ b/test/unit/geometry/geometry_strategy_test.cpp @@ -18,8 +18,8 @@ SECTION("proj and view strategy") { 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::projection source("epsg:4326"); + mapnik::projection dest("epsg:3857"); mapnik::proj_transform proj_trans(source, dest); mapnik::proj_transform proj_trans_rev(dest, source); mapnik::proj_strategy ps(proj_trans); diff --git a/test/unit/map/background.cpp b/test/unit/map/background.cpp index 18c1b4bf6..b83c6119d 100644 --- a/test/unit/map/background.cpp +++ b/test/unit/map/background.cpp @@ -1,3 +1,24 @@ +/***************************************************************************** + * + * This file is part of Mapnik (c++ mapping toolkit) + * + * Copyright (C) 2021 Artem Pavlenko + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + *****************************************************************************/ #include "catch.hpp" @@ -63,4 +84,3 @@ SECTION("set background - cairo") { #endif } - diff --git a/test/unit/map/query_map_point.cpp b/test/unit/map/query_map_point.cpp new file mode 100644 index 000000000..6279db258 --- /dev/null +++ b/test/unit/map/query_map_point.cpp @@ -0,0 +1,60 @@ +/***************************************************************************** + * + * This file is part of Mapnik (c++ mapping toolkit) + * + * Copyright (C) 2021 Artem Pavlenko + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + *****************************************************************************/ + +#include "catch.hpp" + +#include +#include +#include +#include + + +namespace { + +bool test_query_point(mapnik::Map const& map, + double x, double y, + std::string const& name, std::string const& expected_val) +{ + auto featureset = map.query_map_point(0u, x, y); + while (auto feature = featureset->next()) + { + auto val = feature->get(name); + return (val.to_string() == expected_val); + } + return false; +} +} + +TEST_CASE("Query map point") { + +SECTION("Polygons") { + + mapnik::Map map(882,780); + mapnik::load_map(map, "./test/data/good_maps/wgs842merc_reprojection.xml"); + map.zoom_all(); + CHECK(test_query_point(map, 351, 94, "ADMIN", "Greenland")); + CHECK(test_query_point(map, 402, 182,"ADMIN", "Iceland")); + CHECK(test_query_point(map, 339, 687,"ADMIN", "Antarctica")); + CHECK(test_query_point(map, 35, 141, "ADMIN", "Russia")); + CHECK(test_query_point(map, 737, 297,"ADMIN", "Japan")); +} +} diff --git a/test/unit/projection/proj_transform.cpp b/test/unit/projection/proj_transform.cpp index c77bb8f8f..d7136efd8 100644 --- a/test/unit/projection/proj_transform.cpp +++ b/test/unit/projection/proj_transform.cpp @@ -3,20 +3,20 @@ #include #include #include - -#ifdef MAPNIK_USE_PROJ4 -// proj4 -#include -#endif - +#include +#include TEST_CASE("projection transform") { SECTION("Test bounding box transforms - 4326 to 3857") { - mapnik::projection proj_4326("+init=epsg:4326"); - mapnik::projection proj_3857("+init=epsg:3857"); + mapnik::projection proj_4326("epsg:4326"); + mapnik::projection proj_3857("epsg:3857"); + + CHECK(proj_4326.is_geographic()); + CHECK(!proj_3857.is_geographic()); + mapnik::proj_transform prj_trans(proj_4326, proj_3857); double minx = -45.0; @@ -45,36 +45,15 @@ SECTION("Test bounding box transforms - 4326 to 3857") } -#if defined(MAPNIK_USE_PROJ4) && PJ_VERSION >= 480 -SECTION("test pj_transform failure behavior") +#if defined(MAPNIK_USE_PROJ) +SECTION("test proj_transform failure behavior") { - mapnik::projection proj_4269("+init=epsg:4269"); - mapnik::projection proj_3857("+init=epsg:3857"); + mapnik::projection proj_4269("epsg:4269"); + mapnik::projection proj_3857("epsg:3857"); mapnik::proj_transform prj_trans(proj_4269, proj_3857); mapnik::proj_transform prj_trans2(proj_3857, proj_4269); - auto proj_ctx0 = pj_ctx_alloc(); - REQUIRE( proj_ctx0 != nullptr ); - auto proj0 = pj_init_plus_ctx(proj_ctx0, proj_4269.params().c_str()); - REQUIRE( proj0 != nullptr ); - - auto proj_ctx1 = pj_ctx_alloc(); - REQUIRE( proj_ctx1 != nullptr ); - auto proj1 = pj_init_plus_ctx(proj_ctx1, proj_3857.params().c_str()); - REQUIRE( proj1 != nullptr ); - - // first test valid values directly against proj - double x = -180.0; - double y = -60.0; - x *= DEG_TO_RAD; - y *= DEG_TO_RAD; - CHECK( x == Approx(-3.1415926536) ); - CHECK( y == Approx(-1.0471975512) ); - CHECK( 0 == pj_transform(proj0, proj1, 1, 0, &x, &y, nullptr) ); - CHECK( x == Approx(-20037508.3427892439) ); - CHECK( y == Approx(-8399737.8896366451) ); - - // now test mapnik class + // test valid coordinate double x0 = -180.0; double y0 = -60.0; CHECK( prj_trans.forward(&x0,&y0,nullptr,1,1) ); @@ -86,45 +65,69 @@ SECTION("test pj_transform failure behavior") CHECK( x1 == Approx(-20037508.3427892439) ); CHECK( y1 == Approx(-8399737.8896366451) ); - // longitude value outside the value range for mercator - x = -181.0; - y = -91.0; - x *= DEG_TO_RAD; - y *= DEG_TO_RAD; - CHECK( x == Approx(-3.1590459461) ); - CHECK( y == Approx(-1.5882496193) ); - CHECK( 0 == pj_transform(proj0, proj1, 1, 0, &x, &y, nullptr) ); - CHECK( std::isinf(x) ); - CHECK( std::isinf(y) ); - - // now test mapnik class + // now test invalid coordinate double x2 = -181.0; double y2 = -91.0; - CHECK( false == prj_trans.forward(&x2,&y2,nullptr,1,1) ); + prj_trans.forward(&x2,&y2,nullptr,1,1); CHECK( std::isinf(x2) ); CHECK( std::isinf(y2) ); double x3 = -181.0; double y3 = -91.0; - CHECK( false == prj_trans2.backward(&x3,&y3,nullptr,1,1) ); + prj_trans2.backward(&x3,&y3,nullptr,1,1); CHECK( std::isinf(x3) ); CHECK( std::isinf(y3) ); +} - // cleanup - pj_ctx_free(proj_ctx0); - proj_ctx0 = nullptr; - pj_free(proj0); - proj0 = nullptr; - pj_ctx_free(proj_ctx1); - proj_ctx1 = nullptr; - pj_free(proj1); - proj1 = nullptr; +SECTION("test forward/backward transformations") +{ + //WGS 84 - World Geodetic System 1984, used in GPS + mapnik::projection proj_4236("epsg:4236"); + //OSGB 1936 / British National Grid -- United Kingdom Ordnance Survey + mapnik::projection proj_27700("epsg:27700"); + //WGS 84 / Equal Earth Greenwich + mapnik::projection proj_8857("epsg:8857"); + //European Terrestrial Reference System 1989 (ETRS89) + mapnik::projection proj_4937("epsg:4937"); + //"Webmercator" WGS 84 / Pseudo-Mercator -- Spherical Mercator, Google Maps, OpenStreetMap, Bing, ArcGIS, ESRI + mapnik::projection proj_3857("epsg:3857"); + + mapnik::proj_transform tr1(proj_4236, proj_27700); + mapnik::proj_transform tr2(proj_4236, proj_8857); + mapnik::proj_transform tr3(proj_4236, proj_4236); + mapnik::proj_transform tr4(proj_4236, proj_4937); + mapnik::proj_transform tr5(proj_4236, proj_3857); + std::initializer_list> transforms = { + tr1, tr2, tr3, tr4, tr5 + }; + + std::initializer_list> coords = { + {-4.0278869, 57.8796955}, // Dórnach, Highland + {-4.2488787, 55.8609825}, // Glaschú, Alba + {-1.4823897, 51.8726941}, // Charlbury, England + {-3.9732612, 51.7077400} // Felindre, Cymru + }; + + for (auto const& c : coords) + { + double x0, y0; + std::tie(x0, y0) = c; + for (mapnik::proj_transform const& tr : transforms) + { + double x1 = x0; + double y1 = y0; + tr.forward (&x1, &y1, nullptr, 1, 1); + tr.backward(&x1, &y1, nullptr, 1, 1); + CHECK (x0 == Approx(x1)); + CHECK (y0 == Approx(y1)); + } + } } // Github Issue https://github.com/mapnik/mapnik/issues/2648 SECTION("Test proj antimeridian bbox") { - mapnik::projection prj_geog("+init=epsg:4326"); - mapnik::projection prj_proj("+init=epsg:2193"); + mapnik::projection prj_geog("epsg:4326"); + mapnik::projection prj_proj("epsg:2193"); mapnik::proj_transform prj_trans_fwd(prj_proj, prj_geog); mapnik::proj_transform prj_trans_rev(prj_geog, prj_proj); @@ -132,7 +135,7 @@ SECTION("Test proj antimeridian bbox") // reference values taken from proj4 command line tool: // (non-corner points assume PROJ_ENVELOPE_POINTS == 20) // - // cs2cs -Ef %.10f +init=epsg:2193 +to +init=epsg:4326 < normal(148.7667597489, -60.1222810241, + const mapnik::box2d normal(148.7639922894, -60.1222810241, 159.9548489296, -24.9771195155); { @@ -207,12 +210,14 @@ SECTION("Test proj antimeridian bbox") SECTION("proj_transform of coordinate arrays with stride > 1") { - mapnik::projection const proj_4326("+init=epsg:4326"); - mapnik::projection const proj_3857("+init=epsg:3857"); + + mapnik::projection const proj_4326("epsg:4326"); + mapnik::projection const proj_3857("epsg:3857"); + mapnik::projection const proj_2193("epsg:2193"); SECTION("lonlat <-> Web Mercator") { - // cs2cs -Ef %.10f +init=epsg:4326 +to +init=epsg:3857 < 1") } } - #ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ SECTION("lonlat <-> New Zealand Transverse Mercator 2000") { - mapnik::projection const proj_2193("+init=epsg:2193"); - // cs2cs -Ef %.10f +init=epsg:4326 +to +init=epsg:2193 < 1") CHECK(points[1].y == Approx(-39.283333)); } } - #endif // MAPNIK_USE_PROJ4 +#endif // MAPNIK_USE_PROJ } } diff --git a/test/unit/renderer/feature_style_processor.cpp b/test/unit/renderer/feature_style_processor.cpp index 03b9b344d..28d87ec22 100644 --- a/test/unit/renderer/feature_style_processor.cpp +++ b/test/unit/renderer/feature_style_processor.cpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -195,7 +194,7 @@ SECTION("test_renderer - apply() with single layer") { rendering_result result; test_renderer renderer(map, result); std::set attributes; - mapnik::layer & layer = map.get_layer(0); + mapnik::layer const& layer = map.get_layer(0); renderer.apply(layer, attributes); REQUIRE(renderer.painted()); @@ -222,7 +221,7 @@ SECTION("test_renderer - apply_to_layer") { test_renderer renderer(map, result); std::set attributes; mapnik::projection map_proj(map.srs(), true); - mapnik::layer & layer = map.get_layer(0); + mapnik::layer const& layer = map.get_layer(0); renderer.apply_to_layer(layer, renderer, map_proj, diff --git a/test/unit/vertex_adapter/transform_path_adapter.cpp b/test/unit/vertex_adapter/transform_path_adapter.cpp index 33afb320f..a73762e4a 100644 --- a/test/unit/vertex_adapter/transform_path_adapter.cpp +++ b/test/unit/vertex_adapter/transform_path_adapter.cpp @@ -11,7 +11,7 @@ TEST_CASE("transform_path_adapter") { -#ifdef MAPNIK_USE_PROJ4 +#ifdef MAPNIK_USE_PROJ SECTION("polygon closing - epsg 2330") { mapnik::geometry::polygon g; g.emplace_back(); @@ -28,8 +28,8 @@ SECTION("polygon closing - epsg 2330") { va_type va(g); mapnik::box2d extent(16310607, 7704513, 16310621, 7704527); mapnik::view_transform tr(512, 512, extent); - mapnik::projection proj1("+init=epsg:2330"); - mapnik::projection proj2("+init=epsg:4326"); + mapnik::projection proj1("epsg:2330"); + mapnik::projection proj2("epsg:4326"); mapnik::proj_transform prj_trans(proj1, proj2); path_type path(tr, va, prj_trans); @@ -80,8 +80,8 @@ SECTION("polygon closing - epsg 32633") { va_type va(g); mapnik::box2d extent(166022, 0, 833978, 9329005); mapnik::view_transform tr(512, 512, extent); - mapnik::projection proj1("+init=epsg:32633"); - mapnik::projection proj2("+init=epsg:4326"); + mapnik::projection proj1("epsg:32633"); + mapnik::projection proj2("epsg:4326"); mapnik::proj_transform prj_trans(proj1, proj2); path_type path(tr, va, prj_trans); @@ -116,5 +116,5 @@ SECTION("polygon closing - epsg 32633") { CHECK( y == 0 ); } -#endif //MAPNIK_USE_PROJ4 +#endif //MAPNIK_USE_PROJ }