Merge commit '464a1f176b71214b0cb5b224eaf944b4cc3cd0f4' into hb-test2

include/mapnik/polygon_clipper.hpp

@@ -0,0 +1,238 @@
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2013 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_POLYGON_CLIPPER_HPP
+#define MAPNIK_POLYGON_CLIPPER_HPP
+
+// stl
+#include <iostream>
+#include <deque>
+
+// mapnik
+#include <mapnik/box2d.hpp>
+#include <mapnik/geometry.hpp>
+
+// boost
+#include <boost/foreach.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/geometries/box.hpp>
+#include <boost/geometry/geometries/polygon.hpp>
+#include <boost/geometry/geometries/register/point.hpp>
+
+BOOST_GEOMETRY_REGISTER_POINT_2D(mapnik::coord2d, double, cs::cartesian, x, y)
+
+// register mapnik::box2d<double>
+namespace boost { namespace geometry { namespace traits
+{
+
+template<> struct tag<mapnik::box2d<double> > { typedef box_tag type; };
+
+template<> struct point_type<mapnik::box2d<double> > { typedef mapnik::coord2d type; };
+
+template <>
+struct indexed_access<mapnik::box2d<double>, min_corner, 0>
+{
+    typedef coordinate_type<mapnik::coord2d>::type ct;
+    static inline ct get(mapnik::box2d<double> const& b) { return b.minx();}
+    static inline void set(mapnik::box2d<double> &b, ct const& value) { b.set_minx(value); }
+};
+
+template <>
+struct indexed_access<mapnik::box2d<double>, min_corner, 1>
+{
+    typedef coordinate_type<mapnik::coord2d>::type ct;
+    static inline ct get(mapnik::box2d<double> const& b) { return b.miny();}
+    static inline void set(mapnik::box2d<double> &b, ct const& value) { b.set_miny(value); }
+};
+
+template <>
+struct indexed_access<mapnik::box2d<double>, max_corner, 0>
+{
+    typedef coordinate_type<mapnik::coord2d>::type ct;
+    static inline ct get(mapnik::box2d<double> const& b) { return b.maxx();}
+    static inline void set(mapnik::box2d<double> &b, ct const& value) { b.set_maxx(value); }
+};
+
+template <>
+struct indexed_access<mapnik::box2d<double>, max_corner, 1>
+{
+    typedef coordinate_type<mapnik::coord2d>::type ct;
+    static inline ct get(mapnik::box2d<double> const& b) { return b.maxy();}
+    static inline void set(mapnik::box2d<double> &b , ct const& value) { b.set_maxy(value); }
+};
+
+}}}
+
+namespace mapnik {
+
+using namespace boost::geometry;
+
+template <typename Geometry>
+struct polygon_clipper
+{
+    typedef mapnik::coord2d point_2d;
+    typedef model::polygon<mapnik::coord2d> polygon_2d;
+    typedef std::deque<polygon_2d> polygon_list;
+
+    polygon_clipper(Geometry & geom)
+        : clip_box_(),
+          geom_(geom)
+    {
+
+    }
+
+    polygon_clipper( box2d<double> const& clip_box,Geometry & geom)
+        : clip_box_(clip_box),
+          geom_(geom)
+    {
+        init();
+    }
+
+    void set_clip_box(box2d<double> const& clip_box)
+    {
+        clip_box_ = clip_box;
+        init();
+    }
+
+    unsigned type() const
+    {
+        return geom_.type();
+    }
+
+    void rewind(unsigned path_id)
+    {
+        output_.rewind(path_id);
+    }
+
+    unsigned vertex (double * x, double * y)
+    {
+        return output_.vertex(x,y);
+    }
+
+private:
+
+    void init()
+    {
+        polygon_2d subject_poly;
+        double x,y;
+        double prev_x, prev_y;
+        geom_.rewind(0);
+        unsigned ring_count = 0;
+        while (true)
+        {
+            unsigned cmd = geom_.vertex(&x,&y);
+            if (cmd == SEG_END) break;
+            if (cmd == SEG_MOVETO)
+            {
+                prev_x = x;
+                prev_y = y;
+                if (ring_count == 0)
+                {
+                    append(subject_poly, make<point_2d>(x,y));
+                }
+                else
+                {
+                    subject_poly.inners().push_back(polygon_2d::inner_container_type::value_type());
+                    append(subject_poly.inners().back(),make<point_2d>(x,y));
+                }
+                ++ring_count;
+            }
+            else if (cmd == SEG_LINETO)
+            {
+                if (std::abs(x - prev_x) < 1e-12 && std::abs(y - prev_y) < 1e-12)
+                {
+                    std::cerr << std::setprecision(12) << "coincident vertices:(" << prev_x << ","
+                              <<  prev_y << ") , (" << x << "," << y <<  ")" << std::endl;
+                    continue;
+                }
+                prev_x = x;
+                prev_x = y;
+                if (ring_count == 1)
+                {
+                    append(subject_poly, make<point_2d>(x,y));
+                }
+                else
+                {
+                    append(subject_poly.inners().back(),make<point_2d>(x,y));
+                }
+            }
+        }
+
+        polygon_list clipped_polygons;
+        bool dissolved = false;
+        try
+        {
+            boost::geometry::intersection(clip_box_, subject_poly, clipped_polygons);
+        }
+        catch (boost::geometry::exception const& ex)
+        {
+            std::cerr << ex.what() << std::endl;
+        }
+
+        unsigned count=0;
+        BOOST_FOREACH(polygon_2d const& poly, clipped_polygons)
+        {
+            bool move_to = true;
+            BOOST_FOREACH(point_2d const& c, boost::geometry::exterior_ring(poly))
+            {
+                if (move_to)
+                {
+                    move_to = false;
+                    output_.move_to(c.x,c.y);
+                }
+                else
+                {
+                    output_.line_to(c.x,c.y);
+                }
+            }
+            output_.close_path();
+            // interior rings
+            BOOST_FOREACH(polygon_2d::inner_container_type::value_type const& ring, boost::geometry::interior_rings(poly))
+            {
+                move_to = true;
+                BOOST_FOREACH(point_2d const& c, ring)
+                {
+                    if (move_to)
+                    {
+                        move_to = false;
+                        output_.move_to(c.x,c.y);
+                    }
+                    else
+                    {
+                        output_.line_to(c.x,c.y);
+                    }
+                }
+                output_.close_path();
+            }
+        }
+    }
+
+    box2d<double> clip_box_;
+    Geometry & geom_;
+    mapnik::geometry_type output_;
+
+};
+
+}
+
+#endif //MAPNIK_POLYGON_CLIPPER_HPP

src/agg/process_markers_symbolizer.cpp

@@ -192,9 +192,9 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
             }
             else // raster markers
             {
-                box2d<double> const& bbox = (*mark)->bounding_box();
+                setup_transform_scaling(tr, (*mark)->width(), (*mark)->height(), feature, sym);
-                setup_transform_scaling(tr, bbox.width(), bbox.height(), feature, sym);
                 evaluate_transform(tr, feature, sym.get_image_transform());
+                box2d<double> const& bbox = (*mark)->bounding_box();
                 coord2d center = bbox.center();
                 agg::trans_affine_translation recenter(-center.x, -center.y);
                 agg::trans_affine marker_trans = recenter * tr;

src/conversions.cpp

@@ -28,6 +28,10 @@
 
 #include <boost/spirit/include/qi.hpp>
 
+#if _MSC_VER
+#define snprintf _snprintf
+#endif
+
 #define BOOST_SPIRIT_AUTO(domain_, name, expr)                  \
     typedef boost::proto::result_of::                           \
     deep_copy<BOOST_TYPEOF(expr)>::type name##_expr_type;       \

src/grid/process_markers_symbolizer.cpp

@@ -209,9 +209,9 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
             }
             else // raster markers
             {
-                box2d<double> const& bbox = (*mark)->bounding_box();
+                setup_transform_scaling(tr, (*mark)->width(), (*mark)->height(), feature, sym);
-                setup_transform_scaling(tr, bbox.width(), bbox.height(), feature, sym);
                 evaluate_transform(tr, feature, sym.get_image_transform());
+                box2d<double> const& bbox = (*mark)->bounding_box();
                 // - clamp sizes to > 4 pixels of interactivity
                 coord2d center = bbox.center();
                 agg::trans_affine_translation recenter(-center.x, -center.y);

src/marker_cache.cpp

@@ -181,6 +181,7 @@ boost::optional<marker_ptr> marker_cache::find(std::string const& uri,
                 double lox,loy,hix,hiy;
                 svg.bounding_rect(&lox, &loy, &hix, &hiy);
                 marker_path->set_bounding_box(lox,loy,hix,hiy);
+                marker_path->set_dimensions(svg.width(),svg.height());
                 marker_ptr mark(boost::make_shared<marker>(marker_path));
                 result.reset(mark);
                 if (update_cache)