rgeo 0.5.1 → 0.5.2

data/ext/geos_c_impl/factory.h

@@ -0,0 +1,238 @@
+/*
+  Factory and utility functions for GEOS wrapper
+*/
+
+#ifndef RGEO_GEOS_FACTORY_INCLUDED
+#define RGEO_GEOS_FACTORY_INCLUDED
+
+#include <ruby.h>
+#include <geos_c.h>
+
+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;
+  GEOSWKTWriter* wkt_writer;
+  GEOSWKBWriter* wkb_writer;
+  VALUE wkrep_wkt_generator;
+  VALUE wkrep_wkb_generator;
+  VALUE wkrep_wkt_parser;
+  VALUE wkrep_wkb_parser;
+  GEOSWKTReader* psych_wkt_reader;
+  GEOSWKBReader* marshal_wkb_reader;
+  GEOSWKTWriter* psych_wkt_writer;
+  GEOSWKBWriter* marshal_wkb_writer;
+  VALUE proj4_obj;
+  VALUE coord_sys_obj;
+  int flags;
+  int srid;
+  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
+
+
+/*
+  Wrapped structure for Geometry objects.
+  Includes a handle to the underlying GEOS geometry itself (which could
+  be null for an uninitialized geometry).
+  It also provides a handle to the factory that created this geometry.
+
+  The klasses object is used by geometry collections. Its value is
+  generally an array of the ruby classes for the colletion's elements,
+  so that we can reproduce the exact class for those elements in cases
+  where the class cannot be inferred directly from the GEOS type (as
+  in Line objects, which have no GEOS type). Any array element, or the
+  array itself, could be Qnil, indicating fall back to the default
+  inferred from the GEOS type.
+
+  The GEOS context handle is also included here. Ideally, it would be
+  available by following the factory reference and getting it from the
+  factory data. However, one use case is in the destroy_geometry_func
+  in factory.c, and Rubinius 1.1.1 seems to crash when you try to
+  evaluate a DATA_PTR from that function, so we copy the context handle
+  here so the destroy_geometry_func can get to it.
+*/
+typedef struct {
+  GEOSContextHandle_t geos_context;
+  GEOSGeometry* geom;
+  const GEOSPreparedGeometry* prep;
+  VALUE factory;
+  VALUE klasses;
+} RGeo_GeometryData;
+
+
+// Returns the RGeo_FactoryData* given a ruby Factory object
+#define RGEO_FACTORY_DATA_PTR(factory) ((RGeo_FactoryData*)DATA_PTR(factory))
+
+// Returns the RGeo_GeometryData* given a ruby Geometry object
+#define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)DATA_PTR(geometry))
+
+
+/*
+  Initializes the factory module. This should be called first in the
+  initialization process.
+*/
+RGeo_Globals* rgeo_init_geos_factory();
+
+/*
+  Given a GEOS geometry handle, wraps it in a ruby Geometry object of the
+  given klass. The geometry is then owned by the ruby object, so make sure
+  you clone the GEOS object first if something else thinks it owns it.
+  You may pass Qnil for the klass to have the klass auto-detected. (But
+  note that it cannot auto-detect the Line type because GEOS doesn't
+  explicitly represent that type-- it will come out as LineString.)
+  You may also pass a ruby Array for the klass if the geometry is a
+  collection of some sort. In this case, the array elements should be the
+  classes for the elements of the collection.
+  Returns Qnil if the wrapping failed for any reason.
+*/
+VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass);
+
+/*
+  Same as rgeo_wrap_geos_geometry except that it wraps a clone of the
+  given geom, so the original geom doesn't change ownership.
+*/
+VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VALUE klass);
+
+/*
+  Gets the GEOS geometry for a given ruby Geometry object. If the given
+  ruby object is not a GEOS geometry implementation, it is converted to a
+  GEOS implementation first. You may also optionally cast it to a type,
+  specified by an appropriate feature module. Passing Qnil for the type
+  disables this auto-cast. The returned GEOS geometry is owned by rgeo,
+  and you should not dispose it or take ownership of it yourself.
+*/
+const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type);
+
+/*
+  Gets a GEOS geometry for a given ruby Geometry object. You must provide
+  a GEOS factory for the geometry; the object is cast to that factory if
+  it is not already of it. You may also optionally cast it to a type,
+  specified by an appropriate feature module. Passing Qnil for the type
+  disables this auto-cast. The returned GEOS geometry is owned by the
+  caller-- that is, if the original ruby object is already of the desired
+  factory, the returned GEOS geometry is a clone of the original.
+
+  If the klasses parameter is not NULL, its referent is set to the
+  klasses saved in the original ruby Geometry object (if any), or else to
+  the class of the converted GEOS object. This is so that you can use the
+  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.
+*/
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses);
+
+/*
+  Returns 1 if the given ruby object is a GEOS Geometry implementation,
+  or 0 if not.
+*/
+char rgeo_is_geos_object(VALUE obj);
+
+/*
+  Gets the underlying GEOS geometry for a given ruby object. Returns NULL
+  if the given ruby object is not a GEOS geometry wrapper.
+*/
+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
+  are of the same type and factory), or Qfalse otherwise.
+*/
+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
+
+#endif

data/ext/geos_c_impl/geometry.c

@@ -0,0 +1,1028 @@
+/*
+  Geometry base class methods for GEOS wrapper
+*/
+
+
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include <string.h>
+#include <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+#include "geometry.h"
+
+RGEO_BEGIN_C
+
+
+/**** INTERNAL UTILITY FUNCTIONS ****/
+
+
+// Determine the dimension of the given geometry. Empty collections have dimension -1.
+// Recursively checks collection elemenets.
+
+static int compute_dimension(GEOSContextHandle_t context, const GEOSGeometry* geom)
+{
+  int result;
+  int size;
+  int i;
+  int dim;
+
+  result = -1;
+  if (geom) {
+    switch (GEOSGeomTypeId_r(context, geom)) {
+    case GEOS_POINT:
+      result = 0;
+      break;
+    case GEOS_MULTIPOINT:
+      if (!GEOSisEmpty_r(context, geom)) {
+        result = 0;
+      }
+      break;
+    case GEOS_LINESTRING:
+    case GEOS_LINEARRING:
+      result = 1;
+      break;
+    case GEOS_MULTILINESTRING:
+      if (!GEOSisEmpty_r(context, geom)) {
+        result = 1;
+      }
+      break;
+    case GEOS_POLYGON:
+      result = 2;
+      break;
+    case GEOS_MULTIPOLYGON:
+      if (!GEOSisEmpty_r(context, geom)) {
+        result = 2;
+      }
+      break;
+    case GEOS_GEOMETRYCOLLECTION:
+      size = GEOSGetNumGeometries_r(context, geom);
+      for (i=0; i<size; ++i) {
+        dim = compute_dimension(context, GEOSGetGeometryN_r(context, geom, i));
+        if (dim > result) {
+          result = dim;
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+
+
+// Returns a prepared geometry, honoring the preparation policy.
+
+static const GEOSPreparedGeometry* rgeo_request_prepared_geometry(RGeo_GeometryData* object_data)
+{
+  const GEOSPreparedGeometry* prep;
+
+  prep = object_data->prep;
+  if (prep == (const GEOSPreparedGeometry*)1) {
+    object_data->prep = (GEOSPreparedGeometry*)2;
+    prep = NULL;
+  }
+  else if (prep == (const GEOSPreparedGeometry*)2) {
+    if (object_data->geom) {
+      prep = GEOSPrepare_r(object_data->geos_context, object_data->geom);
+    }
+    else {
+      prep = NULL;
+    }
+    if (prep) {
+      object_data->prep = prep;
+    }
+    else {
+      object_data->prep = (const GEOSPreparedGeometry*)3;
+    }
+  }
+  else if (prep == (const GEOSPreparedGeometry*)3) {
+    prep = NULL;
+  }
+  return prep;
+}
+
+
+/**** RUBY METHOD DEFINITIONS ****/
+
+
+static VALUE method_geometry_initialized_p(VALUE self)
+{
+  return RGEO_GEOMETRY_DATA_PTR(self)->geom ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_geometry_factory(VALUE self)
+{
+  return RGEO_GEOMETRY_DATA_PTR(self)->factory;
+}
+
+
+static VALUE method_geometry_set_factory(VALUE self, VALUE factory)
+{
+  RGEO_GEOMETRY_DATA_PTR(self)->factory = factory;
+  return factory;
+}
+
+
+static VALUE method_geometry_prepared_p(VALUE self)
+{
+  const GEOSPreparedGeometry* prep;
+
+  prep = RGEO_GEOMETRY_DATA_PTR(self)->prep;
+  return (prep && prep != (const GEOSPreparedGeometry*)1 &&
+    prep != (const GEOSPreparedGeometry*)2 &&
+    prep != (GEOSPreparedGeometry*)3) ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_geometry_prepare(VALUE self)
+{
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  if (self_data->geom) {
+    prep = self_data->prep;
+    if (!prep || prep == (const GEOSPreparedGeometry*)1 || prep == (const GEOSPreparedGeometry*)2) {
+      prep = GEOSPrepare_r(self_data->geos_context, self_data->geom);
+      if (prep) {
+        self_data->prep = prep;
+      }
+      else {
+        self_data->prep = (const GEOSPreparedGeometry*)3;
+      }
+    }
+  }
+  return self;
+}
+
+
+static VALUE method_geometry_dimension(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 = INT2NUM(compute_dimension(self_data->geos_context, self_geom));
+  }
+  return result;
+}
+
+
+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;
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_srid(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 = INT2NUM(GEOSGetSRID_r(self_data->geos_context, self_geom));
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_envelope(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t geos_context;
+  GEOSGeometry* envelope;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    geos_context = self_data->geos_context;
+    envelope = GEOSEnvelope_r(geos_context, self_geom);
+    if (!envelope) {
+      envelope = GEOSGeom_createCollection_r(geos_context, GEOS_GEOMETRYCOLLECTION, NULL, 0);
+    }
+    result = rgeo_wrap_geos_geometry(self_data->factory, envelope, Qnil);
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_boundary(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t geos_context;
+  GEOSGeometry* boundary;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    geos_context = self_data->geos_context;
+    boundary = GEOSBoundary_r(geos_context, self_geom);
+    if (boundary) {
+      result = rgeo_wrap_geos_geometry(self_data->factory, boundary, Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_as_text(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  RGeo_FactoryData* factory_data;
+  VALUE wkt_generator;
+  GEOSWKTWriter* wkt_writer;
+  GEOSContextHandle_t geos_context;
+  char* str;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    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);
+    }
+    else {
+      wkt_writer = factory_data->wkt_writer;
+      geos_context = self_data->geos_context;
+      if (!wkt_writer) {
+        wkt_writer = GEOSWKTWriter_create_r(geos_context);
+        factory_data->wkt_writer = wkt_writer;
+      }
+      str = GEOSWKTWriter_write_r(geos_context, wkt_writer, self_geom);
+      if (str) {
+        result = rb_str_new2(str);
+        GEOSFree_r(geos_context, str);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_as_binary(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  RGeo_FactoryData* factory_data;
+  VALUE wkb_generator;
+  GEOSWKBWriter* wkb_writer;
+  GEOSContextHandle_t geos_context;
+  size_t size;
+  char* str;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    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);
+    }
+    else {
+      wkb_writer = factory_data->wkb_writer;
+      geos_context = self_data->geos_context;
+      if (!wkb_writer) {
+        wkb_writer = GEOSWKBWriter_create_r(geos_context);
+        factory_data->wkb_writer = wkb_writer;
+      }
+      str = (char*)GEOSWKBWriter_write_r(geos_context, wkb_writer, self_geom, &size);
+      if (str) {
+        result = rb_str_new(str, size);
+        GEOSFree_r(geos_context, str);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_is_empty(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    val = GEOSisEmpty_r(self_data->geos_context, self_geom);
+    if (val == 0) {
+      result = Qfalse;
+    }
+    else if (val == 1) {
+      result = Qtrue;
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_is_simple(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    val = GEOSisSimple_r(self_data->geos_context, self_geom);
+    if (val == 0) {
+      result = Qfalse;
+    }
+    else if (val == 1) {
+      result = Qtrue;
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_equals(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  GEOSContextHandle_t self_context;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    rhs_geom = rgeo_get_geos_geometry_safe(rhs);
+    if (rhs_geom) {
+      self_context = self_data->geos_context;
+      // GEOS has a bug where empty geometries are not spatially equal
+      // to each other. Work around this case first.
+      if (GEOSisEmpty_r(self_context, self_geom) == 1 &&
+          GEOSisEmpty_r(RGEO_GEOMETRY_DATA_PTR(rhs)->geos_context, rhs_geom) == 1) {
+        result = Qtrue;
+      }
+      else {
+        val = GEOSEquals_r(self_context, self_geom, rhs_geom);
+        if (val == 0) {
+          result = Qfalse;
+        }
+        else if (val == 1) {
+          result = Qtrue;
+        }
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_eql(VALUE self, VALUE rhs)
+{
+  // This should be overridden by the subclass.
+  return self == rhs ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_geometry_disjoint(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedDisjoint_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSDisjoint_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_intersects(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedIntersects_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSIntersects_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_touches(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedTouches_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSTouches_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_crosses(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedCrosses_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSCrosses_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_within(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedWithin_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSWithin_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_contains(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedContains_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSContains_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_overlaps(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  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) {
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedOverlaps_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSOverlaps_r(self_data->geos_context, self_geom, rhs_geom);
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom, StringValuePtr(pattern));
+      if (val == 0) {
+        result = Qfalse;
+      }
+      else if (val == 1) {
+        result = Qtrue;
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_distance(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  double dist;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom, &dist)) {
+        result = rb_float_new(dist);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_buffer(VALUE self, VALUE distance)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  int resolution;
+
+  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, GEOSBuffer_r(self_data->geos_context, self_geom,
+      rb_num2dbl(distance), RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution), Qnil);
+  }
+  return result;
+}
+
+static VALUE method_geometry_buffer_with_style(VALUE self, VALUE distance, VALUE endCapStyle, VALUE joinStyle, VALUE mitreLimit)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  int resolution;
+
+  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, 
+                                     GEOSBufferWithStyle_r(self_data->geos_context, self_geom,
+                                                           rb_num2dbl(distance),
+                                                           RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution,
+                                                           endCapStyle, joinStyle, mitreLimit),
+                                     Qnil);
+  }
+  return result;
+}
+
+static VALUE method_geometry_simplify(VALUE self, VALUE tolerance)
+{
+  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, GEOSSimplify_r(self_data->geos_context, self_geom,
+      rb_num2dbl(tolerance)), Qnil);
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_convex_hull(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_wrap_geos_geometry(self_data->factory, GEOSConvexHull_r(self_data->geos_context, self_geom), Qnil);
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_intersection(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_union(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_difference(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_sym_difference(VALUE self, VALUE rhs)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  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_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
+{
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+  const GEOSGeometry* geom;
+  RGeo_GeometryData* orig_data;
+  GEOSContextHandle_t orig_context;
+  GEOSGeometry* clone_geom;
+  RGeo_FactoryData* factory_data;
+
+  // Clear out any existing value
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  if (self_data->geom) {
+    GEOSGeom_destroy_r(self_data->geos_context, self_data->geom);
+    self_data->geom = NULL;
+  }
+  prep = self_data->prep;
+  if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+    GEOSPreparedGeom_destroy_r(self_data->geos_context, prep);
+  }
+  self_data->prep = NULL;
+  self_data->geos_context = NULL;
+  self_data->factory = Qnil;
+  self_data->klasses = Qnil;
+
+  // Copy value from orig
+  geom = rgeo_get_geos_geometry_safe(orig);
+  if (geom) {
+    orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
+    orig_context = orig_data->geos_context;
+    clone_geom = GEOSGeom_clone_r(orig_context, geom);
+    if (clone_geom) {
+      factory_data = RGEO_FACTORY_DATA_PTR(orig_data->factory);
+      GEOSSetSRID_r(orig_context, clone_geom, GEOSGetSRID_r(orig_context, geom));
+      self_data->geom = clone_geom;
+      self_data->geos_context = orig_context;
+      self_data->prep = factory_data && ((factory_data->flags & RGEO_FACTORYFLAGS_PREPARE_HEURISTIC) != 0) ?
+        (GEOSPreparedGeometry*)1 : NULL;
+      self_data->factory = orig_data->factory;
+      self_data->klasses = orig_data->klasses;
+    }
+  }
+  return self;
+}
+
+
+static VALUE method_geometry_steal(VALUE self, VALUE orig)
+{
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+  const GEOSGeometry* geom;
+  RGeo_GeometryData* orig_data;
+
+  geom = rgeo_get_geos_geometry_safe(orig);
+  if (geom) {
+    // Clear out any existing value
+    self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    if (self_data->geom) {
+      GEOSGeom_destroy_r(self_data->geos_context, self_data->geom);
+    }
+    prep = self_data->prep;
+    if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+      GEOSPreparedGeom_destroy_r(self_data->geos_context, prep);
+    }
+
+    // Steal value from orig
+    orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
+    self_data->geom = orig_data->geom;
+    self_data->prep = orig_data->prep;
+    self_data->geos_context = orig_data->geos_context;
+    self_data->factory = orig_data->factory;
+    self_data->klasses = orig_data->klasses;
+
+    // Clear out orig
+    orig_data->geom = NULL;
+    orig_data->prep = NULL;
+    orig_data->geos_context = NULL;
+    orig_data->factory = Qnil;
+    orig_data->klasses = Qnil;
+  }
+  return self;
+}
+
+
+/**** INITIALIZATION FUNCTION ****/
+
+
+void rgeo_init_geos_geometry(RGeo_Globals* globals)
+{
+  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, "buffer_with_style", method_geometry_buffer_with_style, 4);
+  rb_define_method(geos_geometry_methods, "simplify", method_geometry_simplify, 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);
+}
+
+
+RGEO_END_C
+
+#endif