geo-distance2 0.2.1

data/lib/geo-distance/conversion/meters.rb

@@ -0,0 +1,29 @@
+class GeoDistance
+  module Conversion
+    module Meters
+      def in_meters
+        convert_to_meters distance
+      end
+      alias_method :to_meters, :in_meters
+      alias_method :as_meters, :in_meters
+
+      def to_meters!
+        self.distance = convert_to_meters distance
+        self.unit = :meters
+        self
+      end
+      alias_method :in_meters!, :to_meters!
+      alias_method :as_meters!, :to_meters!
+
+      def convert_to_meters dist
+        (unit == :meters) ? dist : distance / GeoUnits.meters_map[unit]
+      end
+
+      def to_meters!
+        @distance = in_meters
+        @unit = :meters
+        self
+      end 
+    end
+  end
+end

data/lib/geo-distance/conversion/radians.rb

@@ -0,0 +1,36 @@
+class GeoDistance
+  module Conversion
+    module Radians
+      def to_radians
+        cloned = self.dup               
+        cloned.distance = in_radians
+        cloned.unit = :radians
+        cloned
+      end        
+
+      def to_radians! lat = 0
+        @distance = in_radians(lat)
+        @unit = :radians
+      end        
+
+      def radians_conversion_factor 
+        unit.radians_ratio
+      end
+
+      # calculate the distance in radians for the given latitude
+      def in_radians lat = 0
+        (unit != :radians) ? distance.to_f / earth_factor(lat) : distance # radians_conversion_factor
+      end
+
+      protected
+      
+      def earth_factor u = nil, lat = 0
+        (GeoDistance.earth_radius[u ||= unit] / 180) * latitude_factor(lat)
+      end      
+      
+      def latitude_factor latitude = 0
+        90 / (90 - latitude)
+      end      
+    end
+  end
+end

data/lib/geo-distance/core_ext.rb

@@ -0,0 +1,20 @@
+require 'sugar-high/numeric'
+
+module GeoDistanceExt
+  ::GeoDistance.all_units.each do |unit|
+    class_eval %{
+      def #{unit}
+        GeoDistance.new(self, :#{unit})
+      end
+    }
+  end
+end
+
+class Fixnum
+  include GeoDistanceExt
+end
+
+class Float
+  include GeoDistanceExt
+end
+  

data/lib/geo-distance/distance.rb

@@ -0,0 +1,24 @@
+require 'geo-distance/class_methods'
+
+class GeoDistance
+  include Comparable
+
+  include Conversion
+   
+  attr_accessor :distance, :unit
+
+  def initialize distance, unit = :radians
+    @distance = distance
+    @unit = GeoUnits.key(unit)
+  end
+
+  alias_method :units, :unit
+
+  def <=> other
+     in_meters <=> other.in_meters
+  end
+
+  def number
+    distance.round_to(precision[unit])
+  end
+end

data/lib/geo-distance/formula.rb

@@ -0,0 +1,62 @@
+class GeoDistance
+  include GeoUnits
+  
+  class DistanceFormula
+    extend Math
+    extend GeoUnits
+     
+    def initialize
+      raise NotImplementedError
+    end  
+
+    # use underlying distance formula
+    def self.geo_distance *args
+      GeoDistance.new distance(args), get_units(args.last_option)
+    end
+
+    # used to convert various argument types into GeoPoints
+    def self.get_points(*args)
+      args.flatten!
+      options = args.delete(args.last_option) || {}
+      units = options[:units] || GeoDistance.default_units
+
+      case args.size
+      when 2
+        [GeoPoint.new(args.first), GeoPoint.new(args.last), units]
+      when 4
+        [GeoPoint.new(args[0..1]), GeoPoint.new(args[2..3]), units]        
+      else
+        raise "Distance from point A to B, must be given either as 4 arguments (lat1, lng1, lat2, lng2) or 2 arguments: (pointA, pointB), was: #{args}"
+      end
+    end
+
+    # used to get the units for how to calculate the distance
+    def self.get_units options = {}
+      GeoUnits.key(options[:units] || :kms)
+    end
+        
+    # def self.degrees_to_radians(degrees)   
+    #   # degrees.to_f / 180.0 * Math::PI
+    #   degrees.to_f * radians_per_degree
+    # end
+
+    # def self.units_sphere_multiplier(units)
+    #   earth_radius_map[GeoUnit.key units]
+    # end
+    # 
+    # def self.units_per_latitude_degree(units)
+    #   GeoUnits.radian_multiplier[units.to_sym]
+    # end
+    # 
+    # def self.units_per_longitude_degree(lat, units)
+    #   miles_per_longitude_degree = (latitude_degrees * Math.cos(lat * pi_div_rad)).abs
+    #   case units
+    #     when :kms
+    #       miles_per_longitude_degree * kms_per_mile
+    #     when :miles
+    #       miles_per_longitude_degree
+    #   end
+    # end    
+  end
+end
+    

data/lib/geo-distance/formula/flat.rb

@@ -0,0 +1,21 @@
+require 'geo-distance/core_ext'
+require 'geo-distance/formula'
+
+class GeoDistance
+  class Flat < DistanceFormula
+
+    # Calculate distance using Flat earth formula, returns distance in whatever unit is specified (kms by default)
+    def self.distance *args
+      from, to, units = get_points(args)
+
+      return 0 if from == to # return 0.0 if points are have the same coordinates      
+
+      Math.sqrt(
+        (units_per_latitude_degree(units) * (from.lat - to.lat))**2 +
+        (units_per_longitude_degree(from.lat, units) * (from.lng - to.lng))**2
+      )
+    end
+  end
+end
+
+

data/lib/geo-distance/formula/haversine.rb

@@ -0,0 +1,60 @@
+#
+# haversine formula to compute the great circle distance between two points given their latitude and longitudes
+#
+# Copyright (C) 2008, 360VL, Inc
+# Copyright (C) 2008, Landon Cox
+#
+# http://www.esawdust.com (Landon Cox)
+# contact:
+# http://www.esawdust.com/blog/businesscard/businesscard.html
+#
+# LICENSE: GNU Affero GPL v3
+# The ruby implementation of the Haversine formula is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License version 3 as published by the Free Software Foundation. 
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public
+# License version 3 for more details.  http://www.gnu.org/licenses/
+#
+# Landon Cox - 9/25/08
+#
+# Notes:
+#
+# translated into Ruby based on information contained in:
+#   http://mathforum.org/library/drmath/view/51879.html  Doctors Rick and Peterson - 4/20/99
+#   http://www.movable-type.co.uk/scripts/latlong.html
+#   http://en.wikipedia.org/wiki/Haversine_formula
+#
+# This formula can compute accurate distances between two points given latitude and longitude, even for
+# short distances.
+ 
+# PI = 3.1415926535 
+
+require 'geo-distance/core_ext'
+require 'geo-distance/formula'
+
+class GeoDistance
+  class Haversine < DistanceFormula
+    # given two lat/lon points, compute the distance between the two points using the haversine formula
+    #  the result will be a Hash of distances which are key'd by 'mi','km','ft', and 'm'
+    
+    def self.distance *args
+      begin
+        from, to, units = get_points(args)
+        
+        lat1, lon1, lat2, lon2 = [from.lat, from.lng, to.lat, to.lng]               
+        dlon = lon2 - lon1
+        dlat = lat2 - lat1
+    
+        a = (Math.sin(dlat.rpd/2))**2 + Math.cos(lat1.rpd) * Math.cos((lat2.rpd)) * (Math.sin(dlon.rpd/2))**2
+        c = (2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a)))
+        c = c.to_deg
+                
+        units ? c.radians_to(units) : c
+      rescue Errno::EDOM
+        0.0        
+      end
+    end  
+  end
+  
+end 

data/lib/geo-distance/formula/n_vector.rb

@@ -0,0 +1,30 @@
+class GeoDistance
+  class NVector < DistanceFormula
+    def self.distance *args
+      from, to, units = get_points(args)
+      lat1, lon1, lat2, lon2 = [from.lat, from.lng, to.lat, to.lng]
+      
+      sin_x1 = Math.sin(lon1)
+      cos_x1 = Math.cos(lon1)
+
+      sin_y1 = Math.sin(lat1)
+      cos_y1 = Math.cos(lat1)
+
+      sin_x2 = Math.sin(lon2)
+      cos_x2 = Math.cos(lon2)
+
+      sin_y2 = Math.sin(lat2)
+      cos_y2 = Math.cos(lat2)
+
+      cross_prod =  (cos_y1*cos_x1 * cos_y2*cos_x2) + (cos_y1*sin_x1 * cos_y2*sin_x2) + (sin_y1 * sin_y2)
+        
+      c = Math.acos(cross_prod)
+      
+      # puts "c: #{c}"
+      # radians_per_degree                          
+      c = (c * 0.0201324).to_deg      
+      
+      units ? c.radians_to(units) : c
+    end
+  end
+end

data/lib/geo-distance/formula/spherical.rb

@@ -0,0 +1,44 @@
+require 'geo-distance/core_ext'
+require 'geo-distance/formula'
+
+# module GeoDistance
+#   class Spherical < DistanceFormula
+#     def self.distance( lat1, lon1, lat2, lon2) 
+#       from_longitude  = lon1.to_radians
+#       from_latitude   = lat1.to_radians
+#       to_longitude    = lon2.to_radians
+#       to_latitude     = lat2.to_radians
+# 
+#       c = Math.acos(
+#           Math.sin(from_latitude) *
+#           Math.sin(to_latitude) +
+# 
+#           Math.cos(from_latitude) * 
+#           Math.cos(to_latitude) *
+#           Math.cos(to_longitude - from_longitude)
+#       ) #* EARTH_RADIUS[units.to_sym]
+#       
+#       GeoDistance::Distance.new c
+#     end
+#   end
+# end   
+
+class GeoDistance
+  class Spherical < DistanceFormula
+    def self.distance *args
+      from, to, units = get_points(args)        
+      
+      return 0.0 if from == to #return 0.0 if points are have the same coordinates
+
+      c = Math.acos( 
+        Math.sin(degrees_to_radians(from.lat)) * Math.sin(degrees_to_radians(to.lat)) + 
+        Math.cos(degrees_to_radians(from.lat)) * Math.cos(degrees_to_radians(to.lat)) * 
+        Math.cos(degrees_to_radians(to.lng) - degrees_to_radians(from.lng))
+      ).to_deg
+      
+      units ? c.radians_to(units) : c
+    rescue Errno::EDOM
+      0.0
+    end
+  end
+end

data/lib/geo-distance/formula/vincenty.rb

@@ -0,0 +1,80 @@
+require 'geo-distance/core_ext'
+require 'geo-distance/formula'
+
+class GeoDistance
+  class Vincenty < DistanceFormula
+
+    # Calculate the distance between two Locations using the Vincenty formula
+    #
+    def self.distance *args
+      begin
+        from, to, units = get_points(args)        
+        lat1, lon1, lat2, lon2 = [from.lat, from.lng, to.lat, to.lng]
+        
+        from_longitude  = lon1.to_radians
+        from_latitude   = lat1.to_radians
+        to_longitude    = lon2.to_radians
+        to_latitude     = lat2.to_radians
+    
+        earth_major_axis_radius = earth_major_axis_radius_map[:kilometers]
+        earth_minor_axis_radius = earth_minor_axis_radius_map[:kilometers]
+
+        f = (earth_major_axis_radius - earth_minor_axis_radius) / earth_major_axis_radius
+
+        l = to_longitude - from_longitude
+        u1 = atan((1-f) * tan(from_latitude))
+        u2 = atan((1-f) * tan(to_latitude))
+        sin_u1 = sin(u1)
+        cos_u1 = cos(u1)
+        sin_u2 = sin(u2)
+        cos_u2 = cos(u2)
+
+        lambda = l
+        lambda_p = 2 * Math::PI
+        iteration_limit = 20
+        while (lambda-lambda_p).abs > 1e-12 && (iteration_limit -= 1) > 0
+          sin_lambda = sin(lambda)
+          cos_lambda = cos(lambda)
+          sin_sigma = sqrt((cos_u2*sin_lambda) * (cos_u2*sin_lambda) + 
+            (cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda) * (cos_u1*sin_u2-sin_u1*cos_u2*cos_lambda))
+          return 0 if sin_sigma == 0  # co-incident points
+          cos_sigma = sin_u1*sin_u2 + cos_u1*cos_u2*cos_lambda
+          sigma = atan2(sin_sigma, cos_sigma)
+          sin_alpha = cos_u1 * cos_u2 * sin_lambda / sin_sigma
+          cosSqAlpha = 1 - sin_alpha*sin_alpha
+          cos2SigmaM = cos_sigma - 2*sin_u1*sin_u2/cosSqAlpha
+
+          cos2SigmaM = 0 if cos2SigmaM.nan?  # equatorial line: cosSqAlpha=0 (§6)
+
+          c = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha))
+          lambda_p = lambda
+          lambda = l + (1-c) * f * sin_alpha *
+            (sigma + c*sin_sigma*(cos2SigmaM+c*cos_sigma*(-1+2*cos2SigmaM*cos2SigmaM)))
+       end
+       # formula failed to converge (happens on antipodal points)
+       # We'll call Haversine formula instead.
+       return Haversine.distance(from, to, units) if iteration_limit == 0 
+
+       uSq = cosSqAlpha * (earth_major_axis_radius**2 - earth_minor_axis_radius**2) / (earth_minor_axis_radius**2)
+       a = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)))
+       b = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)))
+       delta_sigma = b*sin_sigma*(cos2SigmaM+b/4*(cos_sigma*(-1+2*cos2SigmaM*cos2SigmaM)-
+         b/6*cos2SigmaM*(-3+4*sin_sigma*sin_sigma)*(-3+4*cos2SigmaM*cos2SigmaM)))
+     
+        c = earth_minor_axis_radius * a * (sigma-delta_sigma)
+
+        c = (c / unkilometer).to_deg
+
+        units ? c.radians_to(units) : c
+      rescue Errno::EDOM
+        0.0
+      end
+    end
+
+    private
+    
+    def self.unkilometer    
+      6378.135
+    end      
+  end
+end

data/lib/geo-distance/scale.rb

@@ -0,0 +1,18 @@
+class GeoDistance
+  module Scale
+    def * arg
+      multiply arg
+    end
+
+    def / arg
+      multiply(1.0/arg)
+      self
+    end
+
+    def multiply arg
+      check_numeric! arg
+      self.distance *= arg
+      self
+    end
+  end
+end

data/spec/geo_distance/class_methods_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+GeoPoint.coord_mode = :lng_lat
+
+describe "GeoDistance class methods" do
+  describe '#earth_radius' do
+    it 'should return in kms' do
+      GeoDistance.earth_radius(:kms).should be_between(6371, 6380)
+    end
+
+    it 'should return in meters' do
+      GeoDistance.earth_radius(:meters).should be_between(6371000, 6380000)
+    end
+  end
+
+  describe '#radians_ratio unit' do
+    it 'should return in kms' do
+      puts GeoDistance.radians_ratio unit(:kms) #.should be_between(6371, 6380)
+    end
+
+    it 'should return in meters' do
+      puts GeoDistance.radians_ratio unit(:meters) #.should be_between(6371000, 6380000)
+    end
+  end
+  
+  describe '#default_algorithm' do
+    let(:from)  { [-104.88544, 39.06546].geo_point }
+    let(:to)    { [-104.80, 39.06546].geo_point }
+
+    it "should NOT set it to :haver" do
+      lambda { GeoDistance.default_algorithm = :haver}.should raise_error
+    end
+
+    it "should set it to :haversine" do
+      GeoDistance.default_algorithm = :haversine
+
+      dist = GeoDistance.geo_distance(from, to)
+
+      puts "the distance from #{from} to #{to} is: #{dist.meters} meters"
+
+      dist.feet.should == 24193.0
+      dist.to_feet.should == 24193.0
+      dist.kms.to_s.should match(/7\.376*/)
+    end
+
+    it "should set it to :flat" do
+      GeoDistance.default_algorithm = :flat
+
+      dist = GeoDistance.geo_distance(from, to)
+      puts "the distance from #{from} to #{to} is: #{dist.meters} meters"
+      dist.feet.should be_between(23500, 25000)
+    end
+
+    it "should set it to :sphere" do
+      GeoDistance.default_algorithm = :sphere
+
+      dist = GeoDistance.geo_distance(from, to)
+      puts "the distance from #{from} to #{to} is: #{dist.meters} meters"
+      dist.feet.should be_between(23500, 25000)
+    end
+
+    it "should set it to :vincenty" do
+      GeoDistance.default_algorithm = :vincenty
+
+      dist = GeoDistance.geo_distance(from, to)
+      puts "the distance from #{from} to #{to} is: #{dist.meters} meters"
+      dist.feet.should be_between(23500, 25000)
+    end
+  end
+end