Ticket #381: further_cairo_rendering_abstraction.patch

src/image_util.cpp

@@ -35 +35 @@
 #include <mapnik/memory.hpp>
 #include <mapnik/image_view.hpp>
 
+#ifdef HAVE_CAIRO
+#include <mapnik/cairo_renderer.hpp>
+#endif
+
 // stl
 #include <string>
 #include <iostream>
@@ -103 +107 @@
                 }
             }
             else throw ImageWriterException("unknown file type: " + type);
-        } 
+        }
+        else throw ImageWriterException("Could not write file to " + filename );
     }
+
         
     template <typename T>
     void save_to_file(T const& image,std::string const& filename)
@@ -112 +118 @@
         std::string type = type_from_filename(filename);
         save_to_file<T>(image,filename,type);
     }
-     
 
+
+#if defined(HAVE_CAIRO)
+
+    void save_to_cairo_file(mapnik::Map const& map, std::string const& filename)
+    {
+        std::string type = type_from_filename(filename);
+        save_to_cairo_file(map,filename,type);
+    }
+
+    void save_to_cairo_file(mapnik::Map const& map,
+                      std::string const& filename,
+                      std::string const& type)
+    {
+        std::ofstream file (filename.c_str(), std::ios::out|std::ios::trunc|std::ios::binary);
+        if (file)
+        {
+          Cairo::RefPtr<Cairo::Surface> surface;
+          if (type == "pdf")
+              surface = Cairo::PdfSurface::create(filename, map.getWidth(),map.getHeight());
+          else if (type == "svg")
+              surface = Cairo::SvgSurface::create(filename, map.getWidth(),map.getHeight());
+          else if (type == "ps")
+              surface = Cairo::PsSurface::create(filename, map.getWidth(),map.getHeight());
+          else if (type == "ARGB32")
+              surface = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, map.getWidth(),map.getHeight());
+          else if (type == "RGB24")
+              surface = Cairo::ImageSurface::create(Cairo::FORMAT_RGB24, map.getWidth(),map.getHeight());
+          else 
+              throw ImageWriterException("unknown file type: " + type);    
+          Cairo::RefPtr<Cairo::Context> context = Cairo::Context::create(surface);
+    
+          if (type == "ARGB32" | type == "RGB24") 
+          { 
+              context->set_antialias(Cairo::ANTIALIAS_NONE); 
+          }
+    
+          mapnik::cairo_renderer<Cairo::Context> ren(map, context);
+          ren.apply();
+    
+          if (type == "ARGB32" | type == "RGB24") 
+          { 
+              surface->write_to_png(filename);
+          }
+          surface->finish();
+        }
+    }
+
+#endif
+
     template void save_to_file<ImageData32>(ImageData32 const&,
                                             std::string const&,
                                             std::string const&);
-
+                                            
     template void save_to_file<ImageData32>(ImageData32 const&,
                                             std::string const&);
 

include/mapnik/image_util.hpp

@@ -27 +27 @@
 
 // mapnik
 #include <mapnik/config.hpp>
+#include <mapnik/map.hpp>
 #include <mapnik/graphics.hpp>
 
 // boost
@@ -53 +54 @@
         }
     };
 
+   MAPNIK_DECL void save_to_cairo_file(mapnik::Map const& map,
+                                        std::string const& filename,
+                                        std::string const& type);
+
    template <typename T>
    MAPNIK_DECL void save_to_file(T const& image,
                                  std::string const& filename,
@@ -91 +96 @@
       return boost::algorithm::iends_with(filename,std::string(".tif")) ||
          boost::algorithm::iends_with(filename,std::string(".tiff"));
    }
-   
+
+   inline bool is_pdf (std::string const& filename)
+   {
+      return boost::algorithm::iends_with(filename,std::string(".pdf"));
+   }
+
+   inline bool is_svg (std::string const& filename)
+   {
+      return boost::algorithm::iends_with(filename,std::string(".svg"));
+   }
+
+   inline bool is_ps (std::string const& filename)
+   {
+      return boost::algorithm::iends_with(filename,std::string(".ps"));
+   }
+      
    inline std::string type_from_filename(std::string const& filename)
    {
       if (is_png(filename)) return "png";
       if (is_jpeg(filename)) return "jpeg";
       if (is_tiff(filename)) return "tiff";
+      if (is_pdf(filename)) return "pdf";
+      if (is_svg(filename)) return "svg";
+      if (is_ps(filename)) return "ps";
       return "unknown";
    }
 

bindings/python/mapnik_python.cpp

@@ -194 +194 @@
                     const std::string& filename,
                     const std::string& format)
 {
-    mapnik::Image32 image(map.getWidth(),map.getHeight());
-    render(map,image,0,0);
-    mapnik::save_to_file(image,filename,format); 
+    if (format == "pdf" | format == "svg" | format =="ps" | format == "ARGB32" | format == "RGB24")
+    {
+#if defined(HAVE_CAIRO)
+        mapnik::save_to_cairo_file(map,filename,format);
+#else
+        throw mapnik::ImageWriterException("Cairo backend not available, cannot write to format: " + format);
+#endif
+    }
+    else 
+    {
+        mapnik::Image32 image(map.getWidth(),map.getHeight());
+        render(map,image,0,0);
+        mapnik::save_to_file(image,filename,format); 
+    }
 }
 
-void render_to_file2(const mapnik::Map& map,
-                    const std::string& filename)
+void render_to_file2(const mapnik::Map& map,const std::string& filename)
 {
-    mapnik::Image32 image(map.getWidth(),map.getHeight());
-    render(map,image,0,0);
-    mapnik::save_to_file(image,filename); 
+    std::string format = mapnik::guess_type(filename);
+    if (format == "pdf" | format == "svg" | format =="ps")
+    {
+#if defined(HAVE_CAIRO)
+        mapnik::save_to_cairo_file(map,filename,format);
+#else
+        throw mapnik::ImageWriterException("Cairo backend not available, cannot write to format: " + format);
+#endif
+    }
+    else 
+    {
+        mapnik::Image32 image(map.getWidth(),map.getHeight());
+        render(map,image,0,0);
+        mapnik::save_to_file(image,filename); 
+    }
 }
 
-
 double scale_denominator(mapnik::Map const &map, bool geographic)
 {
     return mapnik::scale_denominator(map, geographic);