geokit 1.8.5 → 1.9.0

data/lib/geokit/mappable.rb

@@ -1,44 +1,43 @@
-#require 'forwardable'
+# require 'forwardable'
 
 module Geokit
-  # Contains class and instance methods providing distance calcuation services.  This
-  # module is meant to be mixed into classes containing lat and lng attributes where
-  # distance calculation is desired.
+  # Contains class and instance methods providing distance calcuation services.
+  # This module is meant to be mixed into classes containing lat and lng
+  # attributes where distance calculation is desired.
   #
   # At present, two forms of distance calculations are provided:
   #
-  # * Pythagorean Theory (flat Earth) - which assumes the world is flat and loses accuracy over long distances.
+  # * Pythagorean Theory (flat Earth) - which assumes the world is flat and
+  #   loses accuracy over long distances.
   # * Haversine (sphere) - which is fairly accurate, but at a performance cost.
   #
   # Distance units supported are :miles, :kms, and :nms.
   module Mappable
-    PI_DIV_RAD = 0.0174
-    KMS_PER_MILE = 1.609
-    NMS_PER_MILE = 0.868976242
-    EARTH_RADIUS_IN_MILES = 3963.19
-    EARTH_RADIUS_IN_KMS = EARTH_RADIUS_IN_MILES * KMS_PER_MILE
-    EARTH_RADIUS_IN_NMS = EARTH_RADIUS_IN_MILES * NMS_PER_MILE
-    MILES_PER_LATITUDE_DEGREE = 69.1
-    KMS_PER_LATITUDE_DEGREE = MILES_PER_LATITUDE_DEGREE * KMS_PER_MILE
-    NMS_PER_LATITUDE_DEGREE = MILES_PER_LATITUDE_DEGREE * NMS_PER_MILE
-    LATITUDE_DEGREES = EARTH_RADIUS_IN_MILES / MILES_PER_LATITUDE_DEGREE
-
     # Mix below class methods into the includer.
     def self.included(receiver) # :nodoc:
       receiver.extend ClassMethods
     end
 
     module ClassMethods #:nodoc:
+      PI_DIV_RAD = Math::PI / 180
+      EARTH_RADIUS_IN_METERS = 6376772.71
+      METERS_PER_LATITUDE_DEGREE = 111181.9
+
+      EARTH_RADIUS = {}
+      PER_LATITUDE_DEGREE = {}
+
       # Returns the distance between two points.  The from and to parameters are
       # required to have lat and lng attributes.  Valid options are:
-      # :units - valid values are :miles, :kms, :nms (Geokit::default_units is the default)
-      # :formula - valid values are :flat or :sphere (Geokit::default_formula is the default)
-      def distance_between(from, to, options={})
-        from=Geokit::LatLng.normalize(from)
-        to=Geokit::LatLng.normalize(to)
+      # :units - valid values are :miles, :kms, :nms
+      # (Geokit::default_units is the default)
+      # :formula - valid values are :flat or :sphere
+      # (Geokit::default_formula is the default)
+      def distance_between(from, to, options = {})
+        from = Geokit::LatLng.normalize(from)
+        to = Geokit::LatLng.normalize(to)
         return 0.0 if from == to # fixes a "zero-distance" bug
-        units = options[:units] || Geokit::default_units
-        formula = options[:formula] || Geokit::default_formula
+        units = options[:units] || Geokit.default_units
+        formula = options[:formula] || Geokit.default_formula
         case formula
         when :sphere then distance_between_sphere(from, to, units)
         when :flat   then distance_between_flat(from, to, units)
@@ -56,8 +55,9 @@ module Geokit
 
       def distance_between_flat(from, to, units)
         lat_length = units_per_latitude_degree(units) * (from.lat - to.lat)
-        lng_length = units_per_longitude_degree(from.lat, units) * (from.lng - to.lng)
-        Math.sqrt(lat_length ** 2 + lng_length ** 2)
+        lng_length = units_per_longitude_degree(from.lat, units) *
+                     (from.lng - to.lng)
+        Math.sqrt(lat_length**2 + lng_length**2)
       end
 
       # Ruby 1.9 raises {Math::DomainError}, but it is not defined in Ruby 1.8
@@ -67,25 +67,26 @@ module Geokit
       end
 
       # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-      # from the first point to the second point. Typicaly, the instance methods will be used
-      # instead of this method.
-      def heading_between(from,to)
-        from=Geokit::LatLng.normalize(from)
-        to=Geokit::LatLng.normalize(to)
-
-        d_lng=deg2rad(to.lng-from.lng)
-        from_lat=deg2rad(from.lat)
-        to_lat=deg2rad(to.lat)
-        y=Math.sin(d_lng) * Math.cos(to_lat)
-        x=Math.cos(from_lat)*Math.sin(to_lat)-Math.sin(from_lat)*Math.cos(to_lat)*Math.cos(d_lng)
-        heading=to_heading(Math.atan2(y,x))
+      # from the first point to the second point. Typicaly, the instance methods
+      # will be used instead of this method.
+      def heading_between(from, to)
+        from = Geokit::LatLng.normalize(from)
+        to = Geokit::LatLng.normalize(to)
+
+        d_lng = deg2rad(to.lng - from.lng)
+        from_lat = deg2rad(from.lat)
+        to_lat = deg2rad(to.lat)
+        y = Math.sin(d_lng) * Math.cos(to_lat)
+        x = Math.cos(from_lat) * Math.sin(to_lat) -
+            Math.sin(from_lat) * Math.cos(to_lat) * Math.cos(d_lng)
+        to_heading(Math.atan2(y, x))
       end
 
       # Given a start point, distance, and heading (in degrees), provides
       # an endpoint. Returns a LatLng instance. Typically, the instance method
       # will be used instead of this method.
-      def endpoint(start,heading, distance, options={})
-        units   = options[:units] || Geokit::default_units
+      def endpoint(start, heading, distance, options = {})
+        units   = options[:units] || Geokit.default_units
         ratio   = distance.to_f / units_sphere_multiplier(units)
         start   = Geokit::LatLng.normalize(start)
         lat     = deg2rad(start.lat)
@@ -103,21 +104,20 @@ module Geokit
         end_lng = lng + Math.atan2(Math.sin(heading) * sin_ratio * cos_lat,
                                    cos_ratio - sin_lat * Math.sin(end_lat))
 
-        LatLng.new(rad2deg(end_lat),rad2deg(end_lng))
+        LatLng.new(rad2deg(end_lat), rad2deg(end_lng))
       end
 
       # Returns the midpoint, given two points. Returns a LatLng.
       # Typically, the instance method will be used instead of this method.
       # Valid option:
-      #   :units - valid values are :miles, :kms, or :nms (:miles is the default)
-      def midpoint_between(from,to,options={})
-        from=Geokit::LatLng.normalize(from)
-
-        units = options[:units] || Geokit::default_units
-
-        heading=from.heading_to(to)
-        distance=from.distance_to(to,options)
-        midpoint=from.endpoint(heading,distance/2,options)
+      #   :units - valid values are :miles, :kms, or :nms
+      #   (:miles is the default)
+      def midpoint_between(from, to, options = {})
+        from = Geokit::LatLng.normalize(from)
+
+        heading = from.heading_to(to)
+        distance = from.distance_to(to, options)
+        from.endpoint(heading, distance / 2, options)
       end
 
       # Geocodes a location using the multi geocoder.
@@ -139,8 +139,6 @@ module Geokit
             (seconds % 60)          # seconds as positive float
         ]
       end
-      
-      protected
 
       def deg2rad(degrees)
         degrees.to_f / 180.0 * Math::PI
@@ -151,35 +149,34 @@ module Geokit
       end
 
       def to_heading(rad)
-        (rad2deg(rad)+360)%360
+        (rad2deg(rad) + 360) % 360
+      end
+
+      def self.register_unit(key, in_meters)
+        EARTH_RADIUS[key] = EARTH_RADIUS_IN_METERS * in_meters
+        PER_LATITUDE_DEGREE[key] = METERS_PER_LATITUDE_DEGREE * in_meters
       end
 
+      register_unit :meters, 1
+      register_unit :kms,   1 / 1000.0
+      register_unit :miles, 1 / 1609.0
+      register_unit :nms,   0.0005400722448725917
+
       # Returns the multiplier used to obtain the correct distance units.
+      # TODO make more accurate by coping
+      # http://msi.nga.mil/MSISiteContent/StaticFiles/Calculators/degree.html
       def units_sphere_multiplier(units)
-        case units
-          when :kms; EARTH_RADIUS_IN_KMS
-          when :nms; EARTH_RADIUS_IN_NMS
-          else EARTH_RADIUS_IN_MILES
-        end
+        EARTH_RADIUS[units]
       end
 
       # Returns the number of units per latitude degree.
       def units_per_latitude_degree(units)
-        case units
-          when :kms; KMS_PER_LATITUDE_DEGREE
-          when :nms; NMS_PER_LATITUDE_DEGREE
-          else MILES_PER_LATITUDE_DEGREE
-        end
+        PER_LATITUDE_DEGREE[units]
       end
 
       # Returns the number units per longitude degree.
       def 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 :nms; miles_per_longitude_degree * NMS_PER_MILE
-          else miles_per_longitude_degree
-        end
+        units_sphere_multiplier(units) * Math.cos(lat * PI_DIV_RAD) * PI_DIV_RAD
       end
     end
 
@@ -189,46 +186,49 @@ module Geokit
 
     # Extracts a LatLng instance. Use with models that are acts_as_mappable
     def to_lat_lng
-      return self if instance_of?(Geokit::LatLng) || instance_of?(Geokit::GeoLoc)
-      return LatLng.new(send(self.class.lat_column_name), send(self.class.lng_column_name))
-      nil
+      if instance_of?(Geokit::LatLng) || instance_of?(Geokit::GeoLoc)
+        return self
+      end
+      lat = send(self.class.lat_column_name)
+      lng = send(self.class.lng_column_name)
+      LatLng.new(lat, lng)
     end
 
     # Returns the distance from another point.  The other point parameter is
     # required to have lat and lng attributes.  Valid options are:
     # :units - valid values are :miles, :kms, :or :nms (:miles is the default)
     # :formula - valid values are :flat or :sphere (:sphere is the default)
-    def distance_to(other, options={})
+    def distance_to(other, options = {})
       self.class.distance_between(self, other, options)
     end
     alias distance_from distance_to
 
-    # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-    # to the given point. The given point can be a LatLng or a string to be Geocoded
+    # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc) to
+    # the given point. The given point can be a LatLng or a string to be
+    # Geocoded
     def heading_to(other)
-      self.class.heading_between(self,other)
+      self.class.heading_between(self, other)
     end
 
     # Returns heading in degrees (0 is north, 90 is east, 180 is south, etc)
-    # FROM the given point. The given point can be a LatLng or a string to be Geocoded
+    # FROM the given point. The given point can be a LatLng or a string to be
+    # Geocoded
     def heading_from(other)
-      self.class.heading_between(other,self)
+      self.class.heading_between(other, self)
     end
 
     # Returns the endpoint, given a heading (in degrees) and distance.
     # Valid option:
     # :units - valid values are :miles, :kms, or :nms (:miles is the default)
-    def endpoint(heading,distance,options={})
-      self.class.endpoint(self,heading,distance,options)
+    def endpoint(heading, distance, options = {})
+      self.class.endpoint(self, heading, distance, options)
     end
 
     # Returns the midpoint, given another point on the map.
     # Valid option:
     # :units - valid values are :miles, :kms, or :nms (:miles is the default)
-    def midpoint_to(other, options={})
-      self.class.midpoint_between(self,other,options)
+    def midpoint_to(other, options = {})
+      self.class.midpoint_between(self, other, options)
     end
-
   end
-
 end

data/lib/geokit/multi_geocoder.rb

@@ -1,26 +1,29 @@
 module Geokit
   module Geocoders
-    # -------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
     # The Multi Geocoder
-    # -------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------
 
-    # Provides methods to geocode with a variety of geocoding service providers, plus failover
-    # among providers in the order you configure. When 2nd parameter is set 'true', perform
-    # ip location lookup with 'address' as the ip address.
+    # Provides methods to geocode with a variety of geocoding service providers,
+    # plus failover among providers in the order you configure. When 2nd
+    # parameter is set 'true', perform ip location lookup with 'address' as the
+    # ip address.
     #
     # Goal:
     # - homogenize the results of multiple geocoders
     #
     # Limitations:
-    # - currently only provides the first result. Sometimes geocoders will return multiple results.
+    # - currently only provides the first result. Sometimes geocoders will
+    #   return multiple results.
     # - currently discards the "accuracy" component of the geocoding calls
     class MultiGeocoder < Geocoder
-
       private
-      # This method will call one or more geocoders in the order specified in the
-      # configuration until one of the geocoders work.
+
+      # This method will call one or more geocoders in the order specified in
+      # the configuration until one of the geocoders work.
       #
-      # The failover approach is crucial for production-grade apps, but is rarely used.
+      # The failover approach is crucial for production-grade apps, but is
+      # rarely used.
       # 98% of your geocoding calls will be successful with the first call
       def self.do_geocode(address, *args)
         provider_order = provider_order_for(address, args)
@@ -31,24 +34,26 @@ module Geokit
             res = klass.send :geocode, address, *args
             return res if res.success?
           rescue => e
-            logger.error("An error has occurred during geocoding: #{e}\nAddress: #{address}. Provider: #{provider}")
+            logger.error("An error has occurred during geocoding: #{e}\n" +
+                         "Address: #{address}. Provider: #{provider}")
           end
         end
         # If we get here, we failed completely.
         GeoLoc.new
       end
 
-      # This method will call one or more geocoders in the order specified in the
-      # configuration until one of the geocoders work, only this time it's going
-      # to try to reverse geocode a geographical point.
+      # This method will call one or more geocoders in the order specified in
+      # the configuration until one of the geocoders work, only this time it's
+      # going to try to reverse geocode a geographical point.
       def self.do_reverse_geocode(latlng)
-        Geokit::Geocoders::provider_order.each do |provider|
+        Geokit::Geocoders.provider_order.each do |provider|
           klass = geocoder(provider)
           begin
             res = klass.send :reverse_geocode, latlng
             return res if res.success?
           rescue => e
-            logger.error("An error has occurred during geocoding: #{e}\nLatlng: #{latlng}. Provider: #{provider}")
+            logger.error("An error has occurred during geocoding: #{e}\n" +
+                         "Latlng: #{latlng}. Provider: #{provider}")
           end
         end
         # If we get here, we failed completely.
@@ -56,7 +61,8 @@ module Geokit
       end
 
       def self.geocoder(provider)
-        Geokit::Geocoders.const_get "#{Geokit::Inflector::camelize(provider.to_s)}Geocoder"
+        class_name = "#{Geokit::Inflector.camelize(provider.to_s)}Geocoder"
+        Geokit::Geocoders.const_get class_name
       end
 
       def self.provider_order_for(address, args)
@@ -64,13 +70,12 @@ module Geokit
           args.last.delete(:provider_order)
         else
           if /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.match(address)
-            Geokit::Geocoders::ip_provider_order
+            Geokit::Geocoders.ip_provider_order
           else
-            Geokit::Geocoders::provider_order
+            Geokit::Geocoders.provider_order
           end
         end
       end
     end
   end
 end
-

data/lib/geokit/net_adapter/net_http.rb

@@ -6,16 +6,19 @@ module Geokit
         req = Net::HTTP::Get.new(url)
         req.basic_auth(uri.user, uri.password) if uri.userinfo
         net_http_args = [uri.host, uri.port]
-        if (proxy_uri_string = Geokit::Geocoders::proxy)
+        if (proxy_uri_string = Geokit::Geocoders.proxy)
           proxy_uri = URI.parse(proxy_uri_string)
-          net_http_args += [proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password]
+          net_http_args += [proxy_uri.host,
+                            proxy_uri.port,
+                            proxy_uri.user,
+                            proxy_uri.password]
         end
-        http = Net::HTTP::new(*net_http_args)
+        http = Net::HTTP.new(*net_http_args)
         if uri.scheme == 'https'
           http.use_ssl = true
           http.verify_mode = Geokit::Geocoders.ssl_verify_mode
         end
-        http.start { |http| http.request(req) }
+        http.start { |h| h.request(req) }
       end
 
       def self.success?(response)

data/lib/geokit/polygon.rb

@@ -1,13 +1,12 @@
 module Geokit
   # A complex polygon made of multiple points.  End point must equal start point to close the poly.
   class Polygon
-    
     attr_accessor :points
-    
+
     # Pass in an array of Geokit::LatLng
     def initialize(points)
       @points = points
-      
+
       # A Polygon must be 'closed', the last point equal to the first point
       # Append the first point to the array to close the polygon
       @points << points[0] if points[0] != points[-1]
@@ -30,11 +29,44 @@ module Geokit
             oddNodes = !oddNodes
           end
         end
- 
+
         last_point = p
       end
 
       oddNodes
     end # contains?
+
+    # A polygon is static and can not be updated with new points, as a result
+    # calculate the centroid once and store it when requested.
+    def centroid
+      @centroid ||= calculate_centroid
+    end # end centroid
+
+    private
+
+    def calculate_centroid
+      centroid_lat = 0.0
+      centroid_lng = 0.0
+      signed_area = 0.0
+
+      # Iterate over each element in the list but the last item as it's
+      # calculated by the i+1 logic
+      @points[0...-1].each_index do |i|
+        x0 = @points[i].lat
+        y0 = @points[i].lng
+        x1 = @points[i + 1].lat
+        y1 = @points[i + 1].lng
+        a = (x0 * y1) - (x1 * y0)
+        signed_area += a
+        centroid_lat += (x0 + x1) * a
+        centroid_lng += (y0 + y1) * a
+      end
+
+      signed_area *= 0.5
+      centroid_lat /= (6.0 * signed_area)
+      centroid_lng /= (6.0 * signed_area)
+
+      Geokit::LatLng.new(centroid_lat, centroid_lng)
+    end # end calculate_centroid
   end # class Polygon
 end