ruby_mapnik 0.1

data/ext/ruby_mapnik/_mapnik_coord.rb.cpp

@@ -0,0 +1,145 @@
+/*****************************************************************************
+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_coord.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+
+// Mapnik
+#include <mapnik/coord.hpp>
+
+namespace {
+  void wrap_mapnik_coord_double__2__x_set(mapnik::coord2d* self, double val) {
+    self->x = val;
+  }
+  double wrap_mapnik_coord_double__2__x_get(mapnik::coord2d* self) {
+    return self->x;
+  }
+  void wrap_mapnik_coord_double__2__y_set(mapnik::coord2d* self, double val) {
+    self->y = val;
+  }
+  double wrap_mapnik_coord_double__2__y_get(mapnik::coord2d* self) {
+    return self->y;
+  }
+
+  mapnik::coord2d wrap_mapnik_coord_double__2__times_equals(mapnik::coord2d self, float value){
+    return self *= value;
+  }
+
+  mapnik::coord2d wrap_mapnik_coord_double__2__addition(mapnik::coord2d self, float value){
+    return self += value;
+  }
+
+  mapnik::coord2d wrap_mapnik_coord_double__2__subtraction(mapnik::coord2d self, float value){
+    return self -= value;
+  }
+
+  mapnik::coord2d wrap_mapnik_coord_double__2__division(mapnik::coord2d self, float value){
+    return self /= value;
+  }
+
+  bool wrap_mapnik_coord_double__2__equality(mapnik::coord2d self, mapnik::coord2d rhs){
+    return self == rhs;
+  }
+}
+void register_coord(Rice::Module rb_mapnik) {
+  /*
+  * @@Module_var rb_mapnik = Mapnik
+  *  
+  * Document-class: Mapnik::Coord2d
+  * A two dimensional coordinate
+  */
+  Rice::Data_Type< mapnik::coord2d > rb_ccoord2d = Rice::define_class_under< mapnik::coord2d >(rb_mapnik, "Coord2d");
+  
+  /*
+  * Document-method: new
+  * call-seq:
+  *   new(x,y)
+  * Returns a new Coord2d object
+  */
+  rb_ccoord2d.define_constructor(Rice::Constructor< mapnik::coord2d,double,double >());
+  
+  /*
+  * Document-method: x=
+  * @param [Float]
+  * Sets the x value of the coord
+  */
+  rb_ccoord2d.define_method("x=", &wrap_mapnik_coord_double__2__x_set);
+  rb_ccoord2d.define_method("x", &wrap_mapnik_coord_double__2__x_get);
+
+  /*
+  * Document-method: y=
+  * @param [Float]
+  * Sets the y value of the coord
+  */
+  rb_ccoord2d.define_method("y=", &wrap_mapnik_coord_double__2__y_set);
+  rb_ccoord2d.define_method("y", &wrap_mapnik_coord_double__2__y_get);
+  
+
+  /*
+  * Document-method: *
+  * call-seq:
+  *   * value
+  * @param [Float]
+  * Multiplies the x and y coordinates of the receiver by the value provided
+  */
+  rb_ccoord2d.define_method("*", &wrap_mapnik_coord_double__2__times_equals, (Rice::Arg("value")));
+
+  /*
+  * Document-method: ==
+  * call-seq:
+  *   ==(other_coord)
+  * @param [Mapnik::Coord2d]
+  * Returns true if the x and y values of other_coord equal those of the reciever
+  */
+  rb_ccoord2d.define_method("==", &wrap_mapnik_coord_double__2__equality, (Rice::Arg("rhs")));
+
+  /*
+  * Document-method: +=
+  * call-seq:
+  *   + value 
+  * @param [Float]
+  * Adds the x and y coordinates of the receiver by the value provided
+  */
+  rb_ccoord2d.define_method("+", &wrap_mapnik_coord_double__2__addition, (Rice::Arg("value")));
+  
+  /*
+  * Document-method: -=
+  * call-seq:
+  *   - value 
+  * @param [Float]
+  * Subtracts the x and y coordinates of the receiver by the value provided
+  */
+  rb_ccoord2d.define_method("-", &wrap_mapnik_coord_double__2__subtraction, (Rice::Arg("value")));
+  
+  /*
+  * Document-method: /=
+  * call-seq:
+  *   /=(value)
+  * @param [Float]
+  * Divides the x and y coordinates of the receiver by the value provided
+  */
+  rb_ccoord2d.define_method("/", &wrap_mapnik_coord_double__2__division, (Rice::Arg("value")));
+
+}

data/ext/ruby_mapnik/_mapnik_coord.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_COORD
+#define PIKA2_MAPNIK_COORD
+
+namespace Rice
+{
+  class Module; 
+}
+
+void register_coord(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_datasource.rb.cpp

@@ -0,0 +1,150 @@
+/*****************************************************************************
+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_datasource.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/layer.hpp>
+#include <mapnik/datasource.hpp>
+#include <mapnik/datasource_cache.hpp>
+#include <mapnik/feature_layer_desc.hpp>
+#include <mapnik/box2d.hpp>
+
+namespace {
+  class mapnik_value_holder_to_ruby_visitor : public boost::static_visitor<Rice::Object>
+  {
+  public:
+
+   Rice::Object operator()(int i) const {
+     return to_ruby<int>(i);
+   }
+
+   Rice::Object operator()(double i) const {
+     return to_ruby<double>(i);
+   }
+
+   Rice::Object operator()(const std::string & str) const {
+     return to_ruby<std::string>(str);
+   }
+  };
+
+
+  std::string name(boost::shared_ptr<mapnik::datasource> self){
+    mapnik::layer_descriptor ld = self->get_descriptor();
+    return ld.get_name();
+  }
+
+  boost::shared_ptr<mapnik::datasource> create(Rice::Object params){
+    bool bind=true;
+    Rice::Hash options = (Rice::Hash) params;
+    mapnik::parameters datasource_params;
+
+    Rice::Hash::iterator it = options.begin();
+    Rice::Hash::iterator end = options.end();
+    for(; it != end; ++it) {
+      Rice::String keyString = it->key.to_s();
+      Rice::Object value = it->value;
+      switch (value.rb_type()) {
+        case T_STRING:
+          datasource_params[keyString.str()] = ((Rice::String) value).str();
+          break;
+        case T_FLOAT:
+          datasource_params[keyString.str()] = NUM2DBL(value.value());
+          break;
+        case T_FIXNUM:
+          // The compiler wanted this explicit cast here, not sure why...
+          datasource_params[keyString.str()] = (int)NUM2INT(value.value());
+          break;
+      }
+    }
+    
+    return mapnik::datasource_cache::create(datasource_params, bind);
+  }
+
+
+  mapnik::box2d<double> get_datasource_envelope(boost::shared_ptr<mapnik::datasource> self){
+    return self->envelope();
+  }
+
+  Rice::Object get_datasource_params(boost::shared_ptr<mapnik::datasource> const & self){
+    Rice::Hash params;
+    mapnik::parameters ds_params = self->params();
+    mapnik::parameters::const_iterator pos=ds_params.begin();
+    while(pos!=ds_params.end())
+    {
+      params[Rice::Symbol(pos->first)] = boost::apply_visitor(mapnik_value_holder_to_ruby_visitor(), pos->second);
+      ++pos;
+    }
+    return params;
+  }
+}
+void register_datasource(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< boost::shared_ptr<mapnik::datasource> > rb_cdatasource = Rice::define_class_under< boost::shared_ptr<mapnik::datasource> >(rb_mapnik, "Datasource");
+  
+  /*
+  * Document-method: envelope
+  * @return [Mapnik::Envelope]
+  * Returns an envelope containing the datasource's features
+  */
+  rb_cdatasource.define_method("envelope", &get_datasource_envelope);
+
+  /*
+  * Document-method: name
+  * @return [String]
+  * The name of the datasource
+  */
+  rb_cdatasource.define_method("name", &name);
+
+  /*
+  * Document-method: params
+  * @return [Hash]
+  * The params used to create the datasource
+  */
+  rb_cdatasource.define_method("params", &get_datasource_params);
+
+  /*
+  * Document-method: create
+  * call-seq:
+  *   Mapnik::Datasource.create(params)
+  * 
+  * @param [Hash] the parameters for the datasource
+  *
+  * Creates a new datasource, with the params provided. The parameters required
+  * will depend on the input plugin
+  *
+  * -- TODO: more
+  */
+  rb_cdatasource.define_singleton_method("create", &create, (Rice::Arg("params")));
+  
+  // TODO: Descriptor, features at point...
+  // rb_cdatasource.define_method("descriptor", &mapnik::datasource::get_descriptor);
+  
+}

data/ext/ruby_mapnik/_mapnik_datasource.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_DATASOURCE
+#define PIKA2_MAPNIK_DATASOURCE
+
+namespace Rice
+{
+  class Module; 
+}
+
+void register_datasource(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_datasource_cache.rb.cpp

@@ -0,0 +1,79 @@
+/*****************************************************************************
+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_datasource_cache.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+#include <rice/Array.hpp>
+#include <rice/Hash.hpp>
+
+// Mapnik
+#include <mapnik/datasource.hpp>
+#include <mapnik/datasource_cache.hpp>
+
+namespace {
+  bool rubysafe_register_sources(std::string path){
+    mapnik::datasource_cache::instance()->register_datasources(path);
+    return true;
+  }
+
+  Rice::Array rubysafe_plugin_names(){
+    std::vector<std::string, std::allocator<std::string> > names = mapnik::datasource_cache::instance()->plugin_names();
+
+    Rice::Array o;
+
+    int unsigned count = names.size();
+    
+    for (unsigned i=0;i<count;++i){
+      Rice::String n = names[i];
+      o.push(n);
+    }
+    
+    return o;
+  }
+}
+void register_datasource_cache(Rice::Module rb_mapnik) {
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::datasource_cache > rb_cdatasource_cache =  Rice::define_class_under< mapnik::datasource_cache >(rb_mapnik, "DatasourceCache");
+  
+  /*
+  * Document-method: available_plugins
+  *
+  * @return [Array] the datasource plugins available. (Determined by your Mapnik install)
+  */
+  rb_cdatasource_cache.define_singleton_method("available_plugins", &rubysafe_plugin_names);  
+  
+  /*
+  * Document-method: register
+  * call-seq:
+  *   Mapnik::DatasourceCache.register(path_to_mapnik_input_plugins)
+  * @param [String] The path
+  * 
+  * Registers the input plugins with mapnik. Used internally by Ruby-Mapnik. 
+  * You should never have to call this. 
+  */
+  rb_cdatasource_cache.define_singleton_method("register", &rubysafe_register_sources, Rice::Arg("path"));
+}

data/ext/ruby_mapnik/_mapnik_datasource_cache.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_DATASOURCE_CACHE
+#define PIKA2_MAPNIK_DATASOURCE_CACHE
+
+namespace Rice
+{
+ class Module; 
+}
+
+void register_datasource_cache(Rice::Module rb_mapnik);
+
+#endif

data/ext/ruby_mapnik/_mapnik_envelope.rb.cpp

@@ -0,0 +1,220 @@
+/*****************************************************************************
+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_envelope.rb.h"
+
+// Rice
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Class.hpp>
+
+// Mapnik
+#include <mapnik/box2d.hpp>
+
+namespace {
+  // Height
+  typedef double ( mapnik::box2d<double>::*height_func_type )() const;
+  typedef void ( mapnik::box2d<double>::*set_height_func_type )(double h);
+
+  // Width
+  typedef double ( mapnik::box2d<double>::*width_func_type )() const;
+  typedef void ( mapnik::box2d<double>::*set_width_func_type )(double w);
+
+  // Re-center
+  typedef void ( mapnik::box2d<double>::*re_center_func_type )( double x, double y );
+  typedef void ( mapnik::box2d<double>::*re_center_func_type_coord )( const mapnik::coord2d& other );
+
+  // Contains
+  typedef bool (mapnik::box2d<double>::*contains_xy_func_type)(double x,double y) const;
+  typedef bool (mapnik::box2d<double>::*contains_coord_func_type)(const mapnik::coord2d &c) const;
+  typedef bool (mapnik::box2d<double>::*contains_envelope_func_type)(const mapnik::box2d<double> &other) const;
+
+  // Intersects
+  typedef bool (mapnik::box2d<double>::*intersects_xy_func_type)(double x,double y) const;
+  typedef bool (mapnik::box2d<double>::*intersects_coord_func_type)(const mapnik::coord2d &c) const;
+  typedef bool (mapnik::box2d<double>::*intersects_envelope_func_type)(const mapnik::box2d<double> &other) const;
+
+  // Expand to include
+  typedef void ( mapnik::box2d<double>::*expand_to_include_xy_func_type )( double x, double y );
+  typedef void ( mapnik::box2d<double>::*expand_to_include_coord_func_type )( const mapnik::coord2d& c );
+  typedef void ( mapnik::box2d<double>::*expand_to_include_envelope_func_type )( const mapnik::box2d<double>& other );
+
+  bool wrap_mapnik_box2d_double__2__equality(mapnik::box2d<double> self, mapnik::box2d<double> rhs){
+    return self == rhs;
+  }
+}
+void register_envelope(Rice::Module rb_mapnik){
+  /*
+    @@Module_var rb_mapnik = Mapnik
+  */
+  Rice::Data_Type< mapnik::box2d<double> > rb_cenvelope = Rice::define_class_under< mapnik::box2d<double> >(rb_mapnik, "Envelope");
+  
+  /*
+  * Document-method: new
+  * call-seq:
+  *   new(min_x, min_y, max_x, max_y)
+  * 
+  * @param [Float] min_x
+  * @param [Float] min_y
+  * @param [Float] max_x
+  * @param [Float] max_y
+  *
+  * Returns a new Mapnik::Envelope
+  */
+  rb_cenvelope.define_constructor(Rice::Constructor< mapnik::box2d<double>,double,double,double,double >());
+  
+  /*
+  * Document-method: min_x
+  * @return [Float]
+  */
+  rb_cenvelope.define_method("min_x", &mapnik::box2d<double>::minx);
+  
+  /*
+  * Document-method: min_y
+  * @return [Float]
+  */
+  rb_cenvelope.define_method("min_y", &mapnik::box2d<double>::miny);
+  
+  /*
+  * Document-method: max_x
+  * @return [Float]
+  */
+  rb_cenvelope.define_method("max_x", &mapnik::box2d<double>::maxx);
+  
+  /*
+  * Document-method: max_y
+  * @return [Float]
+  */
+  rb_cenvelope.define_method("max_y", &mapnik::box2d<double>::maxy);
+
+  /*
+  * Document-method: center
+  * @return [Mapnik::Coord2d] the center of the envelope.
+  */
+  rb_cenvelope.define_method("center", &mapnik::box2d<double>::center);
+
+  /*
+  * Dont-Document-method: re_center_to_xy!
+  */
+  rb_cenvelope.define_method("re_center_to_xy!", re_center_func_type( &mapnik::box2d<double>::re_center ), (Rice::Arg("x"), Rice::Arg("y")));
+  
+  /*
+  * Dont-Document-method: re_center_to_coord!
+  */
+  rb_cenvelope.define_method("re_center_to_coord!", re_center_func_type_coord( &mapnik::box2d<double>::re_center ), (Rice::Arg("other")));
+
+
+  rb_cenvelope.define_method("height", height_func_type( &mapnik::box2d<double>::height ));
+  rb_cenvelope.define_method("height=", set_height_func_type( &mapnik::box2d<double>::height ), (Rice::Arg("h")));
+  
+  rb_cenvelope.define_method("width", height_func_type( &mapnik::box2d<double>::width ));
+  rb_cenvelope.define_method("width=", set_height_func_type( &mapnik::box2d<double>::width ), (Rice::Arg("w")));
+  
+  /*
+  * Dont-Document-method: contains_xy?
+  */
+  rb_cenvelope.define_method("contains_xy?", contains_xy_func_type( &mapnik::box2d<double>::contains ), (Rice::Arg("x"), Rice::Arg("y")));
+  
+  /*
+  * Dont-Document-method: contains_coord?
+  */
+  rb_cenvelope.define_method("contains_coord?", contains_coord_func_type( &mapnik::box2d<double>::contains ), (Rice::Arg("c")));
+  
+  /*
+  * Dont-Document-method: contains_envelope?
+  */
+  rb_cenvelope.define_method("contains_envelope?", contains_envelope_func_type( &mapnik::box2d<double>::contains ), (Rice::Arg("other")));
+  
+  /*
+  * Dont-Document-method: intersects_xy?
+  */
+  rb_cenvelope.define_method("intersects_xy?", intersects_xy_func_type( &mapnik::box2d<double>::intersects ), (Rice::Arg("x"), Rice::Arg("y")));
+  
+  /*
+  * Dont-Document-method: intersects_coord?
+  */
+  rb_cenvelope.define_method("intersects_coord?", intersects_coord_func_type( &mapnik::box2d<double>::intersects ), (Rice::Arg("c")));
+  
+  /*
+  * Dont-Document-method: intersects_envelope?
+  */
+  rb_cenvelope.define_method("intersects_envelope?", intersects_envelope_func_type( &mapnik::box2d<double>::intersects ), (Rice::Arg("other")));  
+  
+  /*
+  * Dont-Document-method: expand_to_include_xy!
+  */
+  rb_cenvelope.define_method("expand_to_include_xy!", expand_to_include_xy_func_type( &mapnik::box2d<double>::expand_to_include ), (Rice::Arg("x"), Rice::Arg("y")));
+  
+  /*
+  * Dont-Document-method: expand_to_include_coord!
+  */
+  rb_cenvelope.define_method("expand_to_include_coord!", expand_to_include_coord_func_type( &mapnik::box2d<double>::expand_to_include ), (Rice::Arg("c")));
+  
+  /*
+  * Dont-Document-method: expand_to_include_envelope!
+  */
+  rb_cenvelope.define_method("expand_to_include_envelope!", expand_to_include_envelope_func_type( &mapnik::box2d<double>::expand_to_include ), (Rice::Arg("other")));
+  
+  /*
+  * Document-method: intersection
+  * call-seq:
+  *  intersection(other_envelope)
+  *
+  * @param [Mapnik::Envelope] the other envelope
+  *
+  * Returns a new envelope that is the intersection of another envelope and
+  * the reciever.
+  *
+  * @return [Mapnik::Envelope]
+  */
+  rb_cenvelope.define_method("intersection", &mapnik::box2d<double>::intersect, Rice::Arg("other"));
+  
+  /*
+  * Document-method: clip!
+  * call-seq:
+  *  clip!(other_envelope)
+  *
+  * @param [Mapnik::Envelope] the other envelope
+  *
+  * Clips the reciever by another other envelope
+  * @return [nil]
+  */
+  rb_cenvelope.define_method("clip!", &mapnik::box2d<double>::clip, Rice::Arg("other"));
+  
+  /*
+  * Document-method: valid?
+  * Returns true if the envelope is sound.
+  * @return [Boolean]
+  */
+  rb_cenvelope.define_method("valid?", &mapnik::box2d<double>::valid);
+  
+  /*
+  * Document-method: ==
+  * call-seq:
+  *  ==(other_envelope)
+  *
+  * Returns true if the other envelope's coordinates match the reciever's
+  *
+  * @return [Boolean]
+  */
+  rb_cenvelope.define_method("==", &wrap_mapnik_box2d_double__2__equality, (Rice::Arg("rhs")));
+  
+}