rgeo 0.3.13 → 0.3.14

data/History.rdoc

@@ -1,3 +1,11 @@
+=== 0.3.14 / 2012-07-08
+
+* Compatibility note: The class names for some of the factory and feature implementations, as well as the superclass relationships, have changed in this release. These class names and hierarchy are internal, and clients should not depend on them. That is, RGeo types are generally duck-types. If you need to interrogate type, see the documentation for the ::RGeo::Feature::Type module.
+* The gemspec no longer includes the timestamp in the version, so that bundler can pull from github. (Reported by corneverbruggen)
+* Mixins were not being added to GEOS features with both Z and M coordinate. Fixed.
+* Mixins are added last to feature objects, so they should override anything added by other modules such as Enumerable. (Reported by Ben Hughes)
+* Some object hashes were not consistent with equality. Fixed. Hashes should now be consistent with representational equivalence (i.e. the eql? method). Therefore, it should now be possible to use RGeo factories and features as hash keys.
+
 === 0.3.13 / 2012-05-04
 
 * The spherical factory and the simple cartesian factory now support buffers around points (but not around other types). Accordingly, those factories now take the :buffer_resolution property argument.

data/README.rdoc

@@ -100,10 +100,10 @@ The RGeo suite of tools is evolving rapidly. The current to-do list for
 the core library includes:
 
 * Better error handling and reporting.
-* JRuby support for Proj4
+* JRuby support for Proj4.
+* GDAL integration including coordinate system interpretation.
 * Ellipsoidal geography implementation, possibly utilizing geographiclib.
 * Windows build support.
-* GDAL integration including coordinate system interpretation.
 
 Each of the current add-on modules also has its own feature roadmap, and
 we are planning on introducing more add-on modules, including:
@@ -111,12 +111,12 @@ we are planning on introducing more add-on modules, including:
 * Raster support via GDAL.
 * GeoRSS and KML format support.
 * Custom spatial indexes.
-* Possible additional ActiveRecord adapters (esp. JDBC adapters)
+* Possible additional ActiveRecord adapters (esp. JDBC-based adapters).
 * Integration with third-party APIs.
 
 === Development and support
 
-Documentation is available at http://virtuoso.rubyforge.org/rgeo/README_rdoc.html
+Documentation is available at http://dazuma.github.com/rgeo/rdoc
 
 Source code is hosted on Github at http://github.com/dazuma/rgeo
 

data/Version

@@ -1 +1 @@
-0.3.13
+0.3.14

data/ext/geos_c_impl/extconf.rb

@@ -79,6 +79,7 @@ else
     have_func('GEOSPreparedContains_r', 'geos_c.h')
     have_func('GEOSPreparedDisjoint_r', 'geos_c.h')
     have_func('GEOSWKTWriter_setOutputDimension_r', 'geos_c.h')
+    have_func('rb_memhash', 'ruby.h')
   end
   unless found_geos_
     puts "**** WARNING: Unable to find GEOS headers or GEOS version is too old."

data/ext/geos_c_impl/factory.c

@@ -577,6 +577,12 @@ static VALUE method_get_wkb_parser(VALUE self)
 }
 
 
+static VALUE alloc_geometry(VALUE klass)
+{
+  return rgeo_wrap_geos_geometry(Qnil, NULL, klass);
+}
+
+
 /**** INITIALIZATION FUNCTION ****/
 
 
@@ -586,17 +592,32 @@ RGeo_Globals* rgeo_init_geos_factory()
   VALUE rgeo_module;
   VALUE geos_factory_class;
   VALUE wrapped_globals;
+  VALUE feature_module;
 
   globals = ALLOC(RGeo_Globals);
+
+  // Cache some modules so we don't have to look them up by name every time
   rgeo_module = rb_define_module("RGeo");
+  feature_module = rb_define_module_under(rgeo_module, "Feature");
+  globals->feature_module = feature_module;
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
-  globals->feature_module = rb_define_module_under(rgeo_module, "Feature");
-  globals->global_mixins = rb_const_get_at(rb_const_get_at(globals->feature_module, rb_intern("MixinCollection")), rb_intern("GLOBAL"));
-
+  globals->feature_geometry = rb_const_get_at(feature_module, rb_intern("Geometry"));
+  globals->feature_point = rb_const_get_at(feature_module, rb_intern("Point"));
+  globals->feature_line_string = rb_const_get_at(feature_module, rb_intern("LineString"));
+  globals->feature_linear_ring = rb_const_get_at(feature_module, rb_intern("LinearRing"));
+  globals->feature_line = rb_const_get_at(feature_module, rb_intern("Line"));
+  globals->feature_polygon = rb_const_get_at(feature_module, rb_intern("Polygon"));
+  globals->feature_geometry_collection = rb_const_get_at(feature_module, rb_intern("GeometryCollection"));
+  globals->feature_multi_point = rb_const_get_at(feature_module, rb_intern("MultiPoint"));
+  globals->feature_multi_line_string = rb_const_get_at(feature_module, rb_intern("MultiLineString"));
+  globals->feature_multi_polygon = rb_const_get_at(feature_module, rb_intern("MultiPolygon"));
+
+  // Cache some commonly used names
   globals->id_cast = rb_intern("cast");
   globals->id_eql = rb_intern("eql?");
   globals->id_generate = rb_intern("generate");
   globals->id_enum_for = rb_intern("enum_for");
+  globals->id_hash = rb_intern("hash");
   globals->sym_force_new = ID2SYM(rb_intern("force_new"));
   globals->sym_keep_subtype = ID2SYM(rb_intern("keep_subtype"));
 #ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
@@ -604,9 +625,8 @@ RGeo_Globals* rgeo_init_geos_factory()
   globals->marshal_wkb_generator = Qnil;
 #endif
 
-
   // Add C methods to the factory.
-  geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
+  geos_factory_class = rb_define_class_under(globals->geos_module, "CAPIFactory", rb_cObject);
   rb_define_alloc_func(geos_factory_class, alloc_factory);
   rb_define_method(geos_factory_class, "initialize_copy", method_factory_initialize_copy, 1);
   rb_define_method(geos_factory_class, "_parse_wkt_impl", method_factory_parse_wkt, 1);
@@ -627,6 +647,28 @@ RGeo_Globals* rgeo_init_geos_factory()
   rb_define_method(geos_factory_class, "_write_for_psych", method_factory_write_for_psych, 1);
   rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 7);
 
+  // Pre-define implementation classes and set up allocation methods
+  globals->geos_geometry = rb_define_class_under(globals->geos_module, "CAPIGeometryImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_geometry, alloc_geometry);
+  globals->geos_point = rb_define_class_under(globals->geos_module, "CAPIPointImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_point, alloc_geometry);
+  globals->geos_line_string = rb_define_class_under(globals->geos_module, "CAPILineStringImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_line_string, alloc_geometry);
+  globals->geos_linear_ring = rb_define_class_under(globals->geos_module, "CAPILinearRingImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_linear_ring, alloc_geometry);
+  globals->geos_line = rb_define_class_under(globals->geos_module, "CAPILineImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_line, alloc_geometry);
+  globals->geos_polygon = rb_define_class_under(globals->geos_module, "CAPIPolygonImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_polygon, alloc_geometry);
+  globals->geos_geometry_collection = rb_define_class_under(globals->geos_module, "CAPIGeometryCollectionImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_geometry_collection, alloc_geometry);
+  globals->geos_multi_point = rb_define_class_under(globals->geos_module, "CAPIMultiPointImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_multi_point, alloc_geometry);
+  globals->geos_multi_line_string = rb_define_class_under(globals->geos_module, "CAPIMultiLineStringImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_multi_line_string, alloc_geometry);
+  globals->geos_multi_polygon = rb_define_class_under(globals->geos_module, "CAPIMultiPolygonImpl", rb_cObject);
+  rb_define_alloc_func(globals->geos_multi_polygon, alloc_geometry);
+
   // Wrap the globals in a Ruby object and store it off so we have access
   // to it later. Each factory instance will reference it internally.
   wrapped_globals = Data_Wrap_Struct(rb_cObject, mark_globals_func, destroy_globals_func, globals);
@@ -891,6 +933,77 @@ VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2)
 }
 
 
+typedef struct {
+  st_index_t seed_hash;
+  double x;
+  double y;
+  double z;
+} RGeo_Coordseq_Hash_Struct;
+
+st_index_t rgeo_geos_coordseq_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
+{
+  const GEOSCoordSequence* cs;
+  unsigned int len;
+  unsigned int i;
+  RGeo_Coordseq_Hash_Struct hash_struct;
+
+  if (geom) {
+    cs = GEOSGeom_getCoordSeq_r(context, geom);
+    if (cs) {
+      if (GEOSCoordSeq_getSize_r(context, cs, &len)) {
+        for (i=0; i<len; ++i) {
+          if (GEOSCoordSeq_getX_r(context, cs, i, &hash_struct.x)) {
+            if (GEOSCoordSeq_getY_r(context, cs, i, &hash_struct.y)) {
+              if (!GEOSCoordSeq_getY_r(context, cs, i, &hash_struct.z)) {
+                hash_struct.z = 0;
+              }
+              hash_struct.seed_hash = hash;
+              hash = rb_memhash(&hash_struct, sizeof(RGeo_Coordseq_Hash_Struct));
+            }
+          }
+        }
+      }
+    }
+  }
+  return hash;
+}
+
+
+typedef struct {
+  st_index_t seed_hash;
+  st_index_t h1;
+  st_index_t h2;
+} RGeo_Objbase_Hash_Struct;
+
+st_index_t rgeo_geos_objbase_hash(VALUE factory, VALUE type_module, st_index_t hash)
+{
+  ID hash_method;
+  RGeo_Objbase_Hash_Struct hash_struct;
+
+  hash_method = RGEO_FACTORY_DATA_PTR(factory)->globals->id_hash;
+  hash_struct.seed_hash = hash;
+  hash_struct.h1 = FIX2LONG(rb_funcall(factory, hash_method, 0));
+  hash_struct.h2 = FIX2LONG(rb_funcall(type_module, hash_method, 0));
+  return rb_memhash(&hash_struct, sizeof(RGeo_Objbase_Hash_Struct));
+}
+
+
+st_index_t rgeo_internal_memhash(const void* ptr, long len)
+{
+  const char* bytes;
+  st_index_t hval;
+  long i;
+
+  bytes = (const char*)ptr;
+  hval = 0x811c9dc5;
+  for (i=0; i<len; ++i) {
+    hval ^= (unsigned int)(*bytes++);
+    hval *= 0x01000193;
+  }
+  return hval;
+}
+
+
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/factory.h

@@ -52,7 +52,6 @@ RGEO_BEGIN_C
 */
 typedef struct {
   VALUE feature_module;
-  VALUE global_mixins;
   VALUE feature_geometry;
   VALUE feature_point;
   VALUE feature_line_string;
@@ -78,6 +77,7 @@ typedef struct {
   ID id_eql;
   ID id_generate;
   ID id_enum_for;
+  ID id_hash;
   VALUE sym_force_new;
   VALUE sym_keep_subtype;
 #ifndef RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
@@ -242,6 +242,29 @@ VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* g
 */
 VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2);
 
+/*
+  A tool for building up hash values.
+  You must pass in the context, a geos geometry, and a seed hash.
+  Returns an updated hash.
+  This call is useful in sequence, and should be bracketed by calls to
+  rb_hash_start and rb_hash_end.
+*/
+st_index_t rgeo_geos_coordseq_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
+
+/*
+  A tool for building up hash values.
+  You must pass in a factory, a feature type module, and a seed hash.
+  Returns an updated hash.
+  This call is useful in sequence, and should be bracketed by calls to
+  rb_hash_start and rb_hash_end.
+*/
+st_index_t rgeo_geos_objbase_hash(VALUE factory, VALUE type_module, st_index_t hash);
+
+/*
+  Internal tool for creating simple (FNV-1A 32 bit) hashes.
+*/
+st_index_t rgeo_internal_memhash(const void* ptr, long len);
+
 
 RGEO_END_C
 

data/ext/geos_c_impl/geometry.c

@@ -885,12 +885,6 @@ static VALUE method_geometry_sym_difference(VALUE self, VALUE rhs)
 }
 
 
-static VALUE alloc_geometry(VALUE klass)
-{
-  return rgeo_wrap_geos_geometry(Qnil, NULL, klass);
-}
-
-
 static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
 {
   RGeo_GeometryData* self_data;
@@ -980,53 +974,48 @@ static VALUE method_geometry_steal(VALUE self, VALUE orig)
 
 void rgeo_init_geos_geometry(RGeo_Globals* globals)
 {
-  VALUE geos_geometry_class;
-
-  geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
-  globals->geos_geometry = geos_geometry_class;
-  globals->feature_geometry = rb_const_get_at(globals->feature_module, rb_intern("Geometry"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_geometry, geos_geometry_class);
-
-  rb_define_alloc_func(geos_geometry_class, alloc_geometry);
-  rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);
-  rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
-  rb_define_method(geos_geometry_class, "_steal", method_geometry_steal, 1);
-  rb_define_method(geos_geometry_class, "initialized?", method_geometry_initialized_p, 0);
-  rb_define_method(geos_geometry_class, "factory", method_geometry_factory, 0);
-  rb_define_method(geos_geometry_class, "prepared?", method_geometry_prepared_p, 0);
-  rb_define_method(geos_geometry_class, "prepare!", method_geometry_prepare, 0);
-  rb_define_method(geos_geometry_class, "dimension", method_geometry_dimension, 0);
-  rb_define_method(geos_geometry_class, "geometry_type", method_geometry_geometry_type, 0);
-  rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);
-  rb_define_method(geos_geometry_class, "envelope", method_geometry_envelope, 0);
-  rb_define_method(geos_geometry_class, "boundary", method_geometry_boundary, 0);
-  rb_define_method(geos_geometry_class, "_as_text", method_geometry_as_text, 0);
-  rb_define_method(geos_geometry_class, "as_binary", method_geometry_as_binary, 0);
-  rb_define_method(geos_geometry_class, "is_empty?", method_geometry_is_empty, 0);
-  rb_define_method(geos_geometry_class, "is_simple?", method_geometry_is_simple, 0);
-  rb_define_method(geos_geometry_class, "equals?", method_geometry_equals, 1);
-  rb_define_method(geos_geometry_class, "==", method_geometry_equals, 1);
-  rb_define_method(geos_geometry_class, "rep_equals?", method_geometry_eql, 1);
-  rb_define_method(geos_geometry_class, "eql?", method_geometry_eql, 1);
-  rb_define_method(geos_geometry_class, "disjoint?", method_geometry_disjoint, 1);
-  rb_define_method(geos_geometry_class, "intersects?", method_geometry_intersects, 1);
-  rb_define_method(geos_geometry_class, "touches?", method_geometry_touches, 1);
-  rb_define_method(geos_geometry_class, "crosses?", method_geometry_crosses, 1);
-  rb_define_method(geos_geometry_class, "within?", method_geometry_within, 1);
-  rb_define_method(geos_geometry_class, "contains?", method_geometry_contains, 1);
-  rb_define_method(geos_geometry_class, "overlaps?", method_geometry_overlaps, 1);
-  rb_define_method(geos_geometry_class, "relate?", method_geometry_relate, 2);
-  rb_define_method(geos_geometry_class, "distance", method_geometry_distance, 1);
-  rb_define_method(geos_geometry_class, "buffer", method_geometry_buffer, 1);
-  rb_define_method(geos_geometry_class, "convex_hull", method_geometry_convex_hull, 0);
-  rb_define_method(geos_geometry_class, "intersection", method_geometry_intersection, 1);
-  rb_define_method(geos_geometry_class, "*", method_geometry_intersection, 1);
-  rb_define_method(geos_geometry_class, "union", method_geometry_union, 1);
-  rb_define_method(geos_geometry_class, "+", method_geometry_union, 1);
-  rb_define_method(geos_geometry_class, "difference", method_geometry_difference, 1);
-  rb_define_method(geos_geometry_class, "-", method_geometry_difference, 1);
-  rb_define_method(geos_geometry_class, "sym_difference", method_geometry_sym_difference, 1);
+  VALUE geos_geometry_methods;
+
+  geos_geometry_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryMethods");
+
+  rb_define_method(geos_geometry_methods, "_set_factory", method_geometry_set_factory, 1);
+  rb_define_method(geos_geometry_methods, "initialize_copy", method_geometry_initialize_copy, 1);
+  rb_define_method(geos_geometry_methods, "_steal", method_geometry_steal, 1);
+  rb_define_method(geos_geometry_methods, "initialized?", method_geometry_initialized_p, 0);
+  rb_define_method(geos_geometry_methods, "factory", method_geometry_factory, 0);
+  rb_define_method(geos_geometry_methods, "prepared?", method_geometry_prepared_p, 0);
+  rb_define_method(geos_geometry_methods, "prepare!", method_geometry_prepare, 0);
+  rb_define_method(geos_geometry_methods, "dimension", method_geometry_dimension, 0);
+  rb_define_method(geos_geometry_methods, "geometry_type", method_geometry_geometry_type, 0);
+  rb_define_method(geos_geometry_methods, "srid", method_geometry_srid, 0);
+  rb_define_method(geos_geometry_methods, "envelope", method_geometry_envelope, 0);
+  rb_define_method(geos_geometry_methods, "boundary", method_geometry_boundary, 0);
+  rb_define_method(geos_geometry_methods, "_as_text", method_geometry_as_text, 0);
+  rb_define_method(geos_geometry_methods, "as_binary", method_geometry_as_binary, 0);
+  rb_define_method(geos_geometry_methods, "is_empty?", method_geometry_is_empty, 0);
+  rb_define_method(geos_geometry_methods, "is_simple?", method_geometry_is_simple, 0);
+  rb_define_method(geos_geometry_methods, "equals?", method_geometry_equals, 1);
+  rb_define_method(geos_geometry_methods, "==", method_geometry_equals, 1);
+  rb_define_method(geos_geometry_methods, "rep_equals?", method_geometry_eql, 1);
+  rb_define_method(geos_geometry_methods, "eql?", method_geometry_eql, 1);
+  rb_define_method(geos_geometry_methods, "disjoint?", method_geometry_disjoint, 1);
+  rb_define_method(geos_geometry_methods, "intersects?", method_geometry_intersects, 1);
+  rb_define_method(geos_geometry_methods, "touches?", method_geometry_touches, 1);
+  rb_define_method(geos_geometry_methods, "crosses?", method_geometry_crosses, 1);
+  rb_define_method(geos_geometry_methods, "within?", method_geometry_within, 1);
+  rb_define_method(geos_geometry_methods, "contains?", method_geometry_contains, 1);
+  rb_define_method(geos_geometry_methods, "overlaps?", method_geometry_overlaps, 1);
+  rb_define_method(geos_geometry_methods, "relate?", method_geometry_relate, 2);
+  rb_define_method(geos_geometry_methods, "distance", method_geometry_distance, 1);
+  rb_define_method(geos_geometry_methods, "buffer", method_geometry_buffer, 1);
+  rb_define_method(geos_geometry_methods, "convex_hull", method_geometry_convex_hull, 0);
+  rb_define_method(geos_geometry_methods, "intersection", method_geometry_intersection, 1);
+  rb_define_method(geos_geometry_methods, "*", method_geometry_intersection, 1);
+  rb_define_method(geos_geometry_methods, "union", method_geometry_union, 1);
+  rb_define_method(geos_geometry_methods, "+", method_geometry_union, 1);
+  rb_define_method(geos_geometry_methods, "difference", method_geometry_difference, 1);
+  rb_define_method(geos_geometry_methods, "-", method_geometry_difference, 1);
+  rb_define_method(geos_geometry_methods, "sym_difference", method_geometry_sym_difference, 1);
 }
 
 

data/ext/geos_c_impl/geometry_collection.c

@@ -177,6 +177,22 @@ static VALUE method_geometry_collection_eql(VALUE self, VALUE rhs)
 }
 
 
+static VALUE method_geometry_collection_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  hash = rb_hash_start(0);
+  hash = rgeo_geos_objbase_hash(factory,
+    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_geometry_collection, hash);
+  hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE method_geometry_collection_geometry_type(VALUE self)
 {
   VALUE result;
@@ -301,6 +317,22 @@ static VALUE method_multi_point_geometry_type(VALUE self)
 }
 
 
+static VALUE method_multi_point_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  hash = rb_hash_start(0);
+  hash = rgeo_geos_objbase_hash(factory,
+    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_point, hash);
+  hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE method_multi_line_string_geometry_type(VALUE self)
 {
   VALUE result;
@@ -315,6 +347,22 @@ static VALUE method_multi_line_string_geometry_type(VALUE self)
 }
 
 
+static VALUE method_multi_line_string_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  hash = rb_hash_start(0);
+  hash = rgeo_geos_objbase_hash(factory,
+    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_line_string, hash);
+  hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE method_multi_line_string_length(VALUE self)
 {
   VALUE result;
@@ -381,6 +429,22 @@ static VALUE method_multi_polygon_geometry_type(VALUE self)
 }
 
 
+static VALUE method_multi_polygon_hash(VALUE self)
+{
+  st_index_t hash;
+  RGeo_GeometryData* self_data;
+  VALUE factory;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  hash = rb_hash_start(0);
+  hash = rgeo_geos_objbase_hash(factory,
+    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_multi_polygon, hash);
+  hash = rgeo_geos_geometry_collection_hash(self_data->geos_context, self_data->geom, hash);
+  return LONG2FIX(rb_hash_end(hash));
+}
+
+
 static VALUE method_multi_polygon_area(VALUE self)
 {
   VALUE result;
@@ -461,68 +525,48 @@ static VALUE cmethod_multi_polygon_create(VALUE module, VALUE factory, VALUE arr
 
 void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
 {
-  VALUE geos_geometry_collection_class;
-  VALUE geos_multi_point_class;
-  VALUE geos_multi_line_string_class;
-  VALUE geos_multi_polygon_class;
-
-  // Create implementation classes
-  geos_geometry_collection_class = rb_define_class_under(globals->geos_module, "GeometryCollectionImpl", globals->geos_geometry);
-  globals->geos_geometry_collection = geos_geometry_collection_class;
-  globals->feature_geometry_collection = rb_const_get_at(globals->feature_module, rb_intern("GeometryCollection"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_geometry_collection, geos_geometry_collection_class);
-
-  geos_multi_point_class = rb_define_class_under(globals->geos_module, "MultiPointImpl", geos_geometry_collection_class);
-  globals->geos_multi_point = geos_multi_point_class;
-  globals->feature_multi_point = rb_const_get_at(globals->feature_module, rb_intern("MultiPoint"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_multi_point, geos_multi_point_class);
-
-  geos_multi_line_string_class = rb_define_class_under(globals->geos_module, "MultiLineStringImpl", geos_geometry_collection_class);
-  globals->geos_multi_line_string = geos_multi_line_string_class;
-  globals->feature_multi_line_string = rb_const_get_at(globals->feature_module, rb_intern("MultiLineString"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    rb_const_get_at(globals->feature_module, rb_intern("MultiCurve")), geos_multi_line_string_class);
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_multi_line_string, geos_multi_line_string_class);
-
-  geos_multi_polygon_class = rb_define_class_under(globals->geos_module, "MultiPolygonImpl", geos_geometry_collection_class);
-  globals->geos_multi_polygon = geos_multi_polygon_class;
-  globals->feature_multi_polygon = rb_const_get_at(globals->feature_module, rb_intern("MultiPolygon"));
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    rb_const_get_at(globals->feature_module, rb_intern("MultiSurface")), geos_multi_polygon_class);
-  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
-    globals->feature_multi_polygon, geos_multi_polygon_class);
+  VALUE geos_geometry_collection_methods;
+  VALUE geos_multi_point_methods;
+  VALUE geos_multi_line_string_methods;
+  VALUE geos_multi_polygon_methods;
+
+  // Class methods for geometry collection classes
+  rb_define_module_function(globals->geos_geometry_collection, "create", cmethod_geometry_collection_create, 2);
+  rb_define_module_function(globals->geos_multi_point, "create", cmethod_multi_point_create, 2);
+  rb_define_module_function(globals->geos_multi_line_string, "create", cmethod_multi_line_string_create, 2);
+  rb_define_module_function(globals->geos_multi_polygon, "create", cmethod_multi_polygon_create, 2);
 
   // Methods for GeometryCollectionImpl
-  rb_define_module_function(geos_geometry_collection_class, "create", cmethod_geometry_collection_create, 2);
-  rb_include_module(geos_geometry_collection_class, rb_define_module("Enumerable"));
-  rb_define_method(geos_geometry_collection_class, "rep_equals?", method_geometry_collection_eql, 1);
-  rb_define_method(geos_geometry_collection_class, "eql?", method_geometry_collection_eql, 1);
-  rb_define_method(geos_geometry_collection_class, "geometry_type", method_geometry_collection_geometry_type, 0);
-  rb_define_method(geos_geometry_collection_class, "num_geometries", method_geometry_collection_num_geometries, 0);
-  rb_define_method(geos_geometry_collection_class, "size", method_geometry_collection_num_geometries, 0);
-  rb_define_method(geos_geometry_collection_class, "geometry_n", method_geometry_collection_geometry_n, 1);
-  rb_define_method(geos_geometry_collection_class, "[]", method_geometry_collection_brackets, 1);
-  rb_define_method(geos_geometry_collection_class, "each", method_geometry_collection_each, 0);
+  geos_geometry_collection_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryCollectionMethods");
+  rb_define_method(geos_geometry_collection_methods, "rep_equals?", method_geometry_collection_eql, 1);
+  rb_define_method(geos_geometry_collection_methods, "eql?", method_geometry_collection_eql, 1);
+  rb_define_method(geos_geometry_collection_methods, "hash", method_geometry_collection_hash, 0);
+  rb_define_method(geos_geometry_collection_methods, "geometry_type", method_geometry_collection_geometry_type, 0);
+  rb_define_method(geos_geometry_collection_methods, "num_geometries", method_geometry_collection_num_geometries, 0);
+  rb_define_method(geos_geometry_collection_methods, "size", method_geometry_collection_num_geometries, 0);
+  rb_define_method(geos_geometry_collection_methods, "geometry_n", method_geometry_collection_geometry_n, 1);
+  rb_define_method(geos_geometry_collection_methods, "[]", method_geometry_collection_brackets, 1);
+  rb_define_method(geos_geometry_collection_methods, "each", method_geometry_collection_each, 0);
 
   // Methods for MultiPointImpl
-  rb_define_module_function(geos_multi_point_class, "create", cmethod_multi_point_create, 2);
-  rb_define_method(geos_multi_point_class, "geometry_type", method_multi_point_geometry_type, 0);
+  geos_multi_point_methods = rb_define_module_under(globals->geos_module, "CAPIMultiPointMethods");
+  rb_define_method(geos_multi_point_methods, "geometry_type", method_multi_point_geometry_type, 0);
+  rb_define_method(geos_multi_point_methods, "hash", method_multi_point_hash, 0);
 
   // Methods for MultiLineStringImpl
-  rb_define_module_function(geos_multi_line_string_class, "create", cmethod_multi_line_string_create, 2);
-  rb_define_method(geos_multi_line_string_class, "geometry_type", method_multi_line_string_geometry_type, 0);
-  rb_define_method(geos_multi_line_string_class, "length", method_multi_line_string_length, 0);
-  rb_define_method(geos_multi_line_string_class, "is_closed?", method_multi_line_string_is_closed, 0);
+  geos_multi_line_string_methods = rb_define_module_under(globals->geos_module, "CAPIMultiLineStringMethods");
+  rb_define_method(geos_multi_line_string_methods, "geometry_type", method_multi_line_string_geometry_type, 0);
+  rb_define_method(geos_multi_line_string_methods, "length", method_multi_line_string_length, 0);
+  rb_define_method(geos_multi_line_string_methods, "is_closed?", method_multi_line_string_is_closed, 0);
+  rb_define_method(geos_multi_line_string_methods, "hash", method_multi_line_string_hash, 0);
 
   // Methods for MultiPolygonImpl
-  rb_define_module_function(geos_multi_polygon_class, "create", cmethod_multi_polygon_create, 2);
-  rb_define_method(geos_multi_polygon_class, "geometry_type", method_multi_polygon_geometry_type, 0);
-  rb_define_method(geos_multi_polygon_class, "area", method_multi_polygon_area, 0);
-  rb_define_method(geos_multi_polygon_class, "centroid", method_multi_polygon_centroid, 0);
-  rb_define_method(geos_multi_polygon_class, "point_on_surface", method_multi_polygon_point_on_surface, 0);
+  geos_multi_polygon_methods = rb_define_module_under(globals->geos_module, "CAPIMultiPolygonMethods");
+  rb_define_method(geos_multi_polygon_methods, "geometry_type", method_multi_polygon_geometry_type, 0);
+  rb_define_method(geos_multi_polygon_methods, "area", method_multi_polygon_area, 0);
+  rb_define_method(geos_multi_polygon_methods, "centroid", method_multi_polygon_centroid, 0);
+  rb_define_method(geos_multi_polygon_methods, "point_on_surface", method_multi_polygon_point_on_surface, 0);
+  rb_define_method(geos_multi_polygon_methods, "hash", method_multi_polygon_hash, 0);
 }
 
 
@@ -603,6 +647,45 @@ VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOS
 }
 
 
+st_index_t rgeo_geos_geometry_collection_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
+{
+  const GEOSGeometry* sub_geom;
+  int type;
+  unsigned int len;
+  unsigned int i;
+
+  if (geom) {
+    len = GEOSGetNumGeometries_r(context, geom);
+    for (i=0; i<len; ++i) {
+      sub_geom = GEOSGetGeometryN_r(context, geom, i);
+      if (sub_geom) {
+        type = GEOSGeomTypeId_r(context, sub_geom);
+        if (type >= 0) {
+          hash = hash ^ type;
+          switch (type) {
+          case GEOS_POINT:
+          case GEOS_LINESTRING:
+          case GEOS_LINEARRING:
+            hash = rgeo_geos_coordseq_hash(context, sub_geom, hash);
+            break;
+          case GEOS_POLYGON:
+            hash = rgeo_geos_polygon_hash(context, sub_geom, hash);
+            break;
+          case GEOS_GEOMETRYCOLLECTION:
+          case GEOS_MULTIPOINT:
+          case GEOS_MULTILINESTRING:
+          case GEOS_MULTIPOLYGON:
+            hash = rgeo_geos_geometry_collection_hash(context, sub_geom, hash);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return hash;
+}
+
+
 RGEO_END_C
 
 #endif