ffi-geos 0.0.1.beta1

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 J Smith <dark.panda@gmail.com>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,135 @@
+
+= GEOS Ruby Bindings in FFI
+
+== Requirements
+
+* the ffi extension for Ruby.
+* GEOS version 3.3.0 or greater. GEOS 3.2.2 and below will work to an extent,
+  but some features and methods will be disabled or missing.
+
+Ruby versions known to work:
+
+* Ruby MRI 1.8.7 and 1.9.2, x86_64, OSX 10.6.5+
+* Ruby MRI 1.8.7 and 1.9.2, i386, linux
+* Ruby MRI 1.8.7, x86_64, linux
+* JRuby 1.5 and 1.6 using JRE 1.6.0_22, x86_64, OSX 10.6.5+
+* JRuby 1.5 and 1.6 using JRE 1.6.0_18, i386, linux
+
+== Features
+
+ffi-geos supports all of the features found in the binary SWIG-based GEOS
+Ruby bindings along with the following enhancements and additions:
+
+* support for prepared geometries via Geos::Geometry#to_prepared.
+
+* an implementation of Geos::STRtree.
+
+* use of GEOS's re-entrant interface for thread-safety.
+
+* new options for controlling WKT output like trim and rounding precision.
+
+* many new methods on geometry types. See below for a list.
+
+* Geos::LineString, Geos::LinearRing, Geos::CoordinateSequence and
+  Geos::GeometryCollection and its descendants are now enumerable.
+
+* The aforementioned enumerable classes also define some additional Array-like
+  methods such as [] and slice.
+
+* Geos::WkbWriter and Geos::WktWriter have had their constructors extended
+  to allow for settings via an options Hash.
+
+* Geos::WkbWriter#write, Geos::WkbWriter#write_hex and Geos::WktWriter#write
+  have been enhanced to take options Hashes allowing you to set per-write
+  settings.
+
+== New Methods and Additions
+
+=== Geos
+
+* Geos.create_multi_point
+
+* Geos.create_multi_line_string
+
+* Geos.create_multi_polygon
+
+* Geos.create_geometry_collection
+
+* Geos.create_collection
+
+* Geos.create_empty_point
+
+* Geos.create_empty_polygon
+
+* Geos.create_empty_line_string
+
+* Geos.create_empty_multi_point
+
+* Geos.create_empty_multi_line_string
+
+* Geos.create_empty_multi_polygon
+
+* Geos.create_empty_geometry_collection
+
+=== Geos::Geometry
+
+* Geos::Geometry#buffer_with_style
+
+* Geos::Geometry#num_coordinates
+
+* Geos::Geometry#union_cascaded. Geos::Geometry#union can also be called
+  without a geometry argument to produce the same effect.
+
+* Geos::Geometry#extract_unique_points (aliased to Geos::Geometry#unique_points)
+
+* Geos::Geometry#valid_reason
+
+* Geos::Geometry#valid_detail
+
+* Geos::Geometry#project
+
+* Geos::Geometry#project_normalized
+
+* Geos::Geometry#interpolate
+
+* Geos::Geometry#interpolate_normalized
+
+* Geos::Geometry#start_point
+
+* Geos::Geometry#end_point
+
+* Geos::Geometry#hausdorff_distance
+
+* Geos::Geometry#snap
+
+* Geos::Geometry#shared_paths
+
+* Geos::Geometry#polygonize_full
+
+* Geos::Geometry#polygonize
+
+* Geos::Geometry#polygonize_cut_edges
+
+* Geos::Geometry#to_prepared
+
+=== Geos::LineString and Geos::LinearRing
+
+* Geos::LineString#num_points
+
+* Geos::LineString#point_n
+
+* Geos::LineString#buffer_single_sided
+
+* Geos::LineString#closed?
+
+=== Geos::WktWriter
+
+* Geos::WktWriter#trim=
+
+* Geos::WktWriter#rounding_precision=
+
+* Geos::WktWriter#old_3d=
+
+=== Geos::Utils
+
+* Geos::Utils.orientation_index

data/Rakefile

@@ -0,0 +1,41 @@
+
+# -*- ruby -*-
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+$:.push 'lib'
+
+version = File.read('VERSION') rescue ''
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ffi-geos"
+    gem.summary = "An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS)."
+    gem.description = gem.summary
+    gem.email = "dark.panda@gmail.com"
+    gem.homepage = "http://github.com/dark-panda/ffi-geos"
+    gem.authors =    [ "J Smith" ]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Test GEOS interface'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_tests.rb'
+  t.verbose = !!ENV['VERBOSE_TESTS']
+end
+
+desc 'Build docs'
+Rake::RDocTask.new do |t|
+  require 'rdoc'
+  t.title = "ffi-geos #{version}"
+  t.main = 'README.rdoc'
+  t.rdoc_dir = 'doc'
+  t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1.beta1

data/lib/coordinate_sequence.rb

@@ -0,0 +1,126 @@
+
+module Geos
+
+  # A CoordinateSequence is a list of coordinates in a Geometry.
+  class CoordinateSequence
+    include Enumerable
+
+    attr_reader :ptr
+
+    # :call-seq:
+    #   new(ptr, auto_free = true)
+    #   new(size, dims = 0)
+    #
+    # The ptr version of the initializer is for internal use.
+    def initialize(*args)
+      ptr, auto_free = if args.first.is_a?(FFI::Pointer)
+        [ args.first, args[1] ]
+      else
+        size, dims = if !args.length.between?(1, 2)
+          raise ArgumentError.new("wrong number of arguments (#{args.length} for 1-2)")
+        else
+          [ args[0], args[1] || 0]
+        end
+
+        [ FFIGeos.GEOSCoordSeq_create_r(Geos.current_handle, size, dims), true ]
+      end
+
+      @ptr = FFI::AutoPointer.new(
+        ptr,
+        auto_free ? self.class.method(:release) : self.class.method(:no_release)
+      )
+    end
+
+    def self.no_release(ptr) #:nodoc:
+    end
+
+    def self.release(ptr) #:nodoc:
+      FFIGeos.GEOSCoordSeq_destroy_r(Geos.current_handle, ptr)
+    end
+
+    def clone
+      self.class.new(FFIGeos.GEOSCoordSeq_clone_r(Geos.current_handle, self.ptr))
+    end
+
+    # Yields coordinates as [ x, y, z ]. The z coordinate may be omitted for
+    # 2-dimensional CoordinateSequences.
+    def each
+      self.length.times do |n|
+        yield [
+          self.get_x(n),
+          (self.dimensions >= 2 ? self.get_y(n) : nil),
+          (self.dimensions >= 3 ? self.get_z(n) : nil)
+        ].compact
+      end
+    end
+
+    def set_x(idx, val)
+      self.check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setX_r(Geos.current_handle, self.ptr, idx, val)
+    end
+
+    def set_y(idx, val)
+      self.check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setY_r(Geos.current_handle, self.ptr, idx, val)
+    end
+
+    def set_z(idx, val)
+      self.check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setZ_r(Geos.current_handle, self.ptr, idx, val)
+    end
+
+    def set_ordinate(idx, dim, val)
+      self.check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setOrdinate_r(Geos.current_handle, self.ptr, idx, dim, val)
+    end
+
+    def get_x(idx)
+      self.check_bounds(idx)
+      FFI::MemoryPointer.new(:double).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getX_r(Geos.current_handle, self.ptr, idx, ret)
+      }.read_double
+    end
+
+    def get_y(idx)
+      self.check_bounds(idx)
+      FFI::MemoryPointer.new(:double).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getY_r(Geos.current_handle, self.ptr, idx, ret)
+      }.read_double
+    end
+
+    def get_z(idx)
+      self.check_bounds(idx)
+      FFI::MemoryPointer.new(:double).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getZ_r(Geos.current_handle, self.ptr, idx, ret)
+      }.read_double
+    end
+
+    def get_ordinate(idx, dim)
+      self.check_bounds(idx)
+      FFI::MemoryPointer.new(:double).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getOrdinate_r(Geos.current_handle, self.ptr, idx, dim, ret)
+      }.read_double
+    end
+
+    def length
+      FFI::MemoryPointer.new(:int).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getSize_r(Geos.current_handle, self.ptr, ret)
+      }.read_int
+    end
+    alias :size :length
+
+    def dimensions
+      @dimensions ||= FFI::MemoryPointer.new(:int).tap { |ret|
+        FFIGeos.GEOSCoordSeq_getDimensions_r(Geos.current_handle, self.ptr, ret)
+      }.read_int
+    end
+
+    protected
+
+    def check_bounds(idx) #:nodoc:
+      if idx < 0 || idx >= self.length
+        raise RuntimeError.new("Index out of bounds")
+      end
+    end
+  end
+end

data/lib/ffi-geos.rb

@@ -0,0 +1,810 @@
+
+require 'ffi'
+require 'rbconfig'
+
+module Geos
+  GEOS_BASE = File.dirname(__FILE__)
+
+  autoload :WktReader,
+    File.join(GEOS_BASE, 'wkt_reader')
+  autoload :WktWriter,
+    File.join(GEOS_BASE, 'wkt_writer')
+  autoload :WkbReader,
+    File.join(GEOS_BASE, 'wkb_reader')
+  autoload :WkbWriter,
+    File.join(GEOS_BASE, 'wkb_writer')
+  autoload :CoordinateSequence,
+    File.join(GEOS_BASE, 'coordinate_sequence')
+  autoload :Geometry,
+    File.join(GEOS_BASE, 'geometry')
+  autoload :PreparedGeometry,
+    File.join(GEOS_BASE, 'prepared_geometry')
+  autoload :GeometryCollection,
+    File.join(GEOS_BASE, 'geometry_collection')
+  autoload :LineString,
+    File.join(GEOS_BASE, 'line_string')
+  autoload :LinearRing,
+    File.join(GEOS_BASE, 'linear_ring')
+  autoload :MultiLineString,
+    File.join(GEOS_BASE, 'multi_line_string')
+  autoload :MultiPoint,
+    File.join(GEOS_BASE, 'multi_point')
+  autoload :MultiPolygon,
+    File.join(GEOS_BASE, 'multi_polygon')
+  autoload :Polygon,
+    File.join(GEOS_BASE, 'polygon')
+  autoload :Point,
+    File.join(GEOS_BASE, 'point')
+  autoload :STRtree,
+    File.join(GEOS_BASE, 'strtree')
+  autoload :Tools,
+    File.join(GEOS_BASE, 'tools')
+  autoload :Utils,
+    File.join(GEOS_BASE, 'utils')
+
+  module FFIGeos
+    def self.geos_library_paths
+      return @geos_library_paths if @geos_library_paths
+
+      paths = if ENV['GEOS_LIBRARY_PATH']
+        [ ENV['GEOS_LIBRARY_PATH'] ]
+      else
+        [ '/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}' ]
+      end
+
+      libs = if [
+        Config::CONFIG['arch'],
+        Config::CONFIG['host_os']
+      ].detect { |c| c =~ /darwin/ }
+        %w{ libgeos_c.dylib libgeos.dylib }
+      else
+        %w{ libgeos.so libgeos_c.so }
+      end
+
+      @geos_library_paths = libs.collect { |lib|
+        Dir.glob(paths.collect { |path|
+          "#{path}/#{lib}"
+        }).first
+      }
+    end
+
+    extend ::FFI::Library
+
+    ffi_lib(*geos_library_paths)
+
+    Geos::DimensionTypes = enum(:dimension_type, [
+      :dontcare, -3,
+      :non_empty, -2,
+      :empty, -1,
+      :point, 0,
+      :curve, 1,
+      :surface, 2
+    ])
+
+    Geos::ByteOrders = enum(:byte_order, [
+      :xdr, 0, # Big Endian
+      :ndr, 1 # Little Endian
+    ])
+
+    Geos::BufferCapStyles = enum(:buffer_cap_style, [
+      :round, 1,
+      :flat, 2,
+      :square, 3
+    ])
+
+    Geos::BufferJoinStyles = enum(:buffer_join_style, [
+      :round, 1,
+      :mitre, 2,
+      :bevel, 3
+    ])
+
+    Geos::ValidFlags = enum(:valid_flag, [
+      :allow_selftouching_ring_forming_hole, 1
+    ])
+
+    Geos::RelateBoundaryNodeRules = enum(:relate_boundary_node_rule, [
+      :mod2, 1,
+      :ogc, 1,
+      :endpoint, 2,
+      :multivalent_endpoint, 3,
+      :monovalent_endpoint, 4
+    ])
+
+    FFI_LAYOUT = {
+      #### Utility functions ####
+      :initGEOS_r => [
+        :pointer,
+        callback([ :string, :string ], :void),
+        callback([ :string, :string ], :void)
+      ],
+
+      :finishGEOS_r => [
+        :void, :pointer
+      ],
+
+      :GEOSversion => [
+        :string
+      ],
+
+      :GEOSjtsport => [
+        :string
+      ],
+
+      :GEOSPolygonize_r => [
+        :pointer, :pointer, :pointer, :uint
+      ],
+
+      :GEOSPolygonizer_getCutEdges_r => [
+        :pointer, :pointer, :pointer, :uint
+      ],
+
+      :GEOSPolygonize_full_r => [
+        :pointer, :pointer, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeom_createPoint_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeom_createEmptyPoint_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSGeom_createEmptyLineString_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSGeom_createLinearRing_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeom_createLineString_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeom_createPolygon_r => [
+        :pointer, :pointer, :pointer, :pointer, :uint
+      ],
+
+      :GEOSGeom_createEmptyPolygon_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSGeom_createCollection_r => [
+        :pointer, :pointer, :int, :pointer, :uint
+      ],
+
+      :GEOSGeom_createEmptyCollection_r => [
+        :pointer, :pointer, :int
+      ],
+      #### /Utility functions ####
+
+      #### CoordinateSequence functions ####
+      :GEOSCoordSeq_create_r => [
+        :pointer, :pointer, :uint, :uint
+      ],
+
+      :GEOSCoordSeq_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSCoordSeq_clone_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSCoordSeq_setX_r => [
+        :int, :pointer, :pointer, :uint, :double
+      ],
+
+      :GEOSCoordSeq_setY_r => [
+        :int, :pointer, :pointer, :uint, :double
+      ],
+
+      :GEOSCoordSeq_setZ_r => [
+        :int, :pointer, :pointer, :uint, :double
+      ],
+
+      :GEOSCoordSeq_setOrdinate_r => [
+        :int, :pointer, :pointer, :uint, :uint, :double
+      ],
+
+      :GEOSCoordSeq_getX_r => [
+        :int, :pointer, :pointer, :uint, :pointer
+      ],
+
+      :GEOSCoordSeq_getY_r => [
+        :int, :pointer, :pointer, :uint, :pointer
+      ],
+
+      :GEOSCoordSeq_getZ_r => [
+        :int, :pointer, :pointer, :uint, :pointer
+      ],
+
+      :GEOSCoordSeq_getOrdinate_r => [
+        :int, :pointer, :pointer, :uint, :uint, :pointer
+      ],
+
+      :GEOSCoordSeq_getSize_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSNormalize_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSCoordSeq_getDimensions_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+      #### /CoordinateSequence functions ####
+
+      #### Geometry functions ####
+      :GEOSGeom_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSGeom_clone_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeomTypeId_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGeomType_r => [
+        :string, :pointer, :pointer
+      ],
+
+      :GEOSGetSRID_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSSetSRID_r => [
+        :void, :pointer, :pointer, :int
+      ],
+
+      :GEOSGeom_getDimensions_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGetNumGeometries_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGetNumCoordinates_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGeom_getCoordSeq_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSIntersection_r => [
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSBuffer_r => [
+        :pointer, :pointer, :pointer, :double, :int
+      ],
+
+      :GEOSBufferWithStyle_r => [
+        :pointer, :pointer, :pointer, :double, :int, :buffer_cap_style, :buffer_join_style, :double
+      ],
+
+      :GEOSSingleSidedBuffer_r => [
+        :pointer, :pointer, :pointer, :double, :int, :buffer_join_style, :double, :int
+      ],
+
+      :GEOSConvexHull_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSDifference_r => [
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSymDifference_r => [
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSBoundary_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSUnion_r => [
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSUnaryUnion_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSUnionCascaded_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSPointOnSurface_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGetCentroid_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSEnvelope_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSLineMerge_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSimplify_r => [
+        :pointer, :pointer, :pointer, :double
+      ],
+
+      :GEOSTopologyPreserveSimplify_r => [
+        :pointer, :pointer, :pointer, :double
+      ],
+
+      :GEOSGeom_extractUniquePoints_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSharedPaths_r => [
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSnap_r => [
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      :GEOSRelate_r => [
+        :string, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSRelatePatternMatch_r => [
+        :char, :pointer, :string, :string
+      ],
+
+      :GEOSRelatePattern_r => [
+        :char, :pointer, :pointer, :pointer, :string
+      ],
+
+      :GEOSRelateBoundaryNodeRule_r => [
+        :string, :pointer, :pointer, :pointer, :relate_boundary_node_rule
+      ],
+
+      :GEOSDisjoint_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSTouches_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSIntersects_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSCrosses_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSWithin_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSContains_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSOverlaps_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSCovers_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSCoveredBy_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSEquals_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSEqualsExact_r => [
+        :char, :pointer, :pointer, :pointer, :double
+      ],
+
+      :GEOSisEmpty_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSisValid_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSisValidReason_r => [
+        :string, :pointer, :pointer
+      ],
+
+      :GEOSisValidDetail_r => [
+        :char, :pointer, :pointer, :int, :pointer, :pointer
+      ],
+
+      :GEOSisSimple_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSisRing_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSHasZ_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSisClosed_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSArea_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSLength_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSDistance_r => [
+        :int, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSHausdorffDistance_r => [
+        :int, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGetGeometryN_r => [
+        :pointer, :pointer, :pointer, :int
+      ],
+
+      :GEOSGetNumInteriorRings_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGetInteriorRingN_r => [
+        :pointer, :pointer, :pointer, :int
+      ],
+
+      :GEOSGetExteriorRing_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeomGetNumPoints_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSGeomGetX_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeomGetY_r => [
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeomGetPointN_r => [
+        :pointer, :pointer, :pointer, :int
+      ],
+
+      :GEOSGeomGetStartPoint_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSGeomGetEndPoint_r => [
+        :pointer, :pointer, :pointer
+      ],
+      #### /Geometry functions ####
+
+      #### STRtree functions ####
+      :GEOSSTRtree_create_r => [
+        :pointer, :pointer, :size_t
+      ],
+
+      :GEOSSTRtree_insert_r => [
+        :void, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSTRtree_query_r => [
+        :void, :pointer, :pointer, :pointer, callback([ :pointer, :pointer ], :void), :pointer
+      ],
+
+      :GEOSSTRtree_iterate_r => [
+        :void, :pointer, :pointer, callback([ :pointer, :pointer ], :void), :pointer
+      ],
+
+      :GEOSSTRtree_remove_r => [
+        :char, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSSTRtree_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+      #### /STRtree functions ####
+
+      #### PreparedGeometry functions ####
+      :GEOSPrepare_r => [
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSPreparedGeom_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSPreparedContains_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSPreparedContainsProperly_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSPreparedCovers_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSPreparedIntersects_r => [
+        :char, :pointer, :pointer, :pointer
+      ],
+      #### /PreparedGeometry functions ####
+
+      #### WktReader functions ####
+      :GEOSWKTReader_create_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSWKTReader_read_r => [
+        :pointer, :pointer, :pointer, :string
+      ],
+
+      :GEOSWKTReader_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+      #### /WktReader functions ###
+
+      #### WktWriter functions ####
+      :GEOSWKTWriter_create_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSWKTWriter_write_r => [
+        :string, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSWKTWriter_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSWKTWriter_setTrim_r => [
+        :void, :pointer, :pointer, :char
+      ],
+
+      :GEOSWKTWriter_setRoundingPrecision_r => [
+        :void, :pointer, :pointer, :int
+      ],
+
+      :GEOSWKTWriter_setOutputDimension_r => [
+        :void, :pointer, :pointer, :int
+      ],
+
+      :GEOSWKTWriter_getOutputDimension_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSWKTWriter_setOld3D_r => [
+        :void, :pointer, :pointer, :int
+      ],
+      #### /WktWriter functions ####
+
+      #### WkbReader functions ####
+      :GEOSWKBReader_create_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSWKBReader_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSWKBReader_read_r => [
+        :pointer, :pointer, :pointer, :pointer, :size_t
+      ],
+
+      :GEOSWKBReader_readHEX_r => [
+        :pointer, :pointer, :pointer, :string, :size_t
+      ],
+      #### /WkbReader functions ####
+
+      #### WkbWriter functions ####
+      :GEOSWKBWriter_create_r => [
+        :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_destroy_r => [
+        :void, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_write_r => [
+        :pointer, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_writeHEX_r => [
+        :pointer, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_setOutputDimension_r => [
+        :void, :pointer, :pointer, :int
+      ],
+
+      :GEOSWKBWriter_getOutputDimension_r => [
+        :int, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_getByteOrder_r => [
+        :byte_order, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_setByteOrder_r => [
+        :void, :pointer, :pointer, :byte_order
+      ],
+
+      :GEOSWKBWriter_getIncludeSRID_r => [
+        :char, :pointer, :pointer
+      ],
+
+      :GEOSWKBWriter_setIncludeSRID_r => [
+        :void, :pointer, :pointer, :char
+      ],
+      #### /WkbWriter functions ####
+
+
+      #### Linearref functions ####
+      :GEOSProject_r => [
+        :double, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSProjectNormalized_r => [
+        :double, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSInterpolate_r => [
+        :pointer, :pointer, :pointer, :double
+      ],
+
+      :GEOSInterpolateNormalized_r => [
+        :pointer, :pointer, :pointer, :double
+      ],
+      #### /Linearref functions ####
+
+      #### Algorithms ####
+      :GEOSOrientationIndex_r => [
+        :int, :pointer, :double, :double, :double, :double, :double, :double
+      ]
+      #### /Algorithms ####
+    }
+
+    FFI_LAYOUT.each do |fun, ary|
+      ret = ary.shift
+      begin
+        self.class_eval do
+          attach_function(fun, ary, ret)
+        end
+      rescue FFI::NotFoundError
+        # that's okay
+      end
+    end
+  end
+
+  class Handle
+    attr_reader :ptr
+
+    def initialize
+      @ptr = FFIGeos.initGEOS_r(
+        @notice_handler = self.method(:notice_handler),
+        @error_handler = self.method(:error_handler)
+      )
+
+      Kernel.at_exit {
+        FFIGeos.finishGEOS_r(@ptr)
+      }
+    end
+
+    def notice_handler(*args)
+      # no-op, just to appease initGEOS.
+    end
+
+    def error_handler(*args)
+      raise RuntimeError.new(args[0] % args[1])
+    end
+  end
+
+  class << self
+    def version
+      @version ||= FFIGeos.GEOSversion
+    end
+
+    def jts_port
+      @jts_port ||= FFIGeos.GEOSjtsport
+    end
+
+    def current_handle
+      Thread.current[:ffi_geos_handle] ||= Geos::Handle.new
+      Thread.current[:ffi_geos_handle].ptr
+    end
+
+    %w{
+      create_point
+      create_line_string
+      create_linear_ring
+      create_polygon
+      create_multi_point
+      create_multi_line_string
+      create_multi_polygon
+      create_geometry_collection
+
+      create_empty_point
+      create_empty_line_string
+      create_empty_polygon
+      create_empty_multi_point
+      create_empty_multi_line_string
+      create_empty_multi_polygon
+      create_empty_geometry_collection
+    }.each do |m|
+      self.class_eval <<-EOF
+        def #{m}(*args)
+          Geos::Utils.#{m}(*args)
+        end
+      EOF
+    end
+  end
+
+  module GeomTypes
+    GEOS_POINT = 0
+    GEOS_LINESTRING = 1
+    GEOS_LINEARRING = 2
+    GEOS_POLYGON = 3
+    GEOS_MULTIPOINT = 4
+    GEOS_MULTILINESTRING = 5
+    GEOS_MULTIPOLYGON = 6
+    GEOS_GEOMETRYCOLLECTION = 7
+  end
+
+  module VersionConstants
+    VERSION = File.read(File.join(GEOS_BASE, %w{ .. VERSION })) rescue nil
+    GEOS_JTS_PORT = Geos.jts_port
+    GEOS_VERSION,
+      GEOS_VERSION_MAJOR, GEOS_VERSION_MINOR, GEOS_VERISON_PATCH,
+      GEOS_CAPI_VERSION,
+      GEOS_CAPI_VERSION_MAJOR, GEOS_CAPI_VERSION_MINOR, GEOS_CAPI_VERSION_PATCH =
+        if versions = Geos.version.scan(/^((\d+)\.(\d+)\.(\d+))-CAPI-((\d+)\.(\d+)\.(\d+))$/)
+          versions = versions[0]
+          [
+            versions[0],
+            versions[1].to_i,
+            versions[2].to_i,
+            versions[3].to_i,
+            versions[4],
+            versions[5].to_i,
+            versions[6].to_i,
+            versions[7].to_i
+          ]
+        else
+          []
+        end
+    GEOS_CAPI_FIRST_INTERFACE = GEOS_CAPI_VERSION_MAJOR.to_i
+    GEOS_CAPI_LAST_INTERFACE = GEOS_CAPI_VERSION_MAJOR.to_i + GEOS_CAPI_VERSION_MINOR.to_i
+  end
+
+  include GeomTypes
+  include VersionConstants
+end