rgeo 3.0.0.pre.rc.3 → 3.0.1

data/ext/geos_c_impl/geometry.c

@@ -266,6 +266,7 @@ method_geometry_as_text(VALUE self)
       wkt_writer = factory_data->wkt_writer;
       if (!wkt_writer) {
         wkt_writer = GEOSWKTWriter_create();
+        GEOSWKTWriter_setOutputDimension(wkt_writer, 2);
         GEOSWKTWriter_setTrim(wkt_writer, 1);
         factory_data->wkt_writer = wkt_writer;
       }
@@ -304,6 +305,7 @@ method_geometry_as_binary(VALUE self)
 
       if (!wkb_writer) {
         wkb_writer = GEOSWKBWriter_create();
+        GEOSWKBWriter_setOutputDimension(wkb_writer, 2);
         factory_data->wkb_writer = wkb_writer;
       }
       str = (char*)GEOSWKBWriter_write(wkb_writer, self_geom, &size);
@@ -367,7 +369,6 @@ method_geometry_equals(VALUE self, VALUE rhs)
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
-  char val;
 
   // Shortcut when self and rhs are the same object.
   if (self == rhs) {
@@ -385,12 +386,7 @@ method_geometry_equals(VALUE self, VALUE rhs)
       if (GEOSisEmpty(self_geom) == 1 && GEOSisEmpty(rhs_geom) == 1) {
         result = Qtrue;
       } else {
-        val = GEOSEquals(self_geom, rhs_geom);
-        if (val == 0) {
-          result = Qfalse;
-        } else if (val == 1) {
-          result = Qtrue;
-        }
+        result = GEOSEquals(self_geom, rhs_geom) ? Qtrue : Qfalse;
       }
     }
   }
@@ -411,7 +407,7 @@ method_geometry_disjoint(VALUE self, VALUE rhs)
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
-  char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -420,21 +416,18 @@ method_geometry_disjoint(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedDisjoint(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      result = GEOSPreparedDisjoint(prep, rhs_geom) ? Qtrue : Qfalse;
+    else
 #endif
-        val = GEOSDisjoint(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
-    }
+      result = GEOSDisjoint(self_geom, rhs_geom) ? Qtrue : Qfalse;
   }
   return result;
 }
@@ -447,6 +440,7 @@ method_geometry_intersects(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
   const GEOSPreparedGeometry* prep;
 #endif
@@ -455,20 +449,22 @@ method_geometry_intersects(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedIntersects(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedIntersects(prep, rhs_geom);
+    else
 #endif
-        val = GEOSIntersects(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSIntersects(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -482,6 +478,7 @@ method_geometry_touches(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -490,20 +487,22 @@ method_geometry_touches(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedTouches(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedTouches(prep, rhs_geom);
+    else
 #endif
-        val = GEOSTouches(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSTouches(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -517,6 +516,7 @@ method_geometry_crosses(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -525,20 +525,22 @@ method_geometry_crosses(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedCrosses(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedCrosses(prep, rhs_geom);
+    else
 #endif
-        val = GEOSCrosses(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSCrosses(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -552,6 +554,7 @@ method_geometry_within(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -560,20 +563,22 @@ method_geometry_within(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedWithin(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedWithin(prep, rhs_geom);
+    else
 #endif
-        val = GEOSWithin(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSWithin(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -587,6 +592,7 @@ method_geometry_contains(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
   const GEOSPreparedGeometry* prep;
 #endif
@@ -595,20 +601,22 @@ method_geometry_contains(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedContains(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedContains(prep, rhs_geom);
+    else
 #endif
-        val = GEOSContains(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSContains(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -622,6 +630,7 @@ method_geometry_overlaps(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -630,20 +639,22 @@ method_geometry_overlaps(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedOverlaps(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedOverlaps(prep, rhs_geom);
+    else
 #endif
-        val = GEOSOverlaps(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSOverlaps(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -657,19 +668,23 @@ method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
-      val = GEOSRelatePattern(self_geom, rhs_geom, StringValuePtr(pattern));
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
+
+    val = GEOSRelatePattern(self_geom, rhs_geom, StringValuePtr(pattern));
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -683,16 +698,20 @@ method_geometry_distance(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   double dist;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
-      if (GEOSDistance(self_geom, rhs_geom, &dist)) {
-        result = rb_float_new(dist);
-      }
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
+
+    if (GEOSDistance(self_geom, rhs_geom, &dist)) {
+      result = rb_float_new(dist);
     }
   }
   return result;
@@ -721,6 +740,27 @@ method_geometry_buffer(VALUE self, VALUE distance)
   return result;
 }
 
+#ifdef RGEO_GEOS_SUPPORTS_DENSIFY
+static VALUE
+method_geometry_segmentize(VALUE self, VALUE max_segment_length)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    factory = self_data->factory;
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSDensify(self_geom, rb_num2dbl(max_segment_length)), Qnil);
+  }
+  return result;
+}
+#endif
+
 static VALUE
 method_geometry_buffer_with_style(VALUE self,
                                   VALUE distance,
@@ -816,17 +856,20 @@ method_geometry_intersection(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSIntersection(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSIntersection(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -839,17 +882,20 @@ method_geometry_union(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result =
-        rgeo_wrap_geos_geometry(factory, GEOSUnion(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result =
+      rgeo_wrap_geos_geometry(factory, GEOSUnion(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -880,17 +926,20 @@ method_geometry_difference(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSDifference(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSDifference(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -903,17 +952,20 @@ method_geometry_sym_difference(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSSymDifference(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSSymDifference(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -1277,6 +1329,10 @@ rgeo_init_geos_geometry()
     geos_geometry_methods, "make_valid", method_geometry_make_valid, 0);
   rb_define_method(
     geos_geometry_methods, "polygonize", method_geometry_polygonize, 0);
+#ifdef RGEO_GEOS_SUPPORTS_DENSIFY
+  rb_define_method(
+    geos_geometry_methods, "segmentize", method_geometry_segmentize, 1);
+#endif
 }
 
 RGEO_END_C

data/ext/geos_c_impl/geometry_collection.c

@@ -31,7 +31,6 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
   VALUE result;
   unsigned int len;
   GEOSGeometry** geoms;
-  RGeo_FactoryData* factory_data;
   VALUE klass;
   unsigned int i;
   unsigned int j;
@@ -49,7 +48,6 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
     rb_raise(rb_eRGeoError, "not enough memory available");
   }
 
-  factory_data = RGEO_FACTORY_DATA_PTR(factory);
   klasses = Qnil;
   cast_type = Qnil;
   switch (type) {
@@ -66,9 +64,14 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
   for (i = 0; i < len; ++i) {
     geom = rgeo_convert_to_detached_geos_geometry(
       rb_ary_entry(array, i), factory, cast_type, &klass, &state);
-    if (state || !geom) {
-      break;
+    if (state) {
+      for (j = 0; j < i; j++) {
+        GEOSGeom_destroy(geoms[j]);
+      }
+      FREE(geoms);
+      rb_jump_tag(state);
     }
+
     geoms[i] = geom;
     if (!NIL_P(klass) && NIL_P(klasses)) {
       klasses = rb_ary_new2(len);
@@ -80,24 +83,19 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
       rb_ary_push(klasses, klass);
     }
   }
-  if (i != len) {
-    for (j = 0; j < i; ++j) {
-      GEOSGeom_destroy(geoms[j]);
-    }
-  } else {
-    collection = GEOSGeom_createCollection(type, geoms, len);
-    if (collection) {
-      result = rgeo_wrap_geos_geometry(factory, collection, module);
-      RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
-    }
-    // NOTE: We are assuming that GEOS will do its own cleanup of the
-    // element geometries if it fails to create the collection, so we
-    // are not doing that ourselves. If that turns out not to be the
-    // case, this will be a memory leak.
+  collection = GEOSGeom_createCollection(type, geoms, len);
+  if (collection) {
+    result = rgeo_wrap_geos_geometry(factory, collection, module);
+    RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
   }
+
+  // NOTE: We are assuming that GEOS will do its own cleanup of the
+  // element geometries if it fails to create the collection, so we
+  // are not doing that ourselves. If that turns out not to be the
+  // case, this will be a memory leak.
   FREE(geoms);
   if (state) {
-    rb_exc_raise(rb_errinfo()); // raise $!
+    rb_jump_tag(state);
   }
 
   return result;