From 156a7590f44b123119fe1411a55b834b711b785f Mon Sep 17 00:00:00 2001 From: Rich Wareham Date: Thu, 19 Jul 2012 19:06:44 +0100 Subject: [PATCH] python: a new plugin to use arbitrary Python as a data source This plugin allows you to write data sources in the Python programming language. This is useful if you want to rapidly prototype a plugin, perform some custom manipulation on data or if you want to bind mapnik to a datasource which is most conveniently accessed through Python. The plugin may be used from the existing mapnik Python bindings or it can embed the Python interpreter directly allowing it to be used from C++, XML or even JavaScript. Mapnik already has excellent Python bindings but they only directly support calling *into* mapnik *from* Python. This forces mapnik and its input plugins to be the lowest layer of the stack. The role of this plugin is to allow mapnik to call *into* Python itself. This allows mapnik to sit as rendering middleware between a custom Python frontend and a custom Python datasource. This increases the utility of mapnik as a component in a larger system. There already exists MemoryDatasource which can be used to dynamically create geometry in Python. It suffers from the problem that it does not allow generating only the geometry which is seen by a particular query. Similarly the entire geometry must exist in memory before rendering can progress. By using a custom iterator object or by using generator expressions this plugin allows geometry to be created on demand and to be destroyed after use. This can have a great impact on memory efficiency. Since geometry is generated on-demand as rendering progresses there can be arbitrarily complex 'cleverness' optimising the geometry generated for a particular query. Obvious examples of this would be generating only geometry within the query bounding box and generating geometry with an appropriate level of detail for the output resolution. --- SConstruct | 1 + bindings/python/mapnik/__init__.py | 70 +++++ plugins/input/python/Makefile | 34 +++ plugins/input/python/README.md | 241 ++++++++++++++++++ plugins/input/python/build.py | 149 +++++++++++ .../python/examples/concentric_circles.py | 83 ++++++ .../input/python/examples/simple_points.py | 34 +++ plugins/input/python/examples/simple_xml.py | 8 + plugins/input/python/examples/simple_xml.xml | 16 ++ plugins/input/python/python_datasource.cpp | 208 +++++++++++++++ plugins/input/python/python_datasource.hpp | 56 ++++ plugins/input/python/python_featureset.cpp | 30 +++ plugins/input/python/python_featureset.hpp | 30 +++ plugins/input/python/python_utils.hpp | 16 ++ .../good_maps/python_circle_datasource.xml | 50 ++++ .../good_maps/python_point_datasource.xml | 18 ++ .../support/mapnik-python-circle-render1.png | Bin 0 -> 138036 bytes .../support/mapnik-python-point-render1.png | Bin 0 -> 4165 bytes tests/python_tests/python_plugin_test.py | 158 ++++++++++++ 19 files changed, 1202 insertions(+) create mode 100644 plugins/input/python/Makefile create mode 100644 plugins/input/python/README.md create mode 100644 plugins/input/python/build.py create mode 100644 plugins/input/python/examples/concentric_circles.py create mode 100644 plugins/input/python/examples/simple_points.py create mode 100644 plugins/input/python/examples/simple_xml.py create mode 100644 plugins/input/python/examples/simple_xml.xml create mode 100644 plugins/input/python/python_datasource.cpp create mode 100644 plugins/input/python/python_datasource.hpp create mode 100644 plugins/input/python/python_featureset.cpp create mode 100644 plugins/input/python/python_featureset.hpp create mode 100644 plugins/input/python/python_utils.hpp create mode 100644 tests/data/good_maps/python_circle_datasource.xml create mode 100644 tests/data/good_maps/python_point_datasource.xml create mode 100644 tests/python_tests/images/support/mapnik-python-circle-render1.png create mode 100644 tests/python_tests/images/support/mapnik-python-point-render1.png create mode 100644 tests/python_tests/python_plugin_test.py diff --git a/SConstruct b/SConstruct index 0a5053b5a..ec5f0cac9 100644 --- a/SConstruct +++ b/SConstruct @@ -106,6 +106,7 @@ PLUGINS = { # plugins with external dependencies 'raster': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, 'geojson': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, 'kismet': {'default':False,'path':None,'inc':None,'lib':None,'lang':'C++'}, + 'python': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, } diff --git a/bindings/python/mapnik/__init__.py b/bindings/python/mapnik/__init__.py index 78b618827..c55a95385 100644 --- a/bindings/python/mapnik/__init__.py +++ b/bindings/python/mapnik/__init__.py @@ -39,6 +39,7 @@ Several things happen when you do: """ +import itertools import os import sys import warnings @@ -594,6 +595,75 @@ def Geos(**keywords): keywords['type'] = 'geos' return CreateDatasource(keywords) +def Python(**keywords): + """Create a Python Datasource. + + >>> from mapnik import Python, PythonDatasource + >>> datasource = Python('PythonDataSource') + >>> lyr = Layer('Python datasource') + >>> lyr.datasource = datasource + """ + keywords['type'] = 'python' + return CreateDatasource(keywords) + +class PythonDatasource(object): + """A base class for a Python data source. + + Optional arguments: + envelope -- a mapnik.Box2d (minx, miny, maxx, maxy) envelope of the data source, default (-180,-90,180,90) + geometry_type -- one of the DataGeometryType enumeration values, default Point + data_type -- one of the DataType enumerations, default Vector + """ + def __init__(self, envelope=None, geometry_type=None, data_type=None): + self.envelope = envelope or Box2d(-180, -90, 180, 90) + self.geometry_type = geometry_type or DataGeometryType.Point + self.data_type = data_type or DataType.Vector + + def features(self, query): + """Return an iterable which yields instances of Feature for features within the passed query. + + Required arguments: + query -- a Query instance specifying the region for which features should be returned + """ + return None + + def features_at_point(self, point): + """Rarely uses. Return an iterable which yields instances of Feature for the specified point.""" + return None + + @classmethod + def wkb_features(cls, keys, features): + """A convenience function to wrap an iterator yielding pairs of WKB format geometry and dictionaries of + key-value pairs into mapnik features. Return this from PythonDatasource.features() passing it a sequence of keys + to appear in the output and an iterator yielding features. + + For example. One might have a features() method in a derived class like the following: + + def features(self, query): + # ... create WKB features feat1 and feat2 + + return mapnik.PythonDatasource.wkb_features( + keys = ( 'name', 'author' ), + features = [ + (feat1, { 'name': 'feat1', 'author': 'alice' }), + (feat2, { 'name': 'feat2', 'author': 'bob' }), + ] + ) + + """ + ctx = Context() + [ctx.push(x) for x in keys] + + def make_it(feat, idx): + f = Feature(ctx, idx) + geom, attrs = feat + f.add_geometries_from_wkb(geom) + for k, v in attrs.iteritems(): + f[k] = v + return f + + return itertools.imap(make_it, features, itertools.count(1)) + class _TextSymbolizer(TextSymbolizer,_injector): @property def text_size(self): diff --git a/plugins/input/python/Makefile b/plugins/input/python/Makefile new file mode 100644 index 000000000..4d4641eee --- /dev/null +++ b/plugins/input/python/Makefile @@ -0,0 +1,34 @@ +CXX = g++ + +CXXFLAGS = $(shell mapnik-config --cflags) -I/usr/include/python2.7 -fPIC + +LIBS = $(shell mapnik-config --libs --ldflags --dep-libs) -lboost_python + +SRC = $(wildcard *.cpp) + +OBJ = $(SRC:.cpp=.o) + +BIN = python.input + +all : $(SRC) $(BIN) + +$(BIN) : $(OBJ) + $(CXX) -shared $(OBJ) $(LIBS) -o $@ + +.cpp.o : + $(CXX) -c $(CXXFLAGS) $< -o $@ + +.PHONY : clean test + +clean: + rm -f $(OBJ) + rm -f $(BIN) + +deploy : all + cp python.input $(shell mapnik-config --input-plugins) + +install: clean all deploy + +test: deploy + python test.py + diff --git a/plugins/input/python/README.md b/plugins/input/python/README.md new file mode 100644 index 000000000..575e0d7c5 --- /dev/null +++ b/plugins/input/python/README.md @@ -0,0 +1,241 @@ +# Python plugin + +This plugin allows you to write data sources in the Python programming language. +This is useful if you want to rapidly prototype a plugin, perform some custom +manipulation on data or if you want to bind mapnik to a datasource which is most +conveniently accessed through Python. + +The plugin may be used from the existing mapnik Python bindings or it can embed +the Python interpreter directly allowing it to be used from C++, XML or even +JavaScript. + +## Rationale + +Mapnik already has excellent Python bindings but they only directly support +calling *into* mapnik *from* Python. This forces mapnik and its input plugins to +be the lowest layer of the stack. The role of this plugin is to allow mapnik to +call *into* Python itself. This allows mapnik to sit as rendering middleware +between a custom Python frontend and a custom Python datasource. This increases +the utility of mapnik as a component in a larger system. + +There already exists MemoryDatasource which can be used to dynamically create +geometry in Python. It suffers from the problem that it does not allow +generating only the geometry which is seen by a particular query. Similarly the +entire geometry must exist in memory before rendering can progress. By using a +custom iterator object or by using generator expressions this plugin allows +geometry to be created on demand and to be destroyed after use. This can have a +great impact on memory efficiency. Since geometry is generated on-demand as +rendering progresses there can be arbitrarily complex 'cleverness' optimising +the geometry generated for a particular query. Obvious examples of this would +be generating only geometry within the query bounding box and generating +geometry with an appropriate level of detail for the output resolution. + +## Initialization + +Only the `factory` parameter is required. This is of the form +`[module:]callable`. If `module` is present then `module` will be imported and +its attribute named `callable` will be used as a factory callable. If `module` +is omitted, then `__main__` is used. Any other parameter aside from `factory` or +`type` will be passed directly to the callable as keyword arguments. Note that +these will always be passed as strings even if the parameter can be parsed as an +integer of floating point value. + +The callable should return an object with the following required attributes: + +* `envelope` - a 4-tuple giving the (minx, miny, maxx, maxy) extent of the + datasource; + +* `data_type` - a `mapnik.DataType` instance giving the type of data stored in + this datasource. This will usually be one of `mapnik.DataType.Vector` or + `mapnik.DataType.Raster`. + +The following attributes are optional: + +* `geometry_type` - if the dataset is a vector dataset, this is an instance of + `mapnik.DataGeometryType` giving the type of geometry returned by the + datasource. + +The following methods must be present: + +* `features(query)` - takes a single argument which is an instance of + `mapnik.Query` and returns an iterable of `mapnik.Feature` instances for that + query. + +* `features_at_point(point)` - almost never used. Takes a single argument which + is an instance of `mapnik.Point` (I think) and returns an iterable of + features associated with that point. + +## Convenience classes + +The standard `mapnik` module provides a convenience class called +`mapnik.PythonDatasource` which has default implementations for the required +methods and accepts the geometry type, data type and envelope as constructor +arguments. It also provides some convenience class methods which take care of +constructing features for you: + +* `mapnik.PythonDatasource.wkb_features` - constructs features from + well-known-binary (WKB) format geometry. Takes two keyword arguments: `keys` + which is a sequence of keys associated with each feature and `features` which + is a sequence of pairs. The first element in each pair is the WKB + representation of the feature and the second element is a dictionary mapping + keys to values. + +# Caveats + +* If used directly from C++, `Py_Initialize()` must have been called before the + plugin is loaded to initialise the interpreter correctly. + +* When inside the interpreter the global interpreter lock is held each time a + feature is fetched and so multi-threaded rendering performance may suffer. You + can mitigate this by making sure that the feature iterator yields its value as + quickly as possible, potentially from an in-memory buffer filled fom another + process over IPC. + +# Examples + +In XML: + +```xml + + + + + style + + python + test:TestDatasource + + + +``` + +In Python using the shapely geometry library: + +```python +import mapnik +from shapely.geometry import * + +class TestDatasource(mapnik.PythonDatasource): + def __init__(self): + super(TestDatasource, self).__init__() + + def features(self, query): + return mapnik.PythonDatasource.wkb_features( + keys = ('label',), + features = ( + ( Point(5,6).wkb, { 'label': 'foo-bar'} ), + ( Point(100,60).wkb, { 'label': 'buzz-quux'} ), + ) + ) + +if __name__ == '__main__': + m = mapnik.Map(1280,1024) + m.background = mapnik.Color('white') + s = mapnik.Style() + r = mapnik.Rule() + r.symbols.append(mapnik.PointSymbolizer()) + t = mapnik.TextSymbolizer(mapnik.Expression("[label]"),"DejaVu Sans Book",10,mapnik.Color('black')) + t.displacement = (5,5) + r.symbols.append(t) + s.rules.append(r) + m.append_style('point_style',s) + ds = mapnik.Python(factory='TestDatasource') + layer = mapnik.Layer('python') + layer.datasource = ds + layer.styles.append('point_style') + m.layers.append(layer) + m.zoom_all() + mapnik.render_to_file(m,'map.png', 'png') +``` + +A more complex Python example which makes use of iterators to generate geometry +dynamically: + +```python +"""A more complex example which renders an infinite series of concentric +circles centred on a point. + +The circles are represented by a Python iterator which will yield only the +circles which intersect the query's bounding box. The advantage of this +approach over a MemoryDatasource is that a) only those circles which intersect +the viewport are actually generated and b) only the memory for the largest +circle need be available since each circle is created on demand and destroyed +when finished with. +""" +import math +import mapnik +from shapely.geometry import * + +def box2d_to_shapely(box): + import shapely.geometry + return shapely.geometry.box(box.minx, box.miny, box.maxx, box.maxy) + +class ConcentricCircles(object): + def __init__(self, centre, bounds, step=1): + self.centre = centre + self.bounds = bounds + self.step = step + + class Iterator(object): + def __init__(self, container): + self.container = container + + centre = self.container.centre + bounds = self.container.bounds + step = self.container.step + + if centre.within(bounds): + self.radius = 0 + else: + self.radius = math.ceil(centre.distance(bounds) / float(step)) * step + + def next(self): + circle = self.container.centre.buffer(self.radius) + self.radius += self.container.step + + # has the circle grown so large that the boundary is entirely within it? + if circle.contains(self.container.bounds): + raise StopIteration() + + return ( circle.wkb, { } ) + + def __iter__(self): + return ConcentricCircles.Iterator(self) + +class TestDatasource(mapnik.PythonDatasource): + def __init__(self): + super(TestDatasource, self).__init__(geometry_type=mapnik.DataGeometryType.Polygon) + + def features(self, query): + # Get the query bounding-box as a shapely bounding box + bounding_box = box2d_to_shapely(query.bbox) + centre = Point(-20, 0) + + return mapnik.PythonDatasource.wkb_features( + keys = (), + features = ConcentricCircles(centre, bounding_box, 0.5) + ) + +if __name__ == '__main__': + m = mapnik.Map(640, 320) + + m.background = mapnik.Color('white') + s = mapnik.Style() + r = mapnik.Rule() + r.symbols.append(mapnik.LineSymbolizer()) + s.rules.append(r) + m.append_style('point_style',s) + ds = mapnik.Python(factory='TestDatasource') + layer = mapnik.Layer('python') + layer.datasource = ds + layer.styles.append('point_style') + m.layers.append(layer) + box = mapnik.Box2d(-60, -60, 0, -30) + m.zoom_to_box(box) + mapnik.render_to_file(m,'map.png', 'png') +``` diff --git a/plugins/input/python/build.py b/plugins/input/python/build.py new file mode 100644 index 000000000..4a8481eb3 --- /dev/null +++ b/plugins/input/python/build.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python + +# Mapnik uses the build tool SCons. + +# This python file is run to compile a plugin +# It must be called from the main 'SConstruct' file like: + +# SConscript('path/to/this/file.py') + +# see docs at: http://www.scons.org/wiki/SConscript() + +import os + +# Give this plugin a name +# here this happens to be the same as the directory +PLUGIN_NAME = 'python' + +# Here we pull from the SCons environment exported from the main instance +Import ('plugin_base') +Import ('env') + +# the below install details are also pulled from the +# main SConstruct file where configuration happens + +# plugins can go anywhere, and be registered in custom locations by Mapnik +# but the standard location is '/usr/local/lib/mapnik/input' +install_dest = env['MAPNIK_INPUT_PLUGINS_DEST'] + +# clone the environment here +# so that if we modify the env it in this file +# those changes to not pollute other builds later on... +plugin_env = plugin_base.Clone() + +# Add the cpp files that need to be compiled +plugin_sources = Split( + """ + %(PLUGIN_NAME)s_datasource.cpp + %(PLUGIN_NAME)s_featureset.cpp + """ % locals() + ) + +# Add any external libraries this plugin should +# directly link to +libraries = [ '' ] # eg 'libfoo' + +libraries.append('mapnik') +libraries.append('boost_system%s' % env['BOOST_APPEND']) +# link libicuuc, but ICU_LIB_NAME is used custom builds of icu can +# have different library names like osx which offers /usr/lib/libicucore.dylib +libraries.append(env['ICU_LIB_NAME']) + +libraries.append(env['BOOST_PYTHON_LIB']) + +# TODO - do solaris/fedora need direct linking too? +if env['PLATFORM'] == 'Darwin': + if not env['PYTHON_DYNAMIC_LOOKUP']: + libraries.append('png') + if env['JPEG']: + libraries.append('jpeg') + libraries.append(env['ICU_LIB_NAME']) + libraries.append('boost_regex%s' % env['BOOST_APPEND']) + if env['THREADING'] == 'multi': + libraries.append('boost_thread%s' % env['BOOST_APPEND']) + + ##### Python linking on OS X is tricky ### + # Confounding problems are: + # 1) likelyhood of multiple python installs of the same major.minor version + # because apple supplies python built-in and many users may have installed + # further versions using macports + # 2) boost python directly links to a python version + # 3) the below will directly link _mapnik.so to a python version + # 4) _mapnik.so must link to the same python lib as boost_python.dylib otherwise + # python will Abort with a Version Mismatch error. + # See http://trac.mapnik.org/ticket/453 for the seeds of a better approach + # for now we offer control over method of direct linking... + # The default below is to link against the python dylib in the form of + #/path/to/Python.framework/Python instead of -lpython + + # http://developer.apple.com/mac/library/DOCUMENTATION/Darwin/Reference/ManPages/man1/ld.1.html + + if env['PYTHON_DYNAMIC_LOOKUP']: + python_link_flag = '-undefined dynamic_lookup' + elif env['FRAMEWORK_PYTHON']: + if env['FRAMEWORK_SEARCH_PATH']: + # if the user has supplied a custom root path to search for + # a given Python framework, then use that to direct the linker + python_link_flag = '-F%s -framework Python -Z' % env['FRAMEWORK_SEARCH_PATH'] + else: + # otherwise be as explicit as possible for linking to the same Framework + # as the executable we are building with (or is pointed to by the PYTHON variable) + # otherwise we may accidentally link against either: + # /System/Library/Frameworks/Python.framework/Python/Versions/ + # or + # /Library/Frameworks/Python.framework/Python/Versions/ + # See: http://trac.mapnik.org/ticket/380 + link_prefix = env['PYTHON_SYS_PREFIX'] + if '.framework' in link_prefix: + python_link_flag = '-F%s -framework Python -Z' % os.path.dirname(link_prefix.split('.')[0]) + elif '/System' in link_prefix: + python_link_flag = '-F/System/Library/Frameworks/ -framework Python -Z' + else: + # should we fall back to -lpython here? + python_link_flag = '-F/ -framework Python' + + # if we are not linking to a framework then use the *nix standard approach + else: + # TODO - do we need to pass -L/? + python_link_flag = '-lpython%s' % env['PYTHON_VERSION'] + +elif env['PLATFORM'] == 'SunOS': + # make sure to explicitly link mapnik.so against + # libmapnik in its installed location + python_link_flag = '-R%s' % env['MAPNIK_LIB_BASE'] +else: + # all other platforms we don't directly link python + python_link_flag = '' + +if env['CUSTOM_LDFLAGS']: + linkflags = '%s %s' % (env['CUSTOM_LDFLAGS'], python_link_flag) +else: + linkflags = python_link_flag + +plugin_env.Append(CPPPATH = env['PYTHON_INCLUDES']) + +TARGET = plugin_env.SharedLibrary( + # the name of the target to build, eg 'sqlite.input' + '../%s' % PLUGIN_NAME, + # prefix - normally none used + SHLIBPREFIX='', + # extension, mapnik expects '.input' + SHLIBSUFFIX='.input', + # list of source files to compile + source=plugin_sources, + # libraries to link to + LIBS=libraries, + # any custom linkflags, eg. LDFLAGS + # in this case CUSTOM_LDFLAGS comes + # from Mapnik's main SConstruct file + # and can be removed here if you do + # not need it + LINKFLAGS=env.get('CUSTOM_LDFLAGS') + ) + +# if 'uninstall' is not passed on the command line +# then we actually create the install targets that +# scons will install if 'install' is passed as an arg +if 'uninstall' not in COMMAND_LINE_TARGETS: + env.Install(install_dest, TARGET) + env.Alias('install', install_dest) diff --git a/plugins/input/python/examples/concentric_circles.py b/plugins/input/python/examples/concentric_circles.py new file mode 100644 index 000000000..b80531251 --- /dev/null +++ b/plugins/input/python/examples/concentric_circles.py @@ -0,0 +1,83 @@ +"""A more complex example which renders an infinite series of concentric +circles centred on a point. + +The circles are represented by a Python iterator which will yield only the +circles which intersect the query's bounding box. The advantage of this +approach over a MemoryDatasource is that a) only those circles which intersect +the viewport are actually generated and b) only the memory for the largest +circle need be available since each circle is created on demand and destroyed +when finished with. +""" +import math +import mapnik +from shapely.geometry import * + +def box2d_to_shapely(box): + import shapely.geometry + return shapely.geometry.box(box.minx, box.miny, box.maxx, box.maxy) + +class ConcentricCircles(object): + def __init__(self, centre, bounds, step=1): + self.centre = centre + self.bounds = bounds + self.step = step + + class Iterator(object): + def __init__(self, container): + self.container = container + + centre = self.container.centre + bounds = self.container.bounds + step = self.container.step + + if centre.within(bounds): + self.radius = 0 + else: + self.radius = math.ceil(centre.distance(bounds) / float(step)) * step + + def next(self): + circle = self.container.centre.buffer(self.radius) + self.radius += self.container.step + + # has the circle grown so large that the boundary is entirely within it? + if circle.contains(self.container.bounds): + raise StopIteration() + + return ( circle.wkb, { } ) + + def __iter__(self): + return ConcentricCircles.Iterator(self) + +class TestDatasource(mapnik.PythonDatasource): + def __init__(self): + super(TestDatasource, self).__init__( + geometry_type=mapnik.DataGeometryType.Polygon + ) + + def features(self, query): + # Get the query bounding-box as a shapely bounding box + bounding_box = box2d_to_shapely(query.bbox) + centre = Point(-20, 0) + + return mapnik.PythonDatasource.wkb_features( + keys = (), + features = ConcentricCircles(centre, bounding_box, 0.5) + ) + +if __name__ == '__main__': + m = mapnik.Map(640, 320) + + m.background = mapnik.Color('white') + s = mapnik.Style() + r = mapnik.Rule() + r.symbols.append(mapnik.LineSymbolizer()) + s.rules.append(r) + m.append_style('point_style',s) + ds = mapnik.Python(factory='TestDatasource') + layer = mapnik.Layer('python') + layer.datasource = ds + layer.styles.append('point_style') + m.layers.append(layer) + box = mapnik.Box2d(-60, -60, 0, -30) + m.zoom_to_box(box) + mapnik.render_to_file(m,'map.png', 'png') diff --git a/plugins/input/python/examples/simple_points.py b/plugins/input/python/examples/simple_points.py new file mode 100644 index 000000000..1a51fc3cd --- /dev/null +++ b/plugins/input/python/examples/simple_points.py @@ -0,0 +1,34 @@ +import mapnik +from shapely.geometry import * + +class TestDatasource(mapnik.PythonDatasource): + def __init__(self): + super(TestDatasource, self).__init__() + + def features(self, query): + return mapnik.PythonDatasource.wkb_features( + keys = ('label',), + features = ( + ( Point(5,6).wkb, { 'label': 'foo-bar'} ), + ( Point(100,60).wkb, { 'label': 'buzz-quux'} ), + ) + ) + +if __name__ == '__main__': + m = mapnik.Map(1280,1024) + m.background = mapnik.Color('white') + s = mapnik.Style() + r = mapnik.Rule() + r.symbols.append(mapnik.PointSymbolizer()) + t = mapnik.TextSymbolizer(mapnik.Expression("[label]"),"DejaVu Sans Book",10,mapnik.Color('black')) + t.displacement = (5,5) + r.symbols.append(t) + s.rules.append(r) + m.append_style('point_style',s) + ds = mapnik.Python(factory='TestDatasource') + layer = mapnik.Layer('python') + layer.datasource = ds + layer.styles.append('point_style') + m.layers.append(layer) + m.zoom_all() + mapnik.render_to_file(m,'map.png', 'png') diff --git a/plugins/input/python/examples/simple_xml.py b/plugins/input/python/examples/simple_xml.py new file mode 100644 index 000000000..8dbe3261b --- /dev/null +++ b/plugins/input/python/examples/simple_xml.py @@ -0,0 +1,8 @@ +import mapnik +stylesheet = 'simple_xml.xml' +image = 'simple_xml.png' +m = mapnik.Map(600, 300) +mapnik.load_map(m, stylesheet) +m.zoom_all() +mapnik.render_to_file(m, image) +print "rendered image to '%s'" % image diff --git a/plugins/input/python/examples/simple_xml.xml b/plugins/input/python/examples/simple_xml.xml new file mode 100644 index 000000000..d7e3c3b8e --- /dev/null +++ b/plugins/input/python/examples/simple_xml.xml @@ -0,0 +1,16 @@ + + + + + style + + python + test:TestDatasource + + + diff --git a/plugins/input/python/python_datasource.cpp b/plugins/input/python/python_datasource.cpp new file mode 100644 index 000000000..8f5c48ec7 --- /dev/null +++ b/plugins/input/python/python_datasource.cpp @@ -0,0 +1,208 @@ +// file plugin +#include "python_datasource.hpp" +#include "python_featureset.hpp" + +// stl +#include +#include + +// boost +#include +#include +#include +#include +#include + +#include "python_utils.hpp" + +using mapnik::datasource; +using mapnik::parameters; + +DATASOURCE_PLUGIN(python_datasource) + +python_datasource::python_datasource(parameters const& params, bool bind) + : datasource(params), + desc_(*params_.get("type"), *params_.get("encoding","utf-8")), + factory_(*params_.get("factory", "")) +{ + // extract any remaining parameters as keyword args for the factory + BOOST_FOREACH(const mapnik::parameters::value_type& kv, params_) + { + if((kv.first != "type") && (kv.first != "factory")) + { + kwargs_.insert(std::make_pair(kv.first, *params_.get(kv.first))); + } + } + + if (bind) + { + this->bind(); + } +} + +python_datasource::~python_datasource() { } + +// This name must match the plugin filename, eg 'python.input' +const char* python_datasource::name_="python"; + +const char* python_datasource::name() +{ + return name_; +} + +mapnik::layer_descriptor python_datasource::get_descriptor() const +{ + if (!is_bound_) bind(); + + return desc_; +} + +// The following methods call into the Python interpreter and hence require, unfortunately, that the GIL be held. + +void python_datasource::bind() const +{ + using namespace boost; + using namespace boost::python; + + if (is_bound_) return; + + // if no factory callable is defined, bind is a nop + if (factory_.empty()) return; + + // split factory at ':' to parse out module and callable + std::vector factory_split; + split(factory_split, factory_, is_any_of(":")); + if ((factory_split.size() < 1) || (factory_split.size() > 2)) + { + // FIMXE: is this appropriate error reporting? + std::cerr << "python: factory string must be of the form '[module:]callable' when parsing \"" + << factory_ << '"' << std::endl; + return; + } + + // extract the module and the callable + str module_name("__main__"), callable_name; + if (factory_split.size() == 1) + { + callable_name = str(factory_split[0]); + } + else + { + module_name = str(factory_split[0]); + callable_name = str(factory_split[1]); + } + + { + ensure_gil lock; + + // import the main module from Python (in case we're embedding the + // interpreter directly) and also import the callable. + object main_module = import("__main__"); + object callable_module = import(module_name); + object callable = callable_module.attr(callable_name); + + // prepare the arguments + dict kwargs; + typedef std::map::value_type kv_type; + BOOST_FOREACH(const kv_type& kv, kwargs_) + { + kwargs[str(kv.first)] = str(kv.second); + } + + // get our wrapped data source + datasource_ = callable(*boost::python::make_tuple(), **kwargs); + } + + is_bound_ = true; +} + +mapnik::datasource::datasource_t python_datasource::type() const +{ + using namespace boost::python; + + typedef boost::optional return_type; + + if (!is_bound_) bind(); + + ensure_gil lock; + + object data_type = datasource_.attr("data_type"); + long data_type_integer = extract(data_type); + return mapnik::datasource::datasource_t(data_type_integer); +} + +mapnik::box2d python_datasource::envelope() const +{ + using namespace boost::python; + + if (!is_bound_) bind(); + + ensure_gil lock; + return extract >(datasource_.attr("envelope")); +} + +boost::optional python_datasource::get_geometry_type() const +{ + using namespace boost::python; + + typedef boost::optional return_type; + + if (!is_bound_) bind(); + + ensure_gil lock; + + // if the datasource object has no geometry_type attribute, return a 'none' value + if (!PyObject_HasAttrString(datasource_.ptr(), "geometry_type")) + return return_type(); + + object py_geometry_type = datasource_.attr("geometry_type"); + + // if the attribute value is 'None', return a 'none' value + if (py_geometry_type.ptr() == object().ptr()) + return return_type(); + + long geom_type_integer = extract(py_geometry_type); + return mapnik::datasource::geometry_t(geom_type_integer); +} + +mapnik::featureset_ptr python_datasource::features(mapnik::query const& q) const +{ + using namespace boost::python; + + if (!is_bound_) bind(); + + // if the query box intersects our world extent then query for features + if (envelope().intersects(q.get_bbox())) + { + ensure_gil lock; + + object features(datasource_.attr("features")(q)); + + // if 'None' was returned, return an empty feature set + if(features.ptr() == object().ptr()) + return mapnik::featureset_ptr(); + + return boost::make_shared(features); + } + + // otherwise return an empty featureset pointer + return mapnik::featureset_ptr(); +} + +mapnik::featureset_ptr python_datasource::features_at_point(mapnik::coord2d const& pt) const +{ + using namespace boost::python; + + if (!is_bound_) bind(); + + ensure_gil lock; + + object features(datasource_.attr("features_at_point")(pt)); + + // if we returned none, return an empty set + if(features.ptr() == object().ptr()) + return mapnik::featureset_ptr(); + + // otherwise, return a feature set which can iterate over the iterator + return boost::make_shared(features); +} diff --git a/plugins/input/python/python_datasource.hpp b/plugins/input/python/python_datasource.hpp new file mode 100644 index 000000000..6f23fcfc8 --- /dev/null +++ b/plugins/input/python/python_datasource.hpp @@ -0,0 +1,56 @@ +#ifndef PYTHON_DATASOURCE_HPP +#define PYTHON_DATASOURCE_HPP + +// mapnik +#include + +// boost +#include + +class python_datasource : public mapnik::datasource +{ +public: + // constructor + // arguments must not change + python_datasource(mapnik::parameters const& params, bool bind=true); + + // destructor + virtual ~python_datasource (); + + // mandatory: type of the plugin, used to match at runtime + mapnik::datasource::datasource_t type() const; + + // mandatory: name of the plugin + static const char* name(); + + // mandatory: function to query features by box2d + // this is called when rendering, specifically in feature_style_processor.hpp + mapnik::featureset_ptr features(mapnik::query const& q) const; + + // mandatory: function to query features by point (coord2d) + // not used by rendering, but available to calling applications + mapnik::featureset_ptr features_at_point(mapnik::coord2d const& pt) const; + + // mandatory: return the box2d of the datasource + // called during rendering to determine if the layer should be processed + mapnik::box2d envelope() const; + + // mandatory: optionally return the overal geometry type of the datasource + boost::optional get_geometry_type() const; + + // mandatory: return the layer descriptor + mapnik::layer_descriptor get_descriptor() const; + + // mandatory: will bind the datasource given params + void bind() const; + +private: + static const char* name_; + mutable mapnik::layer_descriptor desc_; + const std::string factory_; + std::map kwargs_; + mutable boost::python::object datasource_; +}; + + +#endif // PYTHON_DATASOURCE_HPP diff --git a/plugins/input/python/python_featureset.cpp b/plugins/input/python/python_featureset.cpp new file mode 100644 index 000000000..f8a3edb8f --- /dev/null +++ b/plugins/input/python/python_featureset.cpp @@ -0,0 +1,30 @@ +// boost +#include + +#include "python_featureset.hpp" +#include "python_utils.hpp" + +python_featureset::python_featureset(boost::python::object iterator) +{ + ensure_gil lock; + begin_ = boost::python::stl_input_iterator(iterator); +} + +python_featureset::~python_featureset() +{ + ensure_gil lock; + begin_ = end_; +} + +mapnik::feature_ptr python_featureset::next() +{ + // checking to see if we've reached the end does not require the GIL. + if(begin_ == end_) + return mapnik::feature_ptr(); + + // getting the next feature might call into the interpreter and so the GIL must be held. + ensure_gil lock; + + return *(begin_++); +} + diff --git a/plugins/input/python/python_featureset.hpp b/plugins/input/python/python_featureset.hpp new file mode 100644 index 000000000..ae7525af3 --- /dev/null +++ b/plugins/input/python/python_featureset.hpp @@ -0,0 +1,30 @@ +#ifndef PYTHON_FEATURESET_HPP +#define PYTHON_FEATURESET_HPP + +// boost +#include +#include + +// mapnik +#include + +// extend the mapnik::Featureset defined in include/mapnik/datasource.hpp +class python_featureset : public mapnik::Featureset +{ +public: + // this constructor can have any arguments you need + python_featureset(boost::python::object iterator); + + // desctructor + virtual ~python_featureset(); + + // mandatory: you must expose a next() method, called when rendering + mapnik::feature_ptr next(); + +private: + typedef boost::python::stl_input_iterator feature_iter; + + feature_iter begin_, end_; +}; + +#endif // PYTHON_FEATURESET_HPP diff --git a/plugins/input/python/python_utils.hpp b/plugins/input/python/python_utils.hpp new file mode 100644 index 000000000..2fbed1201 --- /dev/null +++ b/plugins/input/python/python_utils.hpp @@ -0,0 +1,16 @@ +#ifndef PYTHON_UTILS_HPP +#define PYTHON_UTILS_HPP + +#include + +// Use RAII to acquire and release the GIL as needed. +class ensure_gil +{ + public: + ensure_gil() : gil_state_(PyGILState_Ensure()) {} + ~ensure_gil() { PyGILState_Release( gil_state_ ); } + protected: + PyGILState_STATE gil_state_; +}; + +#endif // PYTHON_UTILS_HPP diff --git a/tests/data/good_maps/python_circle_datasource.xml b/tests/data/good_maps/python_circle_datasource.xml new file mode 100644 index 000000000..0d19d45c2 --- /dev/null +++ b/tests/data/good_maps/python_circle_datasource.xml @@ -0,0 +1,50 @@ + + + + + + + + + + 1 + + python + python_plugin_test:CirclesDatasource + + + + + 2 + + python + python_plugin_test:CirclesDatasource + -20 + 50 + + + + + 3 + + python + python_plugin_test:CirclesDatasource + 60 + 140 + 20 + + + + diff --git a/tests/data/good_maps/python_point_datasource.xml b/tests/data/good_maps/python_point_datasource.xml new file mode 100644 index 000000000..3f311d746 --- /dev/null +++ b/tests/data/good_maps/python_point_datasource.xml @@ -0,0 +1,18 @@ + + + + + + 1 + + python + python_plugin_test:PointDatasource + + + + diff --git a/tests/python_tests/images/support/mapnik-python-circle-render1.png b/tests/python_tests/images/support/mapnik-python-circle-render1.png new file mode 100644 index 0000000000000000000000000000000000000000..d4c7b946b51e687fa74e16dbb692be9566482caf GIT binary patch literal 138036 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 Qe-D83&ObTT{uq4wFQ3;cZU6uP literal 0 HcmV?d00001 diff --git a/tests/python_tests/python_plugin_test.py b/tests/python_tests/python_plugin_test.py new file mode 100644 index 000000000..6b180e2fc --- /dev/null +++ b/tests/python_tests/python_plugin_test.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import os +import math +import mapnik +import sys +from utilities import execution_path +from nose.tools import * + +try: + from shapely.geometry import Point + have_shapely = True +except ImportError: + print('Shapely is required for python data source test.') + have_shapely = False + +def setup(): + # All of the paths used are relative, if we run the tests + # from another directory we need to chdir() + os.chdir(execution_path('.')) + +class PointDatasource(mapnik.PythonDatasource): + def __init__(self): + super(PointDatasource, self).__init__( + envelope = mapnik.Box2d(0,-10,100,110) + ) + + def features(self, query): + return mapnik.PythonDatasource.wkb_features( + keys = ('label',), + features = ( + ( Point(5,6).wkb, { 'label': 'foo-bar'} ), + ( Point(60,50).wkb, { 'label': 'buzz-quux'} ), + ) + ) + +def box2d_to_shapely(box): + import shapely.geometry + return shapely.geometry.box(box.minx, box.miny, box.maxx, box.maxy) + +class ConcentricCircles(object): + def __init__(self, centre, bounds, step=1): + self.centre = centre + self.bounds = bounds + self.step = step + + class Iterator(object): + def __init__(self, container): + self.container = container + + centre = self.container.centre + bounds = self.container.bounds + step = self.container.step + + if centre.within(bounds): + self.radius = step + else: + self.radius = math.ceil(centre.distance(bounds) / float(step)) * step + + def next(self): + circle = self.container.centre.buffer(self.radius) + self.radius += self.container.step + + # has the circle grown so large that the boundary is entirely within it? + if circle.contains(self.container.bounds): + raise StopIteration() + + return ( circle.wkb, { } ) + + def __iter__(self): + return ConcentricCircles.Iterator(self) + +class CirclesDatasource(mapnik.PythonDatasource): + def __init__(self, centre_x=-20, centre_y=0, step=10): + super(CirclesDatasource, self).__init__( + geometry_type=mapnik.DataGeometryType.Polygon + ) + + # note that the plugin loader will set all arguments to strings and will not try to parse them + centre_x = int(centre_x) + centre_y = int(centre_y) + step = int(step) + + self.centre_x = centre_x + self.centre_y = centre_y + self.step = step + + def features(self, query): + # Get the query bounding-box as a shapely bounding box + bounding_box = box2d_to_shapely(query.bbox) + centre = Point(self.centre_x, self.centre_y) + + return mapnik.PythonDatasource.wkb_features( + keys = (), + features = ConcentricCircles(centre, bounding_box, self.step) + ) + +if 'python' in mapnik.DatasourceCache.instance().plugin_names() and have_shapely: + # make sure we can load from ourself as a module + sys.path.append(execution_path('.')) + + def test_python_point_init(): + ds = mapnik.Python(factory='python_plugin_test:PointDatasource') + e = ds.envelope() + + assert_almost_equal(e.minx, 0, places=7) + assert_almost_equal(e.miny, -10, places=7) + assert_almost_equal(e.maxx, 100, places=7) + assert_almost_equal(e.maxy, 110, places=7) + + def test_python_circle_init(): + ds = mapnik.Python(factory='python_plugin_test:CirclesDatasource') + e = ds.envelope() + + assert_almost_equal(e.minx, -180, places=7) + assert_almost_equal(e.miny, -90, places=7) + assert_almost_equal(e.maxx, 180, places=7) + assert_almost_equal(e.maxy, 90, places=7) + + def test_python_circle_init_with_args(): + ds = mapnik.Python(factory='python_plugin_test:CirclesDatasource', centre_x=40, centre_y=7) + e = ds.envelope() + + assert_almost_equal(e.minx, -180, places=7) + assert_almost_equal(e.miny, -90, places=7) + assert_almost_equal(e.maxx, 180, places=7) + assert_almost_equal(e.maxy, 90, places=7) + + def test_python_point_rendering(): + m = mapnik.Map(512,512) + mapnik.load_map(m,'../data/good_maps/python_point_datasource.xml') + m.zoom_all() + im = mapnik.Image(512,512) + mapnik.render(m,im) + actual = '/tmp/mapnik-python-point-render1.png' + expected = 'images/support/mapnik-python-point-render1.png' + im.save(actual) + expected_im = mapnik.Image.open(expected) + eq_(im.tostring(),expected_im.tostring(), + 'failed comparing actual (%s) and expected (%s)' % (actual,'tests/python_tests/'+ expected)) + + def test_python_circle_rendering(): + m = mapnik.Map(512,512) + mapnik.load_map(m,'../data/good_maps/python_circle_datasource.xml') + m.zoom_all() + im = mapnik.Image(512,512) + mapnik.render(m,im) + actual = '/tmp/mapnik-python-circle-render1.png' + expected = 'images/support/mapnik-python-circle-render1.png' + im.save(actual) + expected_im = mapnik.Image.open(expected) + eq_(im.tostring(),expected_im.tostring(), + 'failed comparing actual (%s) and expected (%s)' % (actual,'tests/python_tests/'+ expected)) + +if __name__ == "__main__": + setup() + [eval(run)() for run in dir() if 'test_' in run]