georuby-ext 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*~
+coverage/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in georuby-ext.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.rdoc

@@ -0,0 +1,37 @@
+== georuby-ext
+
+georuby-ext is an extension to Ruby geometry libraries
+
+=== Summary
+
+GeoRuby, rgeo, geokit, proj4j (...) are nice ruby libraries which cover the same domain. georuby-ext allows to <b>use them together</b>.
+
+=== License
+
+Copyright 2011 Dryade SAS
+
+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.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/}
+end

data/georuby-ext.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "georuby-ext"
+  s.version     = "0.0.1"
+  s.authors     = ["Marc Florisson", "Luc Donnet", "Alban Peignier"]
+  s.email       = ["marc@dryade.net", "luc@dryade.net", "alban@dryade.net"]
+  s.homepage    = "http://github.com/dryade/georuby-ext"
+  s.summary     = %q{Extension to Ruby geometry libraries}
+  s.description = %q{Use together GeoRuby, rgeo, geokit, proj4j (and others)}
+
+  s.rubyforge_project = "georuby-ext"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "rcov"
+
+  s.add_runtime_dependency "GeoRuby"
+  s.add_runtime_dependency "geokit"
+  s.add_runtime_dependency "rgeo"
+  s.add_runtime_dependency "proj4rb"
+
+  s.add_runtime_dependency "activesupport"
+end

data/lib/georuby-ext.rb

@@ -0,0 +1,17 @@
+require 'geo_ruby'
+require 'geokit'
+require 'rgeo'
+require 'proj4'
+
+require 'active_support/core_ext/enumerable'
+
+require 'georuby-ext/rgeo'
+require 'georuby-ext/geokit'
+require 'georuby-ext/proj4'
+
+require 'georuby-ext/georuby/point'
+require 'georuby-ext/georuby/line_string'
+require 'georuby-ext/georuby/polygon'
+require 'georuby-ext/georuby/multi_polygon'
+require 'georuby-ext/georuby/envelope'
+require 'georuby-ext/georuby/locators'

data/lib/georuby-ext/geokit.rb

@@ -0,0 +1,25 @@
+module GeoKit
+  class LatLng
+
+    def valid?
+      self.lat and self.lng
+    end
+
+    def wgs84_to_google
+      self.class.from_pro4j Proj4::Projection.wgs84.transform Proj4::Projection.google, self.proj4_point(Math::PI / 180)
+    end
+
+    def google_to_wgs84
+      self.class.from_pro4j Proj4::Projection.google.transform(Proj4::Projection.wgs84, self.proj4_point), 180 / Math::PI  
+    end
+
+    def proj4_point(ratio = 1)
+      Proj4::Point.new(lng * ratio, lat * ratio)
+    end
+
+    def self.from_pro4j(point, ratio = 1)
+      new point.lat * ratio, point.lon * ratio
+    end
+
+  end
+end

data/lib/georuby-ext/georuby/envelope.rb

@@ -0,0 +1,10 @@
+class GeoRuby::SimpleFeatures::Envelope
+  def to_openlayers
+    OpenLayers::Bounds.new lower_corner.x, lower_corner.y, upper_corner.x, upper_corner.y
+  end
+
+  def to_google
+    Envelope.from_points [lower_corner.to_google, upper_corner.to_google],srid, with_z
+  end
+end
+      

data/lib/georuby-ext/georuby/geometry.rb

@@ -0,0 +1,9 @@
+module GeoRuby::SimpleFeatures::Geometry
+
+  def inspect
+    "#<#{self.class}:#{object_id} \"#{as_ewkt}>\""
+  end
+  
+  alias_method :to_ewkt, :as_ewkt
+
+end

data/lib/georuby-ext/georuby/line_string.rb

@@ -0,0 +1,41 @@
+class GeoRuby::SimpleFeatures::LineString
+
+  def change(options)
+    self.class.from_points(options[:points] || points, 
+                           options[:srid] || srid,
+                           options[:with_z] || with_z, 
+                           options[:with_m] || with_m)
+    # or instead of || requires parenthesis
+  end
+
+  def reverse
+    change :points => points.reverse
+  end
+
+  def to_wgs84
+    change :points => points.map(&:to_wgs84), :srid => 4326
+  end
+
+  def self.merge(lines)
+    merged_points = lines.map(&:points).flatten.uniq
+    if merged_points.size > 1
+      from_points merged_points, lines.first.srid, lines.first.with_z, lines.first.with_m
+    end
+  end
+  
+  def to_rgeo
+    RGeo::Geos::factory(:srid => srid).line_string(points.collect(&:to_rgeo))
+  end
+
+  def ==(other)
+    other.respond_to?(:points) and points == other.points
+  end
+
+  alias_method :closed?, :is_closed
+
+  def to_ring
+    ring_points = closed? ? points : points + [first]
+    GeoRuby::SimpleFeatures::LinearRing.from_points ring_points, srid, with_z, with_m
+  end
+
+end

data/lib/georuby-ext/georuby/locators.rb

@@ -0,0 +1,225 @@
+require 'active_support/memoizable'
+require 'active_support/core_ext/module/delegation'
+
+class GeoRuby::SimpleFeatures::MultiLineString
+
+  alias_method :lines, :geometries
+
+  def locate_point(target)
+    nearest_locator = nearest_locator(target)
+    nearest_locator.location + nearest_locator.index
+  end
+
+  def interpolate_point(location)
+    line_index, line_location = location.to_i, location % 1
+    lines[line_index].interpolate_point(line_location)
+  end
+
+  def nearest_locator(target)
+    locators(target).min_by(&:distance_from_line)
+  end
+
+  def locators(point)
+    [].tap do |locators|
+      lines.each_with_index do |line, index| 
+        locators << PointLocator.new(point, line, index) 
+      end
+    end
+  end
+
+  class PointLocator
+
+    attr_reader :target, :line, :index
+
+    def initialize(target, line, index)
+      @target = target
+      @line = line
+      @index = index
+    end
+
+    def location
+      line.locate_point(target)
+    end
+
+    def distance_on_line
+      line.distance_on_line(target)
+    end
+
+    def distance_from_line
+      line.distance_from_line(target)
+    end
+
+  end
+
+end
+
+class GeoRuby::SimpleFeatures::LineString
+
+  def locate_point(target)
+    distance_on_line(target) / distance
+  end
+
+  def distance_on_line(target)
+    nearest_locator = nearest_locator(target)
+    nearest_locator.distance_on_segment + nearest_locator.segment.line_distance_at_departure
+  end
+
+  def distance_from_line(target)
+    nearest_locator(target).distance_from_segment
+  end
+
+  def nearest_locator(target)
+    locators(target).min_by(&:distance_from_segment)
+  end
+
+  def locators(point)
+    segments.collect { |segment| segment.locator(point) }
+  end
+
+  def segments
+    previous_point = nil
+    distance_from_departure = 0
+
+    points.inject([]) do |segments, point|
+      Segment.new(previous_point, point).tap do |segment|
+        segment.line = self
+        segment.line_distance_at_departure = segments.sum(&:distance)
+        
+        segments << segment
+      end if previous_point
+      
+      previous_point = point
+      segments
+    end
+  end
+
+  def distance
+    segments.sum(&:distance)
+  end
+
+  def interpolate_point(location)
+    return points.last if location >= 1
+    return points.first if location <= 0
+
+    distance_on_line = location * distance
+
+    segment = segments.find do |segment|
+      segment.line_distance_at_arrival > distance_on_line
+    end
+
+    location_on_segment =
+      (distance_on_line - segment.line_distance_at_departure) / segment.distance
+
+    segment.interpolate_point location_on_segment
+  end
+
+  class Segment
+
+    attr_reader :departure, :arrival
+    
+    def initialize(departure, arrival)
+      @departure, @arrival = departure, arrival
+    end
+
+    attr_accessor :line, :line_distance_at_departure
+
+    def line_distance_at_arrival
+      line_distance_at_departure + distance
+    end
+
+    def locator(target)
+      PointLocator.new target, self
+    end
+
+    def location_in_line
+      if line and line_distance_at_departure
+        line_distance_at_departure / line.distance
+      end
+    end
+
+    def square_of_distance
+      (arrival.x - departure.x)**2 + (arrival.y - departure.y)**2
+    end
+
+    def distance
+      departure.euclidian_distance(arrival)
+    end
+
+    def to_s
+      "#{departure.x},#{departure.y}..#{arrival.x},#{arrival.y}"
+    end
+
+    def interpolate_point(location)
+      dx, dy = 
+        (arrival.x - departure.x)*location, (arrival.y - departure.y)*location
+      GeoRuby::SimpleFeatures::Point.from_x_y departure.x + dx, departure.y + dy, line.srid
+    end
+
+  end
+
+  class PointLocator
+    extend ActiveSupport::Memoizable
+    include Math
+
+    attr_reader :target, :segment
+    delegate :departure, :arrival, :to => :segment
+    
+    def initialize(target, segment_or_departure, arrival = nil)
+      @segment = 
+        if arrival
+          Segment.new(segment_or_departure, arrival)
+        else
+          segment_or_departure
+        end
+      @target = target
+
+      raise "Target is not defined" unless target
+    end
+
+    def distance_from_segment
+      sin_angle * target_distance_from_departure
+    end
+
+    def distance_on_segment
+      # like cos_angle * target_distance_from_departure
+      # scalar_product / square_of_segment_distance
+      scalar_product / segment_distance
+    end
+
+    def locate_point
+      scalar_product / square_of_segment_distance
+    end
+
+    def scalar_product
+      (target.x-departure.x)*(arrival.x-departure.x) + (target.y-departure.y)*(arrival.y-departure.y).to_f
+    end
+    memoize :scalar_product
+
+    def angle
+      acos cos_angle
+    end
+
+    def sin_angle
+      sin angle
+    end
+
+    def cos_angle
+      scalar_product / segment_distance / target_distance_from_departure
+    end
+
+    def square_of_segment_distance
+      (arrival.x - departure.x)**2 + (arrival.y - departure.y)**2
+    end
+    memoize :square_of_segment_distance
+
+    def segment_distance
+      sqrt square_of_segment_distance
+    end
+
+    def target_distance_from_departure
+      sqrt((target.x - departure.x)**2 + (target.y - departure.y)**2)
+    end
+
+  end
+
+end

data/lib/georuby-ext/georuby/multi_polygon.rb

@@ -0,0 +1,9 @@
+class GeoRuby::SimpleFeatures::MultiPolygon
+  def to_wgs84
+    self.class.from_polygons(self.polygons.collect(&:to_wgs84), 4326)
+  end
+
+  def polygons
+    self.geometries.flatten
+  end
+end