label deferred rendering

layer_label_deferred_rendering_fixed3.diff

Index: include/mapnik/layer.hpp
===================================================================
--- include/mapnik/layer.hpp	(revision 3315)
+++ include/mapnik/layer.hpp	(working copy)
@@ -180,6 +180,10 @@
      */
     bool cache_features() const; 
         
+    void set_deferred_labels(bool deferred_labels);
+    
+    bool deferred_labels() const;
+
     /*!
      * @brief Attach a datasource for this layer.
      *
@@ -214,6 +218,7 @@
     bool cache_features_;
     std::vector<std::string>  styles_;
     datasource_ptr ds_;
+    bool deferred_labels_;
 };
 }
 
Index: include/mapnik/feature_style_processor.hpp
===================================================================
--- include/mapnik/feature_style_processor.hpp	(revision 3315)
+++ include/mapnik/feature_style_processor.hpp	(working copy)
@@ -25,8 +25,16 @@
 #ifndef FEATURE_STYLE_PROCESSOR_HPP
 #define FEATURE_STYLE_PROCESSOR_HPP
 
+#include <mapnik/rule.hpp>
+#include <mapnik/feature.hpp>
+#include <mapnik/datasource.hpp>
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/unordered_map.hpp>
+
 #include <set>
 #include <string>
+#include <vector>
 
 namespace mapnik
 {
@@ -34,11 +42,19 @@
 class Map;
 class layer;
 class projection;
+class proj_transform;
   
 template <typename Processor>
 class feature_style_processor 
 {
     struct symbol_dispatch;
+    
+    typedef boost::tuple<feature_ptr,
+                         text_symbolizer const&> render_pair_type;
+    typedef boost::unordered_multimap<std::string, render_pair_type> deferred_text_cont;
+    
+    mutable deferred_text_cont deferred_;
+    
 public:
     explicit feature_style_processor(Map const& m, double scale_factor = 1.0);
 
@@ -51,6 +67,8 @@
      * @return apply renderer to a single layer, providing pre-populated set of query attribute names.
      */
     void apply(mapnik::layer const& lyr, std::set<std::string>& names);
+    
+    void add_defer(std::string const& srs, render_pair_type const& rp);
 private:
     /*!
      * @return initialize metawriters for a given map and projection.
Index: src/layer.cpp
===================================================================
--- src/layer.cpp	(revision 3315)
+++ src/layer.cpp	(working copy)
@@ -46,7 +46,8 @@
       queryable_(false),
       clear_label_cache_(false),
       cache_features_(false),
-      ds_() {}
+      ds_(),
+      deferred_labels_(false) {}
     
 layer::layer(const layer& rhs)
     : name_(rhs.name_),
@@ -60,7 +61,8 @@
       clear_label_cache_(rhs.clear_label_cache_),
       cache_features_(rhs.cache_features_),
       styles_(rhs.styles_),
-      ds_(rhs.ds_) {}
+      ds_(rhs.ds_),
+      deferred_labels_(rhs.deferred_labels_) {}
     
 layer& layer::operator=(const layer& rhs)
 {
@@ -88,6 +90,7 @@
     cache_features_ = rhs.cache_features_;
     styles_=rhs.styles_;
     ds_=rhs.ds_;
+    deferred_labels_=rhs.deferred_labels_;
 }
 
 layer::~layer() {}
@@ -228,4 +231,14 @@
     return cache_features_;
 }
 
+void layer::set_deferred_labels(bool deferred_labels)
+{
+    deferred_labels_ = deferred_labels;
 }
+
+bool layer::deferred_labels() const
+{
+    return deferred_labels_;
+}
+
+}
Index: src/load_map.cpp
===================================================================
--- src/load_map.cpp	(revision 3315)
+++ src/load_map.cpp	(working copy)
@@ -535,7 +535,8 @@
       << "maxzoom,"
       << "queryable,"
       << "clear-label-cache,"
-      << "cache-features";
+      << "cache-features,"
+      << "deferred-labels";
     ensure_attrs(lay, "Layer", s.str());
     try
     {
@@ -596,6 +597,12 @@
             lyr.set_cache_features( * cache_features );
         }
 
+        optional<boolean> deferred_labels =
+            get_opt_attr<boolean>(lay, "deferred-labels");
+        if (deferred_labels)
+        {
+            lyr.set_deferred_labels( * deferred_labels );
+        }
 
         ptree::const_iterator itr2 = lay.begin();
         ptree::const_iterator end2 = lay.end();
Index: src/feature_style_processor.cpp
===================================================================
--- src/feature_style_processor.cpp	(revision 3315)
+++ src/feature_style_processor.cpp	(working copy)
@@ -65,21 +65,39 @@
 struct feature_style_processor<Processor>::symbol_dispatch : public boost::static_visitor<>
 {
     symbol_dispatch (Processor & output,
-                     Feature const& f,
-                     proj_transform const& prj_trans)
+                     feature_ptr f,
+                     proj_transform const& prj_trans,
+                     bool text_last=false)
         : output_(output),
           f_(f),
-          prj_trans_(prj_trans)  {}
+          prj_trans_(prj_trans),
+          text_last_(text_last)  {}
 
     template <typename T>
     void operator () (T const& sym) const
     {
-        output_.process(sym,f_,prj_trans_);
+        //std::clog << "normal\n";
+        output_.process(sym,*f_,prj_trans_);
     }
 
+    void operator () (text_symbolizer const& sym) const
+    {
+        if (text_last_)
+        {
+        //std::clog << "deferring\n";
+            output_.add_defer(prj_trans_.source().params(),render_pair_type(f_,sym));
+        }
+        else
+        {
+        //std::clog << "normal text\n";
+            output_.process(sym,*f_,prj_trans_);
+        }
+    }
+
     Processor & output_;
-    Feature const& f_;
+    feature_ptr f_;
     proj_transform const& prj_trans_;
+    bool text_last_;
 };
 
 template <typename Processor>
@@ -89,6 +107,12 @@
 }
 
 template <typename Processor>
+void feature_style_processor<Processor>::add_defer(std::string const& srs, render_pair_type const& rp)
+{
+    deferred_.insert(std::make_pair(srs,rp));
+}
+
+template <typename Processor>
 void feature_style_processor<Processor>::apply()
 {
 
@@ -118,6 +142,23 @@
             }
         }
 
+        // process defered text
+        deferred_text_cont::const_iterator itr = deferred_.begin();
+        deferred_text_cont::const_iterator bucket_itr;
+        deferred_text_cont::const_iterator end = deferred_.end();
+        for (; itr!=end; itr = bucket_itr)
+        {
+            std::string const& srs = itr->first;
+            std::pair<deferred_text_cont::const_iterator,
+                      deferred_text_cont::const_iterator> key_range = deferred_.equal_range(srs);
+            proj_transform tr(projection(srs),proj);
+            for (bucket_itr=key_range.first; bucket_itr!=key_range.second; ++bucket_itr)
+            {
+                render_pair_type const& rp = bucket_itr->second;
+                p.process(rp.get<1>(),*(rp.get<0>()),tr);
+            }
+        }
+
         stop_metawriters(m_);
     }
     catch (proj_init_error& ex)
@@ -435,7 +476,7 @@
 
                             BOOST_FOREACH (symbolizer const& sym, symbols)
                             {
-                                boost::apply_visitor(symbol_dispatch(p,*feature,prj_trans),sym);
+                                boost::apply_visitor(symbol_dispatch(p,feature,prj_trans,lay.deferred_labels()),sym);
                             }
                         }
                         if (style->get_filter_mode() == FILTER_FIRST)
@@ -464,7 +505,7 @@
                         {
                             BOOST_FOREACH (symbolizer const& sym, symbols)
                             {
-                                boost::apply_visitor(symbol_dispatch(p,*feature,prj_trans),sym);
+                                boost::apply_visitor(symbol_dispatch(p,feature,prj_trans,lay.deferred_labels()),sym);
                             }
                         }
                     }
@@ -488,7 +529,7 @@
                         {
                             BOOST_FOREACH (symbolizer const& sym, symbols)
                             {
-                                boost::apply_visitor(symbol_dispatch(p,*feature,prj_trans),sym);
+                                boost::apply_visitor(symbol_dispatch(p,feature,prj_trans,lay.deferred_labels()),sym);
                             }
                         }
                     }