-
Notifications
You must be signed in to change notification settings - Fork 826
/
python_datasource.cpp
236 lines (211 loc) · 7.9 KB
/
python_datasource.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
// file plugin
#include "python_datasource.hpp"
#include "python_featureset.hpp"
// stl
#include <string>
#include <vector>
// boost
#include <boost/make_shared.hpp>
#include <boost/python.hpp>
#include <boost/python/stl_iterator.hpp>
#include <boost/algorithm/string.hpp>
#include "python_utils.hpp"
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(python_datasource)
python_datasource::python_datasource(parameters const& params)
: datasource(params),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8")),
factory_(*params.get<std::string>("factory", ""))
{
// extract any remaining parameters as keyword args for the factory
for (const mapnik::parameters::value_type& kv : params)
{
if((kv.first != "type") && (kv.first != "factory"))
{
kwargs_.insert(std::make_pair(kv.first, *params.get<std::string>(kv.first)));
}
}
// The following methods call into the Python interpreter and hence require, unfortunately, that the GIL be held.
using namespace boost;
if (factory_.empty())
{
throw mapnik::datasource_exception("Python: 'factory' option must be defined");
}
try
{
// split factory at ':' to parse out module and callable
std::vector<std::string> factory_split;
split(factory_split, factory_, is_any_of(":"));
if ((factory_split.size() < 1) || (factory_split.size() > 2))
{
throw mapnik::datasource_exception(
std::string("python: factory string must be of the form '[module:]callable' when parsing \"")
+ factory_ + '"');
}
// extract the module and the callable
boost::python::str module_name("__main__"), callable_name;
if (factory_split.size() == 1)
{
callable_name = boost::python::str(factory_split[0]);
}
else
{
module_name = boost::python::str(factory_split[0]);
callable_name = boost::python::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.
boost::python::object main_module = boost::python::import("__main__");
boost::python::object callable_module = boost::python::import(module_name);
boost::python::object callable = callable_module.attr(callable_name);
// prepare the arguments
boost::python::dict kwargs;
typedef std::map<std::string, std::string>::value_type kv_type;
for (kv_type const& kv : kwargs_)
{
kwargs[boost::python::str(kv.first)] = boost::python::str(kv.second);
}
// get our wrapped data source
datasource_ = callable(*boost::python::make_tuple(), **kwargs);
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
}
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
{
return desc_;
}
mapnik::datasource::datasource_t python_datasource::type() const
{
typedef boost::optional<mapnik::datasource::geometry_t> return_type;
try
{
ensure_gil lock;
boost::python::object data_type = datasource_.attr("data_type");
long data_type_integer = boost::python::extract<long>(data_type);
return mapnik::datasource::datasource_t(data_type_integer);
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
}
mapnik::box2d<double> python_datasource::envelope() const
{
mapnik::box2d<double> box;
try
{
ensure_gil lock;
if (!PyObject_HasAttrString(datasource_.ptr(), "envelope"))
{
throw mapnik::datasource_exception("Python: could not access envelope property");
}
else
{
boost::python::object py_envelope = datasource_.attr("envelope");
if (py_envelope.ptr() == boost::python::object().ptr())
{
throw mapnik::datasource_exception("Python: could not access envelope property");
}
else
{
boost::python::extract<double> ex(py_envelope.attr("minx"));
if (!ex.check()) throw mapnik::datasource_exception("Python: could not convert envelope.minx");
box.set_minx(ex());
boost::python::extract<double> ex1(py_envelope.attr("miny"));
if (!ex1.check()) throw mapnik::datasource_exception("Python: could not convert envelope.miny");
box.set_miny(ex1());
boost::python::extract<double> ex2(py_envelope.attr("maxx"));
if (!ex2.check()) throw mapnik::datasource_exception("Python: could not convert envelope.maxx");
box.set_maxx(ex2());
boost::python::extract<double> ex3(py_envelope.attr("maxy"));
if (!ex3.check()) throw mapnik::datasource_exception("Python: could not convert envelope.maxy");
box.set_maxy(ex3());
}
}
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
return box;
}
boost::optional<mapnik::datasource::geometry_t> python_datasource::get_geometry_type() const
{
typedef boost::optional<mapnik::datasource::geometry_t> return_type;
try
{
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();
}
boost::python::object py_geometry_type = datasource_.attr("geometry_type");
// if the attribute value is 'None', return a 'none' value
if (py_geometry_type.ptr() == boost::python::object().ptr())
{
return return_type();
}
long geom_type_integer = boost::python::extract<long>(py_geometry_type);
return mapnik::datasource::geometry_t(geom_type_integer);
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
}
mapnik::featureset_ptr python_datasource::features(mapnik::query const& q) const
{
try
{
// if the query box intersects our world extent then query for features
if (envelope().intersects(q.get_bbox()))
{
ensure_gil lock;
boost::python::object features(datasource_.attr("features")(q));
// if 'None' was returned, return an empty feature set
if(features.ptr() == boost::python::object().ptr())
{
return mapnik::featureset_ptr();
}
return std::make_shared<python_featureset>(features);
}
// otherwise return an empty featureset pointer
return mapnik::featureset_ptr();
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
}
mapnik::featureset_ptr python_datasource::features_at_point(mapnik::coord2d const& pt, double tol) const
{
try
{
ensure_gil lock;
boost::python::object features(datasource_.attr("features_at_point")(pt));
// if we returned none, return an empty set
if(features.ptr() == boost::python::object().ptr())
{
return mapnik::featureset_ptr();
}
// otherwise, return a feature set which can iterate over the iterator
return std::make_shared<python_featureset>(features);
}
catch ( boost::python::error_already_set )
{
throw mapnik::datasource_exception(extractException());
}
}