ruby_mapnik 0.1

data/ext/ruby_mapnik/_mapnik_line_symbolizer.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_LINE_SYMBOLIZER
+#define PIKA2_MAPNIK_LINE_SYMBOLIZER
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_line_symbolizer(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_map.rb.cpp

@@ -0,0 +1,435 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#include "_mapnik_map.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Hash.hpp>
+#include <rice/Array.hpp>
+
+// Mapnik
+#include <mapnik/map.hpp>
+#include <mapnik/agg_renderer.hpp>
+#include <mapnik/graphics.hpp>
+#ifdef HAVE_CAIRO
+  #include <mapnik/cairo_renderer.hpp>
+#endif
+#include <mapnik/image_util.hpp>
+#include <mapnik/load_map.hpp>
+#include <mapnik/save_map.hpp>
+
+
+// Seems like one could metaprogram these two away...
+template<>
+Rice::Object to_ruby<boost::optional<mapnik::color> >(boost::optional<mapnik::color> const & x){
+  if(x)
+  {
+    return to_ruby<mapnik::color>(x.get());
+  } else{
+    return Rice::Object();
+  }
+}
+
+template<>
+Rice::Object to_ruby<boost::optional<mapnik::box2d<double> > >(boost::optional<mapnik::box2d<double> > const & x){
+  if(x)
+  {
+    return to_ruby<mapnik::box2d<double> >(x.get());
+  } else{
+    return Rice::Object();
+  }
+}
+
+template<>
+Rice::Object to_ruby<std::map<std::string,mapnik::feature_type_style> >(std::map<std::string,mapnik::feature_type_style> const & x){
+  Rice::Hash h;
+  std::map<std::string,mapnik::feature_type_style>::const_iterator end = x.end();
+  for (std::map<std::string,mapnik::feature_type_style>::const_iterator it = x.begin(); it != end; ++it){
+    h[to_ruby<std::string>(it->first)] = to_ruby<mapnik::feature_type_style>(it->second);
+  }
+  return h;
+}
+
+template<>
+Rice::Object to_ruby<std::vector<mapnik::layer> >(std::vector<mapnik::layer> const & x)
+{
+  return Rice::Array(x.begin(), x.end());
+}
+
+std::map<std::string,mapnik::feature_type_style> & (mapnik::Map::*_map_styles_)() = &mapnik::Map::styles;
+std::vector<mapnik::layer> & (mapnik::Map::*_map_layers_)() = &mapnik::Map::layers;
+
+namespace {
+
+  void render_map_to_file(const mapnik::Map& map, const std::string& 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::image_32 image(map.width(),map.height());
+        mapnik::agg_renderer<mapnik::image_32> ren(map,image,1.0,0,0);
+        ren.apply();
+        mapnik::save_to_file(image,filename);
+    }
+  }
+
+  std::string render_map_to_string(const mapnik::Map& map, std::string const& format){
+    mapnik::image_32 image(map.width(),map.height());
+    mapnik::agg_renderer<mapnik::image_32> ren(map,image,1.0,0,0);
+    ren.apply();
+    return mapnik::save_to_string(image,format);
+  }
+
+  std::string map_to_string(const mapnik::Map& map){
+    return mapnik::save_map_to_string(map);
+  }
+
+  #if defined(HAVE_CAIRO)
+
+  // TODO: These are temporarily boosted from the ruby cairo gem...
+  cairo_surface_t * rb_cairo_surface_from_ruby_object (VALUE obj) {
+    cairo_surface_t *surface;
+    // if (!rb_cairo__is_kind_of (obj, rb_cCairo_Surface))
+    //   {
+    //     rb_raise (rb_eTypeError, "not a cairo surface");
+    //   }
+    Data_Get_Struct (obj, cairo_surface_t, surface);
+    // if (!surface)
+    //   rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
+    return surface;
+  }
+
+  cairo_t * rb_cairo_context_from_ruby_object (VALUE obj) {
+    cairo_t *context;
+    // if (!rb_cairo__is_kind_of (obj, rb_cCairo_Surface))
+    //   {
+    //     rb_raise (rb_eTypeError, "not a cairo surface");
+    //   }
+    Data_Get_Struct (obj, cairo_t, context);
+    // if (!surface)
+    //   rb_cairo_check_status (CAIRO_STATUS_NULL_POINTER);
+    return context;
+  }
+
+  void render_to_cairo_surface(mapnik::Map const & map, Rice::Object rb_surface, unsigned offset_x = 0, unsigned offset_y = 0){
+    cairo_surface_t * surface = rb_cairo_surface_from_ruby_object(rb_surface);
+    Cairo::RefPtr<Cairo::Surface> s(new Cairo::Surface(surface));
+    mapnik::cairo_renderer<Cairo::Surface> ren(map,s,offset_x, offset_y);
+    ren.apply();
+  }
+
+  void render_to_cairo_context(mapnik::Map const & map, Rice::Object rb_context, unsigned offset_x = 0, unsigned offset_y = 0){
+    cairo_t * context = rb_cairo_context_from_ruby_object(rb_context);
+    Cairo::RefPtr<Cairo::Context> c(new Cairo::Context(context));
+    mapnik::cairo_renderer<Cairo::Context> ren(map, c, offset_x, offset_y);
+    ren.apply();
+  }
+  #endif
+
+  void initialize_map(Rice::Object self){
+    DATA_PTR(self.value()) = new mapnik::Map();
+    if(rb_block_given_p()) {
+      rb_yield(self);
+    }
+  }
+
+}
+
+void register_map(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::Map > rb_cmap = Rice::define_class_under< mapnik::Map >(rb_mapnik, "Map");
+  
+  /* 
+  * Document-method: new
+  * @return [Mapnik::Map] a new map object
+  * @yield [map] the new map object
+  */
+  rb_cmap.define_constructor(Rice::Constructor< mapnik::Map >());
+  
+  /*
+  * Dont-Document-method: __load_map_string__
+  */
+  rb_cmap.define_singleton_method("__load_map_string__", &mapnik::load_map_string);
+  
+  /*
+  * Dont-Document-method: __load_map__
+  */
+  rb_cmap.define_singleton_method("__load_map__", &mapnik::load_map);
+  
+  /*
+  * Dont-document-method: initialize
+  */
+  rb_cmap.define_method("initialize", &initialize_map);
+
+  /*
+  * Document-method: background
+  * @return [Mapnik::Color]
+  */
+  rb_cmap.define_method("background", &mapnik::Map::background);
+  
+  /*
+  * Document-method: background=
+  * call-seq:
+  *   background=(color)
+  * @param [Mapnik::Color]
+  * @return [nil]
+  */
+  rb_cmap.define_method("background=", &mapnik::Map::set_background);
+  
+  /*
+  * Document-method: base_path
+  * @return [String] The path all relative paths will be resolved with
+  */
+  rb_cmap.define_method("base_path", &mapnik::Map::base_path);
+  
+  /*
+  * Document-method: base_path=
+  * call-seq:
+  *   base_path=(path)
+  * @param [String]
+  * @return [nil]
+  */
+  rb_cmap.define_method("base_path=", &mapnik::Map::set_base_path);
+  
+  /*
+  * Document-method: buffer_size
+  * @return [Integer]
+  */  
+  rb_cmap.define_method("buffer_size", &mapnik::Map::buffer_size);
+  
+  /*
+  * Document-method: buffer_size=
+  * call-seq:
+  *   buffer_size=(size)
+  * @param [Integer]
+  * @return [nil]
+  */  
+  rb_cmap.define_method("buffer_size=", &mapnik::Map::set_buffer_size);
+  
+  /*
+  * Document-method: height
+  * @return [Integer]
+  */
+  rb_cmap.define_method("height", &mapnik::Map::height);
+  
+  /*
+  * Document-method: height=
+  * call-seq:
+  *   height=(height_in_pixels) 
+  * @param [Integer]
+  * @return [nil]
+  */
+  rb_cmap.define_method("height=", &mapnik::Map::set_height);
+  
+  /*
+  * Document-method: maximum_extent
+  * @return [Mapnik::Envelope]
+  */
+  rb_cmap.define_method("maximum_extent", &mapnik::Map::maximum_extent);
+
+  /*
+  * Document-method: maximum_extent=
+  * call-seq:
+  *  maximum_extent=(new_extent)
+  * @param [Mapnik::Envelope] new_extent
+  * @return [nil]
+  */
+  rb_cmap.define_method("maximum_extent=", &mapnik::Map::set_maximum_extent, Rice::Arg("new_extent"));
+  
+  /*
+  * Document-method: srs
+  * @return [String]
+  */
+  rb_cmap.define_method("srs", &mapnik::Map::srs);
+  
+  /*
+  * Document-method: srs=
+  * call-seq:
+  *   srs=(new_srs)
+  * @param [String]
+  * @return [nil]
+  */
+  rb_cmap.define_method("srs=", &mapnik::Map::set_srs);
+  
+  /*
+  * Document-method: width
+  * @return [Integer]
+  */
+  rb_cmap.define_method("width", &mapnik::Map::width);
+  
+  /*
+  * Document-method width=
+  * call-seq:
+  *  width=(new_width)
+  * @param [Integer] new_width in pixels
+  * @return [nil]
+  */
+  rb_cmap.define_method("width=", &mapnik::Map::set_width);
+  
+  /*
+  * Document-method: envelope
+  * @return [Mapnik::Envelope]
+  */
+  rb_cmap.define_method("envelope", &mapnik::Map::get_current_extent);
+  
+  /*
+  * Document-method: buffered_envelope
+  * @return [Mapnik::Envelope]
+  * The envelope plus any buffer set in buffer_size
+  */
+  rb_cmap.define_method("buffered_envelope", &mapnik::Map::get_buffered_extent);
+  
+  /*
+  * Document-method: pan
+  * call-seq:
+  *   pan(x, y)
+  * @param [Integer] x
+  * @param [Integer] y
+  * @return [nil]
+  */
+  rb_cmap.define_method("pan", &mapnik::Map::pan);
+  
+  /*
+  * Document-method: zoom
+  * call-seq:
+  *   zoom(zoom_factor)
+  * @param [Integer] zoom_factor
+  * @return [nil]
+  */
+  rb_cmap.define_method("zoom", &mapnik::Map::zoom);
+  
+  /*
+  * Document-method: zoom_all
+  * @return [nil]
+  */
+  rb_cmap.define_method("zoom_all", &mapnik::Map::zoom_all);
+  
+  /*
+  * Document-method: zoom_to_box
+  * call-seq:
+  *   zoom_to_box(envelope)
+  * @param [Mapnik::Envelope] envelope
+  * @return [nil]
+  */
+  rb_cmap.define_method("zoom_to_box", &mapnik::Map::zoom_to_box, Rice::Arg("envelope"));
+  
+  /* 
+  * Document-method: resize
+  * call-seq:
+  *   resize(new_width, new_height)
+  * @param [Integer] new_width in pixels
+  * @param [Integer] new_height in pixels
+  * @return [nil]
+  */
+  rb_cmap.define_method("resize", &mapnik::Map::resize);
+
+  /*
+  * Document-method: scale
+  * @return [Float]
+  */
+  rb_cmap.define_method("scale", &mapnik::Map::scale);
+  
+  /*
+  * Dont-Document-method: __styles__
+  */
+  rb_cmap.define_method("__styles__", _map_styles_);
+  
+  /*
+  * Dont-Document-method: __insert_style__
+  */
+  rb_cmap.define_method("__insert_style__", &mapnik::Map::insert_style);
+  
+  /*
+  * Dont-Document-method: __remove_style__
+  */
+  rb_cmap.define_method("__remove_style__", &mapnik::Map::remove_style);
+  
+  /*
+  * Dont-Document-method: __layers__
+  */
+  rb_cmap.define_method("__layers__", _map_layers_);
+  
+  /*
+  * Dont-Document-method: __add_layer__
+  */
+  rb_cmap.define_method("__add_layer__", &mapnik::Map::addLayer);
+  
+  /*
+  * Dont-Document-method: __remove_layer__
+  */
+  rb_cmap.define_method("__remove_layer__", &mapnik::Map::removeLayer);
+  
+  /*
+  * Dont-Document-method: __render_to_file__
+  */
+  rb_cmap.define_method("__render_to_file__", &render_map_to_file);
+
+  /*
+  * Document-method: to_xml
+  * @return [String] 
+  * An XML representation of the map that can be loaded via the from_xml method, or by other mapnik implementations
+  */
+  rb_cmap.define_method("to_xml", &map_to_string);
+
+  /*
+  * Document-method: render_to_string
+  * call-seq:
+  *   render_to_string(file_format)
+  * @param [String] file_format One of 'png', 'jpg' or 'tiff'
+  * @return [String] A string of the data for the image
+  */
+  rb_cmap.define_method("render_to_string", &render_map_to_string);
+
+#if defined(HAVE_CAIRO)  
+  
+  /* 
+  * Document-method: render_to_cairo_surface
+  * call-seq:
+  *   render_to_cairo_surface(cairo_surface)
+  * @param [Cairo::Surface]
+  * @return [nil]
+  * Only available if Ruby-Mapnik was compiled with Cairo support and the 
+  * Ruby Cairo gem is available
+  */
+  rb_cmap.define_method("render_to_cairo_surface", &render_to_cairo_surface);
+    
+  /* 
+  * Document-method: render_to_cairo_context
+  * call-seq:
+  *   render_to_cairo_context(cairo_context)
+  * @param [Cairo::Context]
+  * @return [nil]
+  * Only available if Ruby-Mapnik was compiled with Cairo support and the 
+  * Ruby Cairo gem is available
+  */
+  rb_cmap.define_method("render_to_cairo_context", &render_to_cairo_context);
+#endif  
+  
+}

data/ext/ruby_mapnik/_mapnik_map.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_MAP
+#define PIKA2_MAPNIK_MAP
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_map(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_markers_symbolizer.rb.cpp

@@ -0,0 +1,139 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#include "_mapnik_markers_symbolizer.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+
+// Mapnik
+#include <mapnik/markers_symbolizer.hpp>
+
+namespace {
+  const std::string get_filename(mapnik::markers_symbolizer const& t) { 
+      return mapnik::path_processor_type::to_string(*t.get_filename()); 
+  }
+
+  void set_filename(mapnik::markers_symbolizer & t, std::string const& file_expr) { 
+      t.set_filename(mapnik::parse_path(file_expr)); 
+  }
+
+  const double get_markers_opacity(mapnik::markers_symbolizer const& t){
+    return t.get_opacity();
+  }
+
+  void set_markers_opacity(mapnik::markers_symbolizer & t, double value){
+    t.set_opacity(value);
+  }
+}
+void register_markers_symbolizer(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::markers_symbolizer > rb_cmarkers_symbolizer = Rice::define_class_under< mapnik::markers_symbolizer >(rb_mapnik, "MarkersSymbolizer");
+  
+  /*
+  * Document-method: new
+  * call-seq:
+  *  new(path_expression)
+  * @param [Mapnik::PathExpression]
+  * @return [Mapnik::MarkersSymbolizer]
+  */
+  rb_cmarkers_symbolizer.define_constructor(Rice::Constructor< mapnik::markers_symbolizer, mapnik::path_expression_ptr>());
+  
+  /*
+  * Document-method: filename
+  * @return [String]
+  */
+  rb_cmarkers_symbolizer.define_method("filename", &get_filename);
+  
+  /*
+  * Document-method: filename=
+  * call-seq:
+  *   filename=(new_filename)
+  * @param [String] filename
+  * @return [nil]
+  */
+  rb_cmarkers_symbolizer.define_method("filename=", &set_filename);
+  
+  /*
+  * Document-method: allow_overlap?
+  * @return [Boolean]
+  */
+  rb_cmarkers_symbolizer.define_method("allow_overlap?", &mapnik::markers_symbolizer::get_allow_overlap);
+  
+  /*
+  * Document-method: allow_overlap=
+  * call-seq:
+  *   allow_overlap=(new_value)
+  * @param [Boolean] new_value
+  * @return [nil]
+  */
+  rb_cmarkers_symbolizer.define_method("allow_overlap=", &mapnik::markers_symbolizer::set_allow_overlap);
+  
+  /*
+  * Document-method: spacing
+  * @return [Integer]
+  */
+  rb_cmarkers_symbolizer.define_method("spacing", &mapnik::markers_symbolizer::get_spacing);
+  
+  /*
+  * Document-method: spacing=
+  * call-seq:
+  *   spacing=(new_spacing_value)
+  * @param [Integer] new_spacing_value
+  * @return [nil]
+  */
+  rb_cmarkers_symbolizer.define_method("spacing=", &mapnik::markers_symbolizer::set_spacing);
+  
+  /*
+  * Document-method: max_error
+  * @return [Integer]
+  */
+  rb_cmarkers_symbolizer.define_method("max_error", &mapnik::markers_symbolizer::get_max_error);
+  
+  /*
+  * Document-method:max_error=
+  * call-seq: 
+  *   max_error=(new_value)
+  * @param [Integer] new_value
+  * @return [nil]
+  */
+  rb_cmarkers_symbolizer.define_method("max_error=", &mapnik::markers_symbolizer::set_max_error);
+  
+  /*
+  * Document-method: opacity
+  * @return [Float]
+  */
+  rb_cmarkers_symbolizer.define_method("opacity", &get_markers_opacity);
+  
+  /*
+  * Document-method: opacity=
+  * call-seq:
+  *   opacity=(new_value)
+  * @param [Float]
+  * @return [nil]
+  */
+  rb_cmarkers_symbolizer.define_method("opacity=", &set_markers_opacity);
+  
+}

data/ext/ruby_mapnik/_mapnik_markers_symbolizer.rb.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+Copyright (C) 2011 Elliot Laster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the ‘Software’), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+ *****************************************************************************/
+#ifndef PIKA2_MAPNIK_MARKERS_SYMBOLIZER
+#define PIKA2_MAPNIK_MARKERS_SYMBOLIZER
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_markers_symbolizer(Rice::Module rb_mapnik);
+
+#endif