geo-distance 0.1.2 → 0.2.0

data/lib/geo-distance/conversion.rb

@@ -0,0 +1,67 @@
+class GeoDistance
+  module Conversion
+    autoload :Meters,   'geo-distance/conversion/meters'
+    autoload :Radians,  'geo-distance/conversion/radians'
+    
+    def self.included(base)
+      base.send :include, Meters
+      base.send :include, Radians
+    end
+    
+    # return new GeoDistance instance with distance converted to specific unit
+    ::GeoDistance.units.each do |unit|
+      class_eval %{
+        def to_#{unit}
+          cloned = self.dup
+          un = GeoUnits.key :#{unit}
+          cloned.distance = in_meters * GeoUnits.meters_map[un]
+          cloned.unit = un
+          cloned
+        end
+      }
+    end
+
+    # in_ and as_ return distance as a Float
+    # to_xxx! and similar, modify distance (self) directly
+    (::GeoDistance.units - [:meters]).each do |unit|
+      class_eval %{
+        def in_#{unit}
+          dist = (unit == :radians) ? in_radians : distance            
+          conv_unit = GeoUnits.key :#{unit}
+          convert_to_meters(dist) * GeoUnits.meters_map[conv_unit]
+        end
+        alias_method :as_#{unit}, :in_#{unit}
+
+        def to_#{unit}!
+          conv_unit = GeoUnits.key :#{unit}
+          self.distance = in_meters * GeoUnits.meters_map[conv_unit]
+          self.unit = conv_unit
+          self
+        end
+        alias_method :in_#{unit}!, :to_#{unit}!
+        alias_method :as_#{unit}!, :to_#{unit}!
+      } 
+    end
+    
+    ::GeoDistance.all_units.each do |unit|
+      class_eval %{
+        def #{unit}
+          un = GeoUnits.key :#{unit}
+          send(:"as_\#{un}")
+        end
+      }
+    end
+        
+    protected
+
+    # distance delta 
+    GeoDistance.units.each do |unit|
+      class_eval %{
+        def delta_#{unit}
+          unit = GeoUnits.key(:#{unit})
+          GeoDistance.earth_radius[:#{unit}] * distance
+        end
+      }
+    end       
+  end
+end

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

@@ -1,31 +1,20 @@
-class Float
-  def round_to(x)
-    (self * 10**x).round.to_f / 10**x
-  end
-
-  def ceil_to(x)
-    (self * 10**x).ceil.to_f / 10**x
-  end
-
-  def floor_to(x)
-    (self * 10**x).floor.to_f / 10**x
-  end
-  
-  def rpd
-    self * GeoDistance.radians_per_degree
-  end  
-  alias_method :to_radians, :rpd
-end             
+require 'sugar-high/numeric'
 
-require 'geo-distance'
-
-class Integer
-  ::GeoDistance.units.each do |unit|
+module GeoDistanceExt
+  ::GeoDistance.all_units.each do |unit|
     class_eval %{
       def #{unit}
-        GeoDistance::Distance.new(self, :#{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

@@ -1,16 +1,62 @@
-module GeoDistance  
-  EARTH_RADIUS = { :kilometers => 6378.135, :miles => 3963.1676 }
-  # WGS-84 numbers
-  EARTH_MAJOR_AXIS_RADIUS = { :kilometers => 6378.137, :miles => 3963.19059 }
-  EARTH_MINOR_AXIS_RADIUS = { :kilometers => 6356.7523142, :miles => 3949.90276 }
-
+class GeoDistance
+  include GeoUnits
+  
   class DistanceFormula
-    include Math
     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/{haversine.rb → formula/haversine.rb}

@@ -33,24 +33,28 @@
 require 'geo-distance/core_ext'
 require 'geo-distance/formula'
 
-module GeoDistance
+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( lat1, lon1, lat2, lon2) 
-      dlon = lon2 - lon1
-      dlat = lat2 - lat1
-
-      a = calc(dlat, lat1, lat2, dlon)
-      c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a))
-
-      GeoDistance::Distance.new c
+    
+    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  
-
-    def self.calc dlat, lat1, lat2, dlon
-      (Math.sin(dlat.rpd/2))**2 + Math.cos(lat1.rpd) * Math.cos((lat2.rpd)) * (Math.sin(dlon.rpd/2))**2    
-    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