schleyfox-rgeo 0.2.5

data/ext/geos_c_impl/factory.h

@@ -0,0 +1,224 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Factory and utility functions for GEOS wrapper
+  
+  -----------------------------------------------------------------------------
+  Copyright 2010 Daniel Azuma
+  
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of the copyright holder, nor the names of any other
+    contributors to this software, may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+  -----------------------------------------------------------------------------
+*/
+
+
+#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 and modules
+  so we don't have to do a lot of constant lookups.
+*/
+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;
+} 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;
+  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
+
+
+/*
+  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 {
+  GEOSGeometry* geom;
+  GEOSContextHandle_t geos_context;
+  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);
+
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/geometry.c

@@ -0,0 +1,705 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Geometry base class methods for GEOS wrapper
+  
+  -----------------------------------------------------------------------------
+  Copyright 2010 Daniel Azuma
+  
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of the copyright holder, nor the names of any other
+    contributors to this software, may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+  -----------------------------------------------------------------------------
+*/
+
+
+#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 = -1;
+  int size, i;
+  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) {
+        int dim = compute_dimension(context, GEOSGetGeometryN_r(context, geom, i));
+        if (dim > result) {
+          result = dim;
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+
+
+/**** 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_dimension(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    GEOSContextHandle_t geos_context = self_data->geos_context;
+    GEOSGeometry* envelope = GEOSEnvelope_r(geos_context, self_geom);
+    // GEOS returns an "empty" point for an empty collection's envelope.
+    // We don't allow that type, so we replace it with an empty collection.
+    if (!envelope ||
+        GEOSGeomTypeId_r(geos_context, envelope) == GEOS_POINT &&
+        GEOSGetNumCoordinates_r(geos_context, envelope) == 0) {
+      if (envelope) {
+        GEOSGeom_destroy_r(geos_context, 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    GEOSContextHandle_t geos_context = self_data->geos_context;
+    GEOSGeometry* boundary = GEOSBoundary_r(geos_context, self_geom);
+    // GEOS returns NULL for the boundary of an empty collection.
+    // Replace that with an empty collection.
+    if (!boundary) {
+      boundary = GEOSGeom_createCollection_r(geos_context, GEOS_GEOMETRYCOLLECTION, NULL, 0);
+    }
+    result = rgeo_wrap_geos_geometry(self_data->factory, boundary, Qnil);
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_as_text(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
+    GEOSWKTWriter* wkt_writer = factory_data->wkt_writer;
+    GEOSContextHandle_t geos_context = self_data->geos_context;
+    if (!wkt_writer) {
+      wkt_writer = GEOSWKTWriter_create_r(geos_context);
+      factory_data->wkt_writer = wkt_writer;
+    }
+    char* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
+    GEOSWKBWriter* wkb_writer = factory_data->wkb_writer;
+    GEOSContextHandle_t geos_context = self_data->geos_context;
+    if (!wkb_writer) {
+      wkb_writer = GEOSWKBWriter_create_r(geos_context);
+      factory_data->wkb_writer = wkb_writer;
+    }
+    size_t size;
+    char* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_get_geos_geometry_safe(rhs);
+    if (rhs_geom) {
+      GEOSContextHandle_t 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 {
+        char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      char 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    if (rhs_geom) {
+      double dist;
+      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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    VALUE factory = self_data->factory;
+    int resolution = NUM2INT(RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution);
+    result = rgeo_wrap_geos_geometry(factory, GEOSBuffer_r(self_data->geos_context, self_geom, rb_num2dbl(distance), resolution), Qnil);
+  }
+  return result;
+}
+
+
+static VALUE method_geometry_convex_hull(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    VALUE factory = self_data->factory;
+    const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    VALUE factory = self_data->factory;
+    const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    VALUE factory = self_data->factory;
+    const GEOSGeometry* 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 = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    VALUE factory = self_data->factory;
+    const GEOSGeometry* 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_polygonize(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if(self_geom) {
+    GEOSGeometry const *vgeoms[1];
+    GEOSContextHandle_t geos_context = self_data->geos_context;
+    GEOSGeometry *geos_result;
+    vgeoms[0] = self_geom;
+
+    geos_result = GEOSPolygonize_r(geos_context, vgeoms, 1);
+    result = rgeo_wrap_geos_geometry(self_data->factory, geos_result, Qnil);
+  }
+  return result;
+}
+
+static VALUE alloc_geometry(VALUE klass)
+{
+  return rgeo_wrap_geos_geometry(Qnil, NULL, klass);
+}
+
+
+static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
+{
+  // Clear out any existing value
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    GEOSGeom_destroy_r(self_data->geos_context, self_geom);
+    self_data->geom = NULL;
+    self_data->geos_context = NULL;
+    self_data->factory = Qnil;
+    self_data->klasses = Qnil;
+  }
+  
+  // Copy value from orig
+  const GEOSGeometry* geom = rgeo_get_geos_geometry_safe(orig);
+  if (geom) {
+    RGeo_GeometryData* orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
+    GEOSContextHandle_t orig_context = orig_data->geos_context;
+    GEOSGeometry* clone_geom = GEOSGeom_clone_r(orig_context, geom);
+    if (clone_geom) {
+      GEOSSetSRID_r(orig_context, clone_geom, GEOSGetSRID_r(orig_context, geom));
+      self_data->geom = clone_geom;
+      self_data->geos_context = orig_context;
+      self_data->factory = orig_data->factory;
+      self_data->klasses = orig_data->klasses;
+    }
+  }
+  return self;
+}
+
+
+/**** INITIALIZATION FUNCTION ****/
+
+
+void rgeo_init_geos_geometry(RGeo_Globals* globals)
+{
+  VALUE geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
+  globals->geos_geometry = geos_geometry_class;
+  globals->feature_geometry = rb_const_get_at(globals->feature_module, rb_intern("Geometry"));
+  
+  rb_define_alloc_func(geos_geometry_class, alloc_geometry);
+  rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);
+  rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
+  rb_define_method(geos_geometry_class, "initialized?", method_geometry_initialized_p, 0);
+  rb_define_method(geos_geometry_class, "factory", method_geometry_factory, 0);
+  rb_define_method(geos_geometry_class, "dimension", method_geometry_dimension, 0);
+  rb_define_method(geos_geometry_class, "geometry_type", method_geometry_geometry_type, 0);
+  rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);
+  rb_define_method(geos_geometry_class, "envelope", method_geometry_envelope, 0);
+  rb_define_method(geos_geometry_class, "boundary", method_geometry_boundary, 0);
+  rb_define_method(geos_geometry_class, "as_text", method_geometry_as_text, 0);
+  rb_define_method(geos_geometry_class, "to_s", method_geometry_as_text, 0);
+  rb_define_method(geos_geometry_class, "as_binary", method_geometry_as_binary, 0);
+  rb_define_method(geos_geometry_class, "is_empty?", method_geometry_is_empty, 0);
+  rb_define_method(geos_geometry_class, "is_simple?", method_geometry_is_simple, 0);
+  rb_define_method(geos_geometry_class, "equals?", method_geometry_equals, 1);
+  rb_define_method(geos_geometry_class, "==", method_geometry_equals, 1);
+  rb_define_method(geos_geometry_class, "eql?", method_geometry_eql, 1);
+  rb_define_method(geos_geometry_class, "disjoint?", method_geometry_disjoint, 1);
+  rb_define_method(geos_geometry_class, "intersects?", method_geometry_intersects, 1);
+  rb_define_method(geos_geometry_class, "touches?", method_geometry_touches, 1);
+  rb_define_method(geos_geometry_class, "crosses?", method_geometry_crosses, 1);
+  rb_define_method(geos_geometry_class, "within?", method_geometry_within, 1);
+  rb_define_method(geos_geometry_class, "contains?", method_geometry_contains, 1);
+  rb_define_method(geos_geometry_class, "overlaps?", method_geometry_overlaps, 1);
+  rb_define_method(geos_geometry_class, "relate?", method_geometry_relate, 2);
+  rb_define_method(geos_geometry_class, "distance", method_geometry_distance, 1);
+  rb_define_method(geos_geometry_class, "buffer", method_geometry_buffer, 1);
+  rb_define_method(geos_geometry_class, "convex_hull", method_geometry_convex_hull, 0);
+  rb_define_method(geos_geometry_class, "intersection", method_geometry_intersection, 1);
+  rb_define_method(geos_geometry_class, "*", method_geometry_intersection, 1);
+  rb_define_method(geos_geometry_class, "union", method_geometry_union, 1);
+  rb_define_method(geos_geometry_class, "+", method_geometry_union, 1);
+  rb_define_method(geos_geometry_class, "difference", method_geometry_difference, 1);
+  rb_define_method(geos_geometry_class, "-", method_geometry_difference, 1);
+  rb_define_method(geos_geometry_class, "sym_difference", method_geometry_sym_difference, 1);
+  rb_define_method(geos_geometry_class, "polygonize", method_geometry_polygonize, 0);
+}
+
+
+RGEO_END_C
+
+#endif