rgeo 2.3.1 → 3.0.0.pre.rc.2

data/ext/geos_c_impl/factory.h

@@ -10,58 +10,13 @@
 
 RGEO_BEGIN_C
 
-/*
-  Per-interpreter globals.
-  Most of these are cached references to commonly used classes, modules,
-  and symbols so we don't have to do a lot of constant lookups and calls
-  to rb_intern.
-*/
-typedef struct {
-  VALUE feature_module;
-  VALUE feature_geometry;
-  VALUE feature_point;
-  VALUE feature_line_string;
-  VALUE feature_linear_ring;
-  VALUE feature_line;
-  VALUE feature_polygon;
-  VALUE feature_geometry_collection;
-  VALUE feature_multi_point;
-  VALUE feature_multi_line_string;
-  VALUE feature_multi_polygon;
-  VALUE geos_module;
-  VALUE geos_geometry;
-  VALUE geos_point;
-  VALUE geos_line_string;
-  VALUE geos_linear_ring;
-  VALUE geos_line;
-  VALUE geos_polygon;
-  VALUE geos_geometry_collection;
-  VALUE geos_multi_point;
-  VALUE geos_multi_line_string;
-  VALUE geos_multi_polygon;
-  ID id_cast;
-  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
-  VALUE psych_wkt_generator;
-  VALUE marshal_wkb_generator;
-#endif
-} RGeo_Globals;
-
-
 /*
   Wrapped structure for Factory objects.
   A factory encapsulates the GEOS context, and GEOS serializer settings.
   It also stores the SRID for all geometries created by this factory,
   and the resolution for buffers created for this factory's geometries.
-  Finally, it provides easy access to the globals.
 */
 typedef struct {
-  RGeo_Globals* globals;
   GEOSContextHandle_t geos_context;
   GEOSWKTReader* wkt_reader;
   GEOSWKBReader* wkb_reader;
@@ -82,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.
@@ -119,18 +97,30 @@ typedef struct {
 } RGeo_GeometryData;
 
 
+// Data types which indicate how RGeo types should be managed by Ruby.
+extern const rb_data_type_t rgeo_factory_type;
+
+extern const rb_data_type_t rgeo_geometry_type;
+
+
+// Convenient macros for checking the type of data from Ruby
+#define RGEO_FACTORY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_factory_type))
+#define RGEO_GEOMETRY_TYPEDDATA_P(object) (_RGEO_TYPEDDATA_P(object, &rgeo_geometry_type))
+
+#define _RGEO_TYPEDDATA_P(object, data_type) (TYPE(object) == T_DATA && RTYPEDDATA(object)->typed_flag == 1 && RTYPEDDATA(object)->type == data_type)
+
 // Returns the RGeo_FactoryData* given a ruby Factory object
-#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)DATA_PTR(factory))
+#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)RTYPEDDATA_DATA(factory))
 
 // Returns the RGeo_GeometryData* given a ruby Geometry object
-#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)DATA_PTR(geometry))
+#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)RTYPEDDATA_DATA(geometry))
 
 
 /*
   Initializes the factory module. This should be called first in the
   initialization process.
 */
-RGeo_Globals* rgeo_init_geos_factory();
+void rgeo_init_geos_factory();
 
 /*
   Given a GEOS geometry handle, wraps it in a ruby Geometry object of the
@@ -177,8 +167,15 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
   result of this function to build a GEOS-backed clone of the original
   geometry, or to include the given geometry in a collection while keeping
   the klasses intact.
+
+  The state parameter is given to follow `rb_protect*` ruby methods: this
+  method calls `#cast`, and this call may raise. if it does raise, state
+  will be set to a non-zero value, and you'll have access to the error
+  in `rb_errinfo()`. IT IS THE CALLER'S RESPONSIBILITY TO PROPAGATE THE
+  ERROR. You could also discard the error with `rb_set_errinfo(Qnil)`,
+  this will just ignore the error altogether.
 */
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses);
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses, int* state);
 
 /*
   Returns 1 if the given ruby object is a GEOS Geometry implementation,
@@ -197,15 +194,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

@@ -11,6 +11,9 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
+#include "errors.h"
 #include "factory.h"
 #include "geometry.h"
 
@@ -180,13 +183,11 @@ static VALUE method_geometry_geometry_type(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
-  const GEOSGeometry* self_geom;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  self_geom = self_data->geom;
-  if (self_geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_geometry;
+  if (self_data->geom) {
+    result = rgeo_feature_geometry_module;
   }
   return result;
 }
@@ -271,7 +272,7 @@ static VALUE method_geometry_as_text(VALUE self)
     factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
     wkt_generator = factory_data->wkrep_wkt_generator;
     if (!NIL_P(wkt_generator)) {
-      result = rb_funcall(wkt_generator, factory_data->globals->id_generate, 1, self);
+      result = rb_funcall(wkt_generator, rb_intern("generate"), 1, self);
     }
     else {
       wkt_writer = factory_data->wkt_writer;
@@ -310,7 +311,7 @@ static VALUE method_geometry_as_binary(VALUE self)
     factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
     wkb_generator = factory_data->wkrep_wkb_generator;
     if (!NIL_P(wkb_generator)) {
-      result = rb_funcall(wkb_generator, factory_data->globals->id_generate, 1, self);
+      result = rb_funcall(wkb_generator, rb_intern("generate"), 1, self);
     }
     else {
       wkb_writer = factory_data->wkb_writer;
@@ -385,6 +386,11 @@ static VALUE method_geometry_equals(VALUE self, VALUE rhs)
   GEOSContextHandle_t self_context;
   char val;
 
+  // Shortcut when self and rhs are the same object.
+  if (self == rhs) {
+    return Qtrue;
+  }
+
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
@@ -863,24 +869,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 +1047,65 @@ 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_invalid_reason_location(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* location = NULL;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    // We use NULL there to tell GEOS that we don't care about the reason.
+    switch(GEOSisValidDetail_r(self_data->geos_context, self_geom, 0, NULL, &location)) {
+      case 0: // invalid
+        result = rgeo_wrap_geos_geometry(self_data->factory, location, Qnil);
+      case 1: // valid
+        break;
+      case 2: // exception
+        break;
+      default:
+        break;
+    };
+  }
+  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,15 +1121,64 @@ static VALUE method_geometry_point_on_surface(VALUE self)
   return result;
 }
 
+/**
+  * call-seq:
+  *   some.polygonize -> RGeo::Feature::GeometryCollection
+  *
+  * Polygonizes a set of Geometries which contain linework that
+  * represents the edges of a planar graph.
+  *
+  * All types of Geometry are accepted as input;
+  * the constituent linework is extracted as the edges to be polygonized.
+  * 
+  * The edges must be correctly noded;
+  * that is, they must only meet at their endpoints and not overlap anywhere.
+  *
+  * @see https://libgeos.org/doxygen/geos__c_8h.html#a9d98e448d3b846d591c726d1c0000d25 GEOSPolygonize
+  */
+static VALUE method_geometry_polygonize(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* geos_polygon_collection;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    geos_polygon_collection = GEOSPolygonize_r(self_data->geos_context, &self_geom, 1);
+
+    if (geos_polygon_collection == NULL) {
+      rb_raise(rb_eGeosError, "GEOS can't polygonize this geometry.");
+    }
+
+    result = rgeo_wrap_geos_geometry(self_data->factory, geos_polygon_collection, Qnil);
+  }
+  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 ****/
 
 
-void rgeo_init_geos_geometry(RGeo_Globals* globals)
+void rgeo_init_geos_geometry()
 {
   VALUE geos_geometry_methods;
 
-  geos_geometry_methods = rb_define_module_under(globals->geos_module, "CAPIGeometryMethods");
+  geos_geometry_methods = rb_define_module_under(rgeo_geos_module, "CAPIGeometryMethods");
 
   rb_define_method(geos_geometry_methods, "factory=", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_methods, "initialize_copy", method_geometry_initialize_copy, 1);
@@ -1125,7 +1224,10 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_methods, "sym_difference", method_geometry_sym_difference, 1);
   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, "invalid_reason_location", method_geometry_invalid_reason_location, 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);
+  rb_define_method(geos_geometry_methods, "polygonize", method_geometry_polygonize, 0);
 }
 
 

data/ext/geos_c_impl/geometry.h

@@ -6,8 +6,6 @@
 #ifndef RGEO_GEOS_GEOMETRY_INCLUDED
 #define RGEO_GEOS_GEOMETRY_INCLUDED
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -15,8 +13,15 @@ RGEO_BEGIN_C
   Initializes the geometry module. This should be called after the factory
   module is initialized, but before any of the other modules.
 */
-void rgeo_init_geos_geometry(RGeo_Globals* globals);
+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