geos-extensions 0.0.2

data/lib/geos_helper.rb

@@ -0,0 +1,51 @@
+
+module Geos::Helper
+  JS_ESCAPE_MAP = {
+    '\\'    => '\\\\',
+    '</'    => '<\/',
+    "\r\n"  => '\n',
+    "\n"    => '\n',
+    "\r"    => '\n',
+    '"'     => '\\"',
+    "'"     => "\\'"
+  }
+
+  # Escape carrier returns and single and double quotes for JavaScript
+  # segments. Borrowed from ActiveSupport.
+  def self.escape_javascript(javascript) #:nodoc:
+    if javascript
+      javascript.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { JS_ESCAPE_MAP[$1] }
+    else
+      ''
+    end
+  end
+
+    def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = false)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      lower_case_and_underscored_word.to_s[0..0].downcase + camelize(lower_case_and_underscored_word, true)[1..-1]
+    end
+    end
+
+    def self.xml_options(*args) #:nodoc:
+    xml = if Builder::XmlMarkup === args.first
+      args.first
+    else
+      Builder::XmlMarkup.new(:indent => 4)
+    end
+
+    options = if Hash === args.last
+      args.last
+    else
+      Hash.new
+    end
+
+    [ xml, options ]
+  end
+
+  def self.number_with_precision(number, precision = 6)
+    rounded_number = (Float(number) * (10 ** precision)).round.to_f / 10 ** precision
+    "%01.#{precision}f" % rounded_number
+  end
+end

data/lib/google_maps.rb

@@ -0,0 +1,7 @@
+
+module Geos
+  module GoogleMaps
+    autoload :PolylineEncoder, File.join(GEOS_EXTENSIONS_BASE, *%w{ google_maps polyline_encoder })
+  end
+end
+

data/lib/google_maps/polyline_encoder.rb

@@ -0,0 +1,60 @@
+
+module Geos
+  module GoogleMaps
+    module PolylineEncoder
+
+      class << self
+        # Encodes a series of points into Google's encoded polyline format. See
+        # http://code.google.com/apis/maps/documentation/reference.html for
+        # details, specifically GPolyline#fromEncoded and
+        # GPolygon#fromEncoded.
+        #
+        # The level parameter is the zoom level you're encoding at. See the
+        # Google Maps API reference for details on that.
+        def encode(points, level = 3)
+          encoded_points = String.new
+          encoded_levels = String.new
+
+          prev_lat = 0
+          prev_lng = 0
+
+          points.each do |p|
+            lat_e5 = (p[1] * 1e5).floor
+            lng_e5 = (p[0] * 1e5).floor
+
+            cur_lat = lat_e5 - prev_lat
+            cur_lng = lng_e5 - prev_lng
+
+            prev_lat = lat_e5
+            prev_lng = lng_e5
+
+            encoded_points += encode_signed_number(cur_lat) + encode_signed_number(cur_lng)
+            encoded_levels += encode_number(level)
+          end
+
+          { :points => encoded_points, :levels => encoded_levels }
+        end
+
+        protected
+
+        # Encodes a signed number into the Google Maps encoded polyline format.
+        def encode_signed_number(n) #:nodoc:
+          signed = n << 1
+          signed = ~(signed) if n < 0
+          encode_number signed
+        end
+
+        # Encodes a number into the Google Maps encoded polyline format.
+        def encode_number(n) #:nodoc:
+          str = String.new
+          while (n >= 0x20) do
+            str += ((0x20 | (n & 0x1f)) + 63).chr
+            n >>= 5
+          end
+          str + (n + 63).chr
+        end
+      end
+    end
+  end
+end
+

data/test/reader_test.rb

@@ -0,0 +1,112 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeosReaderTests < Test::Unit::TestCase
+  include TestHelper
+
+  def test_from_wkb_bin
+    point = Geos.from_wkb_bin(POINT_WKB_BIN)
+    polygon = Geos.from_wkb_bin(POLYGON_WKB_BIN)
+
+    assert_saneness_of_point(point)
+    assert_saneness_of_polygon(polygon)
+  end
+
+  def test_from_wkb
+    point = Geos.from_wkb(POINT_WKB)
+    polygon = Geos.from_wkb(POLYGON_WKB)
+
+    assert_saneness_of_point(point)
+    assert_saneness_of_polygon(polygon)
+  end
+
+  def test_from_wkt
+    point = Geos.from_wkt(POINT_WKT)
+    polygon = Geos.from_wkt(POLYGON_WKT)
+
+    assert_saneness_of_point(point)
+    assert_saneness_of_polygon(polygon)
+  end
+
+  def test_from_ewkb_bin
+    point = Geos.from_wkb_bin(POINT_EWKB_BIN)
+    polygon = Geos.from_wkb_bin(POLYGON_EWKB_BIN)
+
+    assert_saneness_of_point(point)
+    assert_equal(4326, point.srid)
+
+    assert_saneness_of_polygon(polygon)
+    assert_equal(4326, polygon.srid)
+  end
+
+  def test_from_ewkb
+    point = Geos.from_wkb(POINT_EWKB)
+    polygon = Geos.from_wkb(POLYGON_EWKB)
+
+    assert_saneness_of_point(point)
+    assert_equal(4326, point.srid)
+
+    assert_saneness_of_polygon(polygon)
+    assert_equal(4326, polygon.srid)
+  end
+
+  def test_from_ewkt
+    point = Geos.from_wkt(POINT_EWKT)
+    polygon = Geos.from_wkt(POLYGON_EWKT)
+
+    assert_saneness_of_point(point)
+    assert_equal(4326, point.srid)
+
+    assert_saneness_of_polygon(polygon)
+    assert_equal(4326, polygon.srid)
+  end
+
+  def test_from_g_lat_lng
+    point = Geos.from_g_lat_lng(POINT_G_LAT_LNG)
+    assert_saneness_of_point(point)
+
+    point = Geos.from_g_lat_lng(POINT_G_LAT_LNG, :points => true)
+    assert_kind_of(Geos::Point, point)
+    assert_equal(10, point.lat)
+    assert_equal(10.01, point.lng)
+  end
+
+  def test_from_g_lat_lng_bounds
+    bounds = Geos.from_g_lat_lng(BOUNDS_G_LAT_LNG)
+
+    assert_kind_of(Geos::Polygon, bounds)
+    assert_equal([ 0, 0 ], bounds.sw.to_a)
+    assert_equal([ 5, 5 ], bounds.ne.to_a)
+    assert_equal([ 0, 5 ], bounds.nw.to_a)
+    assert_equal([ 5, 0 ], bounds.se.to_a)
+  end
+
+  def test_read
+    [
+      POINT_WKT,
+      POINT_EWKT,
+      POINT_WKB,
+      POINT_WKB_BIN,
+      POINT_EWKB,
+      POINT_EWKB_BIN,
+      POINT_G_LAT_LNG,
+      POINT_G_LAT_LNG_URL_VALUE
+    ].each do |geom|
+      point = Geos.read(geom)
+      assert_saneness_of_point(point)
+    end
+
+    [
+      POLYGON_WKT,
+      POLYGON_EWKT,
+      POLYGON_WKB,
+      POLYGON_WKB_BIN,
+      POLYGON_EWKB,
+      POLYGON_EWKB_BIN
+    ].each do |geom|
+      polygon = Geos.read(geom)
+      assert_saneness_of_polygon(polygon)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,71 @@
+
+require 'rubygems'
+require 'test/unit'
+require File.join(File.dirname(__FILE__), %w{ .. lib geos_extensions })
+
+puts "Ruby version #{RUBY_VERSION} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
+puts "GEOS version #{Geos::GEOS_VERSION}"
+if defined?(Geos::FFIGeos)
+  puts "Using #{Geos::FFIGeos.geos_library_paths.join(', ')}"
+end
+
+module TestHelper
+  POINT_WKT = 'POINT(10 10.01)'
+  POINT_EWKT = 'SRID=4326; POINT(10 10.01)'
+  POINT_WKB = "0101000000000000000000244085EB51B81E052440"
+  POINT_WKB_BIN = "\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
+  POINT_EWKB = "0101000020E6100000000000000000244085EB51B81E052440"
+  POINT_EWKB_BIN = "\x01\x01\x00\x00\x20\xE6\x10\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
+  POINT_G_LAT_LNG = "(10.01, 10)"
+  POINT_G_LAT_LNG_URL_VALUE = "10.01,10"
+
+  POLYGON_WKT = 'POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
+  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
+  POLYGON_WKB = "
+    0103000000010000000500000000000000000000000000000000000000000000000000F
+    03F000000000000F03F0000000000000440000000000000044000000000000014400000
+    00000000144000000000000000000000000000000000
+  ".gsub(/\s/, '')
+  POLYGON_WKB_BIN = [
+    "\x01\x03\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xF0\x3F\x00",
+    "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00",
+    "\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14",
+    "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+  ].join
+  POLYGON_EWKB = "
+    0103000020E610000001000000050000000000000000000000000000000000000000000
+    0000000F03F000000000000F03F00000000000004400000000000000440000000000000
+    1440000000000000144000000000000000000000000000000000
+  ".gsub(/\s/, '')
+  POLYGON_EWKB_BIN = [
+    "\x01\x03\x00\x00\x20\xE6\x10\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00",
+    "\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00",
+    "\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+  ].join
+
+  POLYGON_WITH_INTERIOR_RING = "POLYGON((0 0, 5 0, 5 5, 0 5, 0 0),(4 4, 4 1, 1 1, 1 4, 4 4))"
+
+  BOUNDS_G_LAT_LNG = "((0, 0), (5, 5))"
+
+  def assert_saneness_of_point(point)
+    assert_kind_of(Geos::Point, point)
+    assert_equal(10.01, point.lat)
+    assert_equal(10, point.lng)
+  end
+
+  def assert_saneness_of_polygon(polygon)
+    assert_kind_of(Geos::Polygon, polygon)
+    cs = polygon.exterior_ring.coord_seq
+    assert_equal([
+      [ 0, 0 ],
+      [ 1, 1 ],
+      [ 2.5, 2.5 ],
+      [ 5, 5 ],
+      [ 0, 0 ]
+    ], cs.to_a)
+  end
+end

data/test/writer_test.rb

@@ -0,0 +1,287 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+begin
+  require 'json'
+rescue LoadError
+  # do nothing
+end
+
+begin
+  require 'builder'
+  require 'stringio'
+rescue LoadError
+  # do nothing
+end
+
+class GeosWriterTests < Test::Unit::TestCase
+  include TestHelper
+
+  def initialize(*args)
+    @point = Geos.read(POINT_EWKB)
+    @polygon = Geos.read(POLYGON_EWKB)
+    super(*args)
+  end
+
+  def test_to_wkb_bin
+    assert_equal(POINT_WKB_BIN, @point.to_wkb_bin)
+    assert_equal(POLYGON_WKB_BIN, @polygon.to_wkb_bin)
+  end
+
+  def test_to_wkb
+    assert_equal(POINT_WKB, @point.to_wkb)
+    assert_equal(POLYGON_WKB, @polygon.to_wkb)
+  end
+
+  def test_to_wkt
+    if @point.to_wkt =~ /^POINT\s*\((\d+\.\d+)\s*(\d+\.\d+)\)$/
+      lng, lat = $1.to_f, $2.to_f
+    end
+
+    assert_in_delta(lng, 10.00, 0.000001)
+    assert_in_delta(lat, 10.01, 0.000001)
+  end
+
+  def test_to_ewkb_bin
+    assert_equal(POINT_EWKB_BIN, @point.to_ewkb_bin)
+    assert_equal(POLYGON_EWKB_BIN, @polygon.to_ewkb_bin)
+  end
+
+  def test_to_ewkb
+    assert_equal(POINT_EWKB, @point.to_ewkb)
+    assert_equal(POLYGON_EWKB, @polygon.to_ewkb)
+  end
+
+  def test_to_ewkt
+    if @point.to_ewkt =~ /^SRID=4326;\s*POINT\s*\((\d+\.\d+)\s*(\d+\.\d+)\)$/
+      lng, lat = $1.to_f, $2.to_f
+    end
+
+    assert_in_delta(lng, 10.00, 0.000001)
+    assert_in_delta(lat, 10.01, 0.000001)
+  end
+
+  def test_to_g_lat_lng
+    assert_equal("new google.maps.LatLng(10.01, 10.0)", @point.to_g_lat_lng)
+    assert_equal("new GLatLng(10.01, 10.0)", @point.to_g_lat_lng(:short_class => true))
+  end
+
+  def test_to_flickr_bbox
+    assert_equal('0.0,0.0,5.0,5.0', @polygon.to_flickr_bbox)
+  end
+
+  def test_to_jsonable
+    assert_equal({
+      :type => "point",
+      :lat => 10.01,
+      :lng => 10.0
+    }, @point.to_jsonable)
+
+    assert_equal({
+      :type => "polygon",
+      :polylines => [{
+        :points => "??_ibE_ibE_~cH_~cH_hgN_hgN~po]~po]",
+        :bounds => {
+          :sw => [ 0.0, 0.0 ],
+          :ne => [ 5.0, 5.0 ]
+        },
+        :levels=>"BBBBB"
+      }],
+      :options => {},
+      :encoded => true
+    }, @polygon.to_jsonable)
+  end
+
+  if defined?(JSON)
+    def test_to_g_polygon
+      assert_equal(
+        "new google.maps.Polygon([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], null, null, null, null, null, null)",
+        @polygon.to_g_polygon
+      )
+
+      assert_equal(
+        "new GPolygon([new GLatLng(0.0, 0.0), new GLatLng(1.0, 1.0), new GLatLng(2.5, 2.5), new GLatLng(5.0, 5.0), new GLatLng(0.0, 0.0)], null, null, null, null, null, null)",
+        @polygon.to_g_polygon({}, :short_class => true)
+      )
+
+      assert_equal(
+        "new google.maps.Polygon([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], '#b00b1e', 5, 0.5, '#b00b1e', null, {\"mouseOutTolerence\":5})",
+        @polygon.to_g_polygon(
+          :stroke_color => '#b00b1e',
+          :stroke_weight => 5,
+          :stroke_opacity => 0.5,
+          :fill_color => '#b00b1e',
+          :polygon_options => {
+            :mouse_out_tolerence => 5
+          }
+        )
+      )
+    end
+
+    def test_to_g_polyline
+      assert_equal(
+        "new google.maps.Polyline([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], null, null, null, null)",
+        @polygon.to_g_polyline
+      )
+
+      assert_equal(
+        "new GPolyline([new GLatLng(0.0, 0.0), new GLatLng(1.0, 1.0), new GLatLng(2.5, 2.5), new GLatLng(5.0, 5.0), new GLatLng(0.0, 0.0)], null, null, null, null)",
+        @polygon.to_g_polyline({}, :short_class => true)
+      )
+
+      assert_equal(
+        "new google.maps.Polyline([new google.maps.LatLng(0.0, 0.0), new google.maps.LatLng(1.0, 1.0), new google.maps.LatLng(2.5, 2.5), new google.maps.LatLng(5.0, 5.0), new google.maps.LatLng(0.0, 0.0)], '#b00b1e', 5, 0.5, {\"mouseOutTolerence\":5})",
+        @polygon.to_g_polyline(
+          :color => '#b00b1e',
+          :weight => 5,
+          :opacity => 0.5,
+          :polyline_options => {
+            :mouse_out_tolerence => 5
+          }
+        )
+      )
+    end
+
+    def test_to_g_marker_long
+      marker = @point.to_g_marker
+
+      lat, lng, json = if marker =~ /^new\s+
+        google\.maps\.Marker\(
+          new\s+google\.maps\.LatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            ((\{\}))
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        {},
+        JSON.load(json)
+      )
+    end
+
+    def test_to_g_marker_short_class
+      marker = @point.to_g_marker({}, :short_class => true)
+
+      lat, lng, json = if marker =~ /^new\s+
+        GMarker\(
+          new\s+GLatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            (\{\})
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        {},
+        JSON.load(json)
+      )
+    end
+
+
+    def test_to_g_marker_with_options
+      marker = @point.to_g_marker(
+        :bounce_gravity => 1,
+        :bouncy => true
+      )
+
+      lat, lng, json = if marker =~ /^new\s+
+        google\.maps\.Marker\(
+          new\s+google\.maps\.LatLng\(
+            (\d+\.\d+)\s*,\s*
+            (\d+\.\d+)
+          \),\s*
+            (\{[^}]+\})
+        \)
+        /x
+        [ $1, $2, $3 ]
+      end
+
+      assert_in_delta(lng.to_f, 10.00, 0.000001)
+      assert_in_delta(lat.to_f, 10.01, 0.000001)
+      assert_equal(
+        { "bounceGravity" => 1, "bouncy" => true },
+        JSON.load(json)
+      )
+    end
+
+    def test_to_g_json_point
+      assert_equal(
+        { :coordinates => [ 10.0, 10.01, 0 ] },
+        @point.to_g_json_point
+      )
+    end
+
+    def test_to_g_lat_lon_box
+      assert_equal(
+        { :east => 5.0, :west => 0.0, :north => 5.0, :south => 0.0},
+        @polygon.to_g_lat_lon_box
+      )
+    end
+  end
+
+  if defined?(Builder::XmlMarkup)
+    def test_to_kml_point
+      out = StringIO.new
+      xml = Builder::XmlMarkup.new(:target => out)
+      @point.to_kml(xml, {
+        :extrude => true,
+        :altitude_mode => :relative_to_ground
+      })
+      out.rewind
+
+      assert_equal("<Point id=\"\"><extrude>true</extrude><altitudeMode>relativeToGround</altitudeMode><coordinates>10.0,10.01</coordinates></Point>", out.read)
+    end
+
+    def test_to_kml_polygon
+      out = StringIO.new
+      xml = Builder::XmlMarkup.new(:target => out)
+      @polygon.to_kml(xml, {
+        :extrude => true,
+        :altitude_mode => :relative_to_ground
+      })
+      out.rewind
+
+      assert_equal("<Polygon id=\"\"><extrude>true</extrude><altitudeMode>relativeToGround</altitudeMode><outerBoundaryIs><LinearRing><coordinates>0.0,0.0 1.0,1.0 2.5,2.5 5.0,5.0 0.0,0.0</coordinates></LinearRing></outerBoundaryIs></Polygon>",
+        out.read
+      )
+    end
+
+    def test_to_kml_polygon_with_interior_ring
+      out = StringIO.new
+      polygon = Geos.read(POLYGON_WITH_INTERIOR_RING)
+      xml = Builder::XmlMarkup.new(:target => out)
+      polygon.to_kml(xml, :interior_rings => true)
+      out.rewind
+
+      assert_equal(
+        "<Polygon id=\"\"><outerBoundaryIs><LinearRing><coordinates>0.0,0.0 5.0,0.0 5.0,5.0 0.0,5.0 0.0,0.0</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>4.0,4.0 4.0,1.0 1.0,1.0 1.0,4.0 4.0,4.0</coordinates></LinearRing></innerBoundaryIs></Polygon>",
+        out.read
+      )
+    end
+
+    def test_to_georss
+      out = StringIO.new
+      polygon = Geos.read(POLYGON_WITH_INTERIOR_RING)
+      xml = Builder::XmlMarkup.new(:target => out)
+      polygon.to_georss(xml)
+      out.rewind
+
+      assert_equal(
+        "<georss:where><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>0.0 0.0 0.0 5.0 5.0 5.0 5.0 0.0 0.0 0.0</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></georss:where>",
+        out.read
+      )
+    end
+  end
+end