geokit 1.7.1 → 1.8.0

data/lib/geokit/geocoders/yandex.rb

@@ -0,0 +1,61 @@
+module Geokit
+  module Geocoders
+    # Yandex geocoder implementation. Expects the Geokit::Geocoders::YANDEX variable to
+    # contain a Yandex API key (optional). Conforms to the interface set by the Geocoder class.
+    class YandexGeocoder < Geocoder
+      private
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address)
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        url = submit_url(address_str)
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        parse :json, res.body
+      end
+
+      def self.submit_url(address_str)
+        url = "http://geocode-maps.yandex.ru/1.x/?geocode=#{Geokit::Inflector::url_escape(address_str)}&format=json"
+        url += "&key=#{Geokit::Geocoders::yandex}" if Geokit::Geocoders::yandex
+        url
+      end
+
+      def self.parse_json(result)
+        loc = GeoLoc.new
+
+        coll = result["response"]["GeoObjectCollection"]
+        return loc unless coll["metaDataProperty"]["GeocoderResponseMetaData"]["found"].to_i > 0
+
+        l = coll["featureMember"][0]["GeoObject"]
+
+        loc.success = true
+        loc.provider = "yandex"
+        loc.lng = l["Point"]["pos"].split(" ").first
+        loc.lat = l["Point"]["pos"].split(" ").last
+
+        country = l["metaDataProperty"]["GeocoderMetaData"]["AddressDetails"]["Country"]
+        locality = country["Locality"] || country["AdministrativeArea"]["Locality"] || country["AdministrativeArea"]["SubAdministrativeArea"]["Locality"] rescue nil
+        set_address_components(loc, l, country, locality)
+        set_precision(loc, l, locality)
+
+        loc
+      end
+
+      def self.set_address_components(loc, l, country, locality)
+        loc.country_code = country["CountryNameCode"]
+        loc.full_address = country["AddressLine"]
+        loc.street_address = l["name"]
+        loc.street_number = locality["Thoroughfare"]["Premise"]["PremiseNumber"] rescue nil
+        loc.street_name = locality["Thoroughfare"]["ThoroughfareName"] rescue nil
+        loc.city = locality["LocalityName"] rescue nil
+        loc.state = country["AdministrativeArea"]["AdministrativeAreaName"] rescue nil
+        loc.state ||= country["Locality"]["LocalityName"] rescue nil
+      end
+
+      def self.set_precision(loc, l, locality)
+        loc.precision = l["metaDataProperty"]["GeocoderMetaData"]["precision"].sub(/exact/, "building").sub(/number|near/, "address").sub(/other/, "city")
+        loc.precision = "country" unless locality
+      end
+    end
+  end
+end

data/lib/geokit/inflectors.rb

@@ -23,8 +23,7 @@ module Geokit
     def snake_case(s)
       return s.downcase if s =~ /^[A-Z]+$/u
       s.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/u, '_\&') =~ /_*(.*)/
-        return $+.downcase
-
+      $+.downcase
     end
 
     def url_escape(s)

data/lib/geokit/lat_lng.rb

@@ -0,0 +1,129 @@
+module Geokit
+  class LatLng
+    include Mappable
+
+    attr_accessor :lat, :lng
+
+    # Accepts latitude and longitude or instantiates an empty instance
+    # if lat and lng are not provided. Converted to floats if provided
+    def initialize(lat=nil, lng=nil)
+      lat = lat.to_f if lat && !lat.is_a?(Numeric)
+      lng = lng.to_f if lng && !lng.is_a?(Numeric)
+      @lat = lat
+      @lng = lng
+    end
+
+    def self.from_json(json)
+      new(json['lat'], json['lng'])
+    end
+
+    # Latitude attribute setter; stored as a float.
+    def lat=(lat)
+      @lat = lat.to_f if lat
+    end
+
+    # Longitude attribute setter; stored as a float;
+    def lng=(lng)
+      @lng=lng.to_f if lng
+    end
+
+    # Returns the lat and lng attributes as a comma-separated string.
+    def ll
+      "#{lat},#{lng}"
+    end
+
+    #returns a string with comma-separated lat,lng values
+    def to_s
+      ll
+    end
+
+    #returns a two-element array
+    def to_a
+      [lat,lng]
+    end
+    # Returns true if the candidate object is logically equal.  Logical equivalence
+    # is true if the lat and lng attributes are the same for both objects.
+    def ==(other)
+      return false unless other.is_a?(LatLng)
+      lat == other.lat && lng == other.lng
+    end
+
+    def hash
+      lat.hash + lng.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    # Returns true if both lat and lng attributes are defined
+    def valid?
+      lat && lng
+    end
+
+    # A *class* method to take anything which can be inferred as a point and generate
+    # a LatLng from it. You should use this anything you're not sure what the input is,
+    # and want to deal with it as a LatLng if at all possible. Can take:
+    #  1) two arguments (lat,lng)
+    #  2) a string in the format "37.1234,-129.1234" or "37.1234 -129.1234"
+    #  3) a string which can be geocoded on the fly
+    #  4) an array in the format [37.1234,-129.1234]
+    #  5) a LatLng or GeoLoc (which is just passed through as-is)
+    #  6) anything responding to to_lat_lng -- a LatLng will be extracted from it
+    def self.normalize(thing,other=nil)
+      return Geokit::LatLng.new(thing, other) if other
+
+      case thing
+      when String
+        from_string(thing)
+      when Array
+        thing.size == 2 or raise ArgumentError.new("Must initialize with an Array with both latitude and longitude")
+        Geokit::LatLng.new(thing[0],thing[1])
+      when LatLng # will also be true for GeoLocs
+        thing
+      else
+        if thing.respond_to? :to_lat_lng
+          thing.to_lat_lng
+        else
+          raise ArgumentError.new("#{thing} (#{thing.class}) cannot be normalized to a LatLng. We tried interpreting it as an array, string, etc., but no dice.")
+        end
+      end
+    end
+
+    def self.from_string(thing)
+      thing.strip!
+      if match=thing.match(/(\-?\d+\.?\d*)[, ] ?(\-?\d+\.?\d*)$/)
+        Geokit::LatLng.new(match[1],match[2])
+      else
+        res = Geokit::Geocoders::MultiGeocoder.geocode(thing)
+        return res if res.success?
+        raise Geokit::Geocoders::GeocodeError
+      end
+    end
+
+    # Reverse geocodes a LatLng object using the MultiGeocoder (default), or optionally
+    # using a geocoder of your choosing. Returns a new Geokit::GeoLoc object
+    #
+    # ==== Options
+    # * :using  - Specifies the geocoder to use for reverse geocoding. Defaults to
+    #             MultiGeocoder. Can be either the geocoder class (or any class that
+    #             implements do_reverse_geocode for that matter), or the name of
+    #             the class without the "Geocoder" part (e.g. :google)
+    #
+    # ==== Examples
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => :google) # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => Geokit::Geocoders::GoogleGeocoder) # => #<Geokit::GeoLoc:0x12dac20 @state...>
+    def reverse_geocode(options = { :using => Geokit::Geocoders::MultiGeocoder })
+      if options[:using].is_a?(String) || options[:using].is_a?(Symbol)
+        provider = Geokit::Geocoders.const_get("#{Geokit::Inflector::camelize(options[:using].to_s)}Geocoder")
+      elsif options[:using].respond_to?(:do_reverse_geocode)
+        provider = options[:using]
+      else
+        raise ArgumentError.new("#{options[:using]} is not a valid geocoder.")
+      end
+
+      provider.send(:reverse_geocode, self)
+    end
+  end
+end

data/lib/geokit/mappable.rb

@@ -40,27 +40,34 @@ module Geokit
         units = options[:units] || Geokit::default_units
         formula = options[:formula] || Geokit::default_formula
         case formula
-        when :sphere
-          error_classes = [Errno::EDOM]
-
-          # Ruby 1.9 raises {Math::DomainError}, but it is not defined in Ruby
-          # 1.8. Backwards-compatibly rescue both errors.
-          error_classes << Math::DomainError if defined?(Math::DomainError)
-
-          begin
-            units_sphere_multiplier(units) *
-                Math.acos( Math.sin(deg2rad(from.lat)) * Math.sin(deg2rad(to.lat)) +
-                Math.cos(deg2rad(from.lat)) * Math.cos(deg2rad(to.lat)) *
-                Math.cos(deg2rad(to.lng) - deg2rad(from.lng)))
-          rescue *error_classes
-            0.0
-          end
-        when :flat
-          Math.sqrt((units_per_latitude_degree(units)*(from.lat-to.lat))**2 +
-              (units_per_longitude_degree(from.lat, units)*(from.lng-to.lng))**2)
+        when :sphere then distance_between_sphere(from, to, units)
+        when :flat   then distance_between_flat(from, to, units)
         end
       end
 
+      def distance_between_sphere(from, to, units)
+        lat_sin = Math.sin(deg2rad(from.lat)) * Math.sin(deg2rad(to.lat))
+        lat_cos = Math.cos(deg2rad(from.lat)) * Math.cos(deg2rad(to.lat))
+        lng_cos = Math.cos(deg2rad(to.lng) - deg2rad(from.lng))
+        units_sphere_multiplier(units) * Math.acos(lat_sin + lat_cos * lng_cos)
+      rescue *math_error_classes
+        0.0
+      end
+
+      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)
+      end
+
+      def math_error_classes
+        error_classes = [Errno::EDOM]
+
+        # Ruby 1.9 raises {Math::DomainError}, but it is not defined in Ruby
+        # 1.8. Backwards-compatibly rescue both errors.
+        error_classes << Math::DomainError if defined?(Math::DomainError)
+      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.
@@ -80,23 +87,23 @@ module Geokit
       # 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
-        radius = case units
-          when :kms; EARTH_RADIUS_IN_KMS
-          when :nms; EARTH_RADIUS_IN_NMS
-          else EARTH_RADIUS_IN_MILES
-        end
-        start=Geokit::LatLng.normalize(start)
-        lat=deg2rad(start.lat)
-        lng=deg2rad(start.lng)
-        heading=deg2rad(heading)
-        distance=distance.to_f
+        units   = options[:units] || Geokit::default_units
+        ratio   = distance.to_f / units_sphere_multiplier(units)
+        start   = Geokit::LatLng.normalize(start)
+        lat     = deg2rad(start.lat)
+        lng     = deg2rad(start.lng)
+        heading = deg2rad(heading)
+
+        sin_ratio = Math.sin(ratio)
+        cos_ratio = Math.cos(ratio)
+        sin_lat = Math.sin(lat)
+        cos_lat = Math.cos(lat)
 
-        end_lat=Math.asin(Math.sin(lat)*Math.cos(distance/radius) +
-                          Math.cos(lat)*Math.sin(distance/radius)*Math.cos(heading))
+        end_lat = Math.asin(sin_lat * cos_ratio +
+                            cos_lat * sin_ratio * Math.cos(heading))
 
-        end_lng=lng+Math.atan2(Math.sin(heading)*Math.sin(distance/radius)*Math.cos(lat),
-                               Math.cos(distance/radius)-Math.sin(lat)*Math.sin(end_lat))
+        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))
       end
@@ -172,7 +179,7 @@ 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)) if self.class.respond_to?(:acts_as_mappable)
+      return LatLng.new(send(self.class.lat_column_name), send(self.class.lng_column_name))
       nil
     end
 
@@ -213,394 +220,4 @@ module Geokit
 
   end
 
-  class LatLng
-    include Mappable
-
-    attr_accessor :lat, :lng
-
-    # Accepts latitude and longitude or instantiates an empty instance
-    # if lat and lng are not provided. Converted to floats if provided
-    def initialize(lat=nil, lng=nil)
-      lat = lat.to_f if lat && !lat.is_a?(Numeric)
-      lng = lng.to_f if lng && !lng.is_a?(Numeric)
-      @lat = lat
-      @lng = lng
-    end
-
-    # Latitude attribute setter; stored as a float.
-    def lat=(lat)
-      @lat = lat.to_f if lat
-    end
-
-    # Longitude attribute setter; stored as a float;
-    def lng=(lng)
-      @lng=lng.to_f if lng
-    end
-
-    # Returns the lat and lng attributes as a comma-separated string.
-    def ll
-      "#{lat},#{lng}"
-    end
-
-    #returns a string with comma-separated lat,lng values
-    def to_s
-      ll
-    end
-
-    #returns a two-element array
-    def to_a
-      [lat,lng]
-    end
-    # Returns true if the candidate object is logically equal.  Logical equivalence
-    # is true if the lat and lng attributes are the same for both objects.
-    def ==(other)
-      other.is_a?(LatLng) ? self.lat == other.lat && self.lng == other.lng : false
-    end
-
-    def hash
-      lat.hash + lng.hash
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    # Returns true if both lat and lng attributes are defined
-    def valid?
-      self.lat and self.lng
-    end
-
-    # A *class* method to take anything which can be inferred as a point and generate
-    # a LatLng from it. You should use this anything you're not sure what the input is,
-    # and want to deal with it as a LatLng if at all possible. Can take:
-    #  1) two arguments (lat,lng)
-    #  2) a string in the format "37.1234,-129.1234" or "37.1234 -129.1234"
-    #  3) a string which can be geocoded on the fly
-    #  4) an array in the format [37.1234,-129.1234]
-    #  5) a LatLng or GeoLoc (which is just passed through as-is)
-    #  6) anything which acts_as_mappable -- a LatLng will be extracted from it
-    def self.normalize(thing,other=nil)
-      # if an 'other' thing is supplied, normalize the input by creating an array of two elements
-      thing=[thing,other] if other
-
-      if thing.is_a?(String)
-        thing.strip!
-        if match=thing.match(/(\-?\d+\.?\d*)[, ] ?(\-?\d+\.?\d*)$/)
-          return Geokit::LatLng.new(match[1],match[2])
-        else
-          res = Geokit::Geocoders::MultiGeocoder.geocode(thing)
-          return res if res.success?
-          raise Geokit::Geocoders::GeocodeError
-        end
-      elsif thing.is_a?(Array) && thing.size==2
-        return Geokit::LatLng.new(thing[0],thing[1])
-      elsif thing.is_a?(LatLng) # will also be true for GeoLocs
-        return thing
-      elsif thing.class.respond_to?(:acts_as_mappable) && thing.class.respond_to?(:distance_column_name)
-        return thing.to_lat_lng
-      elsif thing.respond_to? :to_lat_lng
-        return thing.to_lat_lng
-      end
-
-      raise ArgumentError.new("#{thing} (#{thing.class}) cannot be normalized to a LatLng. We tried interpreting it as an array, string, Mappable, etc., but no dice.")
-    end
-
-    # Reverse geocodes a LatLng object using the MultiGeocoder (default), or optionally
-    # using a geocoder of your choosing. Returns a new Geokit::GeoLoc object
-    #
-    # ==== Options
-    # * :using  - Specifies the geocoder to use for reverse geocoding. Defaults to
-    #             MultiGeocoder. Can be either the geocoder class (or any class that
-    #             implements do_reverse_geocode for that matter), or the name of
-    #             the class without the "Geocoder" part (e.g. :google)
-    #
-    # ==== Examples
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => :google) # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    # LatLng.new(51.4578329, 7.0166848).reverse_geocode(:using => Geokit::Geocoders::GoogleGeocoder) # => #<Geokit::GeoLoc:0x12dac20 @state...>
-    def reverse_geocode(options = { :using => Geokit::Geocoders::MultiGeocoder })
-      if options[:using].is_a?(String) or options[:using].is_a?(Symbol)
-        provider = Geokit::Geocoders.const_get("#{Geokit::Inflector::camelize(options[:using].to_s)}Geocoder")
-      elsif options[:using].respond_to?(:do_reverse_geocode)
-        provider = options[:using]
-      else
-        raise ArgumentError.new("#{options[:using]} is not a valid geocoder.")
-      end
-
-      provider.send(:reverse_geocode, self)
-    end
-  end
-
-  # This class encapsulates the result of a geocoding call.
-  # It's primary purpose is to homogenize the results of multiple
-  # geocoding providers. It also provides some additional functionality, such as
-  # the "full address" method for geocoders that do not provide a
-  # full address in their results (for example, Yahoo), and the "is_us" method.
-  #
-  # Some geocoders can return multple results. Geoloc can capture multiple results through
-  # its "all" method.
-  #
-  # For the geocoder setting the results, it would look something like this:
-  #     geo=GeoLoc.new(first_result)
-  #     geo.all.push(second_result)
-  #     geo.all.push(third_result)
-  #
-  # Then, for the user of the result:
-  #
-  #     puts geo.full_address     # just like usual
-  #     puts geo.all.size  => 3   # there's three results total
-  #     puts geo.all.first        # all is just an array or additional geolocs,
-  #                                 so do what you want with it
-  class GeoLoc < LatLng
-
-    # Location attributes.  Full address is a concatenation of all values.  For example:
-    # 100 Spear St, San Francisco, CA, 94101, US
-    # Street number and street name are extracted from the street address attribute if they don't exist
-    attr_accessor :street_number, :street_name, :street_address, :city, :state, :zip, :country_code, :country
-    attr_accessor :full_address, :all, :district, :province, :sub_premise, :neighborhood
-    # Attributes set upon return from geocoding.  Success will be true for successful
-    # geocode lookups.  The provider will be set to the name of the providing geocoder.
-    # Finally, precision is an indicator of the accuracy of the geocoding.
-    attr_accessor :success, :provider, :precision, :suggested_bounds
-    # accuracy is set for Yahoo and Google geocoders, it is a numeric value of the
-    # precision. see http://code.google.com/apis/maps/documentation/geocoding/#GeocodingAccuracy
-    attr_accessor :accuracy
-    # FCC Attributes
-    attr_accessor :district_fips, :state_fips, :block_fips
-
-
-    # Constructor expects a hash of symbols to correspond with attributes.
-    def initialize(h={})
-      @all = [self]
-
-      @street_address=h[:street_address]
-      @sub_premise=nil
-      @street_number=nil
-      @street_name=nil
-      @city=h[:city]
-      @state=h[:state]
-      @zip=h[:zip]
-      @country_code=h[:country_code]
-      @province = h[:province]
-      @success=false
-      @precision='unknown'
-      @full_address=nil
-      super(h[:lat],h[:lng])
-    end
-
-    # Returns true if geocoded to the United States.
-    def is_us?
-      country_code == 'US'
-    end
-
-    def success?
-      success == true
-    end
-
-    # full_address is provided by google but not by yahoo. It is intended that the google
-    # geocoding method will provide the full address, whereas for yahoo it will be derived
-    # from the parts of the address we do have.
-    def full_address
-      @full_address ? @full_address : to_geocodeable_s
-    end
-
-    # Extracts the street number from the street address where possible.
-    def street_number
-      @street_number ||= street_address[/(\d*)/] if street_address
-      @street_number
-    end
-
-    # Returns the street name portion of the street address where possible
-    def street_name
-      @street_name||=street_address[street_number.length, street_address.length].strip if street_address
-      @street_name
-    end
-
-    # gives you all the important fields as key-value pairs
-    def hash
-      res={}
-      [:success, :lat, :lng, :country_code, :city, :state, :zip, :street_address, :province,
-       :district, :provider, :full_address, :is_us?, :ll, :precision, :district_fips, :state_fips,
-       :block_fips, :sub_premise].each { |s| res[s] = self.send(s.to_s) }
-      res
-    end
-    alias to_hash hash
-
-    # Sets the city after capitalizing each word within the city name.
-    def city=(city)
-      @city = Geokit::Inflector::titleize(city) if city
-    end
-
-    # Sets the street address after capitalizing each word within the street address.
-    def street_address=(address)
-      if address and not ['google','google3'].include?(self.provider)
-        @street_address = Geokit::Inflector::titleize(address)
-      else
-        @street_address = address
-      end
-    end
-
-    # Returns a comma-delimited string consisting of the street address, city, state,
-    # zip, and country code.  Only includes those attributes that are non-blank.
-    def to_geocodeable_s
-      a=[street_address, district, city, province, state, zip, country_code].compact
-      a.delete_if { |e| !e || e == '' }
-      a.join(', ')
-    end
-
-    def to_yaml_properties
-      (instance_variables - ['@all', :@all]).sort
-    end
-
-    def encode_with(coder)
-      to_yaml_properties.each do |name|
-        coder[name[1..-1].to_s] = instance_variable_get(name.to_s)
-      end
-    end
-
-    # Returns a string representation of the instance.
-    def to_s
-      "Provider: #{provider}\nStreet: #{street_address}\nCity: #{city}\nState: #{state}\nZip: #{zip}\nLatitude: #{lat}\nLongitude: #{lng}\nCountry: #{country_code}\nSuccess: #{success}"
-    end
-  end
-
-  # Bounds represents a rectangular bounds, defined by the SW and NE corners
-  class Bounds
-    # sw and ne are LatLng objects
-    attr_accessor :sw, :ne
-
-    # provide sw and ne to instantiate a new Bounds instance
-    def initialize(sw,ne)
-      raise ArgumentError if !(sw.is_a?(Geokit::LatLng) && ne.is_a?(Geokit::LatLng))
-      @sw,@ne=sw,ne
-    end
-
-    #returns the a single point which is the center of the rectangular bounds
-    def center
-      @sw.midpoint_to(@ne)
-    end
-
-    # a simple string representation:sw,ne
-    def to_s
-      "#{@sw.to_s},#{@ne.to_s}"
-    end
-
-    # a two-element array of two-element arrays: sw,ne
-    def to_a
-      [@sw.to_a, @ne.to_a]
-    end
-
-    # Returns true if the bounds contain the passed point.
-    # allows for bounds which cross the meridian
-    def contains?(point)
-      point=Geokit::LatLng.normalize(point)
-      res = point.lat > @sw.lat && point.lat < @ne.lat
-      if crosses_meridian?
-        res &= point.lng < @ne.lng || point.lng > @sw.lng
-      else
-        res &= point.lng < @ne.lng && point.lng > @sw.lng
-      end
-      res
-    end
-
-    # returns true if the bounds crosses the international dateline
-    def crosses_meridian?
-      @sw.lng > @ne.lng
-    end
-
-    # Returns true if the candidate object is logically equal.  Logical equivalence
-    # is true if the lat and lng attributes are the same for both objects.
-    def ==(other)
-      other.is_a?(Bounds) ? self.sw == other.sw && self.ne == other.ne : false
-    end
-
-    # Equivalent to Google Maps API's .toSpan() method on GLatLng's.
-    #
-    # Returns a LatLng object, whose coordinates represent the size of a rectangle
-    # defined by these bounds.
-    def to_span
-      lat_span = (@ne.lat - @sw.lat).abs
-      lng_span = (crosses_meridian? ? 360 + @ne.lng - @sw.lng : @ne.lng - @sw.lng).abs
-      Geokit::LatLng.new(lat_span, lng_span)
-    end
-
-    class <<self
-
-      # returns an instance of bounds which completely encompases the given circle
-      def from_point_and_radius(point,radius,options={})
-        point=LatLng.normalize(point)
-        p0=point.endpoint(0,radius,options)
-        p90=point.endpoint(90,radius,options)
-        p180=point.endpoint(180,radius,options)
-        p270=point.endpoint(270,radius,options)
-        sw=Geokit::LatLng.new(p180.lat,p270.lng)
-        ne=Geokit::LatLng.new(p0.lat,p90.lng)
-        Geokit::Bounds.new(sw,ne)
-      end
-
-      # Takes two main combinations of arguments to create a bounds:
-      # point,point   (this is the only one which takes two arguments
-      # [point,point]
-      # . . . where a point is anything LatLng#normalize can handle (which is quite a lot)
-      #
-      # NOTE: everything combination is assumed to pass points in the order sw, ne
-      def normalize (thing,other=nil)
-        # maybe this will be simple -- an actual bounds object is passed, and we can all go home
-        return thing if thing.is_a? Bounds
-
-        # no? OK, if there's no "other," the thing better be a two-element array
-        thing,other=thing if !other && thing.is_a?(Array) && thing.size==2
-
-        # Now that we're set with a thing and another thing, let LatLng do the heavy lifting.
-        # Exceptions may be thrown
-        Bounds.new(Geokit::LatLng.normalize(thing),Geokit::LatLng.normalize(other))
-      end
-    end
-  end
-  
-  # A complex polygon made of multiple points.  End point must equal start point to close the poly.
-  class Polygon
-    
-    attr_accessor :poly_y, :poly_x
-    
-    def initialize(points)
-      # Pass in an array of Geokit::LatLng
-      @poly_x = []
-      @poly_y = []
-
-      points.each do |point|
-        @poly_x << point.lng
-        @poly_y << point.lat
-      end
-      
-      # A Polygon must be 'closed', the last point equal to the first point
-      if not @poly_x[0] == @poly_x[-1] or not @poly_y[0] == @poly_y[-1]
-        # Append the first point to the array to close the polygon
-        @poly_x << @poly_x[0]
-        @poly_y << @poly_y[0]
-      end
-      
-    end
-
-    def contains?(point)
-      j = @poly_x.length - 1
-      oddNodes = false
-      x = point.lng
-      y = point.lat
-
-      for i in (0..j)
-        if (@poly_y[i] < y && @poly_y[j] >= y ||
-            @poly_y[j] < y && @poly_y[i] >= y)
-          if (@poly_x[i] + (y - @poly_y[i]) / (@poly_y[j] - @poly_y[i]) * (@poly_x[j] - @poly_x[i]) < x)
-            oddNodes = !oddNodes
-          end
-        end
- 
-        j=i
-      end
-
-      oddNodes
-    end # contains?
-  end # class Polygon
-  
 end