geos-extensions 0.2.2 → 0.3.0

data/lib/geos/multi_polygon.rb

@@ -0,0 +1,27 @@
+
+module Geos
+  class MultiPolygon < GeometryCollection
+    def to_geojsonable(options = {})
+      options = {
+        :interior_rings => true
+      }.merge(options)
+
+      {
+        :type => 'MultiPolygon',
+        :coordinates => self.to_a.collect { |polygon|
+          coords = [ polygon.exterior_ring.coord_seq.to_a ]
+
+          if options[:interior_rings] && polygon.num_interior_rings > 0
+            coords.concat polygon.interior_rings.collect { |r|
+              r.coord_seq.to_a
+            }
+          end
+
+          coords
+        }
+      }
+    end
+    alias :as_geojson :to_geojsonable
+  end
+end
+

data/lib/geos/point.rb

@@ -0,0 +1,120 @@
+
+module Geos
+  class Point
+    unless method_defined?(:y)
+      # Returns the Y coordinate of the Point.
+      def y
+        self.to_a[1]
+      end
+    end
+
+    %w{
+      latitude lat north south n s
+    }.each do |name|
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        alias #{name} :y
+      EOF
+    end
+
+    unless method_defined?(:x)
+      # Returns the X coordinate of the Point.
+      def x
+        self.to_a[0]
+      end
+    end
+
+    %w{
+      longitude lng east west e w
+    }.each do |name|
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        alias #{name} :x
+      EOF
+    end
+
+    unless method_defined?(:z)
+      # Returns the Z coordinate of the Point.
+      def z
+        if self.has_z?
+          self.to_a[2]
+        else
+          nil
+        end
+      end
+    end
+
+    # Returns the Point's coordinates as an Array in the following format:
+    #
+    #  [ x, y, z ]
+    #
+    # The Z coordinate will only be present for Points which have a Z
+    # dimension.
+    def to_a
+      if defined?(@to_a)
+        @to_a
+      else
+        cs = self.coord_seq
+        @to_a = if self.has_z?
+          [ cs.get_x(0), cs.get_y(0), cs.get_z(0) ]
+        else
+          [ cs.get_x(0), cs.get_y(0) ]
+        end
+      end
+    end
+
+    # Optimize some unnecessary code away:
+    %w{
+      upper_left upper_right lower_right lower_left
+      ne nw se sw
+      northwest northeast southeast southwest
+    }.each do |name|
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def #{name}
+          self
+        end
+      EOF
+    end
+
+    # Build some XmlMarkup for KML. You can set KML options for extrude and
+    # altitudeMode. Use Rails/Ruby-style code and it will be converted
+    # appropriately, i.e. :altitude_mode, not :altitudeMode.
+    def to_kml(*args)
+      xml, options = Geos::Helper.xml_options(*args)
+      xml.Point(:id => options[:id]) do
+        xml.extrude(options[:extrude]) if options[:extrude]
+        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitude_mode]
+        xml.coordinates(self.to_a.join(','))
+      end
+    end
+
+    # Build some XmlMarkup for GeoRSS. You should include the
+    # appropriate georss and gml XML namespaces in your document.
+    def to_georss(*args)
+      xml = Geos::Helper.xml_options(*args)[0]
+      xml.georss(:where) do
+        xml.gml(:Point) do
+          xml.gml(:pos, "#{self.lat} #{self.lng}")
+        end
+      end
+    end
+
+    # Returns a Hash suitable for converting to JSON.
+    def as_json(options = {})
+      cs = self.coord_seq
+      if self.has_z?
+        { :type => 'point', :lat => cs.get_y(0), :lng => cs.get_x(0), :z => cs.get_z(0) }
+      else
+        { :type => 'point', :lat => cs.get_y(0), :lng => cs.get_x(0) }
+      end
+    end
+    alias :to_jsonable :as_json
+
+    def as_geojson(options = {})
+      {
+        :type => 'Point',
+        :coordinates => self.to_a
+      }
+    end
+    alias :to_geojsonable :as_geojson
+  end
+end
+

data/lib/geos/polygon.rb

@@ -0,0 +1,158 @@
+
+module Geos
+  class Polygon
+    # Build some XmlMarkup for XML. You can set various KML options like
+    # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
+    # will be converted automatically, i.e. :altitudeMode, not
+    # :altitude_mode. You can also include interior rings by setting
+    # :interior_rings to true. The default is false.
+    def to_kml(*args)
+      xml, options = Geos::Helper.xml_options(*args)
+
+      xml.Polygon(:id => options[:id]) do
+        xml.extrude(options[:extrude]) if options[:extrude]
+        xml.tessellate(options[:tessellate]) if options[:tessellate]
+        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitude_mode]
+        xml.outerBoundaryIs do
+          xml.LinearRing do
+            xml.coordinates do
+              xml << self.exterior_ring.coord_seq.to_a.collect do |p|
+                p.join(',')
+              end.join(' ')
+            end
+          end
+        end
+        (0...self.num_interior_rings).to_a.each do |n|
+          xml.innerBoundaryIs do
+            xml.LinearRing do
+              xml.coordinates do
+                xml << self.interior_ring_n(n).coord_seq.to_a.collect do |p|
+                  p.join(',')
+                end.join(' ')
+              end
+            end
+          end
+        end if options[:interior_rings] && self.num_interior_rings > 0
+      end
+    end
+
+    # Build some XmlMarkup for GeoRSS. You should include the
+    # appropriate georss and gml XML namespaces in your document.
+    def to_georss(*args)
+      xml = Geos::Helper.xml_options(*args)[0]
+
+      xml.georss(:where) do
+        xml.gml(:Polygon) do
+          xml.gml(:exterior) do
+            xml.gml(:LinearRing) do
+              xml.gml(:posList) do
+                xml << self.exterior_ring.coord_seq.to_a.collect do |p|
+                  "#{p[1]} #{p[0]}"
+                end.join(' ')
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Returns a Hash suitable for converting to JSON.
+    #
+    # Options:
+    #
+    # * :encoded - enable or disable Google Maps encoding. The default is
+    #   true.
+    # * :level - set the level of the Google Maps encoding algorithm.
+    # * :interior_rings - add interior rings to the output. The default
+    #   is false.
+    # * :style_options - any style options you want to pass along in the
+    #   JSON. These options will be automatically camelized into
+    #   Javascripty code.
+    def as_json(options = {})
+      options = {
+        :encoded => true,
+        :level => 3,
+        :interior_rings => false
+      }.merge options
+
+      style_options = Hash.new
+      if options[:style_options] && !options[:style_options].empty?
+        options[:style_options].each do |k, v|
+          style_options[Geos::Helper.camelize(k.to_s)] = v
+        end
+      end
+
+      if options[:encoded]
+        ret = {
+          :type => 'polygon',
+          :encoded => true,
+          :polylines => [ Geos::GoogleMaps::PolylineEncoder.encode(
+              self.exterior_ring.coord_seq.to_a,
+              options[:level]
+            ).merge(:bounds => {
+              :sw => self.lower_left.to_a,
+              :ne => self.upper_right.to_a
+            })
+          ],
+          :options => style_options
+        }
+
+        if options[:interior_rings] && self.num_interior_rings > 0
+          (0..(self.num_interior_rings) - 1).to_a.each do |n|
+            ret[:polylines] << Geos::GoogleMaps::PolylineEncoder.encode(
+              self.interior_ring_n(n).coord_seq.to_a,
+              options[:level]
+            )
+          end
+        end
+        ret
+      else
+        ret = {
+          :type => 'polygon',
+          :encoded => false,
+          :polylines => [{
+            :points => self.exterior_ring.coord_seq.to_a,
+            :bounds => {
+              :sw => self.lower_left.to_a,
+              :ne => self.upper_right.to_a
+            }
+          }]
+        }
+        if options[:interior_rings] && self.num_interior_rings > 0
+          (0..(self.num_interior_rings) - 1).to_a.each do |n|
+            ret[:polylines] << {
+              :points => self.interior_ring_n(n).coord_seq.to_a
+            }
+          end
+        end
+        ret
+      end
+    end
+    alias :to_jsonable :as_json
+
+    # Options:
+    #
+    # * :interior_rings - whether to include any interior rings in the output.
+    #   The default is true.
+    def as_geojson(options = {})
+      options = {
+        :interior_rings => true
+      }.merge(options)
+
+      ret = {
+        :type => 'Polygon',
+        :coordinates => [ self.exterior_ring.coord_seq.to_a ]
+      }
+
+      if options[:interior_rings] && self.num_interior_rings > 0
+        ret[:coordinates].concat self.interior_rings.collect { |r|
+          r.coord_seq.to_a
+        }
+      end
+
+      ret
+    end
+    alias :to_geojsonable :as_geojson
+  end
+end
+

data/lib/geos/yaml.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+# This file adds yaml serialization support to geometries.  The generated yaml
+# has this format:
+#
+#    !ruby/object:Geos::Geometry
+#    geom: SRID=4326; POINT (-104.97 39.71)
+#
+#  So to use this in a rails fixture file you could do something like this:
+#
+#    geometry_1:
+#      id: 1
+#      geom: !ruby/object:Geos::Geometry
+#        geom: SRID=4326; POINT (-104.97 39.71)
+#
+# Note this code assumes the use of Psych (not syck) and ruby 1.9 and higher
+
+require 'yaml'
+
+dirname = File.join(File.dirname(__FILE__), 'yaml')
+
+# Ruby 2.0 check
+if Object.const_defined?(:Psych) && YAML == Psych
+  require File.join(dirname, 'psych')
+# Ruby 1.9 check
+elsif YAML.const_defined?('ENGINE') && YAML::ENGINE.yamler = 'psych'
+  require File.join(dirname, 'psych')
+else
+  require File.join(dirname, 'syck')
+end

data/lib/geos/yaml/psych.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Geos
+  class Geometry
+    def init_with(coder)
+      # Convert wkt to a geos pointer
+      @ptr = Geos.read(coder['geom']).ptr
+    end
+
+    def encode_with(coder)
+      # Note we enforce ASCII encoding so the geom in the YAML file is
+      # readable -- otherwise psych converts it to a binary string.
+      coder['geom'] = self.to_ewkt(
+        :include_srid => self.srid != 0
+      ).force_encoding('ASCII')
+    end
+  end
+end

data/lib/geos/yaml/syck.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+module Geos
+  class Geometry
+    yaml_as "tag:ruby.yaml.org,2002:object:Geos::Geometry"
+
+    def taguri
+      "tag:ruby.yaml.org,2002:object:#{self.class.name}"
+    end
+
+    def self.yaml_new(klass, tag, val)
+      Geos.read(val['geom'])
+    end
+
+    def to_yaml( opts = {} )
+      YAML::quick_emit(self.object_id, opts) do |out|
+        out.map(taguri) do |map|
+          map.add('geom', self.to_ewkt(
+            :include_srid => self.srid != 0
+          ))
+        end
+      end
+    end
+  end
+
+  class Point
+    yaml_as "tag:ruby.yaml.org,2002:object:Geos::Point"
+  end
+
+  class LineString
+    yaml_as "tag:ruby.yaml.org,2002:object:Geos::LineString"
+  end
+
+  class Polygon
+    yaml_as "tag:ruby.yaml.org,2002:object:Geos::Polygon"
+  end
+
+  class GeometryCollection
+    yaml_as "tag:ruby.yaml.org,2002:object:Geos::GeometryCollection"
+  end
+end

data/lib/geos_extensions.rb

@@ -9,14 +9,24 @@ end
 require 'geos' unless defined?(Geos)
 
 require File.join(File.dirname(__FILE__), *%w{ geos extensions version })
+require File.join(File.dirname(__FILE__), *%w{ geos yaml })
 
 # Some custom extensions to the SWIG-based Geos Ruby extension.
 module Geos
   GEOS_EXTENSIONS_BASE = File.join(File.dirname(__FILE__))
   GEOS_EXTENSIONS_VERSION = Geos::Extensions::VERSION
 
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos geometry })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos coordinate_sequence })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos point })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos line_string })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos polygon })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos geometry_collection })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos multi_polygon })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos multi_line_string })
+  require File.join(GEOS_EXTENSIONS_BASE, *%w{ geos multi_point })
+
   autoload :Helper, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos geos_helper })
-  autoload :ActiveRecord, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions })
   autoload :GoogleMaps, File.join(GEOS_EXTENSIONS_BASE, *%w{ geos google_maps })
 
   REGEXP_FLOAT = /(-?\d*(?:\.\d+)?|-?\d*(?:\.\d+?)[eE][-+]?\d+)/
@@ -76,27 +86,67 @@ module Geos
     geom
   end
 
+  ALLOWED_GEOS_READ_TYPES = [
+    :geometry,
+    :wkt,
+    :wkb,
+    :wkb_hex,
+    :g_lat_lng_bounds,
+    :g_lat_lng,
+    :box2d,
+    :wkb,
+    :nil
+  ]
+
   # Tries its best to return a Geometry object.
   def self.read(geom, options = {})
-    geos = case geom
+    allowed = Geos::Helper.array_wrap(options[:allowed] || ALLOWED_GEOS_READ_TYPES)
+    allowed = allowed - Geos::Helper.array_wrap(options[:excluded])
+
+    geom = geom.dup.force_encoding('BINARY') if geom.respond_to?(:force_encoding)
+
+    type = case geom
       when Geos::Geometry
-        geom
+        :geometry
       when REGEXP_WKT
-        Geos.from_wkt(geom, options)
+        :wkt
       when REGEXP_WKB_HEX
-        Geos.from_wkb(geom, options)
-      when REGEXP_G_LAT_LNG_BOUNDS, REGEXP_G_LAT_LNG
-        Geos.from_g_lat_lng(geom, options)
+        :wkb_hex
+      when REGEXP_G_LAT_LNG_BOUNDS
+        :g_lat_lng_bounds
+      when REGEXP_G_LAT_LNG
+        :g_lat_lng
       when REGEXP_BOX2D
-        Geos.from_box2d(geom)
+        :box2d
       when String
-        Geos.from_wkb(geom.unpack('H*').first.upcase, options)
+        :wkb
       when nil
-        nil
+        :nil
       else
         raise ArgumentError.new("Invalid geometry!")
     end
 
+    if !allowed.include?(type)
+      raise ArgumentError.new("geom appears to be a #{type} but #{type} is being filtered")
+    end
+
+    geos = case type
+      when :geometry
+        geom
+      when :wkt
+        Geos.from_wkt($~, options)
+      when :wkb_hex
+        Geos.from_wkb(geom, options)
+      when :g_lat_lng_bounds, :g_lat_lng
+        Geos.from_g_lat_lng($~, options)
+      when :box2d
+        Geos.from_box2d($~)
+      when :wkb
+        Geos.from_wkb(geom.unpack('H*').first.upcase, options)
+      when :nil
+        nil
+    end
+
     if geos && options[:srid]
       geos.srid = options[:srid]
     end
@@ -106,8 +156,13 @@ module Geos
 
   # Returns some kind of Geometry object from the given WKT. This method
   # will also accept PostGIS-style EWKT and its various enhancements.
-  def self.from_wkt(wkt, options = {})
-    srid, raw_wkt = wkt.scan(REGEXP_WKT).first
+  def self.from_wkt(wkt_or_match_data, options = {})
+    srid, raw_wkt = if wkt_or_match_data.kind_of?(MatchData)
+      [ wkt_or_match_data[1], wkt_or_match_data[2] ]
+    else
+      wkt_or_match_data.scan(REGEXP_WKT).first
+    end
+
     geom = self.wkt_reader_singleton.read(raw_wkt.upcase)
     geom.srid = (options[:srid] || srid).to_i if options[:srid] || srid
     geom
@@ -121,729 +176,73 @@ module Geos
   # while for GLatLngBounds we return a Geos::Polygon that encompasses the
   # bounds. Use the option :points to interpret the incoming value as
   # as GPoints rather than GLatLngs.
-  def self.from_g_lat_lng(geometry, options = {})
-    geom = case geometry
-      when REGEXP_G_LAT_LNG_BOUNDS
-        coords = Array.new
-        $~.captures.compact.each_slice(2) { |f|
-          coords << f.collect(&:to_f)
-        }
-
-        unless options[:points]
-          coords.each do |c|
-            c.reverse!
-          end
-        end
-
-        Geos.from_wkt("LINESTRING(%s, %s)" % [
-          coords[0].join(' '),
-          coords[1].join(' ')
-        ]).envelope
-      when REGEXP_G_LAT_LNG
-        coords = $~.captures.collect(&:to_f).tap { |c|
-          c.reverse! unless options[:points]
-        }
-        Geos.from_wkt("POINT(#{coords.join(' ')})")
+  def self.from_g_lat_lng(geometry_or_match_data, options = {})
+    match_data = case geometry_or_match_data
+      when MatchData
+        geometry_or_match_data.captures
+      when REGEXP_G_LAT_LNG_BOUNDS, REGEXP_G_LAT_LNG
+        $~.captures
       else
         raise "Invalid GLatLng format"
     end
 
-    if options[:srid]
-      geom.srid = options[:srid]
-    end
-
-    geom
-  end
-
-  # Same as from_g_lat_lng but uses GPoints instead of GLatLngs and GBounds
-  # instead of GLatLngBounds. Equivalent to calling from_g_lat_lng with a
-  # non-false expression for the points parameter.
-  def self.from_g_point(geometry, options = {})
-    self.from_g_lat_lng(geometry, options.merge(:points => true))
-  end
-
-  # Creates a Geometry from a PostGIS-style BOX string.
-  def self.from_box2d(geometry)
-    if geometry =~ REGEXP_BOX2D
-      coords = []
-      $~.captures.compact.each_slice(2) { |f|
+    geom = if match_data.length > 3
+      coords = Array.new
+      match_data.compact.each_slice(2) { |f|
         coords << f.collect(&:to_f)
       }
 
+      unless options[:points]
+        coords.each do |c|
+          c.reverse!
+        end
+      end
+
       Geos.from_wkt("LINESTRING(%s, %s)" % [
         coords[0].join(' '),
         coords[1].join(' ')
       ]).envelope
     else
-      raise "Invalid BOX2D"
-    end
-  end
-
-  # This is our base module that we use for some generic methods used all
-  # over the place.
-  class Geometry
-    protected
-
-    WKB_WRITER_OPTIONS = [ :output_dimensions, :byte_order, :include_srid ].freeze
-    def wkb_writer(options = {}) #:nodoc:
-      writer = WkbWriter.new
-      options.reject { |k, v| !WKB_WRITER_OPTIONS.include?(k) }.each do |k, v|
-        writer.send("#{k}=", v)
-      end
-      writer
-    end
-
-    public
-
-    # Spits the geometry out into WKB in binary.
-    #
-    # You can set the :output_dimensions, :byte_order and :include_srid
-    # options via the options Hash.
-    def to_wkb_bin(options = {})
-      wkb_writer(options).write(self)
-    end
-
-    # Quickly call to_wkb_bin with :include_srid set to true.
-    def to_ewkb_bin(options = {})
-      options = {
-        :include_srid => true
-      }.merge options
-      to_wkb_bin(options)
-    end
-
-    # Spits the geometry out into WKB in hex.
-    #
-    # You can set the :output_dimensions, :byte_order and :include_srid
-    # options via the options Hash.
-    def to_wkb(options = {})
-      wkb_writer(options).write_hex(self)
-    end
-
-    # Quickly call to_wkb with :include_srid set to true.
-    def to_ewkb(options = {})
-      options = {
-        :include_srid => true
-      }.merge options
-      to_wkb(options)
-    end
-
-    # Spits the geometry out into WKT. You can specify the :include_srid
-    # option to create a PostGIS-style EWKT output.
-    def to_wkt(options = {})
-      writer = WktWriter.new
-
-      # Older versions of the Geos library don't allow for options here.
-      args = if WktWriter.instance_method(:write).arity < -1
-        [ options ]
-      else
-        []
-      end
-
-      ret = ''
-
-      if options[:include_srid]
-        srid = if options[:srid]
-          options[:srid]
-        else
-          self.srid
-        end
-
-        ret << "SRID=#{srid};"
-      end
-
-      ret << writer.write(self, *args)
-      ret
-    end
-
-    # Quickly call to_wkt with :include_srid set to true.
-    def to_ewkt(options = {})
-      options = {
-        :include_srid => true
-      }.merge options
-      to_wkt(options)
-    end
-
-    # Returns a Point for the envelope's upper left coordinate.
-    def upper_left
-      if defined?(@upper_left)
-        @upper_left
-      else
-        cs = self.envelope.exterior_ring.coord_seq
-        @upper_left = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(3)} #{cs.get_y(3)})")
-      end
-    end
-    alias :nw :upper_left
-    alias :northwest :upper_left
-
-    # Returns a Point for the envelope's upper right coordinate.
-    def upper_right
-      if defined?(@upper_right)
-        @upper_right
-      else
-        cs = self.envelope.exterior_ring.coord_seq
-        @upper_right = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(2)} #{cs.get_y(2)})")
-      end
-    end
-    alias :ne :upper_right
-    alias :northeast :upper_right
-
-    # Returns a Point for the envelope's lower right coordinate.
-    def lower_right
-      if defined?(@lower_right)
-        @lower_right
-      else
-        cs = self.envelope.exterior_ring.coord_seq
-        @lower_right = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(1)} #{cs.get_y(1)})")
-      end
-    end
-    alias :se :lower_right
-    alias :southeast :lower_right
-
-    # Returns a Point for the envelope's lower left coordinate.
-    def lower_left
-      if defined?(@lower_left)
-        @lower_left
-      else
-        cs = self.envelope.exterior_ring.coord_seq
-        @lower_left = Geos::wkt_reader_singleton.read("POINT(#{cs.get_x(0)} #{cs.get_y(0)})")
-      end
-    end
-    alias :sw :lower_left
-    alias :southwest :lower_left
-
-    # Northern-most Y coordinate.
-    def top
-      if defined?(@top)
-        @top
-      else
-        @top = self.upper_right.y
-      end
-    end
-    alias :n :top
-    alias :north :top
-
-    # Eastern-most X coordinate.
-    def right
-      if defined?(@right)
-        @right
-      else
-        @right = self.upper_right.x
-      end
-    end
-    alias :e :right
-    alias :east :right
-
-    # Southern-most Y coordinate.
-    def bottom
-      if defined?(@bottom)
-        @bottom
-      else
-        @bottom = self.lower_left.y
-      end
-    end
-    alias :s :bottom
-    alias :south :bottom
-
-    # Western-most X coordinate.
-    def left
-      if defined?(@left)
-        @left
-      else
-        @left = self.lower_left.x
-      end
-    end
-    alias :w :left
-    alias :west :left
-
-    # Spits out a bounding box the way Flickr likes it. You can set the
-    # precision of the rounding using the :precision option. In order to
-    # ensure that the box is indeed a box and not merely a point, the
-    # southwest coordinates are floored and the northeast point ceiled.
-    def to_flickr_bbox(options = {})
-      options = {
-        :precision => 1
-      }.merge(options)
-      precision = 10.0 ** options[:precision]
-
-      [
-        (self.west  * precision).floor / precision,
-        (self.south * precision).floor / precision,
-        (self.east  * precision).ceil / precision,
-        (self.north * precision).ceil / precision
-      ].join(',')
-    end
-
-    def to_geojson(options = {})
-      self.to_geojsonable(options).to_json
-    end
-  end
-
-
-  class CoordinateSequence
-    # Returns a Ruby Array of Arrays of coordinates within the
-    # CoordinateSequence in the form [ x, y, z ].
-    def to_a
-      (0...self.length).to_a.collect do |p|
-        [
-          self.get_x(p),
-          (self.dimensions >= 2 ? self.get_y(p) : nil),
-          (self.dimensions >= 3 && self.get_z(p) > 1.7e-306 ? self.get_z(p) : nil)
-        ].compact
-      end
-    end
-
-    # Build some XmlMarkup for KML. You can set various KML options like
-    # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
-    # will be converted automatically, i.e. :altitudeMode, not
-    # :altitude_mode.
-    def to_kml *args
-      xml, options = Geos::Helper.xml_options(*args)
-
-      xml.LineString(:id => options[:id]) do
-        xml.extrude(options[:extrude]) if options[:extrude]
-        xml.tessellate(options[:tessellate]) if options[:tessellate]
-        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitudeMode]
-        xml.coordinates do
-          self.to_a.each do
-            xml << (self.to_a.join(','))
-          end
-        end
-      end
-    end
-
-    # Build some XmlMarkup for GeoRSS GML. You should include the
-    # appropriate georss and gml XML namespaces in your document.
-    def to_georss *args
-      xml = Geos::Helper.xml_options(*args)[0]
-
-      xml.georss(:where) do
-        xml.gml(:LineString) do
-          xml.gml(:posList) do
-            xml << self.to_a.collect do |p|
-              "#{p[1]} #{p[0]}"
-            end.join(' ')
-          end
-        end
-      end
-    end
-
-    # Returns a Hash suitable for converting to JSON.
-    #
-    # Options:
-    #
-    # * :encoded - enable or disable Google Maps encoding. The default is
-    #   true.
-    # * :level - set the level of the Google Maps encoding algorithm.
-    def to_jsonable options = {}
-      options = {
-        :encoded => true,
-        :level => 3
-      }.merge options
-
-      if options[:encoded]
-        {
-          :type => 'lineString',
-          :encoded => true
-        }.merge(Geos::GoogleMaps::PolylineEncoder.encode(self.to_a, options[:level]))
-      else
-        {
-          :type => 'lineString',
-          :encoded => false,
-          :points => self.to_a
-        }
-      end
-    end
-
-    def to_geojsonable(options = {})
-      {
-        :type => 'LineString',
-        :coordinates => self.to_a
+      coords = match_data.collect(&:to_f).tap { |c|
+        c.reverse! unless options[:points]
       }
+      Geos.from_wkt("POINT(#{coords.join(' ')})")
     end
 
-    def to_geojson(options = {})
-      self.to_geojsonable(options).to_json
-    end
-  end
-
-
-  class Point
-    unless method_defined?(:y)
-      # Returns the Y coordinate of the Point.
-      def y
-        self.to_a[1]
-      end
-    end
-
-    %w{
-      latitude lat north south n s
-    }.each do |name|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        alias #{name} :y
-      EOF
-    end
-
-    unless method_defined?(:x)
-      # Returns the X coordinate of the Point.
-      def x
-        self.to_a[0]
-      end
-    end
-
-    %w{
-      longitude lng east west e w
-    }.each do |name|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        alias #{name} :x
-      EOF
-    end
-
-    unless method_defined?(:z)
-      # Returns the Z coordinate of the Point.
-      def z
-        if self.has_z?
-          self.to_a[2]
-        else
-          nil
-        end
-      end
-    end
-
-    # Returns the Point's coordinates as an Array in the following format:
-    #
-    #  [ x, y, z ]
-    #
-    # The Z coordinate will only be present for Points which have a Z
-    # dimension.
-    def to_a
-      if defined?(@to_a)
-        @to_a
-      else
-        cs = self.coord_seq
-        @to_a = if self.has_z?
-          [ cs.get_x(0), cs.get_y(0), cs.get_z(0) ]
-        else
-          [ cs.get_x(0), cs.get_y(0) ]
-        end
-      end
-    end
-
-    # Optimize some unnecessary code away:
-    %w{
-      upper_left upper_right lower_right lower_left
-      ne nw se sw
-      northwest northeast southeast southwest
-    }.each do |name|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-        def #{name}
-          self
-        end
-      EOF
-    end
-
-    # Build some XmlMarkup for KML. You can set KML options for extrude and
-    # altitudeMode. Use Rails/Ruby-style code and it will be converted
-    # appropriately, i.e. :altitude_mode, not :altitudeMode.
-    def to_kml *args
-      xml, options = Geos::Helper.xml_options(*args)
-      xml.Point(:id => options[:id]) do
-        xml.extrude(options[:extrude]) if options[:extrude]
-        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitude_mode]
-        xml.coordinates(self.to_a.join(','))
-      end
-    end
-
-    # Build some XmlMarkup for GeoRSS. You should include the
-    # appropriate georss and gml XML namespaces in your document.
-    def to_georss *args
-      xml = Geos::Helper.xml_options(*args)[0]
-      xml.georss(:where) do
-        xml.gml(:Point) do
-          xml.gml(:pos, "#{self.lat} #{self.lng}")
-        end
-      end
-    end
-
-    # Returns a Hash suitable for converting to JSON.
-    def to_jsonable options = {}
-      cs = self.coord_seq
-      if self.has_z?
-        { :type => 'point', :lat => cs.get_y(0), :lng => cs.get_x(0), :z => cs.get_z(0) }
-      else
-        { :type => 'point', :lat => cs.get_y(0), :lng => cs.get_x(0) }
-      end
+    if options[:srid]
+      geom.srid = options[:srid]
     end
 
-    def to_geojsonable(options = {})
-      {
-        :type => 'Point',
-        :coordinates => self.to_a
-      }
-    end
+    geom
   end
 
-
-  class LineString
-    def to_jsonable(options = {})
-      self.coord_seq.to_jsonable(options)
-    end
-
-    def to_geojsonable(options = {})
-      self.coord_seq.to_geojsonable(options)
-    end
+  # Same as from_g_lat_lng but uses GPoints instead of GLatLngs and GBounds
+  # instead of GLatLngBounds. Equivalent to calling from_g_lat_lng with a
+  # non-false expression for the points parameter.
+  def self.from_g_point(geometry, options = {})
+    self.from_g_lat_lng(geometry, options.merge(:points => true))
   end
 
-  class Polygon
-    # Build some XmlMarkup for XML. You can set various KML options like
-    # tessellate, altitudeMode, etc. Use Rails/Ruby-style code and it
-    # will be converted automatically, i.e. :altitudeMode, not
-    # :altitude_mode. You can also include interior rings by setting
-    # :interior_rings to true. The default is false.
-    def to_kml *args
-      xml, options = Geos::Helper.xml_options(*args)
-
-      xml.Polygon(:id => options[:id]) do
-        xml.extrude(options[:extrude]) if options[:extrude]
-        xml.tessellate(options[:tessellate]) if options[:tessellate]
-        xml.altitudeMode(Geos::Helper.camelize(options[:altitude_mode])) if options[:altitude_mode]
-        xml.outerBoundaryIs do
-          xml.LinearRing do
-            xml.coordinates do
-              xml << self.exterior_ring.coord_seq.to_a.collect do |p|
-                p.join(',')
-              end.join(' ')
-            end
-          end
-        end
-        (0...self.num_interior_rings).to_a.each do |n|
-          xml.innerBoundaryIs do
-            xml.LinearRing do
-              xml.coordinates do
-                xml << self.interior_ring_n(n).coord_seq.to_a.collect do |p|
-                  p.join(',')
-                end.join(' ')
-              end
-            end
-          end
-        end if options[:interior_rings] && self.num_interior_rings > 0
-      end
-    end
-
-    # Build some XmlMarkup for GeoRSS. You should include the
-    # appropriate georss and gml XML namespaces in your document.
-    def to_georss *args
-      xml = Geos::Helper.xml_options(*args)[0]
-
-      xml.georss(:where) do
-        xml.gml(:Polygon) do
-          xml.gml(:exterior) do
-            xml.gml(:LinearRing) do
-              xml.gml(:posList) do
-                xml << self.exterior_ring.coord_seq.to_a.collect do |p|
-                  "#{p[1]} #{p[0]}"
-                end.join(' ')
-              end
-            end
-          end
-        end
-      end
-    end
-
-    # Returns a Hash suitable for converting to JSON.
-    #
-    # Options:
-    #
-    # * :encoded - enable or disable Google Maps encoding. The default is
-    #   true.
-    # * :level - set the level of the Google Maps encoding algorithm.
-    # * :interior_rings - add interior rings to the output. The default
-    #   is false.
-    # * :style_options - any style options you want to pass along in the
-    #   JSON. These options will be automatically camelized into
-    #   Javascripty code.
-    def to_jsonable options = {}
-      options = {
-        :encoded => true,
-        :level => 3,
-        :interior_rings => false
-      }.merge options
-
-      style_options = Hash.new
-      if options[:style_options] && !options[:style_options].empty?
-        options[:style_options].each do |k, v|
-          style_options[Geos::Helper.camelize(k.to_s)] = v
-        end
-      end
-
-      if options[:encoded]
-        ret = {
-          :type => 'polygon',
-          :encoded => true,
-          :polylines => [ Geos::GoogleMaps::PolylineEncoder.encode(
-              self.exterior_ring.coord_seq.to_a,
-              options[:level]
-            ).merge(:bounds => {
-              :sw => self.lower_left.to_a,
-              :ne => self.upper_right.to_a
-            })
-          ],
-          :options => style_options
-        }
-
-        if options[:interior_rings] && self.num_interior_rings > 0
-          (0..(self.num_interior_rings) - 1).to_a.each do |n|
-            ret[:polylines] << Geos::GoogleMaps::PolylineEncoder.encode(
-              self.interior_ring_n(n).coord_seq.to_a,
-              options[:level]
-            )
-          end
-        end
-        ret
+  # Creates a Geometry from a PostGIS-style BOX string.
+  def self.from_box2d(geometry_or_match_data)
+    match_data = case geometry_or_match_data
+      when MatchData
+        geometry_or_match_data.captures
+      when REGEXP_BOX2D
+        $~.captures
       else
-        ret = {
-          :type => 'polygon',
-          :encoded => false,
-          :polylines => [{
-            :points => self.exterior_ring.coord_seq.to_a,
-            :bounds => {
-              :sw => self.lower_left.to_a,
-              :ne => self.upper_right.to_a
-            }
-          }]
-        }
-        if options[:interior_rings] && self.num_interior_rings > 0
-          (0..(self.num_interior_rings) - 1).to_a.each do |n|
-            ret[:polylines] << {
-              :points => self.interior_ring_n(n).coord_seq.to_a
-            }
-          end
-        end
-        ret
-      end
+        raise "Invalid BOX2D"
     end
 
-    # Options:
-    #
-    # * :interior_rings - whether to include any interior rings in the output.
-    #   The default is true.
-    def to_geojsonable(options = {})
-      options = {
-        :interior_rings => true
-      }.merge(options)
-
-      ret = {
-        :type => 'Polygon',
-        :coordinates => [ self.exterior_ring.coord_seq.to_a ]
-      }
+    coords = []
+    match_data.compact.each_slice(2) { |f|
+      coords << f.collect(&:to_f)
+    }
 
-      if options[:interior_rings] && self.num_interior_rings > 0
-        ret[:coordinates].concat self.interior_rings.collect { |r|
-          r.coord_seq.to_a
-        }
-      end
-
-      ret
-    end
-  end
-
-
-  class GeometryCollection
-    if !GeometryCollection.included_modules.include?(Enumerable)
-      include Enumerable
-
-      # Iterates the collection through the given block.
-      def each
-        self.num_geometries.times do |n|
-          yield self.get_geometry_n(n)
-        end
-        nil
-      end
-
-      # Returns the nth geometry from the collection.
-      def [](*args)
-        self.to_a[*args]
-      end
-      alias :slice :[]
-    end
-
-    # Returns the last geometry from the collection.
-    def last
-      self.get_geometry_n(self.num_geometries - 1) if self.num_geometries > 0
-    end
-
-    # Returns a Hash suitable for converting to JSON.
-    def to_jsonable options = {}
-      self.collect do |p|
-        p.to_jsonable options
-      end
-    end
-
-    # Build some XmlMarkup for KML.
-    def to_kml *args
-      self.collect do |p|
-        p.to_kml(*args)
-      end
-    end
-
-    # Build some XmlMarkup for GeoRSS. Since GeoRSS is pretty trimed down,
-    # we just take the entire collection and use the exterior_ring as
-    # a Polygon. Not to bright, mind you, but until GeoRSS stops with the
-    # suck, what are we to do. You should include the appropriate georss
-    # and gml XML namespaces in your document.
-    def to_georss *args
-      self.exterior_ring.to_georss(*args)
-    end
-
-    def to_geojsonable(options = {})
-      {
-        :type => 'GeometryCollection',
-        :geometries => self.to_a.collect { |g| g.to_geojsonable(options) }
-      }
-    end
-  end
-
-  class MultiPolygon < GeometryCollection
-    def to_geojsonable(options = {})
-      options = {
-        :interior_rings => true
-      }.merge(options)
-
-      {
-        :type => 'MultiPolygon',
-        :coordinates => self.to_a.collect { |polygon|
-          coords = [ polygon.exterior_ring.coord_seq.to_a ]
-
-          if options[:interior_rings] && polygon.num_interior_rings > 0
-            coords.concat polygon.interior_rings.collect { |r|
-              r.coord_seq.to_a
-            }
-          end
-
-          coords
-        }
-      }
-    end
-  end
-
-  class MultiLineString < GeometryCollection
-    def to_geojsonable(options = {})
-      {
-        :type => 'MultiLineString',
-        :coordinates => self.to_a.collect { |linestring|
-          linestring.coord_seq.to_a
-        }
-      }
-    end
-  end
-
-  class MultiPoint < GeometryCollection
-    def to_geojsonable(options = {})
-      {
-        :type => 'MultiPoint',
-        :coordinates => self.to_a.collect { |point|
-          point.to_a
-        }
-      }
-    end
+    Geos.from_wkt("LINESTRING(%s, %s)" % [
+      coords[0].join(' '),
+      coords[1].join(' ')
+    ]).envelope
   end
 end
+