rgeo 2.4.0 → 3.0.0.pre.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb42ec2fb37f915e49d13c7e802279560588d75f376d06d37f3a4e4f0e1ab61
-  data.tar.gz: 6606d1fe12f30d645fb66edf95e694708ffb24ba81afa78ce03a961456f67686
+  metadata.gz: e26b01fb2fff6915756d98e206ee4bdabefeaceadae3cd0b85cb7be9ee6d8285
+  data.tar.gz: 9b94dd4e6c57e9fa5ab07c7b5fb9c622a52d843b67d146b52454933cb817a4a1
 SHA512:
-  metadata.gz: 807c3f239731755e4afe348d70b2ebf0c81f29754a5677a4123dce474c0a18e7a6e63df5ee36fb244a05b04a9ef70356a3e966fab336a0925365afc05e331d5a
-  data.tar.gz: c940601cc0c30944b5bc4e5f8d9ed632704295b28cb8115973a1856c823f01a7a0b655bc2e277ebe09268a08cf4fe9e1b0abbb4c192a598d2f06c95baef58901
+  metadata.gz: 9adb8cc283c8663fb0a178eeb7a1629fe466265f7fa15c54d4e8dac4188646a2682f591a3e76d12271df5dc6c875961833600b88952d035f824933bd454211de
+  data.tar.gz: c1f7e26d5a5edcc060cac2efaa782a586c9ee95e1dda08f7af771648ecc1ea2373a1e4ba9053aae00288332e401370c7f61e254367231ceabb4fb36ad5406209

data/.yardopts

@@ -0,0 +1,6 @@
+--markup rdoc
+--output-dir ./yardoc
+lib/**/*.rb
+ext/**/*.{c,h}
+-
+doc/*.md

data/README.md

@@ -129,6 +129,7 @@ Here's the current list of available topics:
 - [Installing GEOS](https://github.com/rgeo/rgeo/blob/master/doc/Installing-GEOS.md)
 - [Factory Compatibility](https://github.com/rgeo/rgeo/blob/master/doc/Factory-Compatibility.md)
 - [Which factory should I use?](https://github.com/rgeo/rgeo/blob/master/doc/Which-factory-should-I-use.md)
+- [Geometry validity handling](https://github.com/rgeo/rgeo/blob/master/doc/Geometry-Validity.md)
 - [Examples](https://github.com/rgeo/rgeo/blob/master/doc/Examples.md)
 - [Who uses `rgeo`?](https://github.com/rgeo/rgeo/blob/master/doc/Gallery.md)
 

data/ext/geos_c_impl/analysis.c

@@ -37,9 +37,9 @@ VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
   ring_data = RGEO_GEOMETRY_DATA_PTR(ring);
 
   coord_seq = GEOSGeom_getCoordSeq_r(ring_data->geos_context, ring_data->geom);
-  if (!coord_seq) { rb_raise(geos_error, "Could not retrieve CoordSeq from given ring."); }
+  if (!coord_seq) { rb_raise(rb_eGeosError, "Could not retrieve CoordSeq from given ring."); }
   if (!GEOSCoordSeq_isCCW_r(ring_data->geos_context, coord_seq, &is_ccw)) {
-    rb_raise(geos_error, "Could not determine if the CoordSeq is CCW.");
+    rb_raise(rb_eGeosError, "Could not determine if the CoordSeq is CCW.");
   }
 
   return is_ccw ? Qtrue : Qfalse;
@@ -49,8 +49,8 @@ VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
 
 /**
  * call-seq:
- *   RGeo::Geos::Analysis.ccw_supported? -> true or false 
- * 
+ *   RGeo::Geos::Analysis.ccw_supported? -> true or false
+ *
  * Checks if the RGEO_GEOS_SUPPORTS_ISCCW macro is defined, returns +true+
  * if it is, +false+ otherwise
  */

data/ext/geos_c_impl/errors.c

@@ -14,18 +14,20 @@
 
 RGEO_BEGIN_C
 
-// Any error relative to RGeo.
-VALUE rgeo_error;
-// RGeo error specific to the GEOS implementation.
-VALUE geos_error;
+VALUE rb_eRGeoError;
+VALUE rb_eRGeoInvalidGeometry;
+VALUE rb_eRGeoUnsupportedOperation;
+VALUE rb_eGeosError;
 
 
 void rgeo_init_geos_errors() {
   VALUE error_module;
 
   error_module = rb_define_module_under(rgeo_module, "Error");
-  rgeo_error = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
-  geos_error = rb_define_class_under(error_module, "GeosError", rgeo_error);
+  rb_eRGeoError = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
+  rb_eRGeoInvalidGeometry = rb_define_class_under(error_module, "InvalidGeometry", rb_eRGeoError);
+  rb_eRGeoUnsupportedOperation = rb_define_class_under(error_module, "UnsupportedOperation", rb_eRGeoError);
+  rb_eGeosError = rb_define_class_under(error_module, "GeosError", rb_eRGeoError);
 }
 
 RGEO_END_C

data/ext/geos_c_impl/errors.h

@@ -8,10 +8,14 @@
 
 RGEO_BEGIN_C
 
-// Any error relative to RGeo.
-extern VALUE rgeo_error;
+// Main rgeo error type
+extern VALUE rb_eRGeoError;
+// RGeo::Error::InvalidGeometry
+extern VALUE rb_eRGeoInvalidGeometry;
+// RGeo::Error::UnsupportedOperation
+extern VALUE rb_eRGeoUnsupportedOperation;
 // RGeo error specific to the GEOS implementation.
-extern VALUE geos_error;
+extern VALUE rb_eGeosError;
 
 void rgeo_init_geos_errors();
 

data/ext/geos_c_impl/extconf.rb

@@ -14,6 +14,8 @@ if RUBY_DESCRIPTION =~ /^jruby\s/
 else
   require "mkmf"
 
+  $CFLAGS << " -DRGEO_GEOS_DEBUG" if ENV.key?("DEBUG") || ENV.key?("RGEO_GEOS_DEBUG")
+
   geosconfig = with_config("geos-config") || find_executable("geos-config")
 
   if geosconfig

data/ext/geos_c_impl/factory.c

@@ -9,6 +9,9 @@
 
 #include <ruby.h>
 #include <geos_c.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
 
 #include "globals.h"
 
@@ -26,13 +29,50 @@ RGEO_BEGIN_C
 /**** RUBY AND GEOS CALLBACKS ****/
 
 
-// NOP message handler. GEOS requires that a message handler be set
-// for every context handle.
-
-static void message_handler(const char* fmt, ...)
+// The notice handler is very rarely used by GEOS, only in
+// GEOSIsValid_r (check for NOTICE_MESSAGE in GEOS codebase).
+// We still set it to make sure we do not miss any implementation
+// change. Use `DEBUG=1 rake` to show notice.
+#ifdef RGEO_GEOS_DEBUG
+static void notice_handler(const char* fmt, ...)
 {
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "GEOS Notice -- ");
+  vfprintf(stderr, fmt, args);
+  fprintf(stderr, "\n");
+  va_end(args);
 }
+#endif
 
+static void error_handler(const char* fmt, ...)
+{
+  // See https://en.cppreference.com/w/c/io/vfprintf
+  va_list args1;
+  va_start(args1, fmt);
+  va_list args2;
+  va_copy(args2, args1);
+  int size = 1+vsnprintf(NULL, 0, fmt, args1);
+  va_end(args1);
+  char geos_full_error[size];
+  vsnprintf(geos_full_error, sizeof geos_full_error, fmt, args2);
+  va_end(args2);
+
+  // NOTE: strtok is destructive, geos_full_error is not to be used afterwards.
+  char *geos_error = strtok(geos_full_error, ":");
+  char *geos_message = strtok(NULL, ":");
+  while(isspace(*geos_message)) geos_message++;
+
+  if (streq(geos_error, "UnsupportedOperationException")) {
+    rb_raise(rb_eRGeoUnsupportedOperation, "%s", geos_message);
+  } else if (streq(geos_error, "IllegalArgumentException")) {
+    rb_raise(rb_eRGeoInvalidGeometry, "%s", geos_message);
+  } else if (geos_message) {
+    rb_raise(rb_eGeosError, "%s: %s", geos_error, geos_message);
+  } else {
+    rb_raise(rb_eGeosError, "%s", geos_error);
+  }
+}
 
 // Destroy function for factory data. We destroy any serialization
 // objects that have been created for the factory, and then destroy
@@ -227,6 +267,25 @@ static VALUE method_factory_flags(VALUE self)
   return INT2NUM(RGEO_FACTORY_DATA_PTR(self)->flags);
 }
 
+VALUE method_factory_supports_z_p(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z ? Qtrue : Qfalse;
+}
+
+VALUE method_factory_supports_m_p(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->flags & RGEO_FACTORYFLAGS_SUPPORTS_M ? Qtrue : Qfalse;
+}
+
+VALUE method_factory_supports_z_or_m_p(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M ? Qtrue : Qfalse;
+}
+
+VALUE method_factory_prepare_heuristic_p(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->flags & RGEO_FACTORYFLAGS_PREPARE_HEURISTIC ? Qtrue : Qfalse;
+}
 
 static VALUE method_factory_parse_wkt(VALUE self, VALUE str)
 {
@@ -459,7 +518,12 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
   result = Qnil;
   data = ALLOC(RGeo_FactoryData);
   if (data) {
-    context = initGEOS_r(message_handler, message_handler);
+    context = GEOS_init_r();
+#ifdef RGEO_GEOS_DEBUG
+    GEOSContext_setNoticeHandler_r(context, notice_handler);
+#endif
+    GEOSContext_setErrorHandler_r(context, error_handler);
+
     if (context) {
       data->geos_context = context;
       data->flags = NUM2INT(flags);
@@ -629,15 +693,24 @@ void rgeo_init_geos_factory()
   rb_gc_register_address(&marshal_wkb_generator);
 #endif
 
-  // Add C methods to the factory.
   geos_factory_class = rb_define_class_under(rgeo_geos_module, "CAPIFactory", rb_cObject);
   rb_define_alloc_func(geos_factory_class, alloc_factory);
+  // Add C constants to the factory.
+  rb_define_const(geos_factory_class, "FLAG_SUPPORTS_Z", INT2FIX(RGEO_FACTORYFLAGS_SUPPORTS_Z));
+  rb_define_const(geos_factory_class, "FLAG_SUPPORTS_M", INT2FIX(RGEO_FACTORYFLAGS_SUPPORTS_M));
+  rb_define_const(geos_factory_class, "FLAG_SUPPORTS_Z_OR_M", INT2FIX(RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M));
+  rb_define_const(geos_factory_class, "FLAG_PREPARE_HEURISTIC", INT2FIX(RGEO_FACTORYFLAGS_PREPARE_HEURISTIC));
+  // Add C methods to the 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);
   rb_define_method(geos_factory_class, "_parse_wkb_impl", method_factory_parse_wkb, 1);
   rb_define_method(geos_factory_class, "_srid", method_factory_srid, 0);
   rb_define_method(geos_factory_class, "_buffer_resolution", method_factory_buffer_resolution, 0);
   rb_define_method(geos_factory_class, "_flags", method_factory_flags, 0);
+  rb_define_method(geos_factory_class, "supports_z?", method_factory_supports_z_p, 0);
+  rb_define_method(geos_factory_class, "supports_m?", method_factory_supports_m_p, 0);
+  rb_define_method(geos_factory_class, "supports_z_or_m?", method_factory_supports_z_or_m_p, 0);
+  rb_define_method(geos_factory_class, "prepare_heuristic?", method_factory_prepare_heuristic_p, 0);
   rb_define_method(geos_factory_class, "_set_wkrep_parsers", method_set_wkrep_parsers, 2);
   rb_define_method(geos_factory_class, "_proj4", method_get_proj4, 0);
   rb_define_method(geos_factory_class, "_coord_sys", method_get_coord_sys, 0);
@@ -831,7 +904,7 @@ char rgeo_is_geos_object(VALUE obj)
 void rgeo_check_geos_object(VALUE obj)
 {
   if (!rgeo_is_geos_object(obj)) {
-    rb_raise(rgeo_error, "Not a GEOS Geometry object.");
+    rb_raise(rb_eRGeoError, "Not a GEOS Geometry object.");
   }
 }
 

data/ext/geos_c_impl/factory.h

@@ -37,12 +37,35 @@ typedef struct {
   int buffer_resolution;
 } RGeo_FactoryData;
 
-#define RGEO_FACTORYFLAGS_LENIENT_MULTIPOLYGON 1
-#define RGEO_FACTORYFLAGS_SUPPORTS_Z 2
-#define RGEO_FACTORYFLAGS_SUPPORTS_M 4
-#define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M 6
-#define RGEO_FACTORYFLAGS_PREPARE_HEURISTIC 8
+/*
+  Flags that are used to pass options when creating a factory.
+  They are available in ruby under RGeo::Geos::CAPIFactory::FLAG_name
+  where name is the name below without the RGEO_FACTORYFLAGS_ prefix.
+ */
+#define RGEO_FACTORYFLAGS_SUPPORTS_Z                      0b0010
+#define RGEO_FACTORYFLAGS_SUPPORTS_M                      0b0100
+#define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M                 (RGEO_FACTORYFLAGS_SUPPORTS_Z | RGEO_FACTORYFLAGS_SUPPORTS_M)
+#define RGEO_FACTORYFLAGS_PREPARE_HEURISTIC               0b1000
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_z? -> true or false
+ */
+VALUE method_factory_supports_z_p(VALUE self);
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_m? -> true or false
+ */
+VALUE method_factory_supports_m_p(VALUE self);
+
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.supports_z_or_m? -> true or false
+ */
+VALUE method_factory_supports_z_or_m_p(VALUE self);
 
+/* call-seq:
+ *   RGeo::Geos::CAPIFactory.prepare_heuristic? -> true or false
+ */
+VALUE method_factory_prepare_heuristic_p(VALUE self);
 
 /*
   Wrapped structure for Geometry objects.
@@ -164,15 +187,6 @@ void rgeo_check_geos_object(VALUE obj);
 */
 const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj);
 
-/*
-  Compares the coordinate sequences for two given GEOS geometries.
-  The two given geometries MUST be of types backed directly by
-  coordinate sequences-- i.e. points or line strings.
-  Returns Qtrue if the two coordinate sequences are equal, Qfalse
-  if they are inequal, or Qnil if an error occurs.
-*/
-VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
-
 /*
   Compares the ruby classes and geometry factories of the two given ruby
   objects. Returns Qtrue if everything is equal (that is, the two objects

data/ext/geos_c_impl/geometry.c

@@ -13,6 +13,7 @@
 
 #include "globals.h"
 
+#include "errors.h"
 #include "factory.h"
 #include "geometry.h"
 
@@ -863,24 +864,21 @@ static VALUE method_geometry_union(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_unary_union(VALUE self)
 {
-  VALUE result;
+#ifdef RGEO_GEOS_SUPPORTS_UNARYUNION
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
 
-  result = Qnil;
-
-#ifdef RGEO_GEOS_SUPPORTS_UNARYUNION
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     GEOSContextHandle_t self_context = self_data->geos_context;
-    result = rgeo_wrap_geos_geometry(self_data->factory,
+    return rgeo_wrap_geos_geometry(self_data->factory,
       GEOSUnaryUnion_r(self_context, self_geom),
       Qnil);
   }
 #endif
 
-  return result;
+  return Qnil;
 }
 
 
@@ -1044,18 +1042,39 @@ static VALUE method_geometry_invalid_reason(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    str = GEOSisValidReason_r(self_data->geos_context, self_geom);
-    // Per documentation, a valid geometry should give an empty string.
-    // However it seems not to be the case. Hence the comparison against
-    // the string that is really given: `"Valid Geometry"`.
-    // See https://github.com/libgeos/geos/issues/431.
-    if (str) result = (str[0] == '\0' || !strcmp(str, "Valid Geometry")) ? Qnil : rb_str_new2(str);
-    else result = rb_str_new2("Exception");
-    GEOSFree_r(self_data->geos_context, str);
+    // We use NULL there to tell GEOS that we don't care about the position.
+    switch(GEOSisValidDetail_r(self_data->geos_context, self_geom, 0, &str, NULL)) {
+      case 0: // invalid
+        result = rb_utf8_str_new_cstr(str);
+      case 1: // valid
+        break;
+      case 2: // exception
+      default:
+        result = rb_utf8_str_new_cstr("Exception");
+        break;
+    };
+    if (str) GEOSFree_r(self_data->geos_context, str);
   }
   return result;
 }
 
+static VALUE method_geometry_make_valid(VALUE self)
+{
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* valid_geom;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (!self_geom) return Qnil;
+
+  // According to GEOS implementation, MakeValid always returns.
+  valid_geom = GEOSMakeValid_r(self_data->geos_context, self_geom);
+  if (!valid_geom) {
+    rb_raise(rb_eRGeoInvalidGeometry, "%"PRIsVALUE, method_geometry_invalid_reason(self));
+  }
+  return rgeo_wrap_geos_geometry(self_data->factory, valid_geom, Qnil);
+}
+
 static VALUE method_geometry_point_on_surface(VALUE self)
 {
   VALUE result;
@@ -1071,6 +1090,18 @@ static VALUE method_geometry_point_on_surface(VALUE self)
   return result;
 }
 
+VALUE rgeo_geos_geometries_strict_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2)
+{
+  switch (GEOSEqualsExact_r(context, geom1, geom2, 0.0)) {
+  case 0:
+    return Qfalse;
+  case 1:
+    return Qtrue;
+  case 2:
+  default:
+    rb_raise(rb_eGeosError, "Cannot test equality.");
+  }
+}
 
 /**** INITIALIZATION FUNCTION ****/
 
@@ -1126,6 +1157,7 @@ void rgeo_init_geos_geometry()
   rb_define_method(geos_geometry_methods, "valid?", method_geometry_is_valid, 0);
   rb_define_method(geos_geometry_methods, "invalid_reason", method_geometry_invalid_reason, 0);
   rb_define_method(geos_geometry_methods, "point_on_surface", method_geometry_point_on_surface, 0);
+  rb_define_method(geos_geometry_methods, "make_valid", method_geometry_make_valid, 0);
 }
 
 

data/ext/geos_c_impl/geometry.h

@@ -16,6 +16,13 @@ RGEO_BEGIN_C
 void rgeo_init_geos_geometry();
 
 
+/*
+  Compares two geometries using strict GEOS comparison. return Qtrue
+  if they are equal, Qfalse otherwise.
+  May raise a `RGeo::Error::GeosError`.
+*/
+VALUE rgeo_geos_geometries_strict_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2);
+
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/geometry_collection.c

@@ -16,6 +16,7 @@
 #include "geometry.h"
 #include "line_string.h"
 #include "polygon.h"
+#include "geometry.h"
 #include "geometry_collection.h"
 
 #include "coordinates.h"
@@ -43,9 +44,6 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
   VALUE cast_type;
   GEOSGeometry* geom;
   GEOSGeometry* collection;
-  char problem;
-  GEOSGeometry* igeom;
-  GEOSGeometry* jgeom;
 
   result = Qnil;
   Check_Type(array, T_ARRAY);
@@ -90,32 +88,6 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
     }
     else {
       collection = GEOSGeom_createCollection_r(geos_context, type, geoms, len);
-      // Due to a limitation of GEOS, the MultiPolygon assertions are not checked.
-      // We do that manually here.
-      if (collection && type == GEOS_MULTIPOLYGON && (factory_data->flags & 1) == 0) {
-        problem = 0;
-        for (i=1; i<len; ++i) {
-          for (j=0; j<i; ++j) {
-            igeom = geoms[i];
-            jgeom = geoms[j];
-            problem = GEOSRelatePattern_r(geos_context, igeom, jgeom, "2********");
-            if (problem) {
-              break;
-            }
-            problem = GEOSRelatePattern_r(geos_context, igeom, jgeom, "****1****");
-            if (problem) {
-              break;
-            }
-          }
-          if (problem) {
-            break;
-          }
-        }
-        if (problem) {
-          GEOSGeom_destroy_r(geos_context, collection);
-          collection = NULL;
-        }
-      }
       if (collection) {
         result = rgeo_wrap_geos_geometry(factory, collection, module);
         RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
@@ -143,7 +115,7 @@ static VALUE method_geometry_collection_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_geometry_collections_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -635,80 +607,6 @@ void rgeo_init_geos_geometry_collection()
 /**** OTHER PUBLIC FUNCTIONS ****/
 
 
-VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
-{
-  VALUE result;
-  int len1;
-  int len2;
-  int i;
-  const GEOSGeometry* sub_geom1;
-  const GEOSGeometry* sub_geom2;
-  int type1;
-  int type2;
-
-  result = Qnil;
-  if (geom1 && geom2) {
-    len1 = GEOSGetNumGeometries_r(context, geom1);
-    len2 = GEOSGetNumGeometries_r(context, geom2);
-    if (len1 >= 0 && len2 >= 0) {
-      if (len1 == len2) {
-        result = Qtrue;
-        for (i=0; i<len1; ++i) {
-          sub_geom1 = GEOSGetGeometryN_r(context, geom1, i);
-          sub_geom2 = GEOSGetGeometryN_r(context, geom2, i);
-          if (sub_geom1 && sub_geom2) {
-            type1 = GEOSGeomTypeId_r(context, sub_geom1);
-            type2 = GEOSGeomTypeId_r(context, sub_geom2);
-            if (type1 >= 0 && type2 >= 0) {
-              if (type1 == type2) {
-                switch (type1) {
-                case GEOS_POINT:
-                case GEOS_LINESTRING:
-                case GEOS_LINEARRING:
-                  result = rgeo_geos_coordseqs_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                case GEOS_POLYGON:
-                  result = rgeo_geos_polygons_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                case GEOS_GEOMETRYCOLLECTION:
-                case GEOS_MULTIPOINT:
-                case GEOS_MULTILINESTRING:
-                case GEOS_MULTIPOLYGON:
-                  result = rgeo_geos_geometry_collections_eql(context, sub_geom1, sub_geom2, check_z);
-                  break;
-                default:
-                  result = Qnil;
-                  break;
-                }
-                if (!RTEST(result)) {
-                  break;
-                }
-              }
-              else {
-                result = Qfalse;
-                break;
-              }
-            }
-            else {
-              result = Qnil;
-              break;
-            }
-          }
-          else {
-            result = Qnil;
-            break;
-          }
-        }
-      }
-      else {
-        result = Qfalse;
-      }
-    }
-  }
-  return result;
-}
-
-
 st_index_t rgeo_geos_geometry_collection_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
 {
   const GEOSGeometry* sub_geom;

data/ext/geos_c_impl/geometry_collection.h

@@ -18,17 +18,6 @@ RGEO_BEGIN_C
 */
 void rgeo_init_geos_geometry_collection();
 
-/*
-  Comopares the contents of two geometry collections. Does not test the
-  types of the collections themselves, but tests the types, values, and
-  contents of all the contents. The two given geometries MUST be
-  collection types-- i.e. GeometryCollection, MultiPoint, MultiLineString,
-  or MultiPolygon.
-  Returns Qtrue if the contents of the two geometry collections are equal,
-  Qfalse if they are inequal, or Qnil if an error occurs.
-*/
-VALUE rgeo_geos_geometry_collections_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
-
 /*
   A tool for building up hash values.
   You must pass in the context, a geos geometry, and a seed hash.

data/ext/geos_c_impl/line_string.c

@@ -345,7 +345,7 @@ static VALUE method_line_string_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }

data/ext/geos_c_impl/point.c

@@ -155,7 +155,7 @@ static VALUE method_point_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }

data/ext/geos_c_impl/polygon.c

@@ -30,7 +30,7 @@ static VALUE method_polygon_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_polygons_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -299,42 +299,6 @@ void rgeo_init_geos_polygon()
   rb_define_method(geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
 }
 
-
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
-{
-  VALUE result;
-  int len1;
-  int len2;
-  int i;
-
-  result = Qnil;
-  if (geom1 && geom2) {
-    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2), check_z);
-    if (RTEST(result)) {
-      len1 = GEOSGetNumInteriorRings_r(context, geom1);
-      len2 = GEOSGetNumInteriorRings_r(context, geom2);
-      if (len1 >= 0 && len2 >= 0) {
-        if (len1 == len2) {
-          for (i=0; i<len1; ++i) {
-            result = rgeo_geos_coordseqs_eql(context, GEOSGetInteriorRingN_r(context, geom1, i), GEOSGetInteriorRingN_r(context, geom2, i), check_z);
-            if (!RTEST(result)) {
-              break;
-            }
-          }
-        }
-        else {
-          result = Qfalse;
-        }
-      }
-      else {
-        result = Qnil;
-      }
-    }
-  }
-  return result;
-}
-
-
 st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
 {
   unsigned int len;

data/ext/geos_c_impl/preface.h

@@ -47,3 +47,6 @@
 #define RGEO_BEGIN_C
 #define RGEO_END_C
 #endif
+
+// https://ozlabs.org/~rusty/index.cgi/tech/2008-04-01.html
+#define streq(a, b) (!strcmp((a),(b)))