rgeo 0.1.10

data/ext/geos_c_impl/line_string.h

@@ -0,0 +1,74 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  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"
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+}
+#endif
+#endif
+
+
+/*
+  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);
+
+
+#ifdef __cplusplus
+#if 0
+{
+#endif
+}
+#endif
+
+#endif

data/ext/geos_c_impl/main.c

@@ -0,0 +1,65 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  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
+
+
+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
+}

data/ext/geos_c_impl/point.c

@@ -0,0 +1,201 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  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"
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+}
+#endif
+#endif
+
+
+static VALUE method_point_geometry_type(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->features_module, rb_intern("Point"));
+  }
+  return result;
+}
+
+
+static VALUE method_point_x(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    if (coord_seq) {
+      double val;
+      if (GEOSCoordSeq_getX_r(RGEO_CONTEXT_FROM_GEOMETRY(self), coord_seq, 0, &val)) {
+        result = rb_float_new(val);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_point_y(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    if (coord_seq) {
+      double val;
+      if (GEOSCoordSeq_getY_r(RGEO_CONTEXT_FROM_GEOMETRY(self), coord_seq, 0, &val)) {
+        result = rb_float_new(val);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_point_z(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom && GEOSHasZ_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom) == 1) {
+    const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    if (coord_seq) {
+      double val;
+      if (GEOSCoordSeq_getZ_r(RGEO_CONTEXT_FROM_GEOMETRY(self), coord_seq, 0, &val)) {
+        result = rb_float_new(val);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_point_eql(VALUE self, VALUE rhs)
+{
+  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  if (RTEST(result)) {
+    result = rgeo_geos_coordseqs_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs));
+  }
+  return result;
+}
+
+
+static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y)
+{
+  return rgeo_create_geos_point_2d(factory, rb_num2dbl(x), rb_num2dbl(y));
+}
+
+
+static VALUE cmethod_create3d(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
+{
+  return rgeo_create_geos_point_3d(factory, rb_num2dbl(x), rb_num2dbl(y), rb_num2dbl(z));
+}
+
+
+void rgeo_init_geos_point(RGeo_Globals* globals)
+{
+  VALUE geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", rb_const_get_at(globals->geos_module, rb_intern("GeometryImpl")));
+  
+  rb_define_module_function(geos_point_class, "create", cmethod_create, 3);
+  rb_define_module_function(geos_point_class, "create3d", cmethod_create3d, 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);
+}
+
+
+VALUE rgeo_create_geos_point_2d(VALUE factory, double x, double y)
+{
+  VALUE result = Qnil;
+  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(RGEO_CONTEXT_FROM_FACTORY(factory), 1, 2);
+  if (coord_seq) {
+    if (GEOSCoordSeq_setX_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, x)) {
+      if (GEOSCoordSeq_setY_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, y)) {
+        GEOSGeometry* geom = GEOSGeom_createPoint_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq);
+        if (geom) {
+          result = rgeo_wrap_geos_geometry(factory, geom, rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->geos_module, rb_intern("PointImpl")));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+
+VALUE rgeo_create_geos_point_3d(VALUE factory, double x, double y, double z)
+{
+  VALUE result = Qnil;
+  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(RGEO_CONTEXT_FROM_FACTORY(factory), 1, 2);
+  if (coord_seq) {
+    if (GEOSCoordSeq_setX_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, x)) {
+      if (GEOSCoordSeq_setY_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, y)) {
+        if (GEOSCoordSeq_setZ_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, z)) {
+          GEOSGeometry* geom = GEOSGeom_createPoint_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq);
+          if (geom) {
+            result = rgeo_wrap_geos_geometry(factory, geom, rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->geos_module, rb_intern("PointImpl")));
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+
+#ifdef __cplusplus
+#if 0
+{
+#endif
+}
+#endif
+
+#endif

data/ext/geos_c_impl/point.h

@@ -0,0 +1,77 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  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"
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+}
+#endif
+#endif
+
+
+/*
+  Initializes the point module. This should be called after
+  the geometry module is initialized.
+*/
+void rgeo_init_geos_point(RGeo_Globals* globals);
+
+/*
+  Creates a 2d point and returns the ruby object.
+*/
+VALUE rgeo_create_geos_point_2d(VALUE factory, double x, double y);
+
+/*
+  Creates a 3d point and returns the ruby object.
+*/
+VALUE rgeo_create_geos_point_3d(VALUE factory, double x, double y, double z);
+
+
+#ifdef __cplusplus
+#if 0
+{
+#endif
+}
+#endif
+
+#endif

data/ext/geos_c_impl/polygon.c

@@ -0,0 +1,259 @@
+/*
+  -----------------------------------------------------------------------------
+  
+  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"
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+}
+#endif
+#endif
+
+
+static VALUE method_polygon_eql(VALUE self, VALUE rhs)
+{
+  VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
+  if (RTEST(result)) {
+    result = rgeo_geos_polygons_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_geometry_type(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->features_module, rb_intern("Polygon"));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_area(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    double area;
+    if (GEOSArea_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, &area)) {
+      result = rb_float_new(area);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_centroid(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSGetCentroid_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom), rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->geos_module, rb_intern("PointImpl")));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_point_on_surface(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSPointOnSurface_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom), rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->geos_module, rb_intern("PointImpl")));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_exterior_ring(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rgeo_wrap_geos_geometry_clone(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSGetExteriorRing_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom), rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->geos_module, rb_intern("LinearRingImpl")));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_num_interior_rings(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    int num = GEOSGetNumInteriorRings_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    if (num >= 0) {
+      result = INT2NUM(num);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    result = rgeo_wrap_geos_geometry_clone(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSGetInteriorRingN_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, NUM2INT(n)), rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->geos_module, rb_intern("LinearRingImpl")));
+  }
+  return result;
+}
+
+
+static VALUE method_polygon_interior_rings(VALUE self)
+{
+  VALUE result = Qnil;
+  const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
+  if (self_geom) {
+    int count = GEOSGetNumInteriorRings_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    if (count >= 0) {
+      result = rb_ary_new2(count);
+      int i;
+      for (i=0; i<count; ++i) {
+        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSGetInteriorRingN_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom, i), rb_const_get_at(RGEO_GLOBALS_FROM_GEOMETRY(self)->geos_module, rb_intern("LinearRingImpl"))));
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE interior_array)
+{
+  Check_Type(interior_array, T_ARRAY);
+  GEOSGeometry* exterior_geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), exterior, NULL);
+  if (exterior_geom) {
+    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(RGEO_GLOBALS_FROM_FACTORY(factory), rb_ary_entry(interior_array, i), NULL);
+        if (interior_geom) {
+          interior_geoms[actual_len++] = interior_geom;
+        }
+      }
+      if (len == actual_len) {
+        GEOSGeometry* polygon = GEOSGeom_createPolygon_r(RGEO_CONTEXT_FROM_FACTORY(factory), exterior_geom, interior_geoms, actual_len);
+        if (polygon) {
+          free(interior_geoms);
+          return rgeo_wrap_geos_geometry(factory, polygon, rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->geos_module, rb_intern("PolygonImpl")));
+        }
+      }
+      for (i=0; i<actual_len; ++i) {
+        GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_FACTORY(factory), interior_geoms[i]);
+      }
+      free(interior_geoms);
+    }
+    GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_FACTORY(factory), exterior_geom);
+  }
+  return Qnil;
+}
+
+
+void rgeo_init_geos_polygon(RGeo_Globals* globals)
+{
+  VALUE geos_polygon_class = rb_define_class_under(globals->geos_module, "PolygonImpl", rb_const_get_at(globals->geos_module, rb_intern("GeometryImpl")));
+  
+  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)
+{
+  VALUE result = Qnil;
+  if (geom1 && geom2) {
+    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2));
+    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));
+            if (!RTEST(result)) {
+              break;
+            }
+          }
+        }
+        else {
+          result = Qfalse;
+        }
+      }
+      else {
+        result = Qnil;
+      }
+    }
+  }
+  return result;
+}
+
+
+#ifdef __cplusplus
+#if 0
+{
+#endif
+}
+#endif
+
+#endif