geo_calc 0.5.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.5.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Kristian Mandrup
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,181 @@
+h1. Geo calculations
+
+Geo Calculation library. Useful functions to add to your geo arsenal, fx when designing your own Geo library. 
+
+h2. Install
+
+@require 'geo_calc'@
+
+h3. Gemfile
+
+Insert in your Gemfile:
+
+@gem 'geo_calc'@
+
+From command line, run bundler
+
+@$ bundle@
+
+h2. Quick start (Usage)
+
+First define the points on the globe you want to work with.
+The GeoPoint initializer is very flexible with regards to the arguments it can handle.
+
+<pre>
+  # factory method on core ruby classes
+  "51 12 03 N, 24 10 02 E".geo_point
+  [51.5136, -0.0983].geo_point
+  {:latitude => 27.3, :longitude => "24 10 02 E"}.geo_point
+
+  # two arguments
+  p1 = GeoPoint.new 51.5136, -0.0983
+  p2 = GeoPoint.new "14 11 01 N", "-0.0983"
+  p3 = GeoPoint.new 51.5136, "24 10 02 E"
+
+  # a String
+  p1 = GeoPoint.new "51.5136, -0.0983"
+  p1 = GeoPoint.new "51.5136, 24 10 02 E"
+  p3 = GeoPoint.new "51.4778, -0.0015"  
+  p1 = GeoPoint.new "51 12 03 N, 24 10 02 E"
+
+  # an Array
+  p2 = GeoPoint.new [51.5136, -0.0983]
+  p2 = GeoPoint.new [51.5136, "24 10 02 E"]
+  p2 = GeoPoint.new [51.5136, {:lon => 27.3}]
+
+  # a Hash
+  p4 = GeoPoint.new {:lat => 27.3, :lng => "24 10 02 E"}
+  p4 = GeoPoint.new {:latitude => 27.3, :longitude => "24 10 02 E"}  
+</pre>
+
+h3. Shortes distance
+
+Calculate *distance in kms between points p1 and p2*
+
+<pre>  
+  dist = p1.distance_to(p2) # in km
+</pre>
+
+h3. Initial bearing (direction)
+
+Calculate the initial bearing (direction in degrees which p1 points at p2)
+
+<pre>
+  brng = p1.bearing_to(p2) # in degrees clockwise from north
+</pre>
+
+h3. Final bearing (direction)
+
+Calculate the final bearing (direction in degrees) between p1 -> p2)
+
+<pre>
+  final_brng = p1.final_bearing_to(p2) # final bearing in degrees from north  
+</pre>
+
+h3. Midpoint
+
+Find the midpoint between points p1 and p2
+  
+<pre>
+  mid = p1.midpoint_to point(p2) # midpoint between p1 and p2
+</pre>
+
+h3. Destination point
+
+Find the destination point from walking a distance in a given bearing (direction in degrees from p1)
+  
+<pre>
+  dest = p1.destination_point bearing, dist # Bearing in degrees, Distance in km  
+</pre>
+
+h3. Intersection point
+
+Find the intersection point pcross between a path from p1 and a path from p2
+  
+<pre>
+  pcross = GeoPoint.intersection p1, brng1, p2, brng2 # intersection between two paths
+</pre>  
+
+h2. Rhumb lines
+  
+<pre>
+  p1.rhumb_distance_to(p2)
+</pre>  
+  
+<pre>
+  p1.bearing_to(p2)
+</pre>  
+
+<pre>
+  p1.rhumb_destination_point(brng, dist)  
+</pre>    
+
+h2. Utility methods
+
+These are some of the utility methods you can use on a GeoPoint object
+  
+<pre>
+  p1 = GeoPoint.new 5.1, -7
+  p1.lat          # latitude
+  p1.lon          # longitude
+  p1.to_arr       # array representation of [lat, lng]
+  p1.reverse_arr! # reverse to_arr to instead return [lng, lat]
+  p1.normal_arr!  # return to normal to_arr functionality: [lat, lng]
+  p1.to_s         # string representation
+</pre>  
+
+h2. Core Extensions
+
+The library also extends core Ruby classes with geo related functions (see _core_ext_spec.rb_)
+
+h3. Radians to degrees
+
+<pre>
+  (6.28).to_deg # almost 360 deg  
+</pre>
+
+h3. Degrees to radians
+
+<pre>
+  (360).to_deg # about 6.28, or 2 * PI
+</pre>
+
+h3. DMS to degrees 
+
+Convert (degrees-minutes-seconds) to degrees (Float)
+
+<pre>
+  "24 10 02 E".parse_dms(:dm, 2) # dms format and precision 
+</pre>
+
+h3. Degrees to DMS
+
+Convert degrees into to DMS format
+
+<pre>
+  53.2.to_dms # can also take dms format and precision args
+</pre>
+
+And many more...
+
+h2. Javascript
+
+The libary also comes wih a javascript file with the same functionality. 
+
+See _js/geo_calc.js_ in the _/lib_ folder
+
+h2. Contributing to geo_calc
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+h2. Copyright
+
+Copyright (c) 2011 Kristian Mandrup. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "geo_calc"
+  gem.homepage = "http://github.com/kristianmandrup/geo_calc"
+  gem.license = "MIT"
+  gem.summary = %Q{Geo calculation library}
+  gem.description = %Q{Geo calculations in ruby and javascript}
+  gem.email = "kmandrup@gmail.com"
+  gem.authors = ["Kristian Mandrup"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geo_calc #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/geo_calc.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{geo_calc}
+  s.version = "0.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Kristian Mandrup}]
+  s.date = %q{2011-05-13}
+  s.description = %q{Geo calculations in ruby and javascript}
+  s.email = %q{kmandrup@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.textile"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.textile",
+    "Rakefile",
+    "VERSION",
+    "geo_calc.gemspec",
+    "lib/geo_calc.rb",
+    "lib/geo_calc/calculations.rb",
+    "lib/geo_calc/core_ext.rb",
+    "lib/geo_calc/geo.rb",
+    "lib/geo_calc/geo_point.rb",
+    "lib/geo_calc/js/geo_calc.js",
+    "spec/geo_calc/calculations_spec.rb",
+    "spec/geo_calc/core_ext_spec.rb",
+    "spec/geo_calc/geo_point_spec.rb",
+    "spec/geo_calc/geo_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kristianmandrup/geo_calc}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.0}
+  s.summary = %q{Geo calculation library}
+  s.test_files = [
+    "spec/geo_calc/calculations_spec.rb",
+    "spec/geo_calc/core_ext_spec.rb",
+    "spec/geo_calc/geo_point_spec.rb",
+    "spec/geo_calc/geo_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.5.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.5.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/geo_calc/calculations.rb

@@ -0,0 +1,333 @@
+require 'geo_calc/geo'
+require 'geo_calc/core_ext'
+
+ # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
+ #  Latitude/longitude spherical geodesy formulae & scripts (c) Chris Veness 2002-2010            
+ #   - www.movable-type.co.uk/scripts/latlong.html
+ #                                                                                                
+
+module GeoCalc  
+  # Returns the distance from this point to the supplied point, in km 
+  # (using Haversine formula)
+  # 
+  # from: Haversine formula - R. W. Sinnott, "Virtues of the Haversine",
+  #       Sky and Telescope, vol 68, no 2, 1984
+  # 
+  # GeoPoint point: Latitude/longitude of destination point
+  # - Numeric precision=4: number of significant digits to use for returned value
+  #
+  # Returns - Numeric distance in km between this point and destination point
+  
+  def distance_to point, precision = 4
+    # default 4 sig figs reflects typical 0.3% accuracy of spherical model
+    precision ||= 4
+
+    lat1 = lat.to_rad
+    lon1 = lon.to_rad
+
+    lat2 = point.lat.to_rad
+    lon2 = point.lon.to_rad
+
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+
+    a = Math.sin(dlat/2) * Math.sin(dlat/2) + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dlon/2) * Math.sin(dlon/2)
+    c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+    d = radius * c
+    d.round(precision)
+  end
+  
+  
+  # Returns the (initial) bearing from this point to the supplied point, in degrees
+  #   see http:#williams.best.vwh.net/avform.htm#Crs
+  # 
+  # - Point point: Latitude/longitude of destination point
+  # 
+  # Returns -  Numeric: Initial bearing in degrees from North
+  
+  def bearing_to point
+    lat1 = lat.to_rad
+    lat2 = point.lat.to_rad
+    dlon = (point.lon - lon).to_rad
+
+    y = Math.sin(dlon) * Math.cos(lat2)
+    x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dlon)
+    bearing = Math.atan2(y, x)
+
+    (bearing.to_deg + 360) % 360
+  end
+  
+  
+  # Returns final bearing arriving at supplied destination point from this point; the final bearing 
+  # will differ from the initial bearing by varying degrees according to distance and latitude
+  # 
+  # - GeoPoint point: Latitude/longitude of destination point
+  #
+  # Returns Numeric: Final bearing in degrees from North
+  
+  def final_bearing_to point
+    # get initial bearing from supplied point back to this point...
+    lat1 = point.lat.to_rad
+    lat2 = lat.to_rad
+    dlon = (lon - point.lon).to_rad
+
+    y = Math.sin(dlon) * Math.cos(lat2)
+    x = Math.cos(lat1)*Math.sin(lat2) - Math.sin(lat1)*Math.cos(lat2)*Math.cos(dlon)
+    bearing = Math.atan2(y, x)
+
+    # ... & reverse it by adding 180°
+    (bearing.to_deg+180) % 360
+  end
+  
+  
+  # Returns the midpoint between this point and the supplied point.
+  #   see http:#mathforum.org/library/drmath/view/51822.html for derivation
+  # 
+  # - GeoPoint point: Latitude/longitude of destination point
+  # Returns GeoPoint: Midpoint between this point and the supplied point
+  
+  def midpoint_to point
+    lat1 = lat.to_rad
+    lon1 = lon.to_rad;
+    lat2 = point.lat.to_rad
+    dlon = (point.lon - lon).to_rad
+
+    bx = Math.cos(lat2) * Math.cos(dlon)
+    by = Math.cos(lat2) * Math.sin(dlon)
+
+    lat3 = Math.atan2(Math.sin(lat1)+Math.sin(lat2), Math.sqrt( (Math.cos(lat1)+bx)*(Math.cos(lat1)+bx) + by*by) )
+
+    lon3 = lon1 + Math.atan2(by, Math.cos(lat1) + bx)
+
+    GeoPoint.new lat3.to_deg, lon3.to_deg
+  end
+  
+  
+  # Returns the destination point from this point having travelled the given distance (in km) on the 
+  # given initial bearing (bearing may vary before destination is reached)
+  # 
+  #   see http:#williams.best.vwh.net/avform.htm#LL
+  # 
+  # - Numeric bearing: Initial bearing in degrees
+  # - Numeric dist: Distance in km
+  # Returns GeoPoint: Destination point
+  
+  def destination_point brng, dist
+    dist = dist / radius  # convert dist to angular distance in radians
+    brng = brng.to_rad 
+    lat1 = lat.to_rad
+    lon1 = lon.to_rad
+
+    lat2 = Math.asin( Math.sin(lat1) * Math.cos(dist) + Math.cos(lat1) * Math.sin(dist) * Math.cos(brng) )
+    lon2 = lon1 + Math.atan2(Math.sin(brng) * Math.sin(dist) * Math.cos(lat1), Math.cos(dist) - Math.sin(lat1) * Math.sin(lat2))
+
+    lon2 = (lon2 + 3*Math::PI) % (2*Math::PI) - Math::PI  # normalise to -180...+180   
+
+    GeoPoint.new lat2.to_deg, lon2.to_deg
+  end
+
+  
+  # Returns the point of intersection of two paths defined by point and bearing
+  # 
+  #   see http:#williams.best.vwh.net/avform.htm#Intersection
+  # 
+  # @param   {LatLon} p1: First point
+  # @param   {Number} brng1: Initial bearing from first point
+  # @param   {LatLon} p2: Second point
+  # @param   {Number} brng2: Initial bearing from second point
+  # @returns {LatLon} Destination point (null if no unique intersection defined)
+  
+  def self.intersection p1, brng1, p2, brng2
+    lat1 = p1.lat.to_rad
+    lon1 = p1.lon.to_rad
+
+    lat2 = p2.lat.to_rad
+    lon2 = p2.lon.to_rad
+
+    brng13 = brng1.to_rad
+    brng23 = brng2.to_rad
+        
+    dlat = lat2-lat1
+    dlon = lon2-lon1;
+
+    dist12 = 2*Math.asin( Math.sqrt( Math.sin(dlat/2)*Math.sin(dlat/2) + Math.cos(lat1)*Math.cos(lat2)*Math.sin(dlon/2)*Math.sin(dlon/2) ) )
+    return nil if dist12 == 0
+
+    # initial/final bearings between points
+    brng_a = begin
+      Math.acos( ( Math.sin(lat2) - Math.sin(lat1)*Math.cos(dist12) ) / ( Math.sin(dist12)*Math.cos(lat1) ) )
+    rescue # protect against rounding
+      0
+    end
+    
+    brng_b = Math.acos( ( Math.sin(lat1) - Math.sin(lat2)*Math.cos(dist12) ) / ( Math.sin(dist12)*Math.cos(lat2) ) )
+
+    brng12, brng21 = if Math.sin(lon2-lon1) > 0
+      [brng_a, 2*Math::PI - brng_b] 
+    else
+      [2*Math::PI - brng_a, brng_b]
+    end
+
+    alpha1 = (brng13 - brng12 + Math::PI) % (2*Math::PI) - Math::PI  # angle 2-1-3
+    alpha2 = (brng21 - brng23 + Math::PI) % (2*Math::PI) - Math::PI  # angle 1-2-3
+
+    return nil if (Math.sin(alpha1)==0 && Math.sin(alpha2)==0) # infinite intersections
+    return nil if (Math.sin(alpha1)*Math.sin(alpha2) < 0)    # ambiguous intersection
+
+    # alpha1 = Math.abs(alpha1);
+    # alpha2 = Math.abs(alpha2);
+    # ... Ed Williams takes abs of alpha1/alpha2, but seems to break calculation?
+
+    alpha3 = Math.acos( -Math.cos(alpha1)*Math.cos(alpha2) + Math.sin(alpha1)*Math.sin(alpha2)*Math.cos(dist12) )
+
+    dist13 = Math.atan2( Math.sin(dist12)*Math.sin(alpha1)*Math.sin(alpha2), Math.cos(alpha2)+Math.cos(alpha1)*Math.cos(alpha3) )
+
+    lat3 = Math.asin( Math.sin(lat1)*Math.cos(dist13) + Math.cos(lat1)*Math.sin(dist13)*Math.cos(brng13) )
+
+    dlon13 = Math.atan2( Math.sin(brng13)*Math.sin(dist13)*Math.cos(lat1), Math.cos(dist13)-Math.sin(lat1)*Math.sin(lat3) )
+
+    lon3 = lon1 + dlon13;
+    lon3 = (lon3 + Math::PI) % (2*Math::PI) - Math::PI  # normalise to -180..180º
+
+    GeoPoint.new lat3.to_deg, lon3.to_deg
+  end
+    
+
+  # Returns the distance from this point to the supplied point, in km, travelling along a rhumb line
+  # 
+  #   see http:#williams.best.vwh.net/avform.htm#Rhumb
+  # 
+  # - GeoPoint point: Latitude/longitude of destination point
+  # Returns Numeric: Distance in km between this point and destination point
+  
+  def rhumb_distance_to point
+    lat1 = lat.to_rad
+    lat2 = point.lat.to_rad
+
+    dlat = (point.lat-lat).to_rad
+    dlon = (point.lon-lon).abs.to_rad
+
+    dphi = Math.log(Math.tan(lat2/2 + Math::PI/4) / Math.tan(lat1/2 + Math::PI/4))
+
+    q = begin
+      dlat / dphi
+    rescue 
+      Math.cos(lat1) # E-W line gives dPhi=0
+    end
+        
+    # if dlon over 180° take shorter rhumb across 180° meridian:
+    dlon = 2*Math::PI - dlon if (dlon > Math::PI)
+
+    dist = Math.sqrt(dlat*dlat + q*q*dlon*dlon) * radius; 
+
+    dist.round(4)  # 4 sig figures reflects typical 0.3% accuracy of spherical model
+  end
+  
+  
+  # Returns the bearing from this point to the supplied point along a rhumb line, in degrees
+  # 
+  # - GeoPoint point: Latitude/longitude of destination point
+  # Returns Numeric: Bearing in degrees from North
+  
+  def rhumb_bearing_to point
+    lat1 = lat.to_rad
+    lat2 = point.lat.to_rad
+
+    dlon = (point.lon - lon).to_rad
+
+    dphi = Math.log(Math.tan(lat2/2+Math::PI/4) / Math.tan(lat1/2+Math::PI/4))
+    if dlon.abs > Math::PI
+      dlon = dlon>0 ? -(2*Math::PI-dlon) : (2*Math::PI+dlon);
+    end
+
+    brng = Math.atan2(dlon, dphi);
+
+    (brng.to_deg+360) % 360
+  end
+
+  
+  # Returns the destination point from this point having travelled the given distance (in km) on the 
+  # given bearing along a rhumb line
+  # 
+  # @param   {Number} brng: Bearing in degrees from North
+  # @param   {Number} dist: Distance in km
+  # @returns {LatLon} Destination point
+  
+  def rhumb_destination_point brng, dist
+    d = dist / radius  # d = angular distance covered on earth's surface
+    lat1 = lat.to_rad
+    lon1 = lon.to_rad
+    brng = brng.to_rad
+
+    lat2 = lat1 + d*Math.cos(brng);
+    dlat = lat2-lat1;
+    dphi = Math.log(Math.tan(lat2/2+Math::PI/4)/Math.tan(lat1/2+Math::PI/4))
+
+    q = begin
+      dlat/dphi
+    rescue 
+      Math.cos(lat1) # E-W line gives dPhi=0
+    end
+
+    dlon = d*Math.sin(brng)/q
+    # check for some daft bugger going past the pole
+
+    if lat2.abs > Math::PI/2
+      lat2 = lat2>0 ? Math::PI-lat2 : -(Math::PI-lat2)
+    end
+    lon2 = (lon1+dlon+3*Math::PI) % (2*Math::PI) - Math::PI
+
+    GeoPoint.new lat2.to_deg, lon2.to_deg
+  end
+
+  
+  # Returns the latitude of this point; signed numeric degrees if no format, otherwise format & dp 
+  # as per Geo.to_lat
+  # 
+  # - String [format]: Return value as 'd', 'dm', 'dms'
+  # - Numeric [dp=0|2|4]: No of decimal places to display
+  #
+  # Returns {Numeric|String}: Numeric degrees if no format specified, otherwise deg/min/sec
+  # 
+  
+  def to_lat format = :dms, dp = 0
+    return lat if !format
+    Geo.to_lat lat, format, dp
+  end
+
+  
+  # Returns the longitude of this point; signed numeric degrees if no format, otherwise format & dp 
+  # as per Geo.toLon()
+  # 
+  # @param   {String} [format]: Return value as 'd', 'dm', 'dms'
+  # @param   {Number} [dp=0|2|4]: No of decimal places to display
+  # @returns {Number|String} Numeric degrees if no format specified, otherwise deg/min/sec
+  # 
+  # @requires Geo
+  
+  def to_lon format, dp
+    return lon if !format
+    Geo.to_lon lon, format, dp
+  end
+
+  
+  # Returns a string representation of this point; format and dp as per lat()/lon()
+  # 
+  # @param   {String} [format]: Return value as 'd', 'dm', 'dms'
+  # @param   {Number} [dp=0|2|4]: No of decimal places to display
+  
+  # @returns {String} Comma-separated latitude/longitude
+  # 
+  
+  def to_s format = :dms, dp = 0 
+    format ||= :dms
+  
+    return '-,-' if !lat || !lon
+  
+    _lat = Geo.to_lat lat, format, dp
+    _lon = Geo.to_lon lon, format, dp
+  
+    "#{_lat}, #{_lon}"
+  end
+end
+