235 lines
7.9 KiB
C++
235 lines
7.9 KiB
C++
// file plugin
|
|
#include "python_datasource.hpp"
|
|
#include "python_featureset.hpp"
|
|
|
|
// stl
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
// boost
|
|
|
|
#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_(python_datasource::name(), *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());
|
|
}
|
|
|
|
}
|