schleyfox-rgeo 0.2.5

data/ext/geos_c_impl/line_string.h

@@ -0,0 +1,64 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Line string 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.
+  -----------------------------------------------------------------------------
+*/
+
+
+#ifndef RGEO_GEOS_LINE_STRING_INCLUDED
+#define RGEO_GEOS_LINE_STRING_INCLUDED
+
+#include <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+
+RGEO_BEGIN_C
+
+
+/*
+  Initializes the line string module. This should be called after
+  the geometry module is initialized.
+*/
+void rgeo_init_geos_line_string(RGeo_Globals* globals);
+
+/*
+  Determines whether the given GEOS line string is closed.
+  Returns Qtrue if true, Qfalse if false, or Qnil on an error.
+*/
+VALUE rgeo_is_geos_line_string_closed(GEOSContextHandle_t context, const GEOSGeometry* geom);
+
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/main.c

@@ -0,0 +1,70 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Main initializer 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 <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+#include "geometry.h"
+#include "point.h"
+#include "line_string.h"
+#include "polygon.h"
+#include "geometry_collection.h"
+
+#endif
+
+RGEO_BEGIN_C
+
+
+void Init_geos_c_impl()
+{
+#ifdef RGEO_GEOS_SUPPORTED
+  RGeo_Globals* globals = rgeo_init_geos_factory();
+  rgeo_init_geos_geometry(globals);
+  rgeo_init_geos_point(globals);
+  rgeo_init_geos_line_string(globals);
+  rgeo_init_geos_polygon(globals);
+  rgeo_init_geos_geometry_collection(globals);
+#endif
+}
+
+
+RGEO_END_C

data/ext/geos_c_impl/point.c

@@ -0,0 +1,193 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Point 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 <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+#include "geometry.h"
+#include "point.h"
+
+RGEO_BEGIN_C
+
+
+static VALUE method_point_geometry_type(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  if (self_data->geom) {
+    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_point;
+  }
+  return result;
+}
+
+
+static VALUE method_point_x(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 self_context = self_data->geos_context;
+    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
+    if (coord_seq) {
+      double val;
+      if (GEOSCoordSeq_getX_r(self_context, coord_seq, 0, &val)) {
+        result = rb_float_new(val);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_point_y(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 self_context = self_data->geos_context;
+    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
+    if (coord_seq) {
+      double val;
+      if (GEOSCoordSeq_getY_r(self_context, coord_seq, 0, &val)) {
+        result = rb_float_new(val);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE get_3d_point(VALUE self, int flag)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    if (RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & flag) {
+      GEOSContextHandle_t self_context = self_data->geos_context;
+      const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(self_context, self_geom);
+      if (coord_seq) {
+        double val;
+        if (GEOSCoordSeq_getZ_r(self_context, coord_seq, 0, &val)) {
+          result = rb_float_new(val);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_point_z(VALUE self)
+{
+  return get_3d_point(self, RGEO_FACTORYFLAGS_SUPPORTS_Z);
+}
+
+
+static VALUE method_point_m(VALUE self)
+{
+  return get_3d_point(self, RGEO_FACTORYFLAGS_SUPPORTS_M);
+}
+
+
+static VALUE method_point_eql(VALUE self, VALUE rhs)
+{
+  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  if (RTEST(result)) {
+    RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    result = rgeo_geos_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+  }
+  return result;
+}
+
+
+static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
+{
+  return rgeo_create_geos_point(factory, rb_num2dbl(x), rb_num2dbl(y),
+    RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M ? rb_num2dbl(z) : 0);
+}
+
+
+void rgeo_init_geos_point(RGeo_Globals* globals)
+{
+  VALUE geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", globals->geos_geometry);
+  globals->geos_point = geos_point_class;
+  globals->feature_point = rb_const_get_at(globals->feature_module, rb_intern("Point"));
+  
+  rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
+  
+  rb_define_method(geos_point_class, "eql?", method_point_eql, 1);
+  rb_define_method(geos_point_class, "geometry_type", method_point_geometry_type, 0);
+  rb_define_method(geos_point_class, "x", method_point_x, 0);
+  rb_define_method(geos_point_class, "y", method_point_y, 0);
+  rb_define_method(geos_point_class, "z", method_point_z, 0);
+  rb_define_method(geos_point_class, "m", method_point_m, 0);
+}
+
+
+VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z)
+{
+  VALUE result = Qnil;
+  RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  GEOSContextHandle_t context = factory_data->geos_context;
+  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(context, 1, 3);
+  if (coord_seq) {
+    if (GEOSCoordSeq_setX_r(context, coord_seq, 0, x)) {
+      if (GEOSCoordSeq_setY_r(context, coord_seq, 0, y)) {
+        if (GEOSCoordSeq_setZ_r(context, coord_seq, 0, z)) {
+          GEOSGeometry* geom = GEOSGeom_createPoint_r(context, coord_seq);
+          if (geom) {
+            result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_point);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/point.h

@@ -0,0 +1,62 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Point 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.
+  -----------------------------------------------------------------------------
+*/
+
+
+#ifndef RGEO_GEOS_POINT_INCLUDED
+#define RGEO_GEOS_POINT_INCLUDED
+
+#include <ruby.h>
+
+#include "factory.h"
+
+RGEO_BEGIN_C
+
+
+/*
+  Initializes the point module. This should be called after
+  the geometry module is initialized.
+*/
+void rgeo_init_geos_point(RGeo_Globals* globals);
+
+/*
+  Creates a 3d point and returns the ruby object.
+*/
+VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z);
+
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/polygon.c

@@ -0,0 +1,265 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  Polygon 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 <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+#include "geometry.h"
+#include "line_string.h"
+#include "polygon.h"
+
+RGEO_BEGIN_C
+
+
+static VALUE method_polygon_eql(VALUE self, VALUE rhs)
+{
+  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  if (RTEST(result)) {
+    RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    result = rgeo_geos_polygons_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_geometry_type(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  if (self_data->geom) {
+    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_polygon;
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_area(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    double area;
+    if (GEOSArea_r(self_data->geos_context, self_geom, &area)) {
+      result = rb_float_new(area);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_centroid(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, GEOSGetCentroid_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_point_on_surface(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, GEOSPointOnSurface_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_exterior_ring(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_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_num_interior_rings(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  const GEOSGeometry* self_geom = self_data->geom;
+  if (self_geom) {
+    int num = GEOSGetNumInteriorRings_r(self_data->geos_context, self_geom);
+    if (num >= 0) {
+      result = INT2NUM(num);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
+{
+  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_clone(self_data->factory, GEOSGetInteriorRingN_r(self_data->geos_context, self_geom, NUM2INT(n)), RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_interior_rings(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 self_context = self_data->geos_context;
+    int count = GEOSGetNumInteriorRings_r(self_context, self_geom);
+    if (count >= 0) {
+      result = rb_ary_new2(count);
+      VALUE factory = self_data->factory;
+      VALUE linear_ring_class = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring;
+      int i;
+      for (i=0; i<count; ++i) {
+        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), linear_ring_class));
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE interior_array)
+{
+  Check_Type(interior_array, T_ARRAY);
+  RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  VALUE linear_ring_type = factory_data->globals->feature_linear_ring;
+  GEOSGeometry* exterior_geom = rgeo_convert_to_detached_geos_geometry(exterior, factory, linear_ring_type, NULL);
+  if (exterior_geom) {
+    GEOSContextHandle_t context = factory_data->geos_context;
+    unsigned int len = (unsigned int)RARRAY_LEN(interior_array);
+    GEOSGeometry** interior_geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
+    if (interior_geoms) {
+      unsigned int actual_len = 0;
+      unsigned int i;
+      for (i=0; i<len; ++i) {
+        GEOSGeometry* interior_geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(interior_array, i), factory, linear_ring_type, NULL);
+        if (interior_geom) {
+          interior_geoms[actual_len++] = interior_geom;
+        }
+      }
+      if (len == actual_len) {
+        GEOSGeometry* polygon = GEOSGeom_createPolygon_r(context, exterior_geom, interior_geoms, actual_len);
+        if (polygon) {
+          free(interior_geoms);
+          return rgeo_wrap_geos_geometry(factory, polygon, factory_data->globals->geos_polygon);
+        }
+      }
+      for (i=0; i<actual_len; ++i) {
+        GEOSGeom_destroy_r(context, interior_geoms[i]);
+      }
+      free(interior_geoms);
+    }
+    GEOSGeom_destroy_r(context, exterior_geom);
+  }
+  return Qnil;
+}
+
+
+void rgeo_init_geos_polygon(RGeo_Globals* globals)
+{
+  VALUE geos_polygon_class = rb_define_class_under(globals->geos_module, "PolygonImpl", globals->geos_geometry);
+  globals->geos_polygon = geos_polygon_class;
+  globals->feature_polygon = rb_const_get_at(globals->feature_module, rb_intern("Polygon"));
+  
+  rb_define_module_function(geos_polygon_class, "create", cmethod_create, 3);
+  
+  rb_define_method(geos_polygon_class, "eql?", method_polygon_eql, 1);
+  rb_define_method(geos_polygon_class, "geometry_type", method_polygon_geometry_type, 0);
+  rb_define_method(geos_polygon_class, "area", method_polygon_area, 0);
+  rb_define_method(geos_polygon_class, "centroid", method_polygon_centroid, 0);
+  rb_define_method(geos_polygon_class, "point_on_surface", method_polygon_point_on_surface, 0);
+  rb_define_method(geos_polygon_class, "exterior_ring", method_polygon_exterior_ring, 0);
+  rb_define_method(geos_polygon_class, "num_interior_rings", method_polygon_num_interior_rings, 0);
+  rb_define_method(geos_polygon_class, "interior_ring_n", method_polygon_interior_ring_n, 1);
+  rb_define_method(geos_polygon_class, "interior_rings", method_polygon_interior_rings, 0);
+}
+
+
+VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
+{
+  VALUE result = Qnil;
+  if (geom1 && geom2) {
+    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2), check_z);
+    if (RTEST(result)) {
+      int len1 = GEOSGetNumInteriorRings_r(context, geom1);
+      int len2 = GEOSGetNumInteriorRings_r(context, geom2);
+      if (len1 >= 0 && len2 >= 0) {
+        if (len1 == len2) {
+          int i;
+          for (i=0; i<len1; ++i) {
+            result = rgeo_geos_coordseqs_eql(context, GEOSGetInteriorRingN_r(context, geom1, i), GEOSGetInteriorRingN_r(context, geom2, i), check_z);
+            if (!RTEST(result)) {
+              break;
+            }
+          }
+        }
+        else {
+          result = Qfalse;
+        }
+      }
+      else {
+        result = Qnil;
+      }
+    }
+  }
+  return result;
+}
+
+
+RGEO_END_C
+
+#endif