geometry.hpp
This commit is contained in:
artemp
parent
f888fef86a
commit
064b99168b
743 changed files with 11298 additions and 8765 deletions
5
.gitmodules
vendored
5
.gitmodules
vendored
|
|
@ -5,10 +5,13 @@
|
|||
[submodule "test/data-visual"]
|
||||
path = test/data-visual
|
||||
url = https://github.com/mapnik/test-data-visual.git
|
||||
branch = master
|
||||
branch = harfbuzz-shaper
|
||||
[submodule "deps/mapbox/variant"]
|
||||
path = deps/mapbox/variant
|
||||
url = https://github.com/mapbox/variant.git
|
||||
branch = master
|
||||
[submodule "deps/mapbox/geometry"]
|
||||
path = deps/mapbox/geometry
|
||||
url = https://github.com/mapbox/geometry.hpp.git
|
||||
branch = master
|
||||
|
||||
|
|
|
|||
48
.travis.yml
48
.travis.yml
|
|
@ -10,8 +10,6 @@ env:
|
|||
- CCACHE_COMPRESS=1
|
||||
- HEAVY_JOBS="2"
|
||||
- PREFIX=/tmp/mapnik
|
||||
- secure: "N3a5nzzsgpuu45k8qWdYsHNxrSnqeAGLTOYpfYoAH7B94vuf7pa7XV1tQjXbxrnx2D6ryTdtUtyRKwy7zXbwXxGt4DpczWEo8f6DUd6+obAp3kdnXABg2Sj4oA7KMs0F0CmoADy0jdUZD5YyOJHu64LCIIgzEQ9q49PFMNbU3IE="
|
||||
- secure: "iQYPNpMtejcgYeUkWZGIWz1msIco5qydJrhZTSCQOYahAQerdT7q5WZEpEo3G6IWOGgO1eo7GFuY8DvqQjw1+jC9b9mhkRNdo3LhGTKS9Gsbl5Q27k0rjlaFZmmQHrfPlQJwhfAIp+KLugHtQw5bCoLh+95E3j0F0DayF1tuJ3s="
|
||||
- secure: "F6ivqDNMBQQnrDGA9+7IX+GDswuIqQQd7YPJdQqa2Ked9jddAQDeJClb05ig3JlwfOlYLGZOd43ZX0pKuMtI2Gbkwz211agGP9S3YunwlRg8iWtJlO5kYFUdKCmJNhjg4icfkGELCgwXn+zuEWFSLpkPcjqAFKFlQrIJeAJJgKM="
|
||||
addons:
|
||||
postgresql: "9.4"
|
||||
|
|
@ -25,24 +23,32 @@ matrix:
|
|||
- os: linux
|
||||
sudo: false
|
||||
compiler: ": clang"
|
||||
env: JOBS=8 MASON_PUBLISH=true CXX="ccache clang++-3.8 -Qunused-arguments" CC="clang-3.8" TRIGGER=true
|
||||
env: JOBS=4 CXX="ccache g++-6" CC="gcc-6"
|
||||
addons:
|
||||
apt:
|
||||
sources: [ 'ubuntu-toolchain-r-test']
|
||||
packages: [ 'libstdc++-5-dev', 'xutils-dev']
|
||||
packages: [ 'libstdc++-6-dev', 'g++-6', 'xutils-dev']
|
||||
- os: linux
|
||||
sudo: false
|
||||
compiler: ": clang"
|
||||
env: JOBS=8 CXX="ccache clang++-3.9 -Qunused-arguments" CC="clang-3.9" TRIGGER=true
|
||||
addons:
|
||||
apt:
|
||||
sources: [ 'ubuntu-toolchain-r-test']
|
||||
packages: [ 'libstdc++-4.9-dev', 'xutils-dev']
|
||||
- os: linux
|
||||
sudo: false
|
||||
compiler: ": clang-coverage"
|
||||
env: JOBS=8 COVERAGE=true CXX="ccache clang++-3.8 -Qunused-arguments" CC="clang-3.8"
|
||||
env: JOBS=8 COVERAGE=true CXX="ccache clang++-3.9 -Qunused-arguments" CC="clang-3.9"
|
||||
addons:
|
||||
apt:
|
||||
sources: [ 'ubuntu-toolchain-r-test']
|
||||
packages: ['libstdc++-5-dev', 'xutils-dev' ]
|
||||
packages: ['libstdc++-4.9-dev', 'xutils-dev' ]
|
||||
- os: osx
|
||||
compiler: ": clang-osx"
|
||||
# https://docs.travis-ci.com/user/languages/objective-c/#Supported-OS-X-iOS-SDK-versions
|
||||
osx_image: xcode7.3 # upgrades clang from 6 -> 7
|
||||
env: JOBS=4 MASON_PUBLISH=true CXX="ccache clang++ -Qunused-arguments"
|
||||
env: JOBS=4 CXX="ccache clang++ -Qunused-arguments"
|
||||
|
||||
before_install:
|
||||
# workaround travis rvm bug
|
||||
|
|
@ -52,8 +58,7 @@ before_install:
|
|||
rvm get head || true
|
||||
fi
|
||||
- source scripts/travis-common.sh
|
||||
- export PYTHONUSERBASE=$(pwd)/mason_packages/.link
|
||||
- export PATH=${PREFIX}/bin:$(pwd)/mason_packages/.link/bin:${PYTHONUSERBASE}/bin:${PATH}
|
||||
- export PATH=${PREFIX}/bin:$(pwd)/mason_packages/.link/bin:${PATH}
|
||||
- export COVERAGE=${COVERAGE:-false}
|
||||
- export MASON_PUBLISH=${MASON_PUBLISH:-false}
|
||||
- export BENCH=${BENCH:-false}
|
||||
|
|
@ -62,8 +67,6 @@ before_install:
|
|||
- git_submodule_update --init --depth=10
|
||||
|
||||
install:
|
||||
- on 'linux' export PYTHONPATH=${PYTHONUSERBASE}/lib/python2.7/site-packages
|
||||
- on 'osx' export PYTHONPATH=${PYTHONUSERBASE}/lib/python/site-packages
|
||||
- on 'osx' export DATA_PATH=$(brew --prefix)/var/postgres
|
||||
- on 'osx' rm -rf ${DATA_PATH}
|
||||
- on 'osx' initdb ${DATA_PATH} -E utf8
|
||||
|
|
@ -72,16 +75,19 @@ install:
|
|||
- on 'osx' createuser -s postgres
|
||||
- psql -c 'create database template_postgis;' -U postgres
|
||||
- psql -c 'create extension postgis;' -d template_postgis -U postgres
|
||||
- enabled ${COVERAGE} pip install --user cpp-coveralls
|
||||
- enabled ${COVERAGE} curl -S -f https://codecov.io/bash -o codecov
|
||||
- enabled ${COVERAGE} chmod +x codecov
|
||||
|
||||
before_script:
|
||||
- source bootstrap.sh
|
||||
- |
|
||||
if [[ $(uname -s) == 'Linux' ]]; then
|
||||
mason install clang 3.8.0
|
||||
export PATH=$(mason prefix clang 3.8.0)/bin:${PATH}
|
||||
which clang++
|
||||
export LLVM_COV="$(mason prefix clang 3.8.0)/bin/llvm-cov"
|
||||
mason install clang++ 3.9.1
|
||||
export PATH=$(mason prefix clang++ 3.9.1)/bin:${PATH}
|
||||
mason install llvm-cov 3.9.1
|
||||
export PATH=$(mason prefix llvm-cov 3.9.1)/bin:${PATH}
|
||||
which llvm-cov
|
||||
export LLVM_COV="$(mason prefix llvm-cov 3.9.1)/bin/llvm-cov"
|
||||
fi
|
||||
- ccache --version
|
||||
- ccache -p || true
|
||||
|
|
@ -98,14 +104,12 @@ script:
|
|||
# (and might work) for the next build
|
||||
- DURATION=2400
|
||||
- scripts/travis-command-wrapper.py -s "date" -i 120 --deadline=$(( $(date +%s) + ${DURATION} )) make
|
||||
- make test
|
||||
- RESULT=0
|
||||
- make test || RESULT=$?
|
||||
# we allow visual failures with g++ for now: https://github.com/mapnik/mapnik/issues/3567
|
||||
- if [[ ${RESULT} != 0 ]] && [[ ${CXX} =~ 'clang++' ]]; then false; fi;
|
||||
- enabled ${COVERAGE} coverage
|
||||
- enabled ${BENCH} make bench
|
||||
|
||||
after_success:
|
||||
- enabled ${TRIGGER} trigger_downstream
|
||||
- if enabled ${MASON_PUBLISH}; then
|
||||
source ./.mason/mason.sh &&
|
||||
./mason_latest.sh build &&
|
||||
./mason_latest.sh publish;
|
||||
fi
|
||||
|
|
|
|||
10
Makefile
10
Makefile
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
OS := $(shell uname -s)
|
||||
|
||||
PYTHON = python
|
||||
|
|
@ -36,15 +35,14 @@ src/json/libmapnik-json.a:
|
|||
src/renderer_common/render_thunk_extractor.os \
|
||||
src/json/libmapnik-json.a \
|
||||
src/wkt/libmapnik-wkt.a \
|
||||
src/css_color_grammar.os \
|
||||
src/expression_grammar.os \
|
||||
src/transform_expression_grammar.os \
|
||||
src/image_filter_grammar.os \
|
||||
src/css_color_grammar_x3.os \
|
||||
src/expression_grammar_x3.os \
|
||||
src/transform_expression_grammar_x3.os \
|
||||
src/image_filter_grammar_x3.os \
|
||||
src/marker_helpers.os \
|
||||
src/svg/svg_transform_parser.os \
|
||||
src/agg/process_line_symbolizer.os \
|
||||
plugins/input/geojson/geojson_datasource.os \
|
||||
utils/mapnik-index/process_geojson_file.o \
|
||||
src/svg/svg_path_parser.os \
|
||||
src/svg/svg_parser.os \
|
||||
src/svg/svg_points_parser.os \
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ _/ _/ _/_/_/ _/_/_/ _/ _/ _/ _/ _/
|
|||
|
||||
[](http://travis-ci.org/mapnik/mapnik)
|
||||
[](https://ci.appveyor.com/project/Mapbox/mapnik)
|
||||
[](https://coveralls.io/github/mapnik/mapnik?branch=master)
|
||||
[](https://codecov.io/gh/mapnik/mapnik)
|
||||
|
||||
Mapnik is an open source toolkit for developing mapping applications. At the core is a C++ shared library providing algorithms and patterns for spatial data access and visualization.
|
||||
|
||||
|
|
|
|||
39
SConstruct
39
SConstruct
|
|
@ -41,8 +41,8 @@ ICU_LIBS_DEFAULT='/usr/'
|
|||
|
||||
DEFAULT_CC = "cc"
|
||||
DEFAULT_CXX = "c++"
|
||||
DEFAULT_CXX11_CXXFLAGS = " -std=c++11"
|
||||
DEFAULT_CXX11_LINKFLAGS = ""
|
||||
DEFAULT_CXX14_CXXFLAGS = " -std=c++14"
|
||||
DEFAULT_CXX14_LINKFLAGS = ""
|
||||
if sys.platform == 'darwin':
|
||||
# homebrew default
|
||||
ICU_INCLUDES_DEFAULT='/usr/local/opt/icu4c/include/'
|
||||
|
|
@ -61,7 +61,7 @@ SCONS_CONFIGURE_CACHE = 'config.cache'
|
|||
SCONF_TEMP_DIR = '.sconf_temp'
|
||||
# auto-search directories for boost libs/headers
|
||||
BOOST_SEARCH_PREFIXES = ['/usr/local','/opt/local','/sw','/usr',]
|
||||
BOOST_MIN_VERSION = '1.47'
|
||||
BOOST_MIN_VERSION = '1.61'
|
||||
#CAIRO_MIN_VERSION = '1.8.0'
|
||||
|
||||
HARFBUZZ_MIN_VERSION = (0, 9, 34)
|
||||
|
|
@ -1037,12 +1037,12 @@ int main()
|
|||
return True
|
||||
return False
|
||||
|
||||
def supports_cxx11(context,silent=False):
|
||||
def supports_cxx14(context,silent=False):
|
||||
ret = context.TryRun("""
|
||||
|
||||
int main()
|
||||
{
|
||||
#if __cplusplus >= 201103
|
||||
#if __cplusplus >= 201402L
|
||||
return 0;
|
||||
#else
|
||||
return -1;
|
||||
|
|
@ -1051,7 +1051,7 @@ int main()
|
|||
|
||||
""", '.cpp')
|
||||
if not silent:
|
||||
context.Message('Checking if compiler (%s) supports -std=c++11 flag... ' % context.env.get('CXX','CXX'))
|
||||
context.Message('Checking if compiler (%s) supports -std=c++14 flag... ' % context.env.get('CXX','CXX'))
|
||||
if silent:
|
||||
context.did_show_result=1
|
||||
context.Result(ret[0])
|
||||
|
|
@ -1080,7 +1080,7 @@ conf_tests = { 'prioritize_paths' : prioritize_paths,
|
|||
'harfbuzz_with_freetype_support': harfbuzz_with_freetype_support,
|
||||
'boost_regex_has_icu' : boost_regex_has_icu,
|
||||
'sqlite_has_rtree' : sqlite_has_rtree,
|
||||
'supports_cxx11' : supports_cxx11,
|
||||
'supports_cxx14' : supports_cxx14,
|
||||
'CheckBoostScopedEnum' : CheckBoostScopedEnum,
|
||||
}
|
||||
|
||||
|
|
@ -1129,6 +1129,7 @@ if not preconfigured:
|
|||
else:
|
||||
color_print(4,'SCons USE_CONFIG specified as false, will not inherit variables python config file...')
|
||||
|
||||
|
||||
conf = Configure(env, custom_tests = conf_tests)
|
||||
|
||||
if env['DEBUG']:
|
||||
|
|
@ -1142,6 +1143,9 @@ if not preconfigured:
|
|||
env['PLATFORM'] = platform.uname()[0]
|
||||
color_print(4,"Configuring on %s in *%s*..." % (env['PLATFORM'],mode))
|
||||
|
||||
cxx_version = call("%s --version" % env["CXX"] ,silent=True)
|
||||
color_print(5, "CXX %s" % cxx_version)
|
||||
|
||||
env['MISSING_DEPS'] = []
|
||||
env['SKIPPED_DEPS'] = []
|
||||
env['HAS_CAIRO'] = False
|
||||
|
|
@ -1213,13 +1217,13 @@ if not preconfigured:
|
|||
|
||||
# set any custom cxxflags and ldflags to come first
|
||||
if sys.platform == 'darwin' and not env['HOST']:
|
||||
DEFAULT_CXX11_CXXFLAGS += ' -stdlib=libc++'
|
||||
DEFAULT_CXX11_LINKFLAGS = ' -stdlib=libc++'
|
||||
DEFAULT_CXX14_CXXFLAGS += ' -stdlib=libc++'
|
||||
DEFAULT_CXX14_LINKFLAGS = ' -stdlib=libc++'
|
||||
env.Append(CPPDEFINES = env['CUSTOM_DEFINES'])
|
||||
env.Append(CXXFLAGS = DEFAULT_CXX11_CXXFLAGS)
|
||||
env.Append(CXXFLAGS = DEFAULT_CXX14_CXXFLAGS)
|
||||
env.Append(CXXFLAGS = env['CUSTOM_CXXFLAGS'])
|
||||
env.Append(CFLAGS = env['CUSTOM_CFLAGS'])
|
||||
env.Append(LINKFLAGS = DEFAULT_CXX11_LINKFLAGS)
|
||||
env.Append(LINKFLAGS = DEFAULT_CXX14_LINKFLAGS)
|
||||
env.Append(LINKFLAGS = env['CUSTOM_LDFLAGS'])
|
||||
|
||||
### platform specific bits
|
||||
|
|
@ -1353,9 +1357,9 @@ if not preconfigured:
|
|||
if env['PRIORITIZE_LINKING']:
|
||||
conf.prioritize_paths(silent=True)
|
||||
|
||||
# test for C++11 support, which is required
|
||||
if not env['HOST'] and not conf.supports_cxx11():
|
||||
color_print(1,"C++ compiler does not support C++11 standard (-std=c++11), which is required. Please upgrade your compiler")
|
||||
# test for C++14 support, which is required
|
||||
if not env['HOST'] and not conf.supports_cxx14():
|
||||
color_print(1,"C++ compiler does not support C++14 standard (-std=c++14), which is required. Please upgrade your compiler")
|
||||
Exit(1)
|
||||
|
||||
if not env['HOST']:
|
||||
|
|
@ -1784,11 +1788,10 @@ if not preconfigured:
|
|||
# Common flags for g++/clang++ CXX compiler.
|
||||
# TODO: clean up code more to make -Wextra -Wsign-compare -Wsign-conversion -Wconversion viable
|
||||
# -Wfloat-equal -Wold-style-cast -Wexit-time-destructors -Wglobal-constructors -Wreserved-id-macro -Wheader-hygiene -Wmissing-noreturn
|
||||
common_cxx_flags = '-fvisibility=hidden -fvisibility-inlines-hidden -Wall %s %s -ftemplate-depth-300 -Wsign-compare -Wshadow ' % (env['WARNING_CXXFLAGS'], pthread)
|
||||
common_cxx_flags = '-fvisibility=hidden -fvisibility-inlines-hidden -Wall %s %s -ftemplate-depth-300 -Wsign-compare ' % (env['WARNING_CXXFLAGS'], pthread)
|
||||
|
||||
if 'clang++' in env['CXX']:
|
||||
common_cxx_flags += ' -Wno-unsequenced -Wtautological-compare -Wheader-hygiene '
|
||||
|
||||
common_cxx_flags += ' -Wno-unsequenced -Wtautological-compare -Wheader-hygiene -Wc++14-extensions '
|
||||
if env['DEBUG']:
|
||||
env.Append(CXXFLAGS = common_cxx_flags + '-O0')
|
||||
else:
|
||||
|
|
@ -1797,7 +1800,7 @@ if not preconfigured:
|
|||
env.Append(CXXFLAGS = '-fsanitize=undefined-trap -fsanitize-undefined-trap-on-error -ftrapv -fwrapv')
|
||||
|
||||
if env['DEBUG_SANITIZE']:
|
||||
env.Append(CXXFLAGS = ['-fsanitize=address'])
|
||||
env.Append(CXXFLAGS = ['-fsanitize=address','-fno-omit-frame-pointer'])
|
||||
env.Append(LINKFLAGS = ['-fsanitize=address'])
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
// mapnik
|
||||
#include <mapnik/debug.hpp>
|
||||
#include <mapnik/params.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/safe_cast.hpp>
|
||||
#include "../test/cleanup.hpp"
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ run test_getline 30 10000000
|
|||
#run test_polygon_clipping 10 1000
|
||||
#run test_polygon_clipping_rendering 10 100
|
||||
run test_proj_transform1 10 100
|
||||
run test_expression_parse 10 1000
|
||||
run test_expression_parse 10 10000
|
||||
run test_face_ptr_creation 10 1000
|
||||
run test_font_registration 10 100
|
||||
run test_offset_converter 10 1000
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
#include "bench_framework.hpp"
|
||||
#include <mapnik/unicode.hpp>
|
||||
#include <mapnik/attribute.hpp>
|
||||
#include <mapnik/expression.hpp>
|
||||
#include <mapnik/expression_string.hpp>
|
||||
#include <mapnik/expression_grammar.hpp>
|
||||
|
||||
class test : public benchmark::test_case
|
||||
{
|
||||
|
|
|
|||
|
|
@ -10,10 +10,10 @@
|
|||
#include <mapnik/geometry.hpp>
|
||||
#include <mapnik/vertex_adapters.hpp>
|
||||
#include <mapnik/geometry.hpp>
|
||||
#include <mapnik/geometry_adapters.hpp>
|
||||
#include <mapnik/geometry_envelope.hpp>
|
||||
#include <mapnik/geometry_correct.hpp>
|
||||
#include <mapnik/geometry_is_empty.hpp>
|
||||
#include <mapnik/geometry/boost_adapters.hpp>
|
||||
#include <mapnik/geometry/envelope.hpp>
|
||||
#include <mapnik/geometry/correct.hpp>
|
||||
#include <mapnik/geometry/is_empty.hpp>
|
||||
#include <mapnik/image_util.hpp>
|
||||
#include <mapnik/color.hpp>
|
||||
// boost geometry
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include "bench_framework.hpp"
|
||||
#include <mapnik/box2d.hpp>
|
||||
#include <mapnik/geometry/box2d.hpp>
|
||||
#include <mapnik/projection.hpp>
|
||||
#include <mapnik/proj_transform.hpp>
|
||||
|
||||
|
|
|
|||
63
bootstrap.sh
63
bootstrap.sh
|
|
@ -11,7 +11,7 @@ todo
|
|||
- shrink icu data
|
||||
'
|
||||
|
||||
MASON_VERSION="new-pkgs"
|
||||
MASON_VERSION="3c6df04"
|
||||
|
||||
function setup_mason() {
|
||||
if [[ ! -d ./.mason ]]; then
|
||||
|
|
@ -19,7 +19,7 @@ function setup_mason() {
|
|||
(cd ./.mason && git checkout ${MASON_VERSION})
|
||||
else
|
||||
echo "Updating to latest mason"
|
||||
(cd ./.mason && git fetch && git checkout ${MASON_VERSION} && git pull)
|
||||
(cd ./.mason && git fetch && git checkout ${MASON_VERSION} && git pull origin ${MASON_VERSION})
|
||||
fi
|
||||
export PATH=$(pwd)/.mason:$PATH
|
||||
export CXX=${CXX:-clang++}
|
||||
|
|
@ -44,45 +44,37 @@ function install() {
|
|||
mason link $1 $2
|
||||
}
|
||||
|
||||
ICU_VERSION="55.1"
|
||||
ICU_VERSION="57.1"
|
||||
|
||||
function install_mason_deps() {
|
||||
FAIL=0
|
||||
install ccache 3.3.0 &
|
||||
install zlib system &
|
||||
install jpeg_turbo 1.5.0 libjpeg &
|
||||
install libpng 1.6.24 libpng &
|
||||
install libtiff 4.0.6 libtiff &
|
||||
install libpq 9.5.2 &
|
||||
install sqlite 3.14.1 libsqlite3 &
|
||||
install expat 2.2.0 libexpat &
|
||||
install icu ${ICU_VERSION} &
|
||||
install proj 4.9.2 libproj &
|
||||
install pixman 0.34.0 libpixman-1 &
|
||||
install cairo 1.14.6 libcairo &
|
||||
install protobuf 2.6.1 &
|
||||
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 expat 2.2.0 libexpat
|
||||
install icu ${ICU_VERSION}
|
||||
install proj 4.9.3 libproj
|
||||
install pixman 0.34.0 libpixman-1
|
||||
install cairo 1.14.8 libcairo
|
||||
install protobuf 3.2.0
|
||||
# technically protobuf is not a mapnik core dep, but installing
|
||||
# here by default helps make mapnik-vector-tile builds easier
|
||||
install webp 0.5.1 libwebp &
|
||||
install gdal 2.1.1 libgdal &
|
||||
install boost 1.61.0 &
|
||||
install boost_libsystem 1.61.0 &
|
||||
install boost_libfilesystem 1.61.0 &
|
||||
install boost_libprogram_options 1.61.0 &
|
||||
install boost_libregex_icu 1.61.0 &
|
||||
install webp 0.6.0 libwebp
|
||||
install libgdal 2.1.3 libgdal
|
||||
install boost 1.63.0
|
||||
install boost_libsystem 1.63.0
|
||||
install boost_libfilesystem 1.63.0
|
||||
install boost_libprogram_options 1.63.0
|
||||
install boost_libregex_icu57 1.63.0
|
||||
# technically boost thread and python are not a core dep, but installing
|
||||
# here by default helps make python-mapnik builds easier
|
||||
install boost_libthread 1.61.0 &
|
||||
install boost_libpython 1.61.0 &
|
||||
install freetype 2.6.5 libfreetype &
|
||||
install harfbuzz 1.3.0 libharfbuzz &
|
||||
for job in $(jobs -p)
|
||||
do
|
||||
wait $job || let "FAIL+=1"
|
||||
done
|
||||
if [[ "$FAIL" != "0" ]]; then
|
||||
exit ${FAIL}
|
||||
fi
|
||||
install boost_libthread 1.63.0
|
||||
install boost_libpython 1.63.0
|
||||
install freetype 2.7.1 libfreetype
|
||||
install harfbuzz 1.4.4-ft libharfbuzz
|
||||
}
|
||||
|
||||
MASON_LINKED_ABS=$(pwd)/mason_packages/.link
|
||||
|
|
@ -95,6 +87,7 @@ function make_config() {
|
|||
echo "
|
||||
CXX = '$CXX'
|
||||
CC = '$CC'
|
||||
CUSTOM_CXXFLAGS = '-D_GLIBCXX_USE_CXX11_ABI=0'
|
||||
RUNTIME_LINK = 'static'
|
||||
INPUT_PLUGINS = 'all'
|
||||
PATH = '${MASON_LINKED_REL}/bin'
|
||||
|
|
|
|||
12
circle.yml
12
circle.yml
|
|
@ -7,11 +7,7 @@ machine:
|
|||
JOBS: 8
|
||||
CCACHE_TEMPDIR: /tmp/.ccache-temp
|
||||
CCACHE_COMPRESS: 1
|
||||
LLVM_VERSION: 3.8
|
||||
pre:
|
||||
- echo "here"
|
||||
post:
|
||||
- echo "there"
|
||||
LLVM_VERSION: 3.9.1
|
||||
|
||||
checkout:
|
||||
post:
|
||||
|
|
@ -32,9 +28,9 @@ dependencies:
|
|||
database:
|
||||
pre:
|
||||
- ./bootstrap.sh
|
||||
- ./.mason/mason install clang ${LLVM_VERSION}.0
|
||||
- ./.mason/mason link clang ${LLVM_VERSION}.0
|
||||
- ./configure CC="$(pwd)/mason_packages/.link/bin/clang-${LLVM_VERSION}" CXX="$(pwd)/mason_packages/.link/bin/ccache $(pwd)/mason_packages/.link/bin/clang++-${LLVM_VERSION} -Qunused-arguments"
|
||||
- ./.mason/mason install clang++ ${LLVM_VERSION}
|
||||
- ./.mason/mason link clang++ ${LLVM_VERSION}
|
||||
- ./configure CC="$(pwd)/mason_packages/.link/bin/clang" CXX="$(pwd)/mason_packages/.link/bin/ccache $(pwd)/mason_packages/.link/bin/clang++ -Qunused-arguments"
|
||||
- make
|
||||
override:
|
||||
- psql -c 'create database template_postgis;'
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -1,20 +0,0 @@
|
|||
This directory contains a sample python script implementing the Mapnik API.
|
||||
|
||||
The script is thoroughly commented and also acts as a mini tutorial. Reading
|
||||
it should get you on your way, and you can use it as a base for your work.
|
||||
|
||||
You must compile and install mapnik and the python bindings FIRST.
|
||||
|
||||
Once this is done, run it:
|
||||
|
||||
/path/to/python rundemo.py
|
||||
|
||||
If all goes well, it should render 2 map images:
|
||||
|
||||
demo.jpg
|
||||
demo.png
|
||||
|
||||
Have a look!
|
||||
|
||||
Cheers,
|
||||
J.F.
|
||||
|
|
@ -1,379 +0,0 @@
|
|||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
#
|
||||
#
|
||||
# This file is part of Mapnik (c++ mapping toolkit)
|
||||
# Copyright (C) 2005 Jean-Francois Doyon
|
||||
#
|
||||
# Mapnik is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or any later version.
|
||||
#
|
||||
# This program 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 General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
from __future__ import print_function
|
||||
import sys
|
||||
from os import path
|
||||
import mapnik
|
||||
|
||||
# Instanciate a map, giving it a width and height. Remember: the word "map" is
|
||||
# reserved in Python! :)
|
||||
|
||||
root = path.dirname(__file__)
|
||||
m = mapnik.Map(800,600,"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs")
|
||||
|
||||
# Set its background colour. More on colours later ...
|
||||
|
||||
m.background = mapnik.Color('white')
|
||||
|
||||
# Now we can start adding layers, in stacking order (i.e. bottom layer first)
|
||||
|
||||
# Canadian Provinces (Polygons)
|
||||
|
||||
# Instanciate a layer. The parameters depend on the type of data:
|
||||
# shape:
|
||||
# type='shape'
|
||||
# file='/path/to/shape'
|
||||
# raster:
|
||||
# type='raster'
|
||||
# file='/path/to/raster'
|
||||
# postgis:
|
||||
# type='postgis'
|
||||
# host='127.0.0.1'
|
||||
# dbname='mydatabase'
|
||||
# user='myusername'
|
||||
# password='mypassword'
|
||||
# table= TODO
|
||||
|
||||
provpoly_lyr = mapnik.Layer('Provinces')
|
||||
provpoly_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
provpoly_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/boundaries'), encoding='latin1')
|
||||
|
||||
# We then define a style for the layer. A layer can have one or many styles.
|
||||
# Styles are named, so they can be shared across different layers.
|
||||
# Multiple styles per layer behaves functionally like multiple layers. The
|
||||
# data is completely re-scanned for each style within one layer, and a style
|
||||
# will be drawn entirely "above" the previous one. Performance wise using
|
||||
# multiple styles in one layer is the same has having multiple layers.
|
||||
# The paradigm is useful mostly as a convenience.
|
||||
|
||||
provpoly_style = mapnik.Style()
|
||||
|
||||
# A Style needs one or more rules. A rule will normally consist of a filter
|
||||
# for feature selection, and one or more symbolizers.
|
||||
|
||||
provpoly_rule_on = mapnik.Rule()
|
||||
|
||||
# A Expression() allows the selection of features to which the symbology will
|
||||
# be applied. More on Mapnik expressions can be found in Tutorial #2.
|
||||
# A given feature can only match one filter per rule per style.
|
||||
|
||||
provpoly_rule_on.filter = mapnik.Expression("[NAME_EN] = 'Ontario'")
|
||||
|
||||
# Here a symbolizer is defined. Available are:
|
||||
# - LineSymbolizer(Color(),<width>)
|
||||
# - LineSymbolizer(Stroke())
|
||||
# - PolygonSymbolizer(Color())
|
||||
# - PointSymbolizer(<file>,<type>,<width>,<height>)
|
||||
|
||||
# Some of them can accept a Color() instance, which can be created with:
|
||||
# - Color(<red>, <green>, <blue>)
|
||||
# - Color(<red>, <green>, <blue>, <alpha>)
|
||||
# - Color(<string>) where <string> will be something like '#00FF00'
|
||||
# or '#0f0' or 'green'
|
||||
|
||||
sym = mapnik.PolygonSymbolizer()
|
||||
sym.fill = mapnik.Color(250, 190, 183);
|
||||
provpoly_rule_on.symbols.append(sym)
|
||||
provpoly_style.rules.append(provpoly_rule_on)
|
||||
|
||||
provpoly_rule_qc = mapnik.Rule()
|
||||
provpoly_rule_qc.filter = mapnik.Expression("[NOM_FR] = 'Québec'")
|
||||
sym = mapnik.PolygonSymbolizer()
|
||||
sym.fill = mapnik.Color(217, 235, 203)
|
||||
provpoly_rule_qc.symbols.append(sym)
|
||||
provpoly_style.rules.append(provpoly_rule_qc)
|
||||
|
||||
# Add the style to the map, giving it a name. This is the name that will be
|
||||
# used to refer to it from here on. Having named styles allows them to be
|
||||
# re-used throughout the map.
|
||||
|
||||
m.append_style('provinces', provpoly_style)
|
||||
|
||||
# Then associate the style to the layer itself.
|
||||
|
||||
provpoly_lyr.styles.append('provinces')
|
||||
|
||||
# Then add the layer to the map. In reality, it's the order in which you
|
||||
# append them to the map that will determine the drawing order, though by
|
||||
# convention it is recommended to define them in drawing order as well.
|
||||
|
||||
m.layers.append(provpoly_lyr)
|
||||
|
||||
# Drainage
|
||||
|
||||
# A simple example ...
|
||||
|
||||
qcdrain_lyr = mapnik.Layer('Quebec Hydrography')
|
||||
qcdrain_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
qcdrain_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/qcdrainage'))
|
||||
|
||||
qcdrain_style = mapnik.Style()
|
||||
qcdrain_rule = mapnik.Rule()
|
||||
qcdrain_rule.filter = mapnik.Expression('[HYC] = 8')
|
||||
sym = mapnik.PolygonSymbolizer()
|
||||
sym.fill = mapnik.Color(153, 204, 255)
|
||||
sym.smooth = 1.0 # very smooth
|
||||
qcdrain_rule.symbols.append(sym)
|
||||
qcdrain_style.rules.append(qcdrain_rule)
|
||||
|
||||
m.append_style('drainage', qcdrain_style)
|
||||
qcdrain_lyr.styles.append('drainage')
|
||||
m.layers.append(qcdrain_lyr)
|
||||
|
||||
# In this case, we have 2 data sets with similar schemas (same filtering
|
||||
# attributes, and same desired style), so we're going to
|
||||
# re-use the style defined in the above layer for the next one.
|
||||
|
||||
ondrain_lyr = mapnik.Layer('Ontario Hydrography')
|
||||
ondrain_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
ondrain_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/ontdrainage'))
|
||||
|
||||
ondrain_lyr.styles.append('drainage')
|
||||
m.layers.append(ondrain_lyr)
|
||||
|
||||
# Provincial boundaries
|
||||
|
||||
provlines_lyr = mapnik.Layer('Provincial borders')
|
||||
provlines_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
provlines_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/boundaries_l'))
|
||||
|
||||
# Here we define a "dash dot dot dash" pattern for the provincial boundaries.
|
||||
|
||||
provlines_style = mapnik.Style()
|
||||
provlines_rule = mapnik.Rule()
|
||||
sym = mapnik.LineSymbolizer()
|
||||
# FIXME - currently adding dash arrays is broken
|
||||
# https://github.com/mapnik/mapnik/issues/2324
|
||||
sym.stroke = mapnik.Color('black')
|
||||
sym.stroke_width = 1.0
|
||||
provlines_rule.symbols.append(sym)
|
||||
provlines_style.rules.append(provlines_rule)
|
||||
|
||||
m.append_style('provlines', provlines_style)
|
||||
provlines_lyr.styles.append('provlines')
|
||||
m.layers.append(provlines_lyr)
|
||||
|
||||
# Roads 3 and 4 (The "grey" roads)
|
||||
|
||||
roads34_lyr = mapnik.Layer('Roads')
|
||||
roads34_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
# create roads datasource (we're going to re-use it later)
|
||||
|
||||
roads34_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/roads'))
|
||||
|
||||
roads34_style = mapnik.Style()
|
||||
roads34_rule = mapnik.Rule()
|
||||
roads34_rule.filter = mapnik.Expression('([CLASS] = 3) or ([CLASS] = 4)')
|
||||
|
||||
# With lines of a certain width, you can control how the ends
|
||||
# are closed off using line_cap as below.
|
||||
|
||||
# Available options are:
|
||||
# line_cap: BUTT_CAP, SQUARE_CAP, ROUND_CAP
|
||||
# line_join: MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN
|
||||
|
||||
# And one last Stroke() attribute not used here is "opacity", which
|
||||
# can be set to a numerical value.
|
||||
|
||||
sym = mapnik.LineSymbolizer()
|
||||
sym.stroke = mapnik.Color(171,158,137)
|
||||
sym.stroke_width = 2.0
|
||||
sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
|
||||
|
||||
roads34_rule.symbols.append(sym)
|
||||
roads34_style.rules.append(roads34_rule)
|
||||
|
||||
m.append_style('smallroads', roads34_style)
|
||||
roads34_lyr.styles.append('smallroads')
|
||||
m.layers.append(roads34_lyr)
|
||||
|
||||
# Roads 2 (The thin yellow ones)
|
||||
|
||||
roads2_lyr = mapnik.Layer('Roads')
|
||||
roads2_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
# Just get a copy from roads34_lyr
|
||||
roads2_lyr.datasource = roads34_lyr.datasource
|
||||
|
||||
roads2_style_1 = mapnik.Style()
|
||||
roads2_rule_1 = mapnik.Rule()
|
||||
roads2_rule_1.filter = mapnik.Expression('[CLASS] = 2')
|
||||
|
||||
sym = mapnik.LineSymbolizer()
|
||||
sym.stroke = mapnik.Color(171,158,137)
|
||||
sym.stroke_width = 4.0
|
||||
sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
|
||||
roads2_rule_1.symbols.append(sym)
|
||||
roads2_style_1.rules.append(roads2_rule_1)
|
||||
|
||||
m.append_style('road-border', roads2_style_1)
|
||||
|
||||
roads2_style_2 = mapnik.Style()
|
||||
roads2_rule_2 = mapnik.Rule()
|
||||
roads2_rule_2.filter = mapnik.Expression('[CLASS] = 2')
|
||||
sym = mapnik.LineSymbolizer()
|
||||
sym.stroke = mapnik.Color(255,250,115)
|
||||
sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
|
||||
sym.stroke_width = 2.0
|
||||
roads2_rule_2.symbols.append(sym)
|
||||
roads2_style_2.rules.append(roads2_rule_2)
|
||||
|
||||
m.append_style('road-fill', roads2_style_2)
|
||||
|
||||
roads2_lyr.styles.append('road-border')
|
||||
roads2_lyr.styles.append('road-fill')
|
||||
|
||||
m.layers.append(roads2_lyr)
|
||||
|
||||
# Roads 1 (The big orange ones, the highways)
|
||||
|
||||
roads1_lyr = mapnik.Layer('Roads')
|
||||
roads1_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
roads1_lyr.datasource = roads34_lyr.datasource
|
||||
|
||||
roads1_style_1 = mapnik.Style()
|
||||
roads1_rule_1 = mapnik.Rule()
|
||||
roads1_rule_1.filter = mapnik.Expression('[CLASS] = 1')
|
||||
sym = mapnik.LineSymbolizer()
|
||||
sym.stroke = mapnik.Color(188,149,28)
|
||||
sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
|
||||
sym.stroke_width = 7.0
|
||||
roads1_rule_1.symbols.append(sym)
|
||||
roads1_style_1.rules.append(roads1_rule_1)
|
||||
m.append_style('highway-border', roads1_style_1)
|
||||
|
||||
roads1_style_2 = mapnik.Style()
|
||||
roads1_rule_2 = mapnik.Rule()
|
||||
roads1_rule_2.filter = mapnik.Expression('[CLASS] = 1')
|
||||
sym.stroke = mapnik.Color(242,191,36)
|
||||
sym.stroke_linecap = mapnik.stroke_linecap.ROUND_CAP
|
||||
sym.stroke_width = 5.0
|
||||
roads1_rule_2.symbols.append(sym)
|
||||
roads1_style_2.rules.append(roads1_rule_2)
|
||||
|
||||
m.append_style('highway-fill', roads1_style_2)
|
||||
|
||||
roads1_lyr.styles.append('highway-border')
|
||||
roads1_lyr.styles.append('highway-fill')
|
||||
|
||||
m.layers.append(roads1_lyr)
|
||||
|
||||
# Populated Places
|
||||
|
||||
popplaces_lyr = mapnik.Layer('Populated Places')
|
||||
popplaces_lyr.srs = "+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs"
|
||||
popplaces_lyr.datasource = mapnik.Shapefile(file=path.join(root,'../data/popplaces'),encoding='latin1')
|
||||
|
||||
popplaces_style = mapnik.Style()
|
||||
popplaces_rule = mapnik.Rule()
|
||||
|
||||
# And here we have a TextSymbolizer, used for labeling.
|
||||
# The first parameter is the name of the attribute to use as the source of the
|
||||
# text to label with. Then there is font size in points (I think?), and colour.
|
||||
|
||||
# TODO - currently broken: https://github.com/mapnik/mapnik/issues/2324
|
||||
#popplaces_text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression("[GEONAME]"),
|
||||
# 'DejaVu Sans Book',
|
||||
# 10, mapnik.Color('black'))
|
||||
|
||||
# We set a "halo" around the text, which looks like an outline if thin enough,
|
||||
# or an outright background if large enough.
|
||||
#popplaces_text_symbolizer.label_placement= mapnik.label_placement.POINT_PLACEMENT
|
||||
#popplaces_text_symbolizer.halo_fill = mapnik.Color(255,255,200)
|
||||
#popplaces_text_symbolizer.halo_radius = 1
|
||||
#popplaces_text_symbolizer.avoid_edges = True
|
||||
#popplaces_text_symbolizer.minimum_padding = 30
|
||||
#popplaces_rule.symbols.append(popplaces_text_symbolizer)
|
||||
|
||||
popplaces_style.rules.append(popplaces_rule)
|
||||
|
||||
m.append_style('popplaces', popplaces_style)
|
||||
popplaces_lyr.styles.append('popplaces')
|
||||
m.layers.append(popplaces_lyr)
|
||||
|
||||
# Draw map
|
||||
|
||||
# Set the initial extent of the map in 'master' spherical Mercator projection
|
||||
m.zoom_to_box(mapnik.Box2d(-8024477.28459,5445190.38849,-7381388.20071,5662941.44855))
|
||||
|
||||
# Render map
|
||||
im = mapnik.Image(m.width,m.height)
|
||||
mapnik.render(m, im)
|
||||
|
||||
# Save image to files
|
||||
images_ = []
|
||||
if mapnik.has_png():
|
||||
im.save('demo.png', 'png') # true-colour RGBA
|
||||
images_.append('demo.png')
|
||||
|
||||
# old behavior, now can do 'png8:c=256'
|
||||
im.save('demo256.png', 'png256') # save to palette based (max 256 colours) png
|
||||
images_.append('demo256.png')
|
||||
|
||||
im.save('demo64_binary_transparency.png', 'png8:c=64:t=1')
|
||||
images_.append('demo64_binary_transparency.png')
|
||||
|
||||
im.save('demo128_colors_hextree_no_alpha.png', 'png8:c=100:m=h:t=0')
|
||||
images_.append('demo128_colors_hextree_no_alpha.png')
|
||||
|
||||
if mapnik.has_jpeg():
|
||||
im.save('demo_high.jpg', 'jpeg100')
|
||||
images_.append('demo_high.jpg')
|
||||
|
||||
im.save('demo_low.jpg', 'jpeg50')
|
||||
images_.append('demo_low.jpg')
|
||||
|
||||
if mapnik.has_tiff():
|
||||
im.save('demo.tif', 'tiff')
|
||||
images_.append('demo.tif')
|
||||
|
||||
if mapnik.has_webp():
|
||||
im.save('demo.webp', 'webp') # default quality is 90
|
||||
images_.append('demo.webp')
|
||||
|
||||
im.save('demo_highest.webp', 'webp:quality=100')
|
||||
images_.append('demo_med.webp')
|
||||
|
||||
im.save('demo_low.webp', 'webp:quality=50')
|
||||
images_.append('demo_low.webp')
|
||||
|
||||
|
||||
# Render cairo examples
|
||||
if mapnik.has_cairo():
|
||||
mapnik.render_to_file(m,'demo.pdf')
|
||||
images_.append('demo.pdf')
|
||||
mapnik.render_to_file(m,'demo.ps')
|
||||
images_.append('demo.ps')
|
||||
mapnik.render_to_file(m,'demo.svg')
|
||||
images_.append('demo.svg')
|
||||
mapnik.render_to_file(m,'demo_cairo_rgb24.png','RGB24')
|
||||
images_.append('demo_cairo_rgb.png')
|
||||
mapnik.render_to_file(m,'demo_cairo_argb32.png','ARGB32')
|
||||
images_.append('demo_cairo_argb.png')
|
||||
|
||||
print ("\n\n", len(images_), "maps have been rendered in the current directory:")
|
||||
|
||||
for im_ in images_:
|
||||
print ("-", im_)
|
||||
|
||||
print ("\n\nHave a look!\n\n")
|
||||
|
||||
mapnik.save_map(m,"map.xml")
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* Mapnik is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
######################################################################
|
||||
# Mapnik viewer - Copyright (C) 2007 Artem Pavlenko
|
||||
######################################################################
|
||||
QMAKE_MAC_SDK = macosx10.11
|
||||
TEMPLATE = app
|
||||
QT += core gui widgets
|
||||
QMAKE_CXX = $$system(mapnik-config --cxx)
|
||||
|
|
|
|||
10
deps/agg/include/agg_vpgen_clip_polygon.h
vendored
10
deps/agg/include/agg_vpgen_clip_polygon.h
vendored
|
|
@ -43,12 +43,12 @@ namespace agg
|
|||
{
|
||||
}
|
||||
|
||||
void clip_box(double x1, double y1, double x2, double y2)
|
||||
void clip_box(double _x1, double _y1, double _x2, double _y2)
|
||||
{
|
||||
m_clip_box.x1 = x1;
|
||||
m_clip_box.y1 = y1;
|
||||
m_clip_box.x2 = x2;
|
||||
m_clip_box.y2 = y2;
|
||||
m_clip_box.x1 = _x1;
|
||||
m_clip_box.y1 = _y1;
|
||||
m_clip_box.x2 = _x2;
|
||||
m_clip_box.y2 = _y2;
|
||||
m_clip_box.normalize();
|
||||
}
|
||||
|
||||
|
|
|
|||
10
deps/agg/include/agg_vpgen_clip_polyline.h
vendored
10
deps/agg/include/agg_vpgen_clip_polyline.h
vendored
|
|
@ -41,12 +41,12 @@ namespace agg
|
|||
{
|
||||
}
|
||||
|
||||
void clip_box(double x1, double y1, double x2, double y2)
|
||||
void clip_box(double _x1, double _y1, double _x2, double _y2)
|
||||
{
|
||||
m_clip_box.x1 = x1;
|
||||
m_clip_box.y1 = y1;
|
||||
m_clip_box.x2 = x2;
|
||||
m_clip_box.y2 = y2;
|
||||
m_clip_box.x1 = _x1;
|
||||
m_clip_box.y1 = _y1;
|
||||
m_clip_box.x2 = _x2;
|
||||
m_clip_box.y2 = _y2;
|
||||
m_clip_box.normalize();
|
||||
}
|
||||
|
||||
|
|
|
|||
2
deps/mapbox/geometry
vendored
2
deps/mapbox/geometry
vendored
|
|
@ -1 +1 @@
|
|||
Subproject commit 03778c6af7f1f116fc5722596a31334315451a53
|
||||
Subproject commit b0d64e6e8d55026781325df1068e8043ff880aff
|
||||
2
deps/mapbox/variant
vendored
2
deps/mapbox/variant
vendored
|
|
@ -1 +1 @@
|
|||
Subproject commit a5a79a594f39d705a7ef969f54a0743516f0bc6d
|
||||
Subproject commit 916139a2e51e125816efce6e19d428385601273f
|
||||
|
|
@ -39,7 +39,10 @@ subdirs = [
|
|||
'text',
|
||||
'text/placements',
|
||||
'text/formatting',
|
||||
'markers_placements'
|
||||
'transform',
|
||||
'markers_placements',
|
||||
'geometry',
|
||||
'value'
|
||||
]
|
||||
|
||||
if env['SVG_RENDERER']:
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -20,13 +20,16 @@
|
|||
*
|
||||
*****************************************************************************/
|
||||
|
||||
#ifndef MAPNIK_AGG_RENDER_MARKER_HPP
|
||||
#define MAPNIK_AGG_RENDER_MARKER_HPP
|
||||
|
||||
#include <mapnik/color.hpp>
|
||||
#include <mapnik/feature.hpp>
|
||||
#include <mapnik/geom_util.hpp>
|
||||
#include <mapnik/svg/svg_path_attributes.hpp>
|
||||
#include <mapnik/svg/svg_converter.hpp>
|
||||
#include <mapnik/vertex_converters.hpp>
|
||||
#include <mapnik/box2d.hpp>
|
||||
#include <mapnik/geometry/box2d.hpp>
|
||||
#include <mapnik/safe_cast.hpp>
|
||||
#include <mapnik/util/const_rendering_buffer.hpp>
|
||||
|
||||
|
|
@ -148,3 +151,5 @@ void render_raster_marker(RendererType renb, RasterizerType & ras, image_rgba8 c
|
|||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // MAPNIK_AGG_RENDER_MARKER_HPP
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -28,15 +28,17 @@
|
|||
#include <mapnik/feature_style_processor.hpp>
|
||||
#include <mapnik/util/noncopyable.hpp> // for noncopyable
|
||||
#include <mapnik/rule.hpp> // for rule, symbolizers
|
||||
#include <mapnik/box2d.hpp> // for box2d
|
||||
#include <mapnik/geometry/box2d.hpp> // for box2d
|
||||
#include <mapnik/view_transform.hpp> // for view_transform
|
||||
#include <mapnik/image_compositing.hpp> // for composite_mode_e
|
||||
#include <mapnik/pixel_position.hpp>
|
||||
#include <mapnik/request.hpp>
|
||||
#include <mapnik/symbolizer_enumerations.hpp>
|
||||
#include <mapnik/renderer_common.hpp>
|
||||
#include <mapnik/image_util.hpp>
|
||||
// stl
|
||||
#include <memory>
|
||||
#include <stack>
|
||||
|
||||
// fwd declaration to avoid dependence on agg headers
|
||||
namespace agg { struct trans_affine; }
|
||||
|
|
@ -58,6 +60,53 @@ namespace mapnik {
|
|||
|
||||
namespace mapnik {
|
||||
|
||||
template <typename T>
|
||||
class buffer_stack
|
||||
{
|
||||
public:
|
||||
buffer_stack(std::size_t width, std::size_t height)
|
||||
: width_(width),
|
||||
height_(height),
|
||||
buffers_(),
|
||||
position_(buffers_.begin())
|
||||
{
|
||||
}
|
||||
|
||||
T & push()
|
||||
{
|
||||
if (position_ == buffers_.begin())
|
||||
{
|
||||
buffers_.emplace_front(width_, height_);
|
||||
position_ = buffers_.begin();
|
||||
}
|
||||
else
|
||||
{
|
||||
position_--;
|
||||
mapnik::fill(*position_, 0); // fill with transparent colour
|
||||
}
|
||||
return *position_;
|
||||
}
|
||||
|
||||
void pop()
|
||||
{
|
||||
if (position_ != buffers_.end())
|
||||
{
|
||||
position_++;
|
||||
}
|
||||
}
|
||||
|
||||
T & top() const
|
||||
{
|
||||
return *position_;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::size_t width_;
|
||||
const std::size_t height_;
|
||||
std::deque<T> buffers_;
|
||||
typename std::deque<T>::iterator position_;
|
||||
};
|
||||
|
||||
template <typename T0, typename T1=label_collision_detector4>
|
||||
class MAPNIK_DECL agg_renderer : public feature_style_processor<agg_renderer<T0> >,
|
||||
private util::noncopyable
|
||||
|
|
@ -160,15 +209,14 @@ protected:
|
|||
void draw_geo_extent(box2d<double> const& extent,mapnik::color const& color);
|
||||
|
||||
private:
|
||||
buffer_type & pixmap_;
|
||||
std::shared_ptr<buffer_type> internal_buffer_;
|
||||
mutable buffer_type * current_buffer_;
|
||||
mutable bool style_level_compositing_;
|
||||
std::stack<std::reference_wrapper<buffer_type>> buffers_;
|
||||
buffer_stack<buffer_type> internal_buffers_;
|
||||
std::unique_ptr<buffer_type> inflated_buffer_;
|
||||
const std::unique_ptr<rasterizer> ras_ptr;
|
||||
gamma_method_enum gamma_method_;
|
||||
double gamma_;
|
||||
renderer_common common_;
|
||||
void setup(Map const& m);
|
||||
void setup(Map const & m, buffer_type & pixmap);
|
||||
};
|
||||
|
||||
extern template class MAPNIK_DECL agg_renderer<image<rgba8_t>>;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -24,7 +24,7 @@
|
|||
#define MAPNIK_ATTRIBUTE_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/value.hpp>
|
||||
#include <mapnik/util/geometry_to_ds_type.hpp>
|
||||
// stl
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -24,7 +24,7 @@
|
|||
#define MAPNIK_ATTRIBUTE_COLLECTOR_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/transform_processor.hpp>
|
||||
#include <mapnik/transform/transform_processor.hpp>
|
||||
#include <mapnik/util/noncopyable.hpp>
|
||||
#include <mapnik/attribute.hpp>
|
||||
#include <mapnik/symbolizer.hpp>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -38,16 +38,15 @@
|
|||
|
||||
namespace mapnik {
|
||||
|
||||
class MAPNIK_DECL color
|
||||
: boost::equality_comparable<color>
|
||||
class MAPNIK_DECL color : boost::equality_comparable<color>
|
||||
{
|
||||
private:
|
||||
public:
|
||||
std::uint8_t red_;
|
||||
std::uint8_t green_;
|
||||
std::uint8_t blue_;
|
||||
std::uint8_t alpha_;
|
||||
bool premultiplied_;
|
||||
public:
|
||||
|
||||
// default ctor
|
||||
color()
|
||||
: red_(0xff),
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -41,10 +41,8 @@ public:
|
|||
config_error(std::string const& what,
|
||||
unsigned line_number,
|
||||
std::string const& filename);
|
||||
virtual ~config_error() throw() {}
|
||||
|
||||
virtual const char * what() const throw();
|
||||
|
||||
virtual ~config_error() {}
|
||||
virtual const char * what() const noexcept;
|
||||
void append_context(std::string const& ctx) const;
|
||||
void append_context(std::string const& ctx, xml_node const& node) const;
|
||||
void append_context(xml_node const& node) const;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -181,6 +181,7 @@ private:
|
|||
};
|
||||
|
||||
using coord2d = coord<double,2>;
|
||||
using coord2f = coord<float,2>;
|
||||
using coord2i = coord<int,2>;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,67 +0,0 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 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_CSS_COLOR_GRAMMAR_HPP
|
||||
#define MAPNIK_CSS_COLOR_GRAMMAR_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/color.hpp>
|
||||
#include <mapnik/util/hsl.hpp>
|
||||
#include <mapnik/safe_cast.hpp>
|
||||
|
||||
// boost
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/include/qi.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
// stl
|
||||
#include <string>
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
|
||||
namespace qi = boost::spirit::qi;
|
||||
namespace ascii = boost::spirit::ascii;
|
||||
|
||||
using ascii_space_type = boost::spirit::ascii::space_type;
|
||||
|
||||
template <typename Iterator>
|
||||
struct css_color_grammar : qi::grammar<Iterator, color(), ascii_space_type>
|
||||
{
|
||||
// ctor
|
||||
css_color_grammar();
|
||||
// rules
|
||||
qi::uint_parser< unsigned, 16, 2, 2 > hex2 ;
|
||||
qi::uint_parser< unsigned, 16, 1, 1 > hex1 ;
|
||||
qi::uint_parser< unsigned, 10, 1, 3 > dec3 ;
|
||||
qi::rule<Iterator, color(), ascii_space_type> rgba_color;
|
||||
qi::rule<Iterator, color(), ascii_space_type> rgba_percent_color;
|
||||
qi::rule<Iterator, qi::locals<double,double,double>,color(), ascii_space_type> hsl_percent_color;
|
||||
qi::rule<Iterator, color(), ascii_space_type> hex_color;
|
||||
qi::rule<Iterator, color(), ascii_space_type> hex_color_small;
|
||||
qi::rule<Iterator, color(), ascii_space_type> css_color;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // MAPNIK_CSS_COLOR_GRAMMAR_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -20,12 +20,36 @@
|
|||
*
|
||||
*****************************************************************************/
|
||||
|
||||
// NOTE: we define this here in a cpp because def is needed twice:
|
||||
// once by src/color_factory.cpp and once by include/mapnik/image_filter_grammar.hpp
|
||||
// otherwise it would make sense to simply do `#include <mapnik/css_color_grammar_impl.hpp>`
|
||||
// in a single file
|
||||
#include <mapnik/color.hpp>
|
||||
#include <mapnik/css_color_grammar_impl.hpp>
|
||||
#include <string>
|
||||
#ifndef MAPNIK_CSS_COLOR_GRAMMAR_X3_HPP
|
||||
#define MAPNIK_CSS_COLOR_GRAMMAR_X3_HPP
|
||||
|
||||
template struct mapnik::css_color_grammar<std::string::const_iterator>;
|
||||
#include <mapnik/color.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/home/x3.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
|
||||
namespace css_color_grammar
|
||||
{
|
||||
|
||||
struct css_color_class;
|
||||
using css_color_grammar_type = x3::rule<css_color_class, mapnik::color>;
|
||||
|
||||
BOOST_SPIRIT_DECLARE(css_color_grammar_type);
|
||||
|
||||
}}
|
||||
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
css_color_grammar::css_color_grammar_type const& color_grammar();
|
||||
}
|
||||
|
||||
|
||||
#endif // MAPNIK_CSS_COLOR_GRAMMAR_X3_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -20,84 +20,49 @@
|
|||
*
|
||||
*****************************************************************************/
|
||||
|
||||
// NOTE: This is an implementation header file and is only meant to be included
|
||||
// from implementation files. It therefore doesn't have an include guard.
|
||||
// mapnik
|
||||
#include <mapnik/css_color_grammar.hpp>
|
||||
// boost
|
||||
// REF: http://www.w3.org/TR/css3-color/
|
||||
|
||||
#ifndef MAPNIK_CSS_COLOR_GRAMMAR_X3_DEF_HPP
|
||||
#define MAPNIK_CSS_COLOR_GRAMMAR_X3_DEF_HPP
|
||||
|
||||
#include <mapnik/css_color_grammar_x3.hpp>
|
||||
#include <mapnik/util/hsl.hpp>
|
||||
#include <mapnik/safe_cast.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <boost/fusion/include/adapt_adt.hpp>
|
||||
#include <boost/spirit/include/phoenix_core.hpp>
|
||||
#include <boost/spirit/include/phoenix_operator.hpp>
|
||||
#include <boost/spirit/include/phoenix_fusion.hpp>
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/home/x3.hpp>
|
||||
#include <boost/fusion/adapted/struct.hpp>
|
||||
#include <boost/fusion/adapted/std_tuple.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
|
||||
BOOST_FUSION_ADAPT_ADT(
|
||||
BOOST_FUSION_ADAPT_STRUCT (
|
||||
mapnik::color,
|
||||
(unsigned, unsigned, obj.red(), obj.set_red(mapnik::safe_cast<uint8_t>(val)))
|
||||
(unsigned, unsigned, obj.green(), obj.set_green(mapnik::safe_cast<uint8_t>(val)))
|
||||
(unsigned, unsigned, obj.blue(), obj.set_blue(mapnik::safe_cast<uint8_t>(val)))
|
||||
(unsigned, unsigned, obj.alpha(), obj.set_alpha(mapnik::safe_cast<uint8_t>(val)))
|
||||
(std::uint8_t, red_)
|
||||
(std::uint8_t, green_)
|
||||
(std::uint8_t, blue_)
|
||||
(std::uint8_t, alpha_)
|
||||
)
|
||||
|
||||
namespace mapnik
|
||||
namespace mapnik {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
|
||||
namespace css_color_grammar {
|
||||
|
||||
using x3::lit;
|
||||
using x3::uint_parser;
|
||||
using x3::hex;
|
||||
using x3::symbols;
|
||||
using x3::omit;
|
||||
using x3::attr;
|
||||
using x3::double_;
|
||||
using x3::no_case;
|
||||
using x3::no_skip;
|
||||
|
||||
struct named_colors_ : x3::symbols<color>
|
||||
{
|
||||
namespace phoenix = boost::phoenix;
|
||||
|
||||
struct percent_conv_impl
|
||||
{
|
||||
using result_type = unsigned;
|
||||
unsigned operator() (double val) const
|
||||
{
|
||||
return safe_cast<uint8_t>(std::lround((255.0 * val)/100.0));
|
||||
}
|
||||
};
|
||||
|
||||
struct alpha_conv_impl
|
||||
{
|
||||
using result_type = unsigned;
|
||||
unsigned operator() (double val) const
|
||||
{
|
||||
return safe_cast<uint8_t>(std::lround((255.0 * val)));
|
||||
}
|
||||
};
|
||||
|
||||
struct hsl_conv_impl
|
||||
{
|
||||
using result_type = void;
|
||||
template <typename T0,typename T1, typename T2, typename T3>
|
||||
void operator() (T0 & c, T1 h, T2 s, T3 l) const
|
||||
{
|
||||
double m1,m2;
|
||||
// normalize values
|
||||
h /= 360.0;
|
||||
s /= 100.0;
|
||||
l /= 100.0;
|
||||
|
||||
if (l <= 0.5)
|
||||
{
|
||||
m2 = l * (s + 1.0);
|
||||
}
|
||||
else
|
||||
{
|
||||
m2 = l + s - l*s;
|
||||
}
|
||||
m1 = l * 2 - m2;
|
||||
|
||||
double r = hue_to_rgb(m1, m2, h + 1.0/3.0);
|
||||
double g = hue_to_rgb(m1, m2, h);
|
||||
double b = hue_to_rgb(m1, m2, h - 1.0/3.0);
|
||||
|
||||
c.set_red(safe_cast<uint8_t>(std::lround(255.0 * r)));
|
||||
c.set_green(safe_cast<uint8_t>(std::lround(255.0 * g)));
|
||||
c.set_blue(safe_cast<uint8_t>(std::lround(255.0 * b)));
|
||||
}
|
||||
};
|
||||
|
||||
struct named_colors : qi::symbols<char,color>
|
||||
{
|
||||
named_colors()
|
||||
named_colors_()
|
||||
{
|
||||
add
|
||||
("aliceblue", color(240, 248, 255))
|
||||
|
|
@ -249,77 +214,241 @@ struct named_colors : qi::symbols<char,color>
|
|||
("transparent", color(0, 0, 0, 0))
|
||||
;
|
||||
}
|
||||
} named_colors;
|
||||
|
||||
x3::uint_parser<std::uint8_t, 16, 2, 2> hex2;
|
||||
x3::uint_parser<std::uint8_t, 16, 1, 1> hex1;
|
||||
x3::uint_parser<std::uint8_t, 10, 1, 3> dec3;
|
||||
|
||||
// starting rule
|
||||
css_color_grammar_type const css_color("css_color");
|
||||
// rules
|
||||
x3::rule<class hex2_color, color> const hex2_color("hex2_color");
|
||||
x3::rule<class hex1_color, color> const hex1_color("hex1_color");
|
||||
x3::rule<class rgb_color, color> const rgb_color("rgb_color");
|
||||
x3::rule<class rgba_color, color> const rgba_color("rgba_color");
|
||||
x3::rule<class rgb_color_percent, color> const rgb_color_percent("rgb_color_percent");
|
||||
x3::rule<class rgba_color_percent, color> const rgba_color_percent("rgba_color_percent");
|
||||
|
||||
struct clip_opacity
|
||||
{
|
||||
static double call(double val)
|
||||
{
|
||||
if (val > 1.0) return 1.0;
|
||||
if (val < 0.0) return 0.0;
|
||||
return val;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Iterator>
|
||||
css_color_grammar<Iterator>::css_color_grammar()
|
||||
: css_color_grammar::base_type(css_color)
|
||||
|
||||
struct percent_converter
|
||||
{
|
||||
qi::lit_type lit;
|
||||
qi::_val_type _val;
|
||||
qi::double_type double_;
|
||||
qi::_1_type _1;
|
||||
qi::_a_type _a;
|
||||
qi::_b_type _b;
|
||||
qi::_c_type _c;
|
||||
qi::lexeme_type lexeme;
|
||||
ascii::no_case_type no_case;
|
||||
using phoenix::at_c;
|
||||
// symbols
|
||||
named_colors named;
|
||||
// functions
|
||||
phoenix::function<percent_conv_impl> percent_converter;
|
||||
phoenix::function<alpha_conv_impl> alpha_converter;
|
||||
phoenix::function<hsl_conv_impl> hsl_converter;
|
||||
static std::uint8_t call(double val)
|
||||
{
|
||||
return safe_cast<std::uint8_t>(std::lround((255.0 * val)/100.0));
|
||||
}
|
||||
};
|
||||
|
||||
css_color %= rgba_color
|
||||
| rgba_percent_color
|
||||
| hsl_percent_color
|
||||
| hex_color
|
||||
| hex_color_small
|
||||
| no_case[named];
|
||||
auto dec_red = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).red_ = _attr(ctx);
|
||||
};
|
||||
|
||||
hex_color = lexeme[ lit('#')
|
||||
>> hex2 [ at_c<0>(_val) = _1 ]
|
||||
>> hex2 [ at_c<1>(_val) = _1 ]
|
||||
>> hex2 [ at_c<2>(_val) = _1 ]
|
||||
>>-hex2 [ at_c<3>(_val) = _1 ] ]
|
||||
auto dec_green = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).green_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto dec_blue = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).blue_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto opacity = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).alpha_ = uint8_t((255.0 * clip_opacity::call(_attr(ctx))) + 0.5);
|
||||
};
|
||||
|
||||
auto percent_red = [] (auto & ctx)
|
||||
{
|
||||
_val(ctx).red_ = percent_converter::call(_attr(ctx));
|
||||
};
|
||||
|
||||
auto percent_green = [] (auto & ctx)
|
||||
{
|
||||
_val(ctx).green_ = percent_converter::call(_attr(ctx));
|
||||
};
|
||||
|
||||
auto percent_blue = [] (auto & ctx)
|
||||
{
|
||||
_val(ctx).blue_ = percent_converter::call(_attr(ctx));
|
||||
};
|
||||
|
||||
auto hex1_red = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).red_ = _attr(ctx) | _attr(ctx) << 4;
|
||||
};
|
||||
|
||||
auto hex1_green = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).green_ = _attr(ctx) | _attr(ctx) << 4;
|
||||
};
|
||||
|
||||
auto hex1_blue = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).blue_ = _attr(ctx) | _attr(ctx) << 4;
|
||||
};
|
||||
|
||||
auto hex1_opacity = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).alpha_ = _attr(ctx) | _attr(ctx) << 4;
|
||||
};
|
||||
|
||||
auto hex2_red = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).red_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto hex2_green = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).green_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto hex2_blue = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).blue_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto hex2_opacity = [](auto& ctx)
|
||||
{
|
||||
_val(ctx).alpha_ = _attr(ctx);
|
||||
};
|
||||
|
||||
auto hsl_to_rgba = [] (auto& ctx)
|
||||
{
|
||||
double h = std::get<0>(_attr(ctx));
|
||||
double s = std::get<1>(_attr(ctx));
|
||||
double l = std::get<2>(_attr(ctx));
|
||||
double m1;
|
||||
double m2;
|
||||
// normalise values
|
||||
h /= 360.0;
|
||||
s /= 100.0;
|
||||
l /= 100.0;
|
||||
if (l <= 0.5)
|
||||
{
|
||||
m2 = l * (s + 1.0);
|
||||
}
|
||||
else
|
||||
{
|
||||
m2 = l + s - l*s;
|
||||
}
|
||||
m1 = l * 2 - m2;
|
||||
|
||||
double r = hue_to_rgb(m1, m2, h + 1.0/3.0);
|
||||
double g = hue_to_rgb(m1, m2, h);
|
||||
double b = hue_to_rgb(m1, m2, h - 1.0/3.0);
|
||||
uint8_t alpha = uint8_t((255.0 * clip_opacity::call(std::get<3>(_attr(ctx)))) + 0.5);
|
||||
_val(ctx) = color(safe_cast<uint8_t>(std::lround(255.0 * r)),
|
||||
safe_cast<uint8_t>(std::lround(255.0 * g)),
|
||||
safe_cast<uint8_t>(std::lround(255.0 * b)),
|
||||
alpha);
|
||||
};
|
||||
|
||||
auto const hex2_color_def = no_skip[lit('#')
|
||||
>> hex2[hex2_red]
|
||||
>> hex2[hex2_green]
|
||||
>> hex2[hex2_blue]
|
||||
>> (hex2[hex2_opacity] | attr(255)[hex2_opacity])];
|
||||
|
||||
auto const hex1_color_def = no_skip[lit('#')
|
||||
>> hex1[hex1_red]
|
||||
>> hex1[hex1_green]
|
||||
>> hex1[hex1_blue]
|
||||
>> (hex1[hex1_opacity] | attr(15)[hex1_opacity])];
|
||||
|
||||
auto const rgb_color_def = lit("rgb")
|
||||
>> lit('(') >> dec3[dec_red]
|
||||
>> lit(',') >> dec3[dec_green]
|
||||
>> lit(',') >> dec3[dec_blue]
|
||||
>> attr(255) >> lit(')');
|
||||
|
||||
auto const rgb_color_percent_def = lit("rgb")
|
||||
>> lit('(') >> dec3[percent_red] >> lit('%')
|
||||
>> lit(',') >> dec3[percent_green] >> lit('%')
|
||||
>> lit(',') >> dec3[percent_blue] >> lit('%')
|
||||
>> attr(255) >> lit(')');
|
||||
|
||||
auto const rgba_color_def = lit("rgba")
|
||||
>> lit('(') >> dec3[dec_red]
|
||||
>> lit(',') >> dec3[dec_green]
|
||||
>> lit(',') >> dec3[dec_blue]
|
||||
>> lit(',') >> double_[opacity] >> lit(')');
|
||||
|
||||
auto const rgba_color_percent_def = lit("rgba")
|
||||
>> lit('(') >> dec3[percent_red] >> lit('%')
|
||||
>> lit(',') >> dec3[percent_green] >> lit('%')
|
||||
>> lit(',') >> dec3[percent_blue] >> lit('%')
|
||||
>> lit(',') >> double_[opacity] >> lit(')');
|
||||
|
||||
auto const hsl_values = x3::rule<class hsl_values, std::tuple<std::uint8_t,std::uint8_t,std::uint8_t, double >> {} =
|
||||
lit("hsl")
|
||||
>> lit('(') >> dec3
|
||||
>> lit(',') >> dec3 >> lit('%')
|
||||
>> lit(',') >> dec3 >> lit('%')
|
||||
>> attr(1.0) >> lit(')')
|
||||
;
|
||||
|
||||
hex_color_small = lexeme[ lit('#')
|
||||
>> hex1 [ at_c<0>(_val) = _1 | _1 << 4 ]
|
||||
>> hex1 [ at_c<1>(_val) = _1 | _1 << 4 ]
|
||||
>> hex1 [ at_c<2>(_val) = _1 | _1 << 4 ]
|
||||
>>-hex1 [ at_c<3>(_val) = _1 | _1 << 4 ] ]
|
||||
auto const hsla_values = x3::rule<class hsla_values, std::tuple<std::uint8_t,std::uint8_t,std::uint8_t, double >> {} =
|
||||
lit("hsla")
|
||||
>> lit('(') >> dec3
|
||||
>> lit(',') >> dec3 >> lit('%')
|
||||
>> lit(',') >> dec3 >> lit('%')
|
||||
>> lit(',') >> double_ >> lit(')')
|
||||
;
|
||||
|
||||
rgba_color = lit("rgb") >> -lit('a')
|
||||
>> lit('(')
|
||||
>> dec3 [at_c<0>(_val) = _1] >> ','
|
||||
>> dec3 [at_c<1>(_val) = _1] >> ','
|
||||
>> dec3 [at_c<2>(_val) = _1]
|
||||
>> -(','>> -double_ [at_c<3>(_val) = alpha_converter(_1)])
|
||||
>> lit(')')
|
||||
auto const hsl_color = x3::rule<class hsl_color, color> {} = hsl_values[hsl_to_rgba];
|
||||
auto const hsla_color = x3::rule<class hsla_color, color> {} = hsla_values[hsl_to_rgba];
|
||||
|
||||
auto const css_color_def =
|
||||
no_case[named_colors]
|
||||
|
|
||||
hex2_color
|
||||
|
|
||||
hex1_color
|
||||
|
|
||||
rgb_color
|
||||
|
|
||||
rgba_color
|
||||
|
|
||||
rgb_color_percent
|
||||
|
|
||||
rgba_color_percent
|
||||
|
|
||||
hsl_color
|
||||
|
|
||||
hsla_color
|
||||
;
|
||||
|
||||
rgba_percent_color = lit("rgb") >> -lit('a')
|
||||
>> lit('(')
|
||||
>> double_ [at_c<0>(_val) = percent_converter(_1)] >> '%' >> ','
|
||||
>> double_ [at_c<1>(_val) = percent_converter(_1)] >> '%' >> ','
|
||||
>> double_ [at_c<2>(_val) = percent_converter(_1)] >> '%'
|
||||
>> -(','>> -double_ [at_c<3>(_val) = alpha_converter(_1)])
|
||||
>> lit(')')
|
||||
;
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
BOOST_SPIRIT_DEFINE(
|
||||
css_color,
|
||||
hex2_color,
|
||||
hex1_color,
|
||||
rgb_color,
|
||||
rgba_color,
|
||||
rgb_color_percent,
|
||||
rgba_color_percent
|
||||
);
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
hsl_percent_color = lit("hsl") >> -lit('a')
|
||||
>> lit('(')
|
||||
>> double_ [ _a = _1] >> ',' // hue 0..360
|
||||
>> double_ [ _b = _1] >> '%' >> ',' // saturation 0..100%
|
||||
>> double_ [ _c = _1] >> '%' // lightness 0..100%
|
||||
>> -(','>> -double_ [at_c<3>(_val) = alpha_converter(_1)]) // opacity 0...1
|
||||
>> lit (')') [ hsl_converter(_val,_a,_b,_c)]
|
||||
;
|
||||
} // ns
|
||||
|
||||
css_color_grammar::css_color_grammar_type const& color_grammar()
|
||||
{
|
||||
return css_color_grammar::css_color;
|
||||
}
|
||||
|
||||
}
|
||||
} //ns mapnik
|
||||
|
||||
#endif //MAPNIK_CSS_COLOR_GRAMMAR_X3_DEF_HPP
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 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_CSV_GRAMMAR_HPP
|
||||
#define MAPNIK_CSV_GRAMMAR_HPP
|
||||
|
||||
#include <mapnik/csv/csv_types.hpp>
|
||||
#include <boost/spirit/include/qi.hpp>
|
||||
|
||||
namespace mapnik {
|
||||
|
||||
namespace qi = boost::spirit::qi;
|
||||
|
||||
struct csv_white_space_skipper : qi::primitive_parser<csv_white_space_skipper>
|
||||
{
|
||||
template <typename Context, typename Iterator>
|
||||
struct attribute
|
||||
{
|
||||
typedef qi::unused_type type;
|
||||
};
|
||||
|
||||
template <typename Iterator, typename Context
|
||||
, typename Skipper, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context& /*context*/, Skipper const& skipper
|
||||
, Attribute& /*attr*/) const
|
||||
{
|
||||
qi::skip_over(first, last, skipper);
|
||||
if (first != last && *first == ' ')
|
||||
{
|
||||
while (++first != last && *first == ' ')
|
||||
;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename Context>
|
||||
qi::info what(Context& /*context*/) const
|
||||
{
|
||||
return qi::info("csv_white_space_skipper");
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename Iterator, typename Skipper = csv_white_space_skipper>
|
||||
struct csv_line_grammar : qi::grammar<Iterator, csv_line(char, char), Skipper>
|
||||
{
|
||||
csv_line_grammar();
|
||||
private:
|
||||
qi::rule<Iterator, csv_line(char, char), Skipper> line;
|
||||
qi::rule<Iterator, csv_value(char, char)> column; // no-skip
|
||||
qi::rule<Iterator, csv_value(char)> text; // no-skip
|
||||
qi::rule<Iterator, csv_value(char)> quoted; // no-skip
|
||||
qi::symbols<char const, char const> unesc_char;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // MAPNIK_CSV_GRAMMAR_HPP
|
||||
67
include/mapnik/csv/csv_grammar_x3.hpp
Normal file
67
include/mapnik/csv/csv_grammar_x3.hpp
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_CSV_GRAMMAR_X3_HPP
|
||||
#define MAPNIK_CSV_GRAMMAR_X3_HPP
|
||||
|
||||
#include <mapnik/csv/csv_types.hpp>
|
||||
#include <boost/spirit/home/x3.hpp>
|
||||
#include <iostream>
|
||||
namespace mapnik {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
|
||||
struct csv_white_space_skipper : x3::parser<csv_white_space_skipper>
|
||||
{
|
||||
using attribute_type = x3::unused_type;
|
||||
static bool const has_attribute = false;
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last,
|
||||
Context const& context, x3::unused_type, Attribute& ) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
if (first != last && *first == ' ')
|
||||
{
|
||||
while (++first != last && *first == ' ')
|
||||
;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
auto static const csv_white_space = csv_white_space_skipper{};
|
||||
|
||||
namespace grammar {
|
||||
|
||||
struct separator_tag;
|
||||
struct quote_tag;
|
||||
|
||||
struct csv_line_class;
|
||||
using csv_line_grammar_type = x3::rule<csv_line_class, csv_line>;
|
||||
|
||||
BOOST_SPIRIT_DECLARE(csv_line_grammar_type);
|
||||
|
||||
}}
|
||||
|
||||
#endif // MAPNIK_CSV_GRAMMAR_X3_HPP
|
||||
120
include/mapnik/csv/csv_grammar_x3_def.hpp
Normal file
120
include/mapnik/csv/csv_grammar_x3_def.hpp
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_CSV_GRAMMAR_X3_DEF_HPP
|
||||
#define MAPNIK_CSV_GRAMMAR_X3_DEF_HPP
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <mapnik/csv/csv_grammar_x3.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
|
||||
namespace mapnik { namespace grammar {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
namespace ascii = boost::spirit::x3::ascii;
|
||||
|
||||
using x3::lit;
|
||||
using x3::lexeme;
|
||||
using ascii::char_;
|
||||
|
||||
struct unesc_char_ : x3::symbols<char>
|
||||
{
|
||||
unesc_char_()
|
||||
{
|
||||
add("\\a", '\a')
|
||||
("\\b", '\b')
|
||||
("\\f", '\f')
|
||||
("\\n", '\n')
|
||||
("\\r", '\r')
|
||||
("\\t", '\t')
|
||||
("\\v", '\v')
|
||||
("\\\\",'\\')
|
||||
("\\\'", '\'')
|
||||
("\\\"", '\"')
|
||||
("\"\"", '\"') // double quote
|
||||
;
|
||||
}
|
||||
} unesc_char;
|
||||
|
||||
template <typename T>
|
||||
struct literal : x3::parser<literal<T>>
|
||||
{
|
||||
using attribute_type = x3::unused_type;
|
||||
using context_tag = T;
|
||||
static bool const has_attribute = false;
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last,
|
||||
Context const& context, x3::unused_type, Attribute& ) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
if (first != last && *first == x3::get<context_tag>(context))
|
||||
{
|
||||
++first;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
auto static const separator = literal<separator_tag>{};
|
||||
auto static const quote = literal<quote_tag>{};
|
||||
|
||||
// starting rule
|
||||
csv_line_grammar_type const line("csv-line");
|
||||
// rules
|
||||
x3::rule<class csv_column, csv_value> column("csv-column");
|
||||
x3::rule<class csv_text, csv_value> text("csv-text");
|
||||
x3::rule<class csc_quoted_text, csv_value> quoted_text("csv-quoted-text");
|
||||
|
||||
auto const line_def = -lit('\r') > -lit('\n') > lexeme[column] % separator
|
||||
;
|
||||
|
||||
auto const column_def = quoted_text | *(char_ - separator)
|
||||
;
|
||||
|
||||
auto const quoted_text_def = quote > text > quote // support unmatched quotes or not (??)
|
||||
;
|
||||
|
||||
auto const text_def = *(unesc_char | (char_ - quote))
|
||||
;
|
||||
|
||||
BOOST_SPIRIT_DEFINE (
|
||||
line,
|
||||
column,
|
||||
quoted_text,
|
||||
text
|
||||
);
|
||||
|
||||
} // grammar
|
||||
|
||||
grammar::csv_line_grammar_type const& csv_line_grammar()
|
||||
{
|
||||
return grammar::line;
|
||||
}
|
||||
|
||||
} // namespace mapnik
|
||||
|
||||
|
||||
#endif // MAPNIK_CSV_GRAMMAR_X3_DEF_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
43
include/mapnik/cxx11_support.hpp
Normal file
43
include/mapnik/cxx11_support.hpp
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_CXX11_SUPPORT_HPP
|
||||
#define MAPNIK_CXX11_SUPPORT_HPP
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace mapnik {
|
||||
namespace detail {
|
||||
|
||||
template <bool B, typename T, typename F>
|
||||
using conditional_t = typename std::conditional<B, T, F>::type;
|
||||
|
||||
template <typename T>
|
||||
using decay_t = typename std::decay<T>::type;
|
||||
|
||||
template <bool B, typename T = void>
|
||||
using enable_if_t = typename std::enable_if<B, T>::type;
|
||||
|
||||
} // namespace detail
|
||||
} // namespace mapnik
|
||||
|
||||
#endif // MAPNIK_CXX11_SUPPORT_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -46,14 +46,11 @@ class MAPNIK_DECL datasource_exception : public std::exception
|
|||
public:
|
||||
datasource_exception(std::string const& message)
|
||||
: message_(message)
|
||||
{
|
||||
}
|
||||
{}
|
||||
|
||||
~datasource_exception() throw()
|
||||
{
|
||||
}
|
||||
~datasource_exception() {}
|
||||
|
||||
virtual const char* what() const throw()
|
||||
virtual const char* what() const noexcept
|
||||
{
|
||||
return message_.c_str();
|
||||
}
|
||||
|
|
@ -69,8 +66,8 @@ public:
|
|||
Raster
|
||||
};
|
||||
|
||||
datasource (parameters const& params)
|
||||
: params_(params) {}
|
||||
datasource (parameters const& _params)
|
||||
: params_(_params) {}
|
||||
|
||||
/*!
|
||||
* @brief Get the configuration parameters of the data source.
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -28,7 +28,6 @@
|
|||
#include <mapnik/debug.hpp>
|
||||
|
||||
// stl
|
||||
#include <bitset>
|
||||
#include <iostream>
|
||||
#include <cstdlib>
|
||||
#include <algorithm>
|
||||
|
|
@ -45,9 +44,9 @@ public:
|
|||
what_( _what )
|
||||
{
|
||||
}
|
||||
virtual ~illegal_enum_value() throw() {}
|
||||
virtual ~illegal_enum_value() {}
|
||||
|
||||
virtual const char * what() const throw()
|
||||
virtual const char * what() const noexcept
|
||||
{
|
||||
return what_.c_str();
|
||||
}
|
||||
|
|
@ -190,6 +189,8 @@ public:
|
|||
for (unsigned i = 0; i < THE_MAX; ++i)
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunknown-pragmas" // clang+gcc
|
||||
#pragma GCC diagnostic ignored "-Wpragmas" // gcc
|
||||
#pragma GCC diagnostic ignored "-Wundefined-var-template"
|
||||
if (str_copy == our_strings_[i])
|
||||
#pragma GCC diagnostic pop
|
||||
|
|
@ -203,6 +204,8 @@ public:
|
|||
}
|
||||
}
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunknown-pragmas" // clang+gcc
|
||||
#pragma GCC diagnostic ignored "-Wpragmas" // gcc
|
||||
#pragma GCC diagnostic ignored "-Wundefined-var-template"
|
||||
throw illegal_enum_value(std::string("Illegal enumeration value '") +
|
||||
str + "' for enum " + our_name_);
|
||||
|
|
@ -213,6 +216,8 @@ public:
|
|||
std::string as_string() const
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wunknown-pragmas" // clang+gcc
|
||||
#pragma GCC diagnostic ignored "-Wpragmas" // gcc
|
||||
#pragma GCC diagnostic ignored "-Wundefined-var-template"
|
||||
return our_strings_[value_];
|
||||
#pragma GCC diagnostic pop
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -43,8 +43,8 @@ struct evaluate_expression
|
|||
{
|
||||
using value_type = T;
|
||||
|
||||
explicit evaluate_expression(Attributes const& attributes)
|
||||
: attributes_(attributes) {}
|
||||
explicit evaluate_expression(Attributes const& attrs)
|
||||
: attrs_(attrs) {}
|
||||
|
||||
value_type operator() (attribute const&) const
|
||||
{
|
||||
|
|
@ -53,8 +53,8 @@ struct evaluate_expression
|
|||
|
||||
value_type operator() (global_attribute const& attr) const
|
||||
{
|
||||
auto itr = attributes_.find(attr.name);
|
||||
if (itr != attributes_.end())
|
||||
auto itr = attrs_.find(attr.name);
|
||||
if (itr != attrs_.end())
|
||||
{
|
||||
return itr->second;
|
||||
}
|
||||
|
|
@ -129,7 +129,7 @@ struct evaluate_expression
|
|||
return value_type(val);
|
||||
}
|
||||
|
||||
Attributes const& attributes_;
|
||||
Attributes const& attrs_;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -221,7 +221,7 @@ struct evaluate_expression<T, boost::none_t>
|
|||
struct assign_value
|
||||
{
|
||||
template<typename Attributes>
|
||||
static void apply(symbolizer_base::value_type & val, expression_ptr const& expr, Attributes const& attributes, property_types target )
|
||||
static void apply(symbolizer_base::value_type & val, expression_ptr const& expr, Attributes const& attrs, property_types target )
|
||||
{
|
||||
|
||||
switch (target)
|
||||
|
|
@ -230,24 +230,24 @@ struct assign_value
|
|||
{
|
||||
// evaluate expression as a string then parse as css color
|
||||
std::string str = util::apply_visitor(mapnik::evaluate_expression<mapnik::value,
|
||||
Attributes>(attributes),*expr).to_string();
|
||||
Attributes>(attrs),*expr).to_string();
|
||||
try { val = parse_color(str); }
|
||||
catch (...) { val = color(0,0,0);}
|
||||
break;
|
||||
}
|
||||
case property_types::target_double:
|
||||
{
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attributes),*expr).to_double();
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_double();
|
||||
break;
|
||||
}
|
||||
case property_types::target_integer:
|
||||
{
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attributes),*expr).to_int();
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_int();
|
||||
break;
|
||||
}
|
||||
case property_types::target_bool:
|
||||
{
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attributes),*expr).to_bool();
|
||||
val = util::apply_visitor(mapnik::evaluate_expression<mapnik::value, Attributes>(attrs),*expr).to_bool();
|
||||
break;
|
||||
}
|
||||
default: // no-op
|
||||
|
|
@ -276,14 +276,14 @@ struct evaluate_global_attributes : util::noncopyable
|
|||
template <typename Attributes>
|
||||
struct evaluator
|
||||
{
|
||||
evaluator(symbolizer_base::cont_type::value_type & prop, Attributes const& attributes)
|
||||
evaluator(symbolizer_base::cont_type::value_type & prop, Attributes const& attrs)
|
||||
: prop_(prop),
|
||||
attributes_(attributes) {}
|
||||
attrs_(attrs) {}
|
||||
|
||||
void operator() (expression_ptr const& expr) const
|
||||
{
|
||||
auto const& meta = get_meta(prop_.first);
|
||||
assign_value::apply(prop_.second, expr, attributes_, std::get<2>(meta));
|
||||
assign_value::apply(prop_.second, expr, attrs_, std::get<2>(meta));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -292,28 +292,28 @@ struct evaluate_global_attributes : util::noncopyable
|
|||
// no-op
|
||||
}
|
||||
symbolizer_base::cont_type::value_type & prop_;
|
||||
Attributes const& attributes_;
|
||||
Attributes const& attrs_;
|
||||
};
|
||||
|
||||
template <typename Attributes>
|
||||
struct extract_symbolizer
|
||||
{
|
||||
extract_symbolizer(Attributes const& attributes)
|
||||
: attributes_(attributes) {}
|
||||
extract_symbolizer(Attributes const& attrs)
|
||||
: attrs_(attrs) {}
|
||||
|
||||
template <typename Symbolizer>
|
||||
void operator() (Symbolizer & sym) const
|
||||
{
|
||||
for (auto & prop : sym.properties)
|
||||
{
|
||||
util::apply_visitor(evaluator<Attributes>(prop, attributes_), prop.second);
|
||||
util::apply_visitor(evaluator<Attributes>(prop, attrs_), prop.second);
|
||||
}
|
||||
}
|
||||
Attributes const& attributes_;
|
||||
Attributes const& attrs_;
|
||||
};
|
||||
|
||||
template <typename Attributes>
|
||||
static void apply(Map & m, Attributes const& attributes)
|
||||
static void apply(Map & m, Attributes const& attrs)
|
||||
{
|
||||
for ( auto & val : m.styles() )
|
||||
{
|
||||
|
|
@ -321,7 +321,7 @@ struct evaluate_global_attributes : util::noncopyable
|
|||
{
|
||||
for (auto & sym : rule)
|
||||
{
|
||||
util::apply_visitor(extract_symbolizer<Attributes>(attributes), sym);
|
||||
util::apply_visitor(extract_symbolizer<Attributes>(attrs), sym);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
// mapnik
|
||||
#include <mapnik/attribute.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/expression_node.hpp>
|
||||
#include <mapnik/function_call.hpp>
|
||||
#include <mapnik/util/variant.hpp>
|
||||
|
|
|
|||
|
|
@ -1,103 +0,0 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 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_EXPRESSIONS_GRAMMAR_HPP
|
||||
#define MAPNIK_EXPRESSIONS_GRAMMAR_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/config.hpp>
|
||||
#include <mapnik/expression_node.hpp>
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/include/qi.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
namespace qi = boost::spirit::qi;
|
||||
namespace standard_wide = boost::spirit::standard_wide;
|
||||
using standard_wide::space_type;
|
||||
|
||||
template <typename T>
|
||||
struct integer_parser
|
||||
{
|
||||
using type = qi::int_parser<T,10,1,-1>;
|
||||
};
|
||||
|
||||
struct unary_function_types : qi::symbols<char, unary_function_impl>
|
||||
{
|
||||
unary_function_types();
|
||||
};
|
||||
|
||||
struct binary_function_types : qi::symbols<char, binary_function_impl>
|
||||
{
|
||||
binary_function_types();
|
||||
};
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
template <typename Iterator>
|
||||
struct MAPNIK_DECL expression_grammar : qi::grammar<Iterator, expr_node(), space_type>
|
||||
#else
|
||||
template <typename Iterator>
|
||||
struct expression_grammar : qi::grammar<Iterator, expr_node(), space_type>
|
||||
#endif
|
||||
{
|
||||
using rule_type = qi::rule<Iterator, expr_node(), space_type>;
|
||||
|
||||
explicit expression_grammar(std::string const& encoding = "utf-8");
|
||||
|
||||
qi::real_parser<double, qi::strict_real_policies<double> > strict_double;
|
||||
typename integer_parser<mapnik::value_integer>::type int__;
|
||||
mapnik::transcoder tr_;
|
||||
|
||||
rule_type expr;
|
||||
rule_type equality_expr;
|
||||
rule_type cond_expr;
|
||||
rule_type relational_expr;
|
||||
rule_type logical_expr;
|
||||
rule_type additive_expr;
|
||||
rule_type multiplicative_expr;
|
||||
rule_type unary_expr;
|
||||
rule_type not_expr;
|
||||
rule_type primary_expr;
|
||||
qi::rule<Iterator, unary_function_call() , space_type> unary_function_expr;
|
||||
qi::rule<Iterator, binary_function_call() , space_type> binary_function_expr;
|
||||
qi::rule<Iterator, std::string() > regex_match_expr;
|
||||
qi::rule<Iterator, expr_node(expr_node), qi::locals<std::string,std::string>, space_type> regex_replace_expr;
|
||||
qi::rule<Iterator, std::string() , space_type> attr;
|
||||
qi::rule<Iterator, std::string() , space_type> global_attr;
|
||||
qi::rule<Iterator, std::string(), qi::locals<char> > quoted_ustring;
|
||||
qi::rule<Iterator, std::string()> unquoted_ustring;
|
||||
qi::rule<Iterator, std::string(), space_type> ustring;
|
||||
|
||||
qi::symbols<char const, char const> unesc_char;
|
||||
qi::rule<Iterator, char() > quote_char;
|
||||
qi::symbols<char, expr_node> constant;
|
||||
unary_function_types unary_func_type;
|
||||
binary_function_types binary_func_type;
|
||||
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_HPP
|
||||
|
|
@ -1,280 +0,0 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 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
|
||||
*
|
||||
*****************************************************************************/
|
||||
|
||||
// NOTE: This is an implementation header file and is only meant to be included
|
||||
// from implementation files. It therefore doesn't have an include guard.
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/expression_node.hpp>
|
||||
#include <mapnik/expression_grammar.hpp>
|
||||
#include <mapnik/unicode.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/function_call.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/fusion/adapted/struct.hpp>
|
||||
#include <boost/spirit/include/phoenix_operator.hpp>
|
||||
#include <boost/spirit/include/phoenix_object.hpp>
|
||||
#include <boost/spirit/include/phoenix_function.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
BOOST_FUSION_ADAPT_STRUCT(mapnik::unary_function_call,
|
||||
(mapnik::unary_function_impl, fun)
|
||||
(mapnik::unary_function_call::argument_type, arg))
|
||||
|
||||
BOOST_FUSION_ADAPT_STRUCT(mapnik::binary_function_call,
|
||||
(mapnik::binary_function_impl, fun)
|
||||
(mapnik::binary_function_call::argument_type, arg1)
|
||||
(mapnik::binary_function_call::argument_type, arg2))
|
||||
|
||||
// fwd declare
|
||||
namespace mapnik {
|
||||
struct attribute;
|
||||
struct geometry_type_attribute;
|
||||
}
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
|
||||
struct unicode_impl
|
||||
{
|
||||
using result_type = mapnik::value_unicode_string;
|
||||
explicit unicode_impl(mapnik::transcoder const& tr)
|
||||
: tr_(tr) {}
|
||||
|
||||
mapnik::value_unicode_string operator()(std::string const& str) const
|
||||
{
|
||||
return tr_.transcode(str.c_str());
|
||||
}
|
||||
|
||||
mapnik::transcoder const& tr_;
|
||||
};
|
||||
|
||||
struct regex_match_impl
|
||||
{
|
||||
using result_type = expr_node;
|
||||
explicit regex_match_impl(mapnik::transcoder const& tr)
|
||||
: tr_(tr) {}
|
||||
|
||||
template <typename T0,typename T1>
|
||||
expr_node operator() (T0 & node, T1 const& pattern) const;
|
||||
|
||||
mapnik::transcoder const& tr_;
|
||||
};
|
||||
|
||||
struct regex_replace_impl
|
||||
{
|
||||
using result_type = expr_node;
|
||||
explicit regex_replace_impl(mapnik::transcoder const& tr)
|
||||
: tr_(tr) {}
|
||||
|
||||
template <typename T0,typename T1,typename T2>
|
||||
expr_node operator() (T0 & node, T1 const& pattern, T2 const& format) const;
|
||||
|
||||
mapnik::transcoder const& tr_;
|
||||
};
|
||||
|
||||
unary_function_types::unary_function_types()
|
||||
{
|
||||
add
|
||||
("sin", sin_impl())
|
||||
("cos", cos_impl())
|
||||
("tan", tan_impl())
|
||||
("atan", atan_impl())
|
||||
("exp", exp_impl())
|
||||
("log", log_impl())
|
||||
("abs", abs_impl())
|
||||
("length",length_impl())
|
||||
;
|
||||
}
|
||||
|
||||
binary_function_types::binary_function_types()
|
||||
{
|
||||
add
|
||||
("min", binary_function_impl(min_impl))
|
||||
("max", binary_function_impl(max_impl))
|
||||
("pow", binary_function_impl(pow_impl))
|
||||
;
|
||||
}
|
||||
|
||||
template <typename T0,typename T1>
|
||||
expr_node regex_match_impl::operator() (T0 & node, T1 const& pattern) const
|
||||
{
|
||||
return regex_match_node(tr_,node,pattern);
|
||||
}
|
||||
|
||||
template <typename T0,typename T1,typename T2>
|
||||
expr_node regex_replace_impl::operator() (T0 & node, T1 const& pattern, T2 const& format) const
|
||||
{
|
||||
return regex_replace_node(tr_,node,pattern,format);
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
expression_grammar<Iterator>::expression_grammar(std::string const& encoding)
|
||||
: expression_grammar::base_type(expr),
|
||||
tr_(encoding)
|
||||
{
|
||||
qi::_1_type _1;
|
||||
qi::_a_type _a;
|
||||
qi::_b_type _b;
|
||||
qi::_r1_type _r1;
|
||||
qi::no_skip_type no_skip;
|
||||
qi::_val_type _val;
|
||||
qi::lit_type lit;
|
||||
qi::double_type double_;
|
||||
qi::hex_type hex;
|
||||
qi::omit_type omit;
|
||||
qi::alpha_type alpha;
|
||||
qi::alnum_type alnum;
|
||||
standard_wide::char_type char_;
|
||||
standard_wide::no_case_type no_case;
|
||||
using boost::phoenix::construct;
|
||||
using boost::phoenix::if_else;
|
||||
|
||||
boost::phoenix::function<unicode_impl> unicode = unicode_impl(tr_);
|
||||
boost::phoenix::function<regex_match_impl> regex_match = regex_match_impl(tr_);
|
||||
boost::phoenix::function<regex_replace_impl> regex_replace = regex_replace_impl(tr_);
|
||||
|
||||
constant.add
|
||||
("null", mapnik::value_null())
|
||||
("false", mapnik::value_bool(false))
|
||||
("true", mapnik::value_bool(true))
|
||||
("point", mapnik::value_integer(1))
|
||||
("linestring", mapnik::value_integer(2))
|
||||
("polygon", mapnik::value_integer(3))
|
||||
("collection", mapnik::value_integer(4))
|
||||
("pi", mapnik::value_double(3.1415926535897932384626433832795))
|
||||
("deg_to_rad", mapnik::value_double(0.017453292519943295769236907684886))
|
||||
("rad_to_deg", mapnik::value_double(57.295779513082320876798154814105))
|
||||
;
|
||||
|
||||
expr = logical_expr [_val = _1]
|
||||
//| ustring [_val = unicode(_1)]
|
||||
;
|
||||
|
||||
logical_expr = not_expr [_val = _1]
|
||||
>>
|
||||
*( ( ( lit("and") | lit("&&")) >> not_expr [_val && _1] )
|
||||
| (( lit("or") | lit("||")) >> not_expr [_val || _1])
|
||||
)
|
||||
;
|
||||
|
||||
not_expr =
|
||||
cond_expr [_val = _1 ]
|
||||
| ((lit("not") | lit('!')) >> cond_expr [ _val = !_1 ])
|
||||
;
|
||||
|
||||
cond_expr = equality_expr [_val = _1] | additive_expr [_val = _1]
|
||||
;
|
||||
|
||||
equality_expr =
|
||||
relational_expr [_val = _1]
|
||||
>> *( ( (lit("=") | lit("eq") | lit("is")) >> relational_expr [_val == _1])
|
||||
| (( lit("!=") | lit("<>") | lit("neq") ) >> relational_expr [_val != _1])
|
||||
)
|
||||
;
|
||||
|
||||
regex_match_expr = lit(".match")
|
||||
>> lit('(')
|
||||
>> quoted_ustring [_val = _1]
|
||||
>> lit(')')
|
||||
;
|
||||
|
||||
regex_replace_expr =
|
||||
lit(".replace")
|
||||
>> lit('(')
|
||||
>> quoted_ustring [_a = _1]
|
||||
>> lit(',')
|
||||
>> quoted_ustring [_b = _1]
|
||||
>> lit(')') [_val = regex_replace(_r1,_a,_b)]
|
||||
;
|
||||
|
||||
relational_expr = additive_expr[_val = _1]
|
||||
>>
|
||||
*( ( (lit("<=") | lit("le") ) >> additive_expr [ _val <= _1 ])
|
||||
| ( (lit('<') | lit("lt") ) >> additive_expr [ _val < _1 ])
|
||||
| ( (lit(">=") | lit("ge") ) >> additive_expr [ _val >= _1 ])
|
||||
| ( (lit('>') | lit("gt") ) >> additive_expr [ _val > _1 ])
|
||||
)
|
||||
;
|
||||
|
||||
additive_expr = multiplicative_expr [_val = _1]
|
||||
>> * ( '+' >> multiplicative_expr[_val += _1]
|
||||
| '-' >> multiplicative_expr[_val -= _1]
|
||||
)
|
||||
;
|
||||
|
||||
multiplicative_expr = unary_expr [_val = _1]
|
||||
>> *( '*' >> unary_expr [_val *= _1]
|
||||
| '/' >> unary_expr [_val /= _1]
|
||||
| '%' >> unary_expr [_val %= construct<mapnik::expr_node>(_1)] //needed by clang++ with -std=c++11
|
||||
| regex_match_expr[_val = regex_match(_val, _1)]
|
||||
| regex_replace_expr(_val) [_val = _1]
|
||||
)
|
||||
;
|
||||
|
||||
unary_function_expr = unary_func_type >> '(' > logical_expr > ')'
|
||||
;
|
||||
|
||||
binary_function_expr = binary_func_type >> '(' > logical_expr > ','
|
||||
> logical_expr > ')'
|
||||
;
|
||||
|
||||
unary_expr = primary_expr [_val = _1]
|
||||
| '+' >> primary_expr [_val = _1]
|
||||
| '-' >> primary_expr [_val = -_1]
|
||||
;
|
||||
|
||||
primary_expr = strict_double [_val = _1]
|
||||
| int__[_val = _1]
|
||||
| no_case[constant] [_val = _1]
|
||||
| quoted_ustring [_val = unicode(_1)]
|
||||
| attr [if_else(_1 == "mapnik::geometry_type",
|
||||
_val = construct<mapnik::geometry_type_attribute>(),
|
||||
_val = construct<mapnik::attribute>(_1))]
|
||||
| global_attr [_val = construct<mapnik::global_attribute>( _1 )]
|
||||
| unary_function_expr [_val = _1]
|
||||
| binary_function_expr [_val = _1]
|
||||
| '(' > logical_expr [_val = _1 ] > ')'
|
||||
// TODO: this is a backward compatibility hack to allow unquoted strings
|
||||
| unquoted_ustring [_val = unicode(_1)]
|
||||
// ^ https://github.com/mapnik/mapnik/pull/3389
|
||||
;
|
||||
|
||||
unesc_char.add("\\a", '\a')("\\b", '\b')("\\f", '\f')("\\n", '\n')
|
||||
("\\r", '\r')("\\t", '\t')("\\v", '\v')("\\\\", '\\')
|
||||
("\\\'", '\'')("\\\"", '\"')
|
||||
;
|
||||
|
||||
ustring %= no_skip[alpha >> *alnum];
|
||||
quote_char %= char_('\'') | char_('"');
|
||||
quoted_ustring %= omit[quote_char[_a = _1]]
|
||||
>> *(unesc_char | "\\x" >> hex | (char_ - lit(_a)))
|
||||
>> lit(_a);
|
||||
unquoted_ustring %= no_skip[alpha >> *alnum] - lit("not");
|
||||
attr %= '[' >> no_skip[+~char_(']')] >> ']';
|
||||
global_attr %= '@' >> no_skip[alpha >> * (alnum | char_('-'))];
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
51
include/mapnik/expression_grammar_x3.hpp
Normal file
51
include/mapnik/expression_grammar_x3.hpp
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_EXPRESSIONS_GRAMMAR_X3_HPP
|
||||
#define MAPNIK_EXPRESSIONS_GRAMMAR_X3_HPP
|
||||
|
||||
#include <mapnik/expression_node.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/home/x3.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
namespace mapnik { namespace grammar {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
struct transcoder_tag;
|
||||
struct expression_class; // top-most ID
|
||||
using expression_grammar_type = x3::rule<expression_class, expr_node>;
|
||||
|
||||
BOOST_SPIRIT_DECLARE(expression_grammar_type);
|
||||
|
||||
}}
|
||||
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
grammar::expression_grammar_type const& expression_grammar();
|
||||
}
|
||||
|
||||
|
||||
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_X3_HPP
|
||||
43
include/mapnik/expression_grammar_x3_config.hpp
Normal file
43
include/mapnik/expression_grammar_x3_config.hpp
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_EXPRESSIONS_GRAMMAR_X3_CONFIG_HPP
|
||||
#define MAPNIK_EXPRESSIONS_GRAMMAR_X3_CONFIG_HPP
|
||||
|
||||
#include <mapnik/expression_grammar_x3.hpp>
|
||||
#include <mapnik/unicode.hpp>
|
||||
#include <string>
|
||||
|
||||
namespace mapnik { namespace grammar {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
using iterator_type = std::string::const_iterator;
|
||||
using phrase_context_type = x3::phrase_parse_context<x3::ascii::space_type>::type;
|
||||
|
||||
// define combined context
|
||||
using context_type = x3::with_context<transcoder_tag,
|
||||
std::reference_wrapper<mapnik::transcoder const> const,
|
||||
phrase_context_type>::type;
|
||||
|
||||
}}
|
||||
|
||||
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_X3_CONFIG_HPP
|
||||
456
include/mapnik/expression_grammar_x3_def.hpp
Normal file
456
include/mapnik/expression_grammar_x3_def.hpp
Normal file
|
|
@ -0,0 +1,456 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2016 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_EXPRESSIONS_GRAMMAR_X3_DEF_HPP
|
||||
#define MAPNIK_EXPRESSIONS_GRAMMAR_X3_DEF_HPP
|
||||
|
||||
#include <mapnik/expression_grammar_x3.hpp>
|
||||
#include <mapnik/json/unicode_string_grammar_x3_def.hpp>
|
||||
#include <mapnik/expression_node.hpp>
|
||||
#include <mapnik/function_call.hpp>
|
||||
#include <mapnik/unicode.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/spirit/home/x3.hpp>
|
||||
#include <boost/spirit/home/x3/support/ast/variant.hpp>
|
||||
#include <boost/fusion/include/adapt_struct.hpp>
|
||||
#include <boost/fusion/include/std_pair.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
BOOST_FUSION_ADAPT_STRUCT(mapnik::unary_function_call,
|
||||
(mapnik::unary_function_impl, fun)
|
||||
(mapnik::unary_function_call::argument_type, arg))
|
||||
|
||||
BOOST_FUSION_ADAPT_STRUCT(mapnik::binary_function_call,
|
||||
(mapnik::binary_function_impl, fun)
|
||||
(mapnik::binary_function_call::argument_type, arg1)
|
||||
(mapnik::binary_function_call::argument_type, arg2))
|
||||
|
||||
|
||||
namespace mapnik { namespace grammar {
|
||||
|
||||
namespace x3 = boost::spirit::x3;
|
||||
namespace ascii = boost::spirit::x3::ascii;
|
||||
using ascii::char_;
|
||||
using ascii::string;
|
||||
using x3::lit;
|
||||
using x3::double_;
|
||||
using x3::int_;
|
||||
using x3::bool_;
|
||||
using x3::_attr;
|
||||
using x3::_val;
|
||||
using x3::no_skip;
|
||||
using x3::lexeme;
|
||||
using x3::no_case;
|
||||
using x3::alpha;
|
||||
using x3::alnum;
|
||||
x3::uint_parser<char, 16, 2, 2> const hex2 {};
|
||||
|
||||
namespace {
|
||||
auto const& escaped_unicode = json::grammar::escaped_unicode;
|
||||
}
|
||||
|
||||
auto append = [](auto const& ctx)
|
||||
{
|
||||
_val(ctx) += _attr(ctx);
|
||||
};
|
||||
|
||||
auto do_assign = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(_attr(ctx));
|
||||
};
|
||||
|
||||
auto do_negate = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(unary_node<mapnik::tags::negate>(_attr(ctx)));
|
||||
};
|
||||
|
||||
auto do_attribute = [] (auto const& ctx)
|
||||
{
|
||||
auto & attr = _attr(ctx);
|
||||
if (attr == "mapnik::geometry_type")
|
||||
{
|
||||
_val(ctx) = std::move(geometry_type_attribute());
|
||||
}
|
||||
else
|
||||
{
|
||||
_val(ctx) = std::move(attribute(attr));
|
||||
}
|
||||
};
|
||||
|
||||
auto do_global_attribute = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(global_attribute(_attr(ctx)));
|
||||
};
|
||||
|
||||
auto do_add = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::plus>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_subt = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::minus>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_mult = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::mult>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_div = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::div>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_mod = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::mod>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_unicode = [] (auto const& ctx)
|
||||
{
|
||||
auto & tr = x3::get<transcoder_tag>(ctx).get();
|
||||
_val(ctx) = std::move(tr.transcode(_attr(ctx).c_str()));
|
||||
};
|
||||
|
||||
auto do_null = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::value_null());
|
||||
};
|
||||
|
||||
auto do_not = [] (auto const& ctx)
|
||||
{
|
||||
mapnik::unary_node<mapnik::tags::logical_not> node(_attr(ctx));
|
||||
_val(ctx) = std::move(node);
|
||||
};
|
||||
|
||||
auto do_and = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::logical_and>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_or = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::logical_or>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_equal = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::equal_to>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_not_equal = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::not_equal_to>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_less = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::less>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_less_equal = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::less_equal>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_greater = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::greater>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_greater_equal = [] (auto const& ctx)
|
||||
{
|
||||
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::greater_equal>(std::move(_val(ctx)), std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
// regex
|
||||
auto do_regex_match = [] (auto const& ctx)
|
||||
{
|
||||
auto const& tr = x3::get<transcoder_tag>(ctx).get();
|
||||
_val(ctx) = std::move(mapnik::regex_match_node(tr, std::move(_val(ctx)) , std::move(_attr(ctx))));
|
||||
};
|
||||
|
||||
auto do_regex_replace = [] (auto const& ctx)
|
||||
{
|
||||
auto const& tr = x3::get<transcoder_tag>(ctx).get();
|
||||
auto const& pair = _attr(ctx);
|
||||
auto const& pattern = std::get<0>(pair);
|
||||
auto const& format = std::get<1>(pair);
|
||||
_val(ctx) = mapnik::regex_replace_node(tr, _val(ctx) , pattern, format);
|
||||
};
|
||||
|
||||
// mapnik::value_integer
|
||||
auto const mapnik_int = x3::int_parser<value_integer,10,1,-1>();
|
||||
// mapnik::value_double
|
||||
auto const mapnik_double = x3::real_parser<value_double, x3::strict_real_policies<value_double>>();
|
||||
// mapnik::value_bool
|
||||
struct boolean_ : x3::symbols<mapnik::value_bool>
|
||||
{
|
||||
boolean_()
|
||||
{
|
||||
add
|
||||
("true", true)
|
||||
("false", false)
|
||||
;
|
||||
}
|
||||
} boolean;
|
||||
|
||||
struct floating_point_constants : x3::symbols<mapnik::value_double>
|
||||
{
|
||||
floating_point_constants()
|
||||
{
|
||||
add
|
||||
("pi", 3.1415926535897932384626433832795)
|
||||
("deg_to_rad",0.017453292519943295769236907684886)
|
||||
("rad_to_deg",57.295779513082320876798154814105)
|
||||
;
|
||||
}
|
||||
} float_const;
|
||||
|
||||
// unary functions
|
||||
struct unary_function_types_ : x3::symbols<unary_function_impl>
|
||||
{
|
||||
unary_function_types_()
|
||||
{
|
||||
add
|
||||
("sin", sin_impl())
|
||||
("cos", cos_impl())
|
||||
("tan", tan_impl())
|
||||
("atan", atan_impl())
|
||||
("exp", exp_impl())
|
||||
("log", log_impl())
|
||||
("abs", abs_impl())
|
||||
("length",length_impl())
|
||||
;
|
||||
}
|
||||
} unary_func_types ;
|
||||
|
||||
|
||||
// binary functions
|
||||
|
||||
struct binary_function_types_ : x3::symbols<binary_function_impl>
|
||||
{
|
||||
binary_function_types_()
|
||||
{
|
||||
add
|
||||
("min", binary_function_impl(min_impl))
|
||||
("max", binary_function_impl(max_impl))
|
||||
("pow", binary_function_impl(pow_impl))
|
||||
;
|
||||
}
|
||||
} binary_func_types;
|
||||
|
||||
// geometry types
|
||||
struct geometry_types_ : x3::symbols<mapnik::value_integer>
|
||||
{
|
||||
geometry_types_()
|
||||
{
|
||||
add
|
||||
("point", 1)
|
||||
("linestring", 2)
|
||||
("polygon",3)
|
||||
("collection",4)
|
||||
;
|
||||
}
|
||||
} geometry_type;
|
||||
|
||||
struct unesc_chars_ : x3::symbols<char>
|
||||
{
|
||||
unesc_chars_()
|
||||
{
|
||||
add
|
||||
("\\a", '\a')
|
||||
("\\b", '\b')
|
||||
("\\f", '\f')
|
||||
("\\n", '\n')
|
||||
("\\r", '\r')
|
||||
("\\t", '\t')
|
||||
("\\v", '\v')
|
||||
("\\\\", '\\')
|
||||
("\\\'", '\'')
|
||||
("\\\"", '\"')
|
||||
;
|
||||
}
|
||||
} unesc_char;
|
||||
// starting rule
|
||||
expression_grammar_type const expression("expression");
|
||||
// rules
|
||||
x3::rule<class logical_expression, mapnik::expr_node> const logical_expression("logical expression");
|
||||
x3::rule<class not_expression, mapnik::expr_node> const not_expression("not expression");
|
||||
x3::rule<class conditional_expression, mapnik::expr_node> const conditional_expression("conditional expression");
|
||||
x3::rule<class equality_expression, mapnik::expr_node> const equality_expression("equality expression");
|
||||
x3::rule<class relational_expression, mapnik::expr_node> const relational_expression("relational expression");
|
||||
x3::rule<class additive_expression, mapnik::expr_node> const additive_expression("additive expression");
|
||||
x3::rule<class multiplicative_expression, mapnik::expr_node> const multiplicative_expression("multiplicative expression");
|
||||
x3::rule<class unary_func_expression, mapnik::unary_function_call> const unary_func_expression("unary function expression");
|
||||
x3::rule<class binary_func_expression, mapnik::binary_function_call> const binary_func_expression("binary function expression");
|
||||
x3::rule<class unary_expression, mapnik::expr_node> const unary_expression("unary expression");
|
||||
x3::rule<class primary_expression, mapnik::expr_node> const primary_expression("primary expression");
|
||||
x3::rule<class regex_match_expression, std::string> const regex_match_expression("regex match expression");
|
||||
x3::rule<class regex_replace_expression, std::pair<std::string,std::string> > const regex_replace_expression("regex replace expression");
|
||||
|
||||
// strings
|
||||
auto const single_quoted_string = x3::rule<class single_quoted_string, std::string> {} = lit('\'')
|
||||
>> no_skip[*(unesc_char[append]
|
||||
|
|
||||
//(lit('\\') > escaped_unicode[append]) // FIXME (!)
|
||||
//|
|
||||
(~char_('\''))[append])] > lit('\'');
|
||||
|
||||
auto const double_quoted_string = x3::rule<class double_quoted_string, std::string> {} = lit('"')
|
||||
>> no_skip[*(unesc_char[append]
|
||||
|
|
||||
(lit('\\') > escaped_unicode[append])
|
||||
|
|
||||
(~char_('"'))[append])] > lit('"');
|
||||
|
||||
auto const quoted_string = x3::rule<class quoted_string, std::string> {} = single_quoted_string | double_quoted_string;
|
||||
|
||||
auto const unquoted_ustring = x3::rule<class ustring, std::string> {} = no_skip[alpha > *alnum] - lit("not");
|
||||
|
||||
// start
|
||||
auto const expression_def = logical_expression [do_assign]
|
||||
;
|
||||
|
||||
auto const logical_expression_def = not_expression[do_assign] >
|
||||
*(((lit("and") | lit("&&")) > not_expression[do_and])
|
||||
|
|
||||
((lit("or") | lit("||")) > not_expression[do_or]));
|
||||
|
||||
auto const not_expression_def = conditional_expression[do_assign]
|
||||
|
|
||||
((lit("not") | lit('!')) > conditional_expression[do_not])
|
||||
;
|
||||
|
||||
auto const conditional_expression_def = equality_expression[do_assign]
|
||||
|
|
||||
additive_expression[do_assign]
|
||||
;
|
||||
|
||||
auto const equality_expression_def = relational_expression[do_assign] >
|
||||
*( ( ( lit("=") | lit("eq") | lit("is")) > relational_expression [do_equal])
|
||||
| (( lit( "!=") | lit("<>") | lit("neq") ) > relational_expression [do_not_equal])
|
||||
);
|
||||
|
||||
auto const relational_expression_def = additive_expression[do_assign] >
|
||||
*( ( (lit("<=") | lit("le")) > additive_expression [do_less_equal])
|
||||
|
|
||||
( (lit("<") | lit("lt")) >> additive_expression[do_less]) // allow backtracking to be able to handle '<' and '<>' correctly
|
||||
|
|
||||
( (lit(">=") | lit("ge")) > additive_expression [do_greater_equal])
|
||||
|
|
||||
( (lit(">") | lit("gt")) > additive_expression [do_greater]));
|
||||
|
||||
|
||||
auto const additive_expression_def = multiplicative_expression[do_assign]
|
||||
> *( ('+' > multiplicative_expression[do_add])
|
||||
|
|
||||
('-' > multiplicative_expression[do_subt]));
|
||||
|
||||
auto const feature_attr = lexeme['[' > +~char_(']') > ']'];
|
||||
auto const global_attr = x3::rule<class global_attr, std::string> {} = lexeme[lit('@') > char_("a-zA-Z_") > *char_("a-zA-Z0-9_")];
|
||||
|
||||
auto const regex_match_expression_def = lit(".match") > '(' > quoted_string > ')';
|
||||
auto const regex_replace_expression_def = lit(".replace") > '(' > quoted_string > ',' > quoted_string > ')';
|
||||
auto const multiplicative_expression_def = unary_expression [do_assign]
|
||||
> *( ('*' > unary_expression [do_mult])
|
||||
|
|
||||
('/' > unary_expression [do_div])
|
||||
|
|
||||
('%' > unary_expression [do_mod])
|
||||
|
|
||||
regex_match_expression[do_regex_match]
|
||||
|
|
||||
regex_replace_expression[do_regex_replace]
|
||||
);
|
||||
|
||||
auto const unary_func_expression_def = unary_func_types > '(' > expression > ')';
|
||||
auto const binary_func_expression_def = binary_func_types > '(' > expression > ',' > expression > ')';
|
||||
|
||||
auto const unary_expression_def =
|
||||
primary_expression[do_assign]
|
||||
|
|
||||
('+' > primary_expression[do_assign])
|
||||
|
|
||||
('-' > primary_expression[do_negate])
|
||||
;
|
||||
|
||||
auto const primary_expression_def =
|
||||
mapnik_double[do_assign]
|
||||
|
|
||||
mapnik_int[do_assign]
|
||||
|
|
||||
no_case[boolean][do_assign]
|
||||
|
|
||||
no_case["null"][do_null]
|
||||
|
|
||||
no_case[geometry_type][do_assign]
|
||||
|
|
||||
float_const[do_assign]
|
||||
|
|
||||
quoted_string[do_unicode]
|
||||
|
|
||||
feature_attr[do_attribute]
|
||||
|
|
||||
global_attr[do_global_attribute]
|
||||
|
|
||||
unary_func_expression[do_assign]
|
||||
|
|
||||
binary_func_expression[do_assign]
|
||||
|
|
||||
('(' > logical_expression[do_assign] > ')')
|
||||
|
|
||||
unquoted_ustring[do_unicode]
|
||||
// ^ https://github.com/mapnik/mapnik/pull/3389
|
||||
;
|
||||
|
||||
BOOST_SPIRIT_DEFINE (
|
||||
expression,
|
||||
logical_expression,
|
||||
not_expression,
|
||||
conditional_expression,
|
||||
equality_expression,
|
||||
relational_expression,
|
||||
additive_expression,
|
||||
regex_match_expression,
|
||||
regex_replace_expression,
|
||||
multiplicative_expression,
|
||||
unary_func_expression,
|
||||
binary_func_expression,
|
||||
unary_expression,
|
||||
primary_expression
|
||||
);
|
||||
|
||||
}}
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
grammar::expression_grammar_type const& expression_grammar()
|
||||
{
|
||||
return grammar::expression;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // MAPNIK_EXPRESSIONS_GRAMMAR_X3_DEF_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -24,7 +24,7 @@
|
|||
#define MAPNIK_EXPRESSION_NODE_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/value.hpp>
|
||||
#include <mapnik/config.hpp>
|
||||
#include <mapnik/unicode.hpp>
|
||||
|
|
@ -59,6 +59,9 @@ template <> struct make_op<mapnik::tags::logical_or> { using type = std::logica
|
|||
template <typename Tag>
|
||||
struct unary_node
|
||||
{
|
||||
unary_node (expr_node && a)
|
||||
: expr(std::move(a)) {}
|
||||
|
||||
unary_node (expr_node const& a)
|
||||
: expr(a) {}
|
||||
|
||||
|
|
@ -73,6 +76,10 @@ struct unary_node
|
|||
template <typename Tag>
|
||||
struct binary_node
|
||||
{
|
||||
binary_node(expr_node && a, expr_node && b)
|
||||
: left(std::move(a)),
|
||||
right(std::move(b)) {}
|
||||
|
||||
binary_node(expr_node const& a, expr_node const& b)
|
||||
: left(a),
|
||||
right(b) {}
|
||||
|
|
@ -130,81 +137,6 @@ struct MAPNIK_DECL regex_replace_node
|
|||
std::shared_ptr<_regex_replace_impl> impl_;
|
||||
};
|
||||
|
||||
inline expr_node & operator- (expr_node& expr)
|
||||
{
|
||||
return expr = unary_node<mapnik::tags::negate>(expr);
|
||||
}
|
||||
|
||||
inline expr_node & operator += ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::plus>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator -= ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::minus>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator *= ( expr_node &left , expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::mult>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator /= ( expr_node &left , expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::div>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator %= ( expr_node &left , expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::mod>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator < ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::less>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator <= ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::less_equal>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator > ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::greater>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator >= ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::greater_equal>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator == ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::equal_to>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator != ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::not_equal_to>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator ! (expr_node & expr)
|
||||
{
|
||||
return expr = unary_node<mapnik::tags::logical_not>(expr);
|
||||
}
|
||||
|
||||
inline expr_node & operator && ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::logical_and>(left,right);
|
||||
}
|
||||
|
||||
inline expr_node & operator || ( expr_node &left, expr_node const& right)
|
||||
{
|
||||
return left = binary_node<mapnik::tags::logical_or>(left,right);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
// mapnik
|
||||
#include <mapnik/config.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/util/variant.hpp>
|
||||
|
||||
namespace mapnik
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
232
include/mapnik/extend_converter.hpp
Normal file
232
include/mapnik/extend_converter.hpp
Normal file
|
|
@ -0,0 +1,232 @@
|
|||
/*****************************************************************************
|
||||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 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_EXTEND_CONVERTER_HPP
|
||||
#define MAPNIK_EXTEND_CONVERTER_HPP
|
||||
|
||||
#include <mapnik/vertex.hpp>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#include <mapnik/warning_ignore.hpp>
|
||||
#include <boost/optional.hpp>
|
||||
#include <boost/msm/back/state_machine.hpp>
|
||||
#include <boost/msm/front/state_machine_def.hpp>
|
||||
#include <boost/msm/front/functor_row.hpp>
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
// stl
|
||||
#include <cmath>
|
||||
|
||||
namespace mapnik
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
namespace msm = boost::msm;
|
||||
namespace mpl = boost::mpl;
|
||||
using namespace msm::front;
|
||||
|
||||
template <typename T>
|
||||
T extend(T const & v1, T const & v2, double length)
|
||||
{
|
||||
double dx = v2.x - v1.x;
|
||||
double dy = v2.y - v1.y;
|
||||
double l12 = std::sqrt(dx * dx + dy * dy);
|
||||
double coef = 1.0 + length / l12;
|
||||
return vertex2d(v1.x + dx * coef,
|
||||
v1.y + dy * coef, v2.cmd);
|
||||
}
|
||||
|
||||
namespace events
|
||||
{
|
||||
struct vertex_event
|
||||
{
|
||||
vertex_event(vertex2d const & vertex) : vertex(vertex) { }
|
||||
vertex2d const & vertex;
|
||||
};
|
||||
|
||||
struct move_to : vertex_event { using vertex_event::vertex_event; };
|
||||
struct line_to : vertex_event { using vertex_event::vertex_event; };
|
||||
struct close : vertex_event { using vertex_event::vertex_event; };
|
||||
struct end : vertex_event { using vertex_event::vertex_event; };
|
||||
}
|
||||
|
||||
namespace actions
|
||||
{
|
||||
struct store
|
||||
{
|
||||
template <class FSM, class EVT, class SourceState, class TargetState>
|
||||
void operator()(EVT const & e, FSM & m, SourceState&, TargetState&)
|
||||
{
|
||||
m.v2 = m.v1;
|
||||
m.v1 = e.vertex;
|
||||
m.output = boost::none;
|
||||
}
|
||||
};
|
||||
|
||||
struct output
|
||||
{
|
||||
template <class FSM, class EVT, class SourceState, class TargetState>
|
||||
void operator()(EVT const & e, FSM & m, SourceState&, TargetState&)
|
||||
{
|
||||
m.output = e.vertex;
|
||||
}
|
||||
};
|
||||
|
||||
struct store_and_output
|
||||
{
|
||||
template <class FSM, class EVT, class SourceState, class TargetState>
|
||||
void operator()(EVT const & e, FSM & m, SourceState&, TargetState&)
|
||||
{
|
||||
m.v2 = m.v1;
|
||||
m.v1 = e.vertex;
|
||||
m.output = m.v2;
|
||||
}
|
||||
};
|
||||
|
||||
struct output_begin
|
||||
{
|
||||
template <class FSM, class EVT, class SourceState, class TargetState>
|
||||
void operator()(EVT const & e, FSM & m, SourceState&, TargetState&)
|
||||
{
|
||||
m.v2 = m.v1;
|
||||
m.v1 = e.vertex;
|
||||
m.output = extend(m.v1, m.v2, m.extend_length);
|
||||
}
|
||||
};
|
||||
|
||||
struct output_end
|
||||
{
|
||||
template <class FSM, class EVT, class SourceState, class TargetState>
|
||||
void operator()(EVT const & e, FSM & m, SourceState&, TargetState&)
|
||||
{
|
||||
m.output = extend(m.v2, m.v1, m.extend_length);
|
||||
m.v1 = e.vertex;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
struct extender_def : public msm::front::state_machine_def<extender_def>
|
||||
{
|
||||
using no_exception_thrown = int;
|
||||
using no_message_queue = int;
|
||||
|
||||
struct initial : public msm::front::state<> { };
|
||||
struct vertex_one : public msm::front::state<> { };
|
||||
struct vertex_two : public msm::front::state<> { };
|
||||
struct end : public msm::front::state<> { };
|
||||
|
||||
using initial_state = initial;
|
||||
|
||||
struct transition_table : mpl::vector<
|
||||
// Start Event Next Action Guard
|
||||
// +------------+-----------------+------------+--------------------+------+
|
||||
Row < initial , events::move_to , vertex_one , actions::store >,
|
||||
Row < initial , events::line_to , vertex_one , actions::store >,
|
||||
Row < initial , events::close , initial >,
|
||||
Row < initial , events::end , end , actions::output >,
|
||||
Row < vertex_one , events::move_to , vertex_one , actions::store_and_output >,
|
||||
Row < vertex_one , events::line_to , vertex_two , actions::output_begin >,
|
||||
Row < vertex_one , events::close , initial , actions::store_and_output >,
|
||||
Row < vertex_one , events::end , end , actions::store_and_output >,
|
||||
Row < vertex_two , events::move_to , vertex_one , actions::output_end >,
|
||||
Row < vertex_two , events::line_to , vertex_two , actions::store_and_output >,
|
||||
Row < vertex_two , events::close , initial , actions::output_end >,
|
||||
Row < vertex_two , events::end , end , actions::output_end >,
|
||||
Row < end , events::end , end , actions::output >
|
||||
> {};
|
||||
|
||||
extender_def(double extend_length)
|
||||
: extend_length(extend_length)
|
||||
{
|
||||
}
|
||||
|
||||
boost::optional<vertex2d> output;
|
||||
vertex2d v1, v2;
|
||||
double extend_length;
|
||||
};
|
||||
|
||||
using extender = msm::back::state_machine<extender_def>;
|
||||
|
||||
}
|
||||
|
||||
template <typename Geometry>
|
||||
struct extend_converter
|
||||
{
|
||||
extend_converter(Geometry & geom)
|
||||
: extend_converter(geom, 0)
|
||||
{}
|
||||
|
||||
extend_converter(Geometry & geom, double extend)
|
||||
: geom_(geom), extender_(extend)
|
||||
{}
|
||||
|
||||
void set_extend(double extend)
|
||||
{
|
||||
extender_.extend_length = extend;
|
||||
}
|
||||
|
||||
unsigned vertex(double * x, double * y)
|
||||
{
|
||||
using namespace detail;
|
||||
vertex2d v;
|
||||
do
|
||||
{
|
||||
v.cmd = geom_.vertex(&v.x, &v.y);
|
||||
switch (v.cmd)
|
||||
{
|
||||
case SEG_MOVETO:
|
||||
extender_.process_event(events::move_to(v));
|
||||
break;
|
||||
case SEG_LINETO:
|
||||
extender_.process_event(events::line_to(v));
|
||||
break;
|
||||
case SEG_CLOSE:
|
||||
extender_.process_event(events::close(v));
|
||||
break;
|
||||
case SEG_END:
|
||||
extender_.process_event(events::end(v));
|
||||
break;
|
||||
}
|
||||
} while(!extender_.output);
|
||||
|
||||
vertex2d const & output = *extender_.output;
|
||||
*x = output.x;
|
||||
*y = output.y;
|
||||
return output.cmd;
|
||||
}
|
||||
|
||||
void rewind(unsigned)
|
||||
{
|
||||
geom_.rewind(0);
|
||||
extender_.start();
|
||||
}
|
||||
|
||||
private:
|
||||
Geometry & geom_;
|
||||
detail::extender extender_;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // MAPNIK_EXTEND_CONVERTER_HPP
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -25,11 +25,11 @@
|
|||
|
||||
// mapnik
|
||||
#include <mapnik/config.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
#include <mapnik/value.hpp>
|
||||
#include <mapnik/box2d.hpp>
|
||||
#include <mapnik/geometry/box2d.hpp>
|
||||
#include <mapnik/geometry.hpp>
|
||||
#include <mapnik/geometry_envelope.hpp>
|
||||
#include <mapnik/geometry/envelope.hpp>
|
||||
//
|
||||
#include <mapnik/feature_kv_iterator.hpp>
|
||||
#include <mapnik/util/noncopyable.hpp>
|
||||
|
|
@ -105,7 +105,7 @@ public:
|
|||
: id_(_id),
|
||||
ctx_(ctx),
|
||||
data_(ctx_->mapping_.size()),
|
||||
geom_(geometry::geometry_empty<double>()),
|
||||
geom_(geometry::geometry_empty()),
|
||||
raster_() {}
|
||||
|
||||
inline mapnik::value_integer id() const { return id_;}
|
||||
|
|
@ -208,6 +208,11 @@ public:
|
|||
return geom_;
|
||||
}
|
||||
|
||||
inline geometry::geometry<double> & get_geometry()
|
||||
{
|
||||
return geom_;
|
||||
}
|
||||
|
||||
inline box2d<double> envelope() const
|
||||
{
|
||||
return mapnik::geometry::envelope(geom_);
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
|
||||
// mapnik
|
||||
#include <mapnik/feature.hpp>
|
||||
#include <mapnik/value_types.hpp>
|
||||
#include <mapnik/value/types.hpp>
|
||||
|
||||
// boost
|
||||
//#include <boost/pool/pool_alloc.hpp>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -24,12 +24,13 @@
|
|||
#define MAPNIK_FEATURE_STYLE_PROCESSOR_HPP
|
||||
|
||||
// mapnik
|
||||
#include <mapnik/box2d.hpp>
|
||||
#include <mapnik/geometry/box2d.hpp>
|
||||
#include <mapnik/featureset.hpp>
|
||||
#include <mapnik/config.hpp>
|
||||
#include <mapnik/feature_style_processor_context.hpp>
|
||||
|
||||
// stl
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <string>
|
||||
|
||||
|
|
@ -93,6 +94,12 @@ private:
|
|||
featureset_ptr features,
|
||||
proj_transform const& prj_trans);
|
||||
|
||||
void prepare_layers(layer_rendering_material & parent_mat,
|
||||
std::vector<layer> const & layers,
|
||||
feature_style_context_map & ctx_map,
|
||||
Processor & p,
|
||||
double scale_denom);
|
||||
|
||||
/*!
|
||||
* \brief prepare features for rendering asynchronously.
|
||||
*/
|
||||
|
|
@ -111,6 +118,7 @@ private:
|
|||
* \brief render features list queued when they are available.
|
||||
*/
|
||||
void render_material(layer_rendering_material const & mat, Processor & p );
|
||||
void render_submaterials(layer_rendering_material const & mat, Processor & p);
|
||||
|
||||
Map const& m_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -33,7 +33,7 @@
|
|||
#include <mapnik/query.hpp>
|
||||
#include <mapnik/datasource.hpp>
|
||||
#include <mapnik/feature_type_style.hpp>
|
||||
#include <mapnik/box2d.hpp>
|
||||
#include <mapnik/geometry/box2d.hpp>
|
||||
#include <mapnik/layer.hpp>
|
||||
#include <mapnik/rule.hpp>
|
||||
#include <mapnik/rule_cache.hpp>
|
||||
|
|
@ -63,6 +63,7 @@ struct layer_rendering_material
|
|||
std::vector<feature_type_style const*> active_styles_;
|
||||
std::vector<featureset_ptr> featureset_ptr_list_;
|
||||
std::vector<rule_cache> rule_caches_;
|
||||
std::vector<layer_rendering_material> materials_;
|
||||
|
||||
layer_rendering_material(layer const& lay, projection const& dest)
|
||||
:
|
||||
|
|
@ -84,6 +85,41 @@ feature_style_processor<Processor>::feature_style_processor(Map const& m, double
|
|||
}
|
||||
}
|
||||
|
||||
template <typename Processor>
|
||||
void feature_style_processor<Processor>::prepare_layers(layer_rendering_material & parent_mat,
|
||||
std::vector<layer> const & layers,
|
||||
feature_style_context_map & ctx_map,
|
||||
Processor & p,
|
||||
double scale_denom)
|
||||
{
|
||||
for (layer const& lyr : layers)
|
||||
{
|
||||
if (lyr.visible(scale_denom))
|
||||
{
|
||||
std::set<std::string> names;
|
||||
layer_rendering_material mat(lyr, parent_mat.proj0_);
|
||||
|
||||
prepare_layer(mat,
|
||||
ctx_map,
|
||||
p,
|
||||
m_.scale(),
|
||||
scale_denom,
|
||||
m_.width(),
|
||||
m_.height(),
|
||||
m_.get_current_extent(),
|
||||
m_.buffer_size(),
|
||||
names);
|
||||
|
||||
// Store active material
|
||||
if (!mat.active_styles_.empty())
|
||||
{
|
||||
prepare_layers(mat, lyr.layers(), ctx_map, p, scale_denom);
|
||||
parent_mat.materials_.emplace_back(std::move(mat));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Processor>
|
||||
void feature_style_processor<Processor>::apply(double scale_denom)
|
||||
{
|
||||
|
|
@ -101,44 +137,16 @@ void feature_style_processor<Processor>::apply(double scale_denom)
|
|||
// in a second time, we fetch the results and
|
||||
// do the actual rendering
|
||||
|
||||
std::vector<layer_rendering_material> mat_list;
|
||||
|
||||
// Define processing context map used by datasources
|
||||
// implementing asynchronous queries
|
||||
feature_style_context_map ctx_map;
|
||||
|
||||
for ( layer const& lyr : m_.layers() )
|
||||
if (!m_.layers().empty())
|
||||
{
|
||||
if (lyr.visible(scale_denom))
|
||||
{
|
||||
std::set<std::string> names;
|
||||
layer_rendering_material mat(lyr, proj);
|
||||
layer_rendering_material root_mat(m_.layers().front(), proj);
|
||||
prepare_layers(root_mat, m_.layers(), ctx_map, p, scale_denom);
|
||||
|
||||
prepare_layer(mat,
|
||||
ctx_map,
|
||||
p,
|
||||
m_.scale(),
|
||||
scale_denom,
|
||||
m_.width(),
|
||||
m_.height(),
|
||||
m_.get_current_extent(),
|
||||
m_.buffer_size(),
|
||||
names);
|
||||
|
||||
// Store active material
|
||||
if (!mat.active_styles_.empty())
|
||||
{
|
||||
mat_list.emplace_back(std::move(mat));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for ( layer_rendering_material const & mat : mat_list )
|
||||
{
|
||||
if (!mat.active_styles_.empty())
|
||||
{
|
||||
render_material(mat, p);
|
||||
}
|
||||
render_submaterials(root_mat, p);
|
||||
}
|
||||
|
||||
p.end_map_processing(m_);
|
||||
|
|
@ -201,9 +209,12 @@ void feature_style_processor<Processor>::apply_to_layer(layer const& lay,
|
|||
buffer_size,
|
||||
names);
|
||||
|
||||
prepare_layers(mat, lay.layers(), ctx_map, p, scale_denom);
|
||||
|
||||
if (!mat.active_styles_.empty())
|
||||
{
|
||||
render_material(mat,p);
|
||||
render_submaterials(mat, p);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -368,10 +379,10 @@ void feature_style_processor<Processor>::prepare_layer(layer_rendering_material
|
|||
continue;
|
||||
}
|
||||
|
||||
std::vector<rule> const& rules = style->get_rules();
|
||||
std::vector<rule> const& style_rules = style->get_rules();
|
||||
bool active_rules = false;
|
||||
rule_cache rc;
|
||||
for(rule const& r : rules)
|
||||
for(rule const& r : style_rules)
|
||||
{
|
||||
if (r.active(scale_denom))
|
||||
{
|
||||
|
|
@ -441,10 +452,27 @@ void feature_style_processor<Processor>::prepare_layer(layer_rendering_material
|
|||
}
|
||||
}
|
||||
|
||||
template <typename Processor>
|
||||
void feature_style_processor<Processor>::render_submaterials(layer_rendering_material const & parent_mat,
|
||||
Processor & p)
|
||||
{
|
||||
for (layer_rendering_material const & mat : parent_mat.materials_)
|
||||
{
|
||||
if (!mat.active_styles_.empty())
|
||||
{
|
||||
p.start_layer_processing(mat.lay_, mat.layer_ext2_);
|
||||
|
||||
render_material(mat, p);
|
||||
render_submaterials(mat, p);
|
||||
|
||||
p.end_layer_processing(mat.lay_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Processor>
|
||||
void feature_style_processor<Processor>::render_material(layer_rendering_material const & mat,
|
||||
Processor & p )
|
||||
Processor & p)
|
||||
{
|
||||
std::vector<feature_type_style const*> const & active_styles = mat.active_styles_;
|
||||
std::vector<featureset_ptr> const & featureset_ptr_list = mat.featureset_ptr_list_;
|
||||
|
|
@ -460,8 +488,6 @@ void feature_style_processor<Processor>::render_material(layer_rendering_materia
|
|||
return;
|
||||
}
|
||||
|
||||
p.start_layer_processing(mat.lay_, mat.layer_ext2_);
|
||||
|
||||
layer const& lay = mat.lay_;
|
||||
|
||||
std::vector<rule_cache> const & rule_caches = mat.rule_caches_;
|
||||
|
|
@ -555,7 +581,6 @@ void feature_style_processor<Processor>::render_material(layer_rendering_materia
|
|||
++i;
|
||||
}
|
||||
}
|
||||
p.end_layer_processing(mat.lay_);
|
||||
}
|
||||
|
||||
template <typename Processor>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -1,8 +0,0 @@
|
|||
// TODO - remove this file at mapnik 3.x
|
||||
#ifdef _MSC_VER
|
||||
#pragma NOTE("filter_factory.hpp" is now called "expression.hpp")
|
||||
#else
|
||||
#warning "filter_factory.hpp" is now called "expression.hpp"
|
||||
#endif
|
||||
|
||||
#include <mapnik/expression.hpp>
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
*
|
||||
* This file is part of Mapnik (c++ mapping toolkit)
|
||||
*
|
||||
* Copyright (C) 2015 Artem Pavlenko
|
||||
* Copyright (C) 2016 Artem Pavlenko
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -47,7 +47,6 @@ struct exp_impl
|
|||
{
|
||||
return std::exp(val.to_double());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// log
|
||||
|
|
@ -58,7 +57,6 @@ struct log_impl
|
|||
{
|
||||
return std::log(val.to_double());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// sin
|
||||
|
|
@ -102,7 +100,7 @@ struct abs_impl
|
|||
{
|
||||
value_type operator() (value_type const& val) const
|
||||
{
|
||||
return std::fabs(val.to_double());
|
||||
return std::abs(val.to_double());
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue