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

SConstruct

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

bindings/python/mapnik_svg.hpp

@@ -25,15 +25,8 @@
 // mapnik
 #include <mapnik/parse_transform.hpp>
 #include <mapnik/symbolizer.hpp>
-#include <mapnik/svg/svg_path_parser.hpp>
 #include <mapnik/value_error.hpp>
 
-// boost
-#include <boost/make_shared.hpp>
-
-// agg
-#include "agg_trans_affine.h"
-
 namespace mapnik {
 using namespace boost::python;
 
@@ -46,8 +39,8 @@ const std::string get_svg_transform(T& symbolizer)
 template <class T>
 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;
         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";
         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

include/mapnik/attribute_collector.hpp

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

include/mapnik/parse_transform.hpp

@@ -25,218 +25,23 @@
 
 // mapnik
 #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/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 {
 
-template <typename Container> struct expression_attributes;
 template <typename Iterator> struct transform_expression_grammar;
 
+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,
                                  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
 

include/mapnik/transform_processor.hpp

@@ -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

plugins/input/geojson/build.py

@@ -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'])

plugins/input/geojson/geojson_datasource.cpp

@@ -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();
+}

plugins/input/geojson/geojson_datasource.hpp

@@ -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

plugins/input/geojson/geojson_featureset.cpp

@@ -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();
+    }
+}

plugins/input/geojson/geojson_featureset.hpp

@@ -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

src/parse_transform.cpp

@@ -27,9 +27,28 @@
 
 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,
                      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 end = str.end();
@@ -43,4 +62,4 @@ bool parse_transform(transform_list& transform,
     return (r && itr==end);
 }
 
-}
+} // namespace mapnik

src/symbolizer.cpp

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

tests/python_tests/object_test.py

@@ -68,7 +68,8 @@ def test_shieldsymbolizer_init():
     # strings for PathExpressions... should we pass objects?
     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)
 
@@ -79,6 +80,13 @@ def test_shieldsymbolizer_init():
 #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'))
 
+# 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():
     p = mapnik.PolygonSymbolizer()