Merge branch 'master' into geometry-refactor

INSTALL.md

@@ -98,7 +98,7 @@ Additional optional dependencies:
  * PostgreSQL (for PostGIS plugin support)
     - libpq - PostreSQL libraries
     - pg_config - PostgreSQL installation capabilities
- * libgdal - GDAL/OGR input (For gdal and ogr plugin support)
+ * libgdal - GDAL/OGR input (For gdal and ogr plugin support) (>= GDAL 2.0.2 for thread safety - https://github.com/mapnik/mapnik/issues/3339)
  * libsqlite3 - SQLite input (needs RTree support builtin) (sqlite plugin support)
 
 Instructions for installing many of these dependencies on

README.md

@@ -20,7 +20,7 @@ For further information see [http://mapnik.org](http://mapnik.org) and also our
 
 # Installation
 
-See [INSTALL.md](https://github.com/mapnik/mapnik/blob/master/INSTALL.md) for installation instructions and the [Install](https://github.com/mapnik/mapnik/wiki/Mapnik-Installation) page on the wiki for guides.
+See [INSTALL.md](INSTALL.md) for installation instructions and the [Install](https://github.com/mapnik/mapnik/wiki/Mapnik-Installation) page on the wiki for guides.
 
 # Code of Conduct
 

SConstruct

@@ -1451,12 +1451,13 @@ if not preconfigured:
         # just turn it off like this, but seems the only available work-
         # around. See https://svn.boost.org/trac/boost/ticket/6779 for more
         # details.
-        boost_version = [int(x) for x in env.get('BOOST_LIB_VERSION_FROM_HEADER').split('_')]
+        if not env['HOST']:
-        if not conf.CheckBoostScopedEnum():
+            boost_version = [int(x) for x in env.get('BOOST_LIB_VERSION_FROM_HEADER').split('_')]
-            if boost_version < [1, 51]:
+            if not conf.CheckBoostScopedEnum():
-                env.Append(CXXFLAGS = '-DBOOST_NO_SCOPED_ENUMS')
+                if boost_version < [1, 51]:
-            elif boost_version < [1, 57]:
+                    env.Append(CXXFLAGS = '-DBOOST_NO_SCOPED_ENUMS')
-                env.Append(CXXFLAGS = '-DBOOST_NO_CXX11_SCOPED_ENUMS')
+                elif boost_version < [1, 57]:
+                    env.Append(CXXFLAGS = '-DBOOST_NO_CXX11_SCOPED_ENUMS')
 
     if not env['HOST'] and env['ICU_LIB_NAME'] not in env['MISSING_DEPS']:
         # http://lists.boost.org/Archives/boost/2009/03/150076.php

deps/agg/include/agg_rasterizer_scanline_aa.h

@@ -2,15 +2,15 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software 
+// Permission to copy, use, modify, sell and distribute this software
-// is granted provided this copyright notice appears in all copies. 
+// is granted provided this copyright notice appears in all copies.
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
 //----------------------------------------------------------------------------
 //
-// The author gratefully acknowleges the support of David Turner, 
+// The author gratefully acknowleges the support of David Turner,
-// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
 // libray - in producing this work. See http://www.freetype.org for details.
 //
 //----------------------------------------------------------------------------
@@ -19,12 +19,12 @@
 //          http://www.antigrain.com
 //----------------------------------------------------------------------------
 //
-// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Adaptation for 32-bit screen coordinates has been sponsored by
 // Liberty Technology Systems, Inc., visit http://lib-sys.com
 //
 // Liberty Technology Systems, Inc. is the provider of
 // PostScript and PDF technology for software developers.
-// 
+//
 //----------------------------------------------------------------------------
 #ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
 #define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
@@ -39,8 +39,8 @@ namespace agg
 
 
     //-----------------------------------------------------------------cell_aa
-    // A pixel cell. There're no constructors defined and it was done 
+    // A pixel cell. There're no constructors defined and it was done
-    // intentionally in order to avoid extra overhead when allocating an 
+    // intentionally in order to avoid extra overhead when allocating an
     // array of cells.
     struct cell_aa
     {
@@ -67,10 +67,10 @@ namespace agg
 
 
     //==================================================rasterizer_scanline_aa
-    // Polygon rasterizer that is used to render filled polygons with 
+    // Polygon rasterizer that is used to render filled polygons with
-    // high-quality Anti-Aliasing. Internally, by default, the class uses 
+    // high-quality Anti-Aliasing. Internally, by default, the class uses
-    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
+    // integer coordinates in format 24.8, i.e. 24 bits for integer part
-    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
+    // and 8 bits for fractional - see poly_subpixel_shift. This class can be
     // used in the following  way:
     //
     // 1. filling_rule(filling_rule_e ft) - optional.
@@ -79,20 +79,20 @@ namespace agg
     //
     // 3. reset()
     //
-    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
+    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create
     //    more than one contour, but each contour must consist of at least 3
     //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
     //    is the absolute minimum of vertices that define a triangle.
     //    The algorithm does not check either the number of vertices nor
-    //    coincidence of their coordinates, but in the worst case it just 
+    //    coincidence of their coordinates, but in the worst case it just
     //    won't draw anything.
-    //    The orger of the vertices (clockwise or counterclockwise) 
+    //    The orger of the vertices (clockwise or counterclockwise)
     //    is important when using the non-zero filling rule (fill_non_zero).
     //    In this case the vertex order of all the contours must be the same
     //    if you want your intersecting polygons to be without "holes".
-    //    You actually can use different vertices order. If the contours do not 
+    //    You actually can use different vertices order. If the contours do not
-    //    intersect each other the order is not important anyway. If they do, 
+    //    intersect each other the order is not important anyway. If they do,
-    //    contours with the same vertex order will be rendered without "holes" 
+    //    contours with the same vertex order will be rendered without "holes"
     //    while the intersecting contours with different orders will have "holes".
     //
     // filling_rule() and gamma() can be called anytime before "sweeping".
@@ -122,7 +122,7 @@ namespace agg
         };
 
         //--------------------------------------------------------------------
-        rasterizer_scanline_aa() : 
+        rasterizer_scanline_aa() :
             m_outline(),
             m_clipper(),
             m_filling_rule(fill_non_zero),
@@ -136,8 +136,8 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        template<class GammaF> 
+        template<class GammaF>
-        rasterizer_scanline_aa(const GammaF& gamma_function) : 
+        rasterizer_scanline_aa(const GammaF& gamma_function) :
             m_outline(),
             m_clipper(m_outline),
             m_filling_rule(fill_non_zero),
@@ -150,7 +150,7 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        void reset(); 
+        void reset();
         void reset_clipping();
         void clip_box(double x1, double y1, double x2, double y2);
         void filling_rule(filling_rule_e filling_rule);
@@ -158,7 +158,7 @@ namespace agg
 
         //--------------------------------------------------------------------
         template<class GammaF> void gamma(const GammaF& gamma_function)
-        { 
+        {
             int i;
             for(i = 0; i < aa_scale; i++)
             {
@@ -167,9 +167,9 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        unsigned apply_gamma(unsigned cover) const 
+        unsigned apply_gamma(unsigned cover) const
-        { 
+        {
-            return m_gamma[cover]; 
+            return m_gamma[cover];
         }
 
         //--------------------------------------------------------------------
@@ -198,7 +198,7 @@ namespace agg
                 add_vertex(x, y, cmd);
             }
         }
-        
+
         //--------------------------------------------------------------------
         int min_x() const { return m_outline.min_x(); }
         int min_y() const { return m_outline.min_y(); }
@@ -237,7 +237,7 @@ namespace agg
                 sl.reset_spans();
                 unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
                 const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
-                int cover = 0;
+                unsigned cover = 0;
 
                 while(num_cells)
                 {
@@ -276,7 +276,7 @@ namespace agg
                         }
                     }
                 }
-        
+
                 if(sl.num_spans()) break;
                 ++m_scan_y;
             }
@@ -294,7 +294,7 @@ namespace agg
         //--------------------------------------------------------------------
         // Disable copying
         rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
-        const rasterizer_scanline_aa<Clip>& 
+        const rasterizer_scanline_aa<Clip>&
         operator = (const rasterizer_scanline_aa<Clip>&);
 
     private:
@@ -321,32 +321,32 @@ namespace agg
 
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
-    void rasterizer_scanline_aa<Clip>::reset() 
+    void rasterizer_scanline_aa<Clip>::reset()
-    { 
+    {
-        m_outline.reset(); 
+        m_outline.reset();
         m_status = status_initial;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
-    void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
+    void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule)
-    { 
+    {
-        m_filling_rule = filling_rule; 
+        m_filling_rule = filling_rule;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
-    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, 
+    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1,
                                                 double x2, double y2)
     {
         reset();
-        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
                            conv_type::upscale(x2), conv_type::upscale(y2));
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::reset_clipping()
     {
         reset();
@@ -354,7 +354,7 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::close_polygon()
     {
         if(m_status == status_line_to)
@@ -365,56 +365,56 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
     {
         if(m_outline.sorted()) reset();
         if(m_auto_close) close_polygon();
-        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+        m_clipper.move_to(m_start_x = conv_type::downscale(x),
                           m_start_y = conv_type::downscale(y));
         m_status = status_move_to;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
     {
-        m_clipper.line_to(m_outline, 
+        m_clipper.line_to(m_outline,
-                          conv_type::downscale(x), 
+                          conv_type::downscale(x),
                           conv_type::downscale(y));
         m_status = status_line_to;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
-    void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y) 
+    void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y)
-    { 
+    {
         if(m_outline.sorted()) reset();
         if(m_auto_close) close_polygon();
-        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+        m_clipper.move_to(m_start_x = conv_type::upscale(x),
-                          m_start_y = conv_type::upscale(y)); 
+                          m_start_y = conv_type::upscale(y));
         m_status = status_move_to;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
-    void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y) 
+    void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y)
-    { 
+    {
-        m_clipper.line_to(m_outline, 
+        m_clipper.line_to(m_outline,
-                          conv_type::upscale(x), 
+                          conv_type::upscale(x),
-                          conv_type::upscale(y)); 
+                          conv_type::upscale(y));
         m_status = status_line_to;
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
     {
-        if(is_move_to(cmd)) 
+        if(is_move_to(cmd))
         {
             move_to_d(x, y);
         }
-        else 
+        else
         if(is_vertex(cmd))
         {
             line_to_d(x, y);
@@ -427,32 +427,32 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
     {
         if(m_outline.sorted()) reset();
         m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
-        m_clipper.line_to(m_outline, 
+        m_clipper.line_to(m_outline,
-                          conv_type::downscale(x2), 
+                          conv_type::downscale(x2),
                           conv_type::downscale(y2));
         m_status = status_move_to;
     }
-    
-    //------------------------------------------------------------------------
-    template<class Clip> 
-    void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, 
-                                              double x2, double y2)
-    {
-        if(m_outline.sorted()) reset();
-        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
-        m_clipper.line_to(m_outline, 
-                          conv_type::upscale(x2), 
-                          conv_type::upscale(y2)); 
-        m_status = status_move_to;
-    }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
+    void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1,
+                                              double x2, double y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
+        m_clipper.line_to(m_outline,
+                          conv_type::upscale(x2),
+                          conv_type::upscale(y2));
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip>
     void rasterizer_scanline_aa<Clip>::sort()
     {
         if(m_auto_close) close_polygon();
@@ -460,12 +460,12 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
     {
         if(m_auto_close) close_polygon();
         m_outline.sort_cells();
-        if(m_outline.total_cells() == 0) 
+        if(m_outline.total_cells() == 0)
         {
             return false;
         }
@@ -475,14 +475,14 @@ namespace agg
 
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
     {
         if(m_auto_close) close_polygon();
         m_outline.sort_cells();
-        if(m_outline.total_cells() == 0 || 
+        if(m_outline.total_cells() == 0 ||
-           y < m_outline.min_y() || 
+           y < m_outline.min_y() ||
-           y > m_outline.max_y()) 
+           y > m_outline.max_y())
         {
             return false;
         }
@@ -491,7 +491,7 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Clip> 
+    template<class Clip>
     bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
     {
         if(!navigate_scanline(ty)) return false;
@@ -507,4 +507,3 @@ namespace agg
 
 
 #endif
-

include/mapnik/debug.hpp

@@ -69,15 +69,15 @@ public:
 
     static void set_severity(severity_type severity_level)
     {
-//#ifdef MAPNIK_THREADSAFE
-//        std::lock_guard<std::mutex> lock(severity_mutex_);
-//#endif
         severity_level_ = severity_level;
     }
 
     // per object security levels
     static severity_type get_object_severity(std::string const& object_name)
     {
+#ifdef MAPNIK_THREADSAFE
+        std::lock_guard<std::mutex> lock(severity_mutex_);
+#endif
         severity_map::iterator it = object_severity_level_.find(object_name);
         if (object_name.empty() || it == object_severity_level_.end())
         {

include/mapnik/value_hash.hpp

@@ -26,22 +26,20 @@
 // mapnik
 #include <mapnik/util/variant.hpp>
 #include <mapnik/value_types.hpp>
-
 // stl
 #include <functional>
 
 #pragma GCC diagnostic push
 #include <mapnik/warning_ignore.hpp>
 #include <unicode/unistr.h>
+
 #pragma GCC diagnostic pop
 
 namespace mapnik { namespace detail {
 
-template <class T>
+inline void hash_combine(std::size_t & seed, std::size_t val)
-inline void hash_combine(std::size_t & seed, T const& v)
 {
-    std::hash<T> hasher;
+    seed ^= val + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-    seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
 }
 
 struct value_hasher
@@ -56,6 +54,11 @@ struct value_hasher
         return static_cast<std::size_t>(val.hashCode());
     }
 
+    std::size_t operator()(value_integer val) const
+    {
+        return static_cast<std::size_t>(val);
+    }
+
     template <class T>
     std::size_t operator()(T const& val) const
     {
@@ -69,7 +72,8 @@ struct value_hasher
 template <typename T>
 std::size_t mapnik_hash_value(T const& val)
 {
-    std::size_t seed = util::apply_visitor(detail::value_hasher(), val);
+    std::size_t seed = 0;
+    detail::hash_combine(seed, util::apply_visitor(detail::value_hasher(), val));
     detail::hash_combine(seed, val.which());
     return seed;
 }

include/mapnik/version.hpp

@@ -27,7 +27,7 @@
 
 #define MAPNIK_MAJOR_VERSION 3
 #define MAPNIK_MINOR_VERSION 0
-#define MAPNIK_PATCH_VERSION 11
+#define MAPNIK_PATCH_VERSION 12
 
 #define MAPNIK_VERSION (MAPNIK_MAJOR_VERSION*100000) + (MAPNIK_MINOR_VERSION*100) + (MAPNIK_PATCH_VERSION)
 

test/unit/serialization/wkb_test.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 #include <fstream>
 
+#if BOOST_VERSION >= 105800
 namespace  {
 
 struct spatially_equal_visitor
@@ -79,6 +80,7 @@ bool spatially_equal(mapnik::geometry::geometry<T> const& g0, mapnik::geometry::
 }
 
 }
+#endif
 
 TEST_CASE("Well-known-geometries")
 {
@@ -106,7 +108,9 @@ TEST_CASE("Well-known-geometries")
             {
                 REQUIRE(wkt0 == wkt1);
                 // compare spatially (NOTE: GeometryCollection comparison also enforces strict order)
+#if BOOST_VERSION >= 105800
                 REQUIRE(spatially_equal(geom_0, geom_1));
+#endif
             }
         }
     }

utils/mapnik-index/mapnik-index.cpp

@@ -180,7 +180,11 @@ int main (int argc, char** argv)
         {
             std::clog << "processing '" << filename << "' as CSV\n";
             auto result = mapnik::detail::process_csv_file(boxes, filename, manual_headers, separator, quote);
-            if (!result.first) continue;
+            if (!result.first)
+            {
+                std::clog << "Error: failed to process " << filename << std::endl;
+                return EXIT_FAILURE;
+            }
             extent = result.second;
         }
         else if (mapnik::detail::is_geojson(filename))
@@ -190,7 +194,7 @@ int main (int argc, char** argv)
             if (!result.first)
             {
                 std::clog << "Error: failed to process " << filename << std::endl;
-                continue;
+                return EXIT_FAILURE;
             }
             extent = result.second;
         }
@@ -224,6 +228,11 @@ int main (int argc, char** argv)
                 file.close();
             }
         }
+        else
+        {
+            std::clog << "Invalid extent " << extent << std::endl;
+            return EXIT_FAILURE;
+        }
     }
     std::clog << "done!" << std::endl;
     return EXIT_SUCCESS;

utils/mapnik-render/mapnik-render.cpp

@@ -21,7 +21,7 @@ int main (int argc,char** argv)
     namespace po = boost::program_options;
 
     bool verbose = false;
-    bool auto_open = true;
+    bool auto_open = false;
     int return_value = 0;
     std::string xml_file;
     std::string img_file;
@@ -37,7 +37,7 @@ int main (int argc,char** argv)
             ("help,h", "produce usage message")
             ("version,V","print version string")
             ("verbose,v","verbose output")
-            ("open","automatically open the file after rendering (os x only)")
+            ("open","automatically open the file after rendering")
             ("xml",po::value<std::string>(),"xml map to read")
             ("img",po::value<std::string>(),"image to render")
             ("scale-factor",po::value<double>(),"scale factor for rendering")