sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:mapnik/mapnik

Browse source
This commit is contained in:
Dane Springmeyer 2012-06-13 17:10:27 -04:00
commit fa46f97b73
13 changed files with 637 additions and 223 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
SConstruct
View file

@ -102,6 +102,7 @@ PLUGINS = { # plugins with external dependencies
'shape': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, 'shape': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'},
'csv': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, 'csv': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'},
'raster': {'default':True,'path':None,'inc':None,'lib':None,'lang':'C++'}, '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++'}, 'kismet': {'default':False,'path':None,'inc':None,'lib':None,'lang':'C++'},
} }

15
bindings/python/mapnik_svg.hpp
View file

@ -25,15 +25,8 @@
// mapnik // mapnik
#include <mapnik/parse_transform.hpp> #include <mapnik/parse_transform.hpp>
#include <mapnik/symbolizer.hpp> #include <mapnik/symbolizer.hpp>
#include <mapnik/svg/svg_path_parser.hpp>
#include <mapnik/value_error.hpp> #include <mapnik/value_error.hpp>
// boost
#include <boost/make_shared.hpp>
// agg
#include "agg_trans_affine.h"
namespace mapnik { namespace mapnik {
using namespace boost::python; using namespace boost::python;
@ -46,8 +39,8 @@ const std::string get_svg_transform(T& symbolizer)
template <class T> template <class T>
void set_svg_transform(T& symbolizer, std::string const& transform_wkt) void set_svg_transform(T& symbolizer, std::string const& transform_wkt)
{ {
agg::trans_affine tr; transform_list_ptr trans_expr = mapnik::parse_transform(transform_wkt);
if (!mapnik::svg::parse_transform(transform_wkt.c_str(), tr)) if (!trans_expr)
{ {
std::stringstream ss; std::stringstream ss;
ss << "Could not parse transform from '" ss << "Could not parse transform from '"
@ -55,9 +48,7 @@ void set_svg_transform(T& symbolizer, std::string const& transform_wkt)
<< "', expected SVG transform attribute"; << "', expected SVG transform attribute";
throw mapnik::value_error(ss.str()); throw mapnik::value_error(ss.str());
} }
transform_list_ptr trans = boost::make_shared<transform_list>(); symbolizer.set_image_transform(trans_expr);
trans->push_back(matrix_node(tr));
symbolizer.set_image_transform(trans);
} }
} // end of namespace mapnik } // end of namespace mapnik

2
include/mapnik/attribute_collector.hpp
View file

@ -25,7 +25,7 @@
// mapnik // mapnik
#include <mapnik/rule.hpp> #include <mapnik/rule.hpp>
#include <mapnik/parse_transform.hpp> #include <mapnik/transform_processor.hpp>
// boost // boost
#include <boost/utility.hpp> #include <boost/utility.hpp>
#include <boost/variant.hpp> #include <boost/variant.hpp>

215
include/mapnik/parse_transform.hpp
View file

@ -25,218 +25,23 @@
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/attribute.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/value.hpp>
#include <mapnik/transform_expression.hpp> #include <mapnik/transform_expression.hpp>
#include <mapnik/expression_evaluator.hpp>
// boost
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/foreach.hpp>
// agg
#include <agg_trans_affine.h>
namespace mapnik { namespace mapnik {
template <typename Container> struct expression_attributes;
template <typename Iterator> struct transform_expression_grammar; template <typename Iterator> struct transform_expression_grammar;
MAPNIK_DECL transform_list_ptr parse_transform(std::string const & str); typedef transform_expression_grammar<std::string::const_iterator>
transform_expression_grammar__string;
MAPNIK_DECL transform_list_ptr parse_transform(std::string const& str);
MAPNIK_DECL transform_list_ptr parse_transform(std::string const& str,
std::string const& encoding);
MAPNIK_DECL bool parse_transform(transform_list& list, MAPNIK_DECL bool parse_transform(transform_list& list,
std::string const & str, std::string const& str,
transform_expression_grammar<std::string::const_iterator> const& g); transform_expression_grammar__string const& g);
template <typename T>
struct transform_processor
{
typedef T feature_type;
typedef agg::trans_affine transform_type;
template <typename Container>
struct attribute_collector : boost::static_visitor<void>
{
expression_attributes<Container> collect_;
attribute_collector(Container& names)
: collect_(names) {}
void operator() (identity_node const& node) const
{
boost::ignore_unused_variable_warning(node);
}
void operator() (matrix_node const& node) const
{
boost::apply_visitor(collect_, node.a_);
boost::apply_visitor(collect_, node.b_);
boost::apply_visitor(collect_, node.c_);
boost::apply_visitor(collect_, node.d_);
boost::apply_visitor(collect_, node.e_);
boost::apply_visitor(collect_, node.f_);
}
void operator() (translate_node const& node) const
{
boost::apply_visitor(collect_, node.tx_);
boost::apply_visitor(collect_, node.ty_);
}
void operator() (scale_node const& node) const
{
boost::apply_visitor(collect_, node.sx_);
boost::apply_visitor(collect_, node.sy_);
}
void operator() (rotate_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
boost::apply_visitor(collect_, node.cx_);
boost::apply_visitor(collect_, node.cy_);
}
void operator() (skewX_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}
void operator() (skewY_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}
};
struct node_evaluator : boost::static_visitor<void>
{
node_evaluator(transform_type& tr, feature_type const& feat)
: transform_(tr), feature_(feat) {}
void operator() (identity_node const& node)
{
boost::ignore_unused_variable_warning(node);
}
void operator() (matrix_node const& node)
{
double a = eval(node.a_);
double b = eval(node.b_);
double c = eval(node.c_);
double d = eval(node.d_);
double e = eval(node.e_);
double f = eval(node.f_);
transform_.multiply(agg::trans_affine(a, b, c, d, e, f));
}
void operator() (translate_node const& node)
{
double tx = eval(node.tx_);
double ty = eval(node.ty_, 0.0);
transform_.translate(tx, ty);
}
void operator() (scale_node const& node)
{
double sx = eval(node.sx_);
double sy = eval(node.sy_, sx);
transform_.scale(sx, sy);
}
void operator() (rotate_node const& node)
{
double angle = deg2rad(eval(node.angle_));
double cx = eval(node.cx_, 0.0);
double cy = eval(node.cy_, 0.0);
transform_.translate(-cx, -cy);
transform_.rotate(angle);
transform_.translate(cx, cy);
}
void operator() (skewX_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(angle, 0.0));
}
void operator() (skewY_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(0.0, angle));
}
private:
static double deg2rad(double d)
{
return d * M_PI / 180.0;
}
double eval(expr_node const& x) const
{
mapnik::evaluate<feature_type, value_type> e(feature_);
return boost::apply_visitor(e, x).to_double();
}
double eval(expr_node const& x, double def) const
{
return is_null(x) ? def : eval(x);
}
transform_type& transform_;
feature_type const& feature_;
};
template <typename Container>
static void collect_attributes(Container& names,
transform_list const& list)
{
attribute_collector<Container> collect(names);
BOOST_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(collect, *node);
}
}
static void evaluate(transform_type& tr, feature_type const& feat,
transform_list const& list)
{
node_evaluator eval(tr, feat);
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: begin with " << to_string(matrix_node(tr));
#endif
BOOST_REVERSE_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(eval, *node);
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: apply " << to_string(*node);
MAPNIK_LOG_DEBUG(transform) << "transform: result " << to_string(matrix_node(tr));
#endif
}
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: end";
#endif
}
static std::string to_string(transform_node const& node)
{
return to_expression_string(node);
}
static std::string to_string(transform_list const& list)
{
return to_expression_string(list);
}
};
typedef mapnik::transform_processor<Feature> transform_processor_type;
} // namespace mapnik } // namespace mapnik

232
include/mapnik/transform_processor.hpp Normal file
View file

@ -0,0 +1,232 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 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_TRANSFORM_PROCESSOR_HPP
#define MAPNIK_TRANSFORM_PROCESSOR_HPP
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/value.hpp>
#include <mapnik/transform_expression.hpp>
#include <mapnik/expression_evaluator.hpp>
// boost
#include <boost/foreach.hpp>
// agg
#include <agg_trans_affine.h>
namespace mapnik {
template <typename Container> struct expression_attributes;
template <typename T>
struct transform_processor
{
typedef T feature_type;
typedef agg::trans_affine transform_type;
template <typename Container>
struct attribute_collector : boost::static_visitor<void>
{
expression_attributes<Container> collect_;
attribute_collector(Container& names)
: collect_(names) {}
void operator() (identity_node const& node) const
{
boost::ignore_unused_variable_warning(node);
}
void operator() (matrix_node const& node) const
{
boost::apply_visitor(collect_, node.a_);
boost::apply_visitor(collect_, node.b_);
boost::apply_visitor(collect_, node.c_);
boost::apply_visitor(collect_, node.d_);
boost::apply_visitor(collect_, node.e_);
boost::apply_visitor(collect_, node.f_);
}
void operator() (translate_node const& node) const
{
boost::apply_visitor(collect_, node.tx_);
boost::apply_visitor(collect_, node.ty_);
}
void operator() (scale_node const& node) const
{
boost::apply_visitor(collect_, node.sx_);
boost::apply_visitor(collect_, node.sy_);
}
void operator() (rotate_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
boost::apply_visitor(collect_, node.cx_);
boost::apply_visitor(collect_, node.cy_);
}
void operator() (skewX_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}
void operator() (skewY_node const& node) const
{
boost::apply_visitor(collect_, node.angle_);
}
};
struct node_evaluator : boost::static_visitor<void>
{
node_evaluator(transform_type& tr, feature_type const& feat)
: transform_(tr), feature_(feat) {}
void operator() (identity_node const& node)
{
boost::ignore_unused_variable_warning(node);
}
void operator() (matrix_node const& node)
{
double a = eval(node.a_);
double b = eval(node.b_);
double c = eval(node.c_);
double d = eval(node.d_);
double e = eval(node.e_);
double f = eval(node.f_);
transform_.multiply(agg::trans_affine(a, b, c, d, e, f));
}
void operator() (translate_node const& node)
{
double tx = eval(node.tx_);
double ty = eval(node.ty_, 0.0);
transform_.translate(tx, ty);
}
void operator() (scale_node const& node)
{
double sx = eval(node.sx_);
double sy = eval(node.sy_, sx);
transform_.scale(sx, sy);
}
void operator() (rotate_node const& node)
{
double angle = deg2rad(eval(node.angle_));
double cx = eval(node.cx_, 0.0);
double cy = eval(node.cy_, 0.0);
transform_.translate(-cx, -cy);
transform_.rotate(angle);
transform_.translate(cx, cy);
}
void operator() (skewX_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(angle, 0.0));
}
void operator() (skewY_node const& node)
{
double angle = deg2rad(eval(node.angle_));
transform_.multiply(agg::trans_affine_skewing(0.0, angle));
}
private:
static double deg2rad(double d)
{
return d * M_PI / 180.0;
}
double eval(expr_node const& x) const
{
mapnik::evaluate<feature_type, value_type> e(feature_);
return boost::apply_visitor(e, x).to_double();
}
double eval(expr_node const& x, double def) const
{
return is_null(x) ? def : eval(x);
}
transform_type& transform_;
feature_type const& feature_;
};
template <typename Container>
static void collect_attributes(Container& names,
transform_list const& list)
{
attribute_collector<Container> collect(names);
BOOST_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(collect, *node);
}
}
static void evaluate(transform_type& tr, feature_type const& feat,
transform_list const& list)
{
node_evaluator eval(tr, feat);
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: begin with " << to_string(matrix_node(tr));
#endif
BOOST_REVERSE_FOREACH (transform_node const& node, list)
{
boost::apply_visitor(eval, *node);
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: apply " << to_string(*node);
MAPNIK_LOG_DEBUG(transform) << "transform: result " << to_string(matrix_node(tr));
#endif
}
#ifdef MAPNIK_LOG
MAPNIK_LOG_DEBUG(transform) << "transform: end";
#endif
}
static std::string to_string(transform_node const& node)
{
return to_expression_string(node);
}
static std::string to_string(transform_list const& list)
{
return to_expression_string(list);
}
};
typedef mapnik::transform_processor<Feature> transform_processor_type;
} // namespace mapnik
#endif // MAPNIK_TRANSFORM_PROCESSOR_HPP

51
plugins/input/geojson/build.py Normal file
View file

@ -0,0 +1,51 @@
#
# This file is part of Mapnik (c++ mapping toolkit)
#
# Copyright (C) 2012 Artem Pavlenko
#
# Mapnik 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
#
Import ('plugin_base')
Import ('env')
prefix = env['PREFIX']
plugin_env = plugin_base.Clone()
geojson_src = Split(
"""
geojson_datasource.cpp
geojson_featureset.cpp
"""
)
libraries = []
# Link Library to Dependencies
libraries.append('mapnik')
libraries.append(env['ICU_LIB_NAME'])
libraries.append('boost_system%s' % env['BOOST_APPEND'])
if env['THREADING'] == 'multi':
libraries.append('boost_thread%s' % env['BOOST_APPEND'])
input_plugin = plugin_env.SharedLibrary('../geojson', source=geojson_src, SHLIBPREFIX='', SHLIBSUFFIX='.input', LIBS=libraries, LINKFLAGS=env['CUSTOM_LDFLAGS'])
# if the plugin links to libmapnik ensure it is built first
Depends(input_plugin, env.subst('../../../src/%s' % env['MAPNIK_LIB_NAME']))
if 'uninstall' not in COMMAND_LINE_TARGETS:
env.Install(env['MAPNIK_INPUT_PLUGINS_DEST'], input_plugin)
env.Alias('install', env['MAPNIK_INPUT_PLUGINS_DEST'])

165
plugins/input/geojson/geojson_datasource.cpp Normal file
View file

@ -0,0 +1,165 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
#include "geojson_datasource.hpp"
#include "geojson_featureset.hpp"
#include <fstream>
#include <iostream>
// boost
#include <boost/make_shared.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/spirit/include/support_multi_pass.hpp>
#include <boost/foreach.hpp>
#include <boost/geometry/geometries/box.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry.hpp>
#include <boost/geometry/extensions/index/rtree/rtree.hpp>
// mapnik
#include <mapnik/box2d.hpp>
#include <mapnik/proj_transform.hpp>
#include <mapnik/projection.hpp>
#include <mapnik/json/feature_collection_parser.hpp>
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(geojson_datasource)
geojson_datasource::geojson_datasource(parameters const& params, bool bind)
: datasource(params),
type_(datasource::Vector),
desc_(*params_.get<std::string>("type"),
*params_.get<std::string>("encoding","utf-8")),
file_(*params_.get<std::string>("file","")),
extent_(),
tr_(new mapnik::transcoder(*params_.get<std::string>("encoding","utf-8"))),
features_(),
tree_(16,1)
{
if (file_.empty()) throw mapnik::datasource_exception("GeoJSON Plugin: missing <file> parameter");
if (bind)
{
this->bind();
}
}
void geojson_datasource::bind() const
{
if (is_bound_) return;
typedef std::istreambuf_iterator<char> base_iterator_type;
std::ifstream is(file_.c_str());
boost::spirit::multi_pass<base_iterator_type> begin =
boost::spirit::make_default_multi_pass(base_iterator_type(is));
boost::spirit::multi_pass<base_iterator_type> end =
boost::spirit::make_default_multi_pass(base_iterator_type());
mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
mapnik::json::feature_collection_parser<boost::spirit::multi_pass<base_iterator_type> > p(ctx,*tr_);
bool result = p.parse(begin,end, features_);
if (!result)
{
MAPNIK_LOG_WARN(geojson) << "geojson_datasource: Failed parse GeoJSON file " << file_;
return;
}
bool first = true;
std::size_t count=0;
BOOST_FOREACH (mapnik::feature_ptr f, features_)
{
mapnik::box2d<double> const& box = f->envelope();
if (first)
{
extent_ = box;
first = false;
}
else
{
extent_.expand_to_include(box);
}
tree_.insert(box_type(point_type(box.minx(),box.miny()),point_type(box.maxx(),box.maxy())), count++);
}
is_bound_ = true;
}
geojson_datasource::~geojson_datasource() { }
std::string const geojson_datasource::name_="geojson";
std::string geojson_datasource::name()
{
return name_;
}
boost::optional<mapnik::datasource::geometry_t> geojson_datasource::get_geometry_type() const
{
return boost::optional<mapnik::datasource::geometry_t>();
}
mapnik::datasource::datasource_t geojson_datasource::type() const
{
return type_;
}
std::map<std::string, mapnik::parameters> geojson_datasource::get_statistics() const
{
return statistics_;
}
// FIXME: implement
mapnik::box2d<double> geojson_datasource::envelope() const
{
if (!is_bound_) bind();
return extent_;
}
mapnik::layer_descriptor geojson_datasource::get_descriptor() const
{
if (!is_bound_) bind();
return desc_;
}
mapnik::featureset_ptr geojson_datasource::features(mapnik::query const& q) const
{
if (!is_bound_) bind();
// if the query box intersects our world extent then query for features
if (extent_.intersects(q.get_bbox()))
{
return boost::make_shared<geojson_featureset>(features_,tree_);
}
// otherwise return an empty featureset pointer
return mapnik::featureset_ptr();
}
// FIXME
mapnik::featureset_ptr geojson_datasource::features_at_point(mapnik::coord2d const& pt) const
{
if (!is_bound_) bind();
return mapnik::featureset_ptr();
}

68
plugins/input/geojson/geojson_datasource.hpp Normal file
View file

@ -0,0 +1,68 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 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 GEOJSON_DATASOURCE_HPP
#define GEOJSON_DATASOURCE_HPP
// mapnik
#include <mapnik/datasource.hpp>
// boost
#include <boost/geometry/geometries/box.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/algorithms/area.hpp>
#include <boost/geometry/extensions/index/rtree/rtree.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/extensions/index/rtree/rtree.hpp>
class geojson_datasource : public mapnik::datasource
{
public:
typedef boost::geometry::model::d2::point_xy<double> point_type;
typedef boost::geometry::model::box<point_type> box_type;
typedef boost::geometry::index::rtree<box_type,std::size_t> spatial_index_type;
// constructor
geojson_datasource(mapnik::parameters const& params, bool bind=true);
virtual ~geojson_datasource ();
mapnik::datasource::datasource_t type() const;
static std::string name();
mapnik::featureset_ptr features(mapnik::query const& q) const;
mapnik::featureset_ptr features_at_point(mapnik::coord2d const& pt) const;
mapnik::box2d<double> envelope() const;
mapnik::layer_descriptor get_descriptor() const;
std::map<std::string, mapnik::parameters> get_statistics() const;
boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
void bind() const;
private:
static const std::string name_;
mapnik::datasource::datasource_t type_;
mutable std::map<std::string, mapnik::parameters> statistics_;
mutable mapnik::layer_descriptor desc_;
mutable std::string file_;
mutable mapnik::box2d<double> extent_;
boost::shared_ptr<mapnik::transcoder> tr_;
mutable std::vector<mapnik::feature_ptr> features_;
mutable spatial_index_type tree_;
};
#endif // FILE_DATASOURCE_HPP

51
plugins/input/geojson/geojson_featureset.cpp Normal file
View file

@ -0,0 +1,51 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 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
*
*****************************************************************************/
// mapnik
#include <mapnik/feature.hpp>
// stl
#include <string>
#include <vector>
#include <fstream>
#include "geojson_featureset.hpp"
geojson_featureset::geojson_featureset(std::vector<mapnik::feature_ptr> const& features,
geojson_datasource::spatial_index_type const& tree)
: feature_id_(1),
features_(features),
tree_(tree) {}
geojson_featureset::~geojson_featureset() {}
mapnik::feature_ptr geojson_featureset::next()
{
feature_id_++;
if (feature_id_ <= features_.size())
{
return features_.at(feature_id_ - 1);
}
else
{
return mapnik::feature_ptr();
}
}

23
plugins/input/geojson/geojson_featureset.hpp Normal file
View file

@ -0,0 +1,23 @@
#ifndef GEOJSON_FEATURESET_HPP
#define GEOJSON_FEATURESET_HPP
#include <mapnik/datasource.hpp>
#include <vector>
#include "geojson_datasource.hpp"
class geojson_featureset : public mapnik::Featureset
{
public:
geojson_featureset(std::vector<mapnik::feature_ptr> const& features,
geojson_datasource::spatial_index_type const& tree);
virtual ~geojson_featureset();
mapnik::feature_ptr next();
private:
mapnik::box2d<double> box_;
unsigned int feature_id_;
std::vector<mapnik::feature_ptr> const& features_;
geojson_datasource::spatial_index_type const& tree_;
};
#endif // GEOJSON_FEATURESET_HPP

25
src/parse_transform.cpp
View file

@ -27,9 +27,28 @@
namespace mapnik { namespace mapnik {
transform_list_ptr parse_transform(std::string const& str)
{
return parse_transform(str, "utf-8");
}
transform_list_ptr parse_transform(std::string const& str, std::string const& encoding)
{
transform_list_ptr tl = boost::make_shared<transform_list>();
transcoder tc(encoding);
expression_grammar<std::string::const_iterator> ge(tc);
transform_expression_grammar__string gte(ge);
if (!parse_transform(*tl, str, gte))
{
tl.reset();
}
return tl;
}
bool parse_transform(transform_list& transform, bool parse_transform(transform_list& transform,
std::string const & str, std::string const& str,
transform_expression_grammar<std::string::const_iterator> const& g) transform_expression_grammar__string const& g)
{ {
std::string::const_iterator itr = str.begin(); std::string::const_iterator itr = str.begin();
std::string::const_iterator end = str.end(); std::string::const_iterator end = str.end();
@ -43,4 +62,4 @@ bool parse_transform(transform_list& transform,
return (r && itr==end); return (r && itr==end);
} }
} } // namespace mapnik

2
src/symbolizer.cpp
View file

@ -23,7 +23,7 @@
//mapnik //mapnik
#include <mapnik/symbolizer.hpp> #include <mapnik/symbolizer.hpp>
#include <mapnik/map.hpp> #include <mapnik/map.hpp>
#include <mapnik/parse_transform.hpp> #include <mapnik/transform_processor.hpp>
namespace mapnik { namespace mapnik {

10
tests/python_tests/object_test.py
View file

@ -68,7 +68,8 @@ def test_shieldsymbolizer_init():
# strings for PathExpressions... should we pass objects? # strings for PathExpressions... should we pass objects?
eq_(s.filename, '../data/images/dummy.png') eq_(s.filename, '../data/images/dummy.png')
eq_(s.transform, 'matrix(1, 0, 0, 1, 0, 0)') # 11c34b1: default transform list is empty, not identity matrix
eq_(s.transform, '')
eq_(len(s.fontset.names), 0) eq_(len(s.fontset.names), 0)
@ -79,6 +80,13 @@ def test_shieldsymbolizer_init():
#def test_shieldsymbolizer_missing_image(): #def test_shieldsymbolizer_missing_image():
# s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../#data/images/broken.png')) # s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../#data/images/broken.png'))
# ShieldSymbolizer modification
def test_shieldsymbolizer_modify():
s = mapnik.ShieldSymbolizer(mapnik.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik.Color('#000000'), mapnik.PathExpression('../data/images/dummy.png'))
# transform expression
s.transform = "rotate(30+[a]) scale(2*[sx] [sy])"
eq_(s.transform, "rotate((30+[a])) scale(2*[sx], [sy])")
def test_polygonsymbolizer_init(): def test_polygonsymbolizer_init():
p = mapnik.PolygonSymbolizer() p = mapnik.PolygonSymbolizer()