rgeo 2.3.0 → 3.0.0.pre.rc.1

data/ext/geos_c_impl/line_string.c

@@ -11,6 +11,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -29,7 +31,7 @@ static VALUE method_line_string_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line_string;
+    result = rgeo_feature_line_string_module;
   }
   return result;
 }
@@ -43,7 +45,7 @@ static VALUE method_linear_ring_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_linear_ring;
+    result = rgeo_feature_linear_ring_module;
   }
   return result;
 }
@@ -57,7 +59,7 @@ static VALUE method_line_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line;
+    result = rgeo_feature_line_module;
   }
   return result;
 }
@@ -264,7 +266,7 @@ static VALUE method_line_string_project_point(VALUE self, VALUE point)
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
 
   if(self_geom && point) {
-    geos_point = rgeo_convert_to_geos_geometry(factory, point, factory_data->globals->geos_point);
+    geos_point = rgeo_convert_to_geos_geometry(factory, point, rgeo_geos_point_class);
     location = GEOSProject_r(self_data->geos_context, self_geom, geos_point);
     result = DBL2NUM(location);
   }
@@ -290,7 +292,7 @@ static VALUE method_line_string_interpolate_point(VALUE self, VALUE loc_num)
 
   if(self_geom) {
     geos_point = GEOSInterpolate_r(self_data->geos_context, self_geom, location);
-    result = rgeo_wrap_geos_geometry(factory, geos_point, factory_data->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(factory, geos_point, rgeo_geos_point_class);
   }
 
   return result;
@@ -343,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;
 }
@@ -358,8 +360,7 @@ static VALUE method_line_string_hash(VALUE self)
   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_line_string, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_string_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -374,8 +375,7 @@ static VALUE method_linear_ring_hash(VALUE self)
   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_linear_ring, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_linear_ring_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -390,8 +390,7 @@ static VALUE method_line_hash(VALUE self)
   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_line, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -415,7 +414,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
 
   Check_Type(array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   len = (unsigned int)RARRAY_LEN(array);
   has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   dims = has_z ? 3 : 2;
@@ -491,7 +490,7 @@ static VALUE cmethod_create_line_string(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLineString_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line_string);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_string_class);
     }
   }
   return result;
@@ -511,7 +510,7 @@ static VALUE cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLinearRing_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_linear_ring);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_linear_ring_class);
     }
   }
   return result;
@@ -557,7 +556,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
   result = Qnil;
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
   has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   context = factory_data->geos_context;
 
   start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
@@ -570,7 +569,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
         populate_geom_into_coord_seq(context, end_geom, coord_seq, 1, has_z);
         geom = GEOSGeom_createLineString_r(context, coord_seq);
         if (geom) {
-          result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line);
+          result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_class);
         }
       }
     }
@@ -631,26 +630,26 @@ static VALUE cmethod_linear_ring_copy_from(VALUE klass, VALUE factory, VALUE ori
 }
 
 
-void rgeo_init_geos_line_string(RGeo_Globals* globals)
+void rgeo_init_geos_line_string()
 {
   VALUE geos_line_string_methods;
   VALUE geos_linear_ring_methods;
   VALUE geos_line_methods;
 
   // Class methods for CAPILineStringImpl
-  rb_define_module_function(globals->geos_line_string, "create", cmethod_create_line_string, 2);
-  rb_define_module_function(globals->geos_line_string, "_copy_from", cmethod_line_string_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "create", cmethod_create_line_string, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
 
   // Class methods for CAPILinearRingImpl
-  rb_define_module_function(globals->geos_linear_ring, "create", cmethod_create_linear_ring, 2);
-  rb_define_module_function(globals->geos_linear_ring, "_copy_from", cmethod_linear_ring_copy_from, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "create", cmethod_create_linear_ring, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "_copy_from", cmethod_linear_ring_copy_from, 2);
 
   // Class methods for CAPILineImpl
-  rb_define_module_function(globals->geos_line, "create", cmethod_create_line, 3);
-  rb_define_module_function(globals->geos_line, "_copy_from", cmethod_line_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_class, "create", cmethod_create_line, 3);
+  rb_define_module_function(rgeo_geos_line_class, "_copy_from", cmethod_line_copy_from, 2);
 
   // CAPILineStringMethods module
-  geos_line_string_methods = rb_define_module_under(globals->geos_module, "CAPILineStringMethods");
+  geos_line_string_methods = rb_define_module_under(rgeo_geos_module, "CAPILineStringMethods");
   rb_define_method(geos_line_string_methods, "rep_equals?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "eql?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "hash", method_line_string_hash, 0);
@@ -663,17 +662,17 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_define_method(geos_line_string_methods, "end_point", method_line_string_end_point, 0);
   rb_define_method(geos_line_string_methods, "project_point", method_line_string_project_point, 1);
   rb_define_method(geos_line_string_methods, "interpolate_point", method_line_string_interpolate_point, 1);
-  rb_define_method(geos_line_string_methods, "is_closed?", method_line_string_is_closed, 0);
-  rb_define_method(geos_line_string_methods, "is_ring?", method_line_string_is_ring, 0);
+  rb_define_method(geos_line_string_methods, "closed?", method_line_string_is_closed, 0);
+  rb_define_method(geos_line_string_methods, "ring?", method_line_string_is_ring, 0);
   rb_define_method(geos_line_string_methods, "coordinates", method_line_string_coordinates, 0);
 
   // CAPILinearRingMethods module
-  geos_linear_ring_methods = rb_define_module_under(globals->geos_module, "CAPILinearRingMethods");
+  geos_linear_ring_methods = rb_define_module_under(rgeo_geos_module, "CAPILinearRingMethods");
   rb_define_method(geos_linear_ring_methods, "geometry_type", method_linear_ring_geometry_type, 0);
   rb_define_method(geos_linear_ring_methods, "hash", method_linear_ring_hash, 0);
 
   // CAPILineMethods module
-  geos_line_methods = rb_define_module_under(globals->geos_module, "CAPILineMethods");
+  geos_line_methods = rb_define_module_under(rgeo_geos_module, "CAPILineMethods");
   rb_define_method(geos_line_methods, "geometry_type", method_line_geometry_type, 0);
   rb_define_method(geos_line_methods, "hash", method_line_hash, 0);
 }

data/ext/geos_c_impl/line_string.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the line string module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_line_string(RGeo_Globals* globals);
+void rgeo_init_geos_line_string();
 
 /*
   Determines whether the given GEOS line string is closed.

data/ext/geos_c_impl/main.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "errors.h"
 
 #include "factory.h"
@@ -26,15 +28,14 @@ RGEO_BEGIN_C
 void Init_geos_c_impl()
 {
 #ifdef RGEO_GEOS_SUPPORTED
-  RGeo_Globals* globals;
-
-  globals = rgeo_init_geos_factory();
-  rgeo_init_geos_geometry(globals);
-  rgeo_init_geos_point(globals);
-  rgeo_init_geos_line_string(globals);
-  rgeo_init_geos_polygon(globals);
-  rgeo_init_geos_geometry_collection(globals);
-  rgeo_init_geos_analysis(globals);
+  rgeo_init_geos_globals();
+  rgeo_init_geos_factory();
+  rgeo_init_geos_geometry();
+  rgeo_init_geos_point();
+  rgeo_init_geos_line_string();
+  rgeo_init_geos_polygon();
+  rgeo_init_geos_geometry_collection();
+  rgeo_init_geos_analysis();
   rgeo_init_geos_errors();
 #endif
 }

data/ext/geos_c_impl/point.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -26,7 +28,7 @@ static VALUE method_point_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_point;
+    result = rgeo_feature_point_module;
   }
   return result;
 }
@@ -153,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;
 }
@@ -168,8 +170,7 @@ static VALUE method_point_hash(VALUE self)
   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_point, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_point_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -182,15 +183,15 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE
 }
 
 
-void rgeo_init_geos_point(RGeo_Globals* globals)
+void rgeo_init_geos_point()
 {
   VALUE geos_point_methods;
 
   // Class methods for CAPIPointImpl
-  rb_define_module_function(globals->geos_point, "create", cmethod_create, 4);
+  rb_define_module_function(rgeo_geos_point_class, "create", cmethod_create, 4);
 
   // CAPIPointMethods module
-  geos_point_methods = rb_define_module_under(globals->geos_module, "CAPIPointMethods");
+  geos_point_methods = rb_define_module_under(rgeo_geos_module, "CAPIPointMethods");
   rb_define_method(geos_point_methods, "rep_equals?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "eql?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "hash", method_point_hash, 0);
@@ -221,7 +222,7 @@ VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z)
         if (GEOSCoordSeq_setZ_r(context, coord_seq, 0, z)) {
           geom = GEOSGeom_createPoint_r(context, coord_seq);
           if (geom) {
-            result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_point);
+            result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_point_class);
           }
         }
       }

data/ext/geos_c_impl/point.h

@@ -8,8 +8,6 @@
 
 #include <ruby.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -17,7 +15,7 @@ RGEO_BEGIN_C
   Initializes the point module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_point(RGeo_Globals* globals);
+void rgeo_init_geos_point();
 
 /*
   Creates a 3d point and returns the ruby object.

data/ext/geos_c_impl/polygon.c

@@ -10,6 +10,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "line_string.h"
@@ -28,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;
 }
@@ -43,8 +45,7 @@ static VALUE method_polygon_hash(VALUE self)
   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_polygon, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_polygon_module, hash);
   hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -58,7 +59,7 @@ static VALUE method_polygon_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_polygon;
+    result = rgeo_feature_polygon_module;
   }
   return result;
 }
@@ -93,7 +94,7 @@ static VALUE method_polygon_centroid(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -109,7 +110,7 @@ static VALUE method_polygon_point_on_surface(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -145,7 +146,7 @@ static VALUE method_polygon_exterior_ring(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+    result = rgeo_wrap_geos_geometry_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), rgeo_geos_linear_ring_class);
   }
   return result;
 }
@@ -191,7 +192,7 @@ static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
       if (i < num) {
         result = rgeo_wrap_geos_geometry_clone(self_data->factory,
           GEOSGetInteriorRingN_r(self_context, self_geom, i),
-          RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+          rgeo_geos_linear_ring_class);
       }
     }
   }
@@ -219,9 +220,8 @@ static VALUE method_polygon_interior_rings(VALUE self)
     if (count >= 0) {
       result = rb_ary_new2(count);
       factory = self_data->factory;
-      linear_ring_class = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring;
       for (i=0; i<count; ++i) {
-        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), linear_ring_class));
+        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), rgeo_geos_linear_ring_class));
       }
     }
   }
@@ -244,7 +244,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 
   Check_Type(interior_array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  linear_ring_type = factory_data->globals->feature_linear_ring;
+  linear_ring_type = rgeo_feature_linear_ring_module;
   exterior_geom = rgeo_convert_to_detached_geos_geometry(exterior, factory, linear_ring_type, NULL);
   if (exterior_geom) {
     context = factory_data->geos_context;
@@ -262,7 +262,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
         polygon = GEOSGeom_createPolygon_r(context, exterior_geom, interior_geoms, actual_len);
         if (polygon) {
           free(interior_geoms);
-          return rgeo_wrap_geos_geometry(factory, polygon, factory_data->globals->geos_polygon);
+          return rgeo_wrap_geos_geometry(factory, polygon, rgeo_geos_polygon_class);
         }
       }
       for (i=0; i<actual_len; ++i) {
@@ -276,15 +276,15 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 }
 
 
-void rgeo_init_geos_polygon(RGeo_Globals* globals)
+void rgeo_init_geos_polygon()
 {
   VALUE geos_polygon_methods;
 
   // Class methods for CAPIPolygonImpl
-  rb_define_module_function(globals->geos_polygon, "create", cmethod_create, 3);
+  rb_define_module_function(rgeo_geos_polygon_class, "create", cmethod_create, 3);
 
   // CAPIPolygonMethods module
-  geos_polygon_methods = rb_define_module_under(globals->geos_module, "CAPIPolygonMethods");
+  geos_polygon_methods = rb_define_module_under(rgeo_geos_module, "CAPIPolygonMethods");
   rb_define_method(geos_polygon_methods, "rep_equals?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_methods, "eql?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_methods, "hash", method_polygon_hash, 0);
@@ -299,42 +299,6 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals)
   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/polygon.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the polygon module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_polygon(RGeo_Globals* globals);
+void rgeo_init_geos_polygon();
 
 /*
   Comopares the values of two GEOS polygons. The two given geometries MUST

data/ext/geos_c_impl/preface.h

@@ -27,6 +27,11 @@
 #ifdef HAVE_RB_MEMHASH
 #define RGEO_SUPPORTS_NEW_HASHING
 #endif
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define mark rb_gc_mark_movable
+#else
+#define mark rb_gc_mark
+#endif
 
 #ifndef RGEO_SUPPORTS_NEW_HASHING
 #define st_index_t int
@@ -42,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)))

data/lib/rgeo/cartesian/analysis.rb

@@ -22,12 +22,12 @@ module RGeo
         # == Note
         #
         # This method does not ensure a correct result for an invalid geometry.
-        # You should make sure your ring is valid beforehand using `is_ring?`
+        # You should make sure your ring is valid beforehand using `ring?`
         # if you are using a LineString, or directly `valid?` for a
         # `linear_ring?`.
         # This will be subject to changes in v3.
         def ccw?(ring)
-          if RGeo::Geos.is_capi_geos?(ring) && RGeo::Geos::Analysis.ccw_supported?
+          if RGeo::Geos.capi_geos?(ring) && RGeo::Geos::Analysis.ccw_supported?
             RGeo::Geos::Analysis.ccw?(ring)
           else
             RGeo::Cartesian::Analysis.ring_direction(ring) == 1

data/lib/rgeo/cartesian/calculations.rb

@@ -69,41 +69,78 @@ module RGeo
       end
 
       def intersects_segment?(seg)
+        !segment_intersection(seg).nil?
+      end
+
+      # If this and the other segment intersect, this method will return the coordinate
+      # at which they intersect, otherwise nil.
+      # In the case of a partial overlap (parallel segments), this will return
+      # a single point on the overlapping portion.
+      #
+      # @param seg [Segment]
+      #
+      # @return [RGeo::Feature::Point, nil]
+      def segment_intersection(seg)
         s2 = seg.s
         # Handle degenerate cases
         if seg.degenerate?
-          if @lensq == 0
-            return @s == s2
+          if @lensq == 0 && @s == s2
+            return @s
           else
-            return contains_point?(s2)
+            return contains_point?(s2) ? s2 : nil
           end
         elsif @lensq == 0
-          return seg.contains_point?(@s)
+          return seg.contains_point?(@s) ? @s : nil
         end
+
         # Both segments have nonzero length.
         sx2 = s2.x
         sy2 = s2.y
         dx2 = seg.dx
         dy2 = seg.dy
         denom = @dx * dy2 - @dy * dx2
+
         if denom == 0
           # Segments are parallel. Make sure they are collinear.
-          return false unless side(s2) == 0
-          # 1-D check.
-          ts = (@dx * (sx2 - @sx) + @dy * (sy2 - @sy)) / @lensq
-          te = (@dx * (sx2 + dx2 - @sx) + @dy * (sy2 + dy2 - @sy)) / @lensq
-          if ts < te
-            te >= 0.0 && ts <= 1.0
-          else
-            ts >= 0.0 && te <= 1.0
-          end
+          return nil unless side(s2) == 0
+
+          # return the first point it finds that intersects another line.
+          # In many cases, the intersection is actually another line
+          # segment, but for now, we will just return a single point.
+          return s2 if contains_point?(s2)
+          return seg.e if contains_point?(seg.e)
+          return @s if seg.contains_point?(@s)
+          return @e if seg.contains_point?(@e)
+          nil
         else
           # Segments are not parallel. Check the intersection of their
           # containing lines.
-          t = (dy2 * (sx2 - @sx) + dx2 * (@sy - sy2)) / denom
-          return false if t < 0.0 || t > 1.0
-          t2 = (@dy * (sx2 - @sx) + @dx * (@sy - sy2)) / denom
-          t2 >= 0.0 && t2 <= 1.0
+          num1 = dx2 * (@sy - sy2) - (dy2 * (@sx - sx2))
+          num2 = @dx * (@sy - sy2) - (@dy * (@sx - sx2))
+          cross1 = num1 / denom
+          cross2 = num2 / denom
+
+          return nil if cross1 < 0.0 || cross1 > 1.0
+          if cross2 >= 0.0 && cross2 <= 1.0
+            x = @sx + (cross1 * @dx)
+            y = @sy + (cross1 * @dy)
+
+            # Check if this segment contains the point.
+            # Sometimes round-off errors occur and intersections
+            # are recorded as off the line segments.
+            #
+            # If this is the case, return the closest point from
+            # either segment.
+            int_pt = @s.factory.point(x, y)
+            if contains_point?(int_pt)
+              int_pt
+            else
+              # find closest of @s, @e, seg.s, seg.e
+              [@e, seg.s, seg.e].reduce(@s) do |closest, pt|
+                int_pt.distance(pt) < int_pt.distance(closest) ? pt : closest
+              end
+            end
+          end
         end
       end