geoutm 0.0.4

data/README.rdoc

@@ -0,0 +1,148 @@
+=NAME
+
+GeoUtm
+
+=SYNOPSIS
+
+  require 'geoutm'
+
+  coordinate = LatLon.new 100.0 100.0
+  utm_coord = coordinate.to_utm
+  reverse = utm_coord.to_lat_lon
+
+=INSTALL
+
+  sudo gem sources -a http://gems.github.com
+  sudo gem install tallakt-geoutm
+
+
+=DESCRIPTION
+
+This module will translate latitude longitude coordinates to Universal Transverse Mercator(UTM) coordinates and vice versa.
+
+This is a shameless port of the Perl library Geo::Coordinates::UTM written by Graham Crookham. Most text is copied directly from this library, adapted to ruby syntax.
+
+
+== Mercator Projection
+
+The Mercator projection was first invented to help mariners. They needed to be able to take a course and know the distance traveled, and draw a line on the map which showed the day's journey. In order to do this, Mercator invented a projection which preserved length, by projecting the earth's surface onto a cylinder, sharing the same axis as the earth itself.
+This caused all Latitude and Longitude lines to intersect at a 90 degree angle, thereby negating the problem that longitude lines get closer together at the poles.
+
+== Transverse Mercator Projection
+
+A Transverse Mercator projection takes the cylinder and turns it on its side. Now the cylinder's axis passes through the equator, and it can be rotated to line up with the area of interest. Many countries use Transverse Mercator for their grid systems.
+
+== Universal Transverse Mercator
+
+The Universal Transverse Mercator(UTM) system sets up a universal world wide system for mapping. The Transverse Mercator projection is used, with the cylinder in 60 positions. This creates 60 zones around the world.
+Positions are measured using Eastings and Northings, measured in meters, instead of Latitude and Longitude. Eastings start at 500,000 on the centre line of each zone.
+In the Northern Hemisphere, Northings are zero at the equator and increase northward. In the Southern Hemisphere, Northings start at 10 million at the equator, and decrease southward. You must know which hemisphere and zone you are in to interpret your location globally. 
+Distortion of scale, distance, direction and area increase away from the central meridian.
+
+UTM projection is used to define horizontal positions world-wide by dividing the surface of the Earth into 6 degree zones, each mapped by the Transverse Mercator projection with a central meridian in the center of the zone. 
+UTM zone numbers designate 6 degree longitudinal strips extending from 80 degrees South latitude to 84 degrees North latitude. UTM zone characters designate 8 degree zones extending north and south from the equator. Eastings are measured from the central meridian (with a 500 km false easting to insure positive coordinates). Northings are measured from the equator (with a 10,000 km false northing for positions south of the equator).
+
+UTM is applied separately to the Northern and Southern Hemisphere, thus within a single UTM zone, a single X / Y pair of values will occur in both the Northern and Southern Hemisphere. 
+To eliminate this confusion, and to speed location of points, a UTM zone is sometimes subdivided into 20 zones of Latitude. These grids can be further subdivided into 100,000 meter grid squares with double-letter designations. This subdivision by Latitude and further division into grid squares is generally referred to as the Military Grid Reference System (MGRS).
+The unit of measurement of UTM is always meters and the zones are numbered from 1 to 60 eastward, beginning at the 180th meridian.
+The scale distortion in a north-south direction parallel to the central meridian (CM) is constant However, the scale distortion increases either direction away from the CM. To equalize the distortion of the map across the UTM zone, a scale factor of 0.9996 is applied to all distance measurements within the zone. The distortion at the zone boundary, 3 degrees away from the CM is approximately 1%.
+
+== Datums and Ellipsoids
+
+Unlike local surveys, which treat the Earth as a plane, the precise determination of the latitude and longitude of points over a broad area must take into account the actual shape of the Earth. To achieve the precision necessary for accurate location, the Earth cannot be assumed to be a sphere. Rather, the Earth's shape more closely approximates an ellipsoid (oblate spheroid): flattened at the poles and bulging at the Equator. Thus the Earth's shape, when cut through its polar axis, approximates an ellipse.
+A "Datum" is a standard representation of shape and offset for coordinates, which includes an ellipsoid and an origin. You must consider the Datum when working with geospatial data, since data with two different Datum will not line up. The difference can be as much as a kilometer!
+
+= EXAMPLES
+
+A description of the available ellipsoids and sample usage of the conversion routines follows
+
+== Ellipsoids
+
+The Ellipsoids available are as follows:
+
+
+1. Airy
+2. Australian National
+3. Bessel 1841
+4. Bessel 1841 Nambia
+5. Clarke 1866
+6. Clarke 1880
+7. Everest 1830 India
+8. Everest 1830 Malaysia
+9. Everest 1956 India
+10. Everest 1964 Malaysia and Singapore
+11. Everest 1969 Malaysia
+12. Everest Pakistan
+13. Fischer 1960 Mercury
+14. Fischer 1968
+15. GRS 1967
+16. GRS 1980
+17. Helmert 1906
+18. Hough
+19. Indonesian 1974
+20. International
+21. Krassovsky
+22. Modified Airy
+23. Modified Everest
+24. Modified Fischer 1960
+25. South American 1969
+26. WGS 60
+27. WGS 66
+28. WGS-72
+29. WGS-84
+
+
+== ellipsoid_names
+
+The ellipsoids can be accessed using
+
+     GeoUtm::Ellipsoid::list_names
+
+Alternatively
+
+  GeouUtm::Ellipsoid::each {|ellipsoid| ... }
+
+When converting to and from UTM coordinates, the ellipsoid
+is specified as a parameter which defaults to WGS-84. To use another
+ellipsoid, use
+
+  coord.to_utm Ellipsoid::lookup :wgs60
+
+The name is not case sensitive and symbols are allowed. Spaces and - 
+are ignored.
+
+== Latitude / longitude to UTM conversion
+
+Latitude values in the southern hemisphere should be supplied as negative values (e.g. 30 deg South will be -30). Similarly Longitude values West of the meridian should also be supplied as negative values. Both latitude and longitude should not be entered as deg,min,sec but as their decimal equivalent, e.g. 30 deg 12 min 22.432 sec should be entered as 30.2062311
+
+The ellipsoid value should correspond to one of the numbers above, e.g. to use WGS-84, the ellipsoid value should be 23
+
+For latitude  57deg 49min 59.000sec North
+    longitude 02deg 47min 20.226sec West
+
+using Clarke 1866 (Ellipsoid 5)
+
+  utm = LatLon.new(57.803055556, -2.788951667).to_utm(Ellipsoid::lookup('clarke 1866'))
+
+returns 
+
+     utm.zone  = 30V
+     utm.e     = 512533.364651484
+     utm.n     = 6409932.13416127
+
+
+== AUTHOR
+
+Graham Crookham, grahamc@cpan.org
+
+Ruby port by Tallak Tveide 2009
+
+== COPYRIGHT
+
+Copyright (c) 2000,2002,2004 by Graham Crookham.  All rights reserved.
+    
+This package is free software; you can redistribute it
+and/or modify it under the same terms as Perl itself.             
+
+
+

data/lib/geoutm/constants.rb

@@ -0,0 +1,4 @@
+module GeoUtm
+  Deg2Rad = Math::PI / 180.0
+  Rad2Deg = 180.0 / Math::PI
+end

data/lib/geoutm/ellipsoid.rb

@@ -0,0 +1,75 @@
+module GeoUtm
+  class Ellipsoid
+    attr_reader :name, :radius, :eccentricity
+
+
+    def initialize(name, radius, eccentricity)
+      @name, @radius, @eccentricity = name, radius, eccentricity
+    end
+
+    def Ellipsoid.lookup(name)
+      List[normalize_name(name.to_s)]
+    end
+
+    def Ellipsoid.list_names
+      List.keys.sort.map do |k|
+        List[k].name
+      end
+    end
+
+    def Ellipsoid.each
+      List.keys.sort do |k|
+        yield List[k]
+      end
+    end
+
+    private
+
+    def Ellipsoid.normalize_name(name)
+      name.gsub(/[\s\-\(\)]/, '').upcase
+    end
+
+    def Ellipsoid.generate_list
+      result = {}
+      data = [
+        [ "Airy", 6377563, 0.00667054],
+        [ "Australian National", 6378160, 0.006694542],
+        [ "Bessel 1841", 6377397, 0.006674372],
+        [ "Bessel 1841 Nambia", 6377484, 0.006674372],
+        [ "Clarke 1866", 6378206, 0.006768658],
+        [ "Clarke 1880", 6378249, 0.006803511],
+        [ "Everest 1830 India", 6377276, 0.006637847],
+        [ "Fischer 1960 Mercury", 6378166, 0.006693422],
+        [ "Fischer 1968", 6378150, 0.006693422],
+        [ "GRS 1967", 6378160, 0.006694605],
+        [ "GRS 1980", 6378137, 0.00669438],
+        [ "Helmert 1906", 6378200, 0.006693422],
+        [ "Hough", 6378270, 0.00672267],
+        [ "International", 6378388, 0.00672267],
+        [ "Krassovsky", 6378245, 0.006693422],
+        [ "Modified Airy", 6377340, 0.00667054],
+        [ "Modified Everest", 6377304, 0.006637847],
+        [ "Modified Fischer 1960", 6378155, 0.006693422],
+        [ "South American 1969", 6378160, 0.006694542],
+        [ "WGS 60", 6378165, 0.006693422],
+        [ "WGS 66", 6378145, 0.006694542],
+        [ "WGS-72", 6378135, 0.006694318],
+        [ "WGS-84", 6378137, 0.00669438 ],
+        [ "Everest 1830 Malaysia", 6377299, 0.006637847],
+        [ "Everest 1956 India", 6377301, 0.006637847],
+        [ "Everest 1964 Malaysia and Singapore", 6377304, 0.006637847],
+        [ "Everest 1969 Malaysia", 6377296, 0.006637847],
+        [ "Everest Pakistan", 6377296, 0.006637534],
+        [ "Indonesian 1974", 6378160, 0.006694609],
+      ]
+      data.each do |item|
+        el = Ellipsoid.new *item
+        result[normalize_name(el.name)] = el
+      end
+      result
+    end
+
+    List = Ellipsoid::generate_list
+  end
+
+end

data/lib/geoutm/latlon.rb

@@ -0,0 +1,136 @@
+require 'geoutm/constants'
+require 'geoutm/ellipsoid'
+require 'geoutm/utm'
+
+module GeoUtm
+  class LatLon
+    include Math
+    attr_reader :lat, :lon
+
+    def initialize(lat, lon)
+      throw RuntimeException.new("Invalid longitude #{lon}") unless (-180.0...180.0).member? lon
+      @lat, @lon = lat, lon
+    end
+    
+    def to_s
+      north_south = if @lat >= 0.0 then 'N' else 'S' end
+      east_west = if @lon >= 0.0 then 'E' else 'W' end
+      '%0.6f%s %0.6f%s' % [@lat.abs, north_south, @lon.abs, east_west]
+    end
+
+    def to_utm(ellipsoid = Ellipsoid::lookup(:wgs84), zone = nil)
+      lat_radian = Deg2Rad * @lat
+      long_radian = Deg2Rad * long2
+
+      k0 = 0.9996 # scale
+
+      if zone
+        zn, zl = UTM::split_zone zone
+      else
+        zn = calc_utm_zone_number
+        zl = calc_utm_zone_letter
+      end
+
+      eccentricity = ellipsoid.eccentricity
+      longorigin = (zn - 1) * 6 - 180 + 3
+      longoriginradian = Deg2Rad * longorigin
+      eccentprime = ellipsoid.eccentricity/(1.0-eccentricity)
+
+      n = ellipsoid.radius / sqrt(1 - eccentricity * sin(lat_radian)*sin(lat_radian))
+      t = tan(lat_radian) * tan(lat_radian)
+      c = eccentprime * cos(lat_radian)*cos(lat_radian)
+      a = cos(lat_radian) * (long_radian - longoriginradian)
+      m = ellipsoid.radius * (
+        (1 - eccentricity/4 - 3 * eccentricity * eccentricity/64 - 
+          5 * eccentricity * eccentricity * eccentricity/256) * lat_radian - 
+        (3 * eccentricity/8 + 3 * eccentricity * eccentricity/32 + 
+          45 * eccentricity * eccentricity * eccentricity/1024) * sin(2 * lat_radian) + 
+        (15 * eccentricity * eccentricity/256 +
+          45 * eccentricity * eccentricity * eccentricity/1024) * sin(4 * lat_radian) - 
+        (35 * eccentricity * eccentricity * eccentricity/3072) * sin(6 * lat_radian)
+      )
+
+      utm_easting = k0*n*(a+(1-t+c)*a*a*a/6 + (5-18*t+t*t+72*c-58*eccentprime)*a*a*a*a*a/120) + 500000.0
+
+      utm_northing = k0 * ( m + n*tan(lat_radian) * ( a*a/2+(5-t+9*c+4*c*c)*a*a*a*a/24 + 
+                                   (61-58*t+t*t+600*c-330*eccentprime) * a*a*a*a*a*a/720))
+      utm_northing += 10000000.0 if @lat < 0
+ 
+      UTM.new '%d%s' % [zn, zl], utm_easting, utm_northing, ellipsoid
+    end
+
+    private 
+
+    def calc_utm_zone_letter
+      case @lat
+        when 72.0..84.0
+          'X'
+        when 64.0..72.0
+          'W'
+        when 56.0..64.0
+          'V'
+        when 48.0..56.0
+          'U'
+        when 40.0..48.0
+          'T'
+        when 32.0..40.0
+          'S'
+        when 24.0..32.0
+          'R'
+        when 16.0..24.0
+          'Q'
+        when 8.0..16.0
+          'P'
+        when 0.0..8.0
+          'N'
+        when -8.0..0.0
+          'M'
+        when -16.0..-8.0
+          'L'
+        when -24.0..-16.0
+          'K'
+        when -32.0..-24.0
+          'J'
+        when -40.0..-32.0
+          'H'
+        when -48.0..-40.0
+          'G'
+        when -56.0..-48.0
+          'F'
+        when -64.0..-56.0
+          'E'
+        when -72.0..-64.0
+          'D'
+        when -80.0..-72.0
+          'C'
+        else
+          throw RuntimeException.new("Latitude #{@lat} out of UTM range")
+        end
+    end
+
+    def long2
+      @lon - ((@lon + 180)/360).to_i * 360
+    end
+
+    def calc_utm_zone_number
+      zone = ((long2 + 180)/6).to_i + 1;
+      if (56.0..64.0).member?(@lat) && (3.0..12.0).member?(long2)
+        zone = 32
+      end
+
+      if (72.0..84.0).member? @lat
+        case long2
+           when 0.0..9.0
+             zone = 31
+           when 9.0..21.0
+             zone = 33
+           when 21.0..33.0
+             zone = 35
+           when 33.0..42.0
+             zone = 37
+         end
+      end
+      zone
+    end
+  end
+end

data/lib/geoutm/utm.rb

@@ -0,0 +1,86 @@
+require 'geoutm/constants'
+require 'geoutm/ellipsoid'
+require 'geoutm/latlon'
+
+module GeoUtm
+  class UTM
+    include Math
+
+    attr_reader :n, :e, :zone, :zone_number, :zone_letter, :ellipsoid
+
+    def initialize(zone, e, n, ellipsoid = Ellipsoid::lookup(:wgs84))
+      @n, @e, @zone, @ellipsoid = n, e, zone, ellipsoid
+      @zone_number, @zone_letter = UTM::split_zone @zone
+    end
+
+    def to_s
+      '%s %.2f %.2f' % [zone, e, n]
+    end
+
+    def to_lat_lon
+      k0 = 0.9996
+      x  = @e - 500000 # Remove Longitude offset
+      y  = @n
+
+      # Set hemisphere (1=Northern, 0=Southern)
+      y    -= 10000000.0 unless northern_hemisphere?
+
+      longorigin = (@zone_number - 1)*6 - 180 + 3
+      ecc = @ellipsoid.eccentricity
+      eccPrimeSquared = (ecc)/(1-ecc)
+      m  = y / k0
+      mu = m / (@ellipsoid.radius * (1 - ecc / 4 - 3 * ecc ** 2 / 64 - 5 * ecc ** 3 / 256))
+      e1 = (1 - sqrt(1 - ecc)) / (1 + sqrt(1 - ecc))
+      phi1rad = mu +
+        (3 * e1 / 2 - 27 * e1 ** 3 / 32) * sin(2 * mu) +
+        (21 * e1 ** 2 / 16 - 55 * e1 ** 4 / 32) * sin(4 * mu) +
+        (151 * e1 ** 3 / 96) * sin(6 * mu)
+      phi1 = phi1rad * Rad2Deg
+      n1 = @ellipsoid.radius / sqrt(1 - ecc * sin(phi1rad) ** 2)
+      t1 = tan(phi1rad) ** 2
+      c1 = ecc * cos(phi1rad)**2
+      r1 = @ellipsoid.radius * (1 - ecc) / ((1 - ecc * sin(phi1rad) ** 2) ** 1.5)
+      d = x / (n1 * k0)
+      latitude = phi1rad-
+        (n1 * tan(phi1rad) / r1) * (d * d / 2 - 
+                                    (5 + 3 * t1 + 10 * c1 - 4 * c1 * c1 - 9 * eccPrimeSquared) * d ** 4 / 24 +
+                                    (61 + 90 * t1 + 298 * c1 + 45 * t1 * t1 - 
+                                     252 * eccPrimeSquared - 3 * c1 * c1) * d ** 6 / 720)
+      latitude = latitude * Rad2Deg
+      longitude = (d - (1 + 2 * t1 + c1) * d ** 3 / 6 +
+                   (5 - 2 * c1 + 28 * t1 - 3 * c1 * c1 + 8 * eccPrimeSquared +
+                    24 * t1 * t1) * d ** 5 / 120) / cos(phi1rad)
+      longitude = longorigin + longitude * Rad2Deg
+      LatLon.new latitude, longitude
+    end
+
+    def distance_to(other)
+      if other.class == LatLon
+        other = other.to_utm(@ellipsoid, @zone)
+      end
+      unless other.zone == @zone
+        throw RuntimeError.new('Cannot calc distance for points in different zones - convert first')
+      end
+      sqrt((@n - other.n) ** 2.0 + (@e - other.e) ** 2.0) 
+    end
+
+    def UTM.split_zone(zone_in)      
+      m = zone_in.match /^(\d+)([CDEFGHJKLMNPQRSTUVWX])$/
+      throw RuntimeError.new('Illegal zone: ' + zone_in) unless m
+      zn, zl = m[1].to_i, m[2]
+      throw RuntimeError.new('Illegal zone: ' + zone_in) unless (1..60).member? zn
+      return zn, zl
+    end
+
+    def UTM.validate_zone(zone_in)
+      UTM::split_zone zone_in # throw exception
+      true
+    end
+
+    private
+
+    def northern_hemisphere?
+      @zone_letter.match /[NPQRSTUVWX]/
+    end
+  end
+end

data/lib/geoutm.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'geoutm/utm'
+require 'geoutm/latlon'
+
+module GeoUtm
+  VERSION = '0.0.4'
+end

data/spec/ellipsoid_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+module GeoUtm
+  # http://rspec.info/
+  describe Ellipsoid do
+    before :each do
+      @wgs84 = Ellipsoid::lookup('WGS-84')
+    end
+
+    it 'should perform lookup with different case' do
+      Ellipsoid::lookup('Wgs-84').should be(@wgs84)
+      Ellipsoid::lookup('wgs-84').should be(@wgs84)
+    end
+
+    it 'should perform lookup ignoring space and -' do
+      Ellipsoid::lookup('WGS84').should be(@wgs84)
+      Ellipsoid::lookup('wGS 84').should be(@wgs84)
+    end
+
+    it 'should lookup with symbol names' do
+      Ellipsoid::lookup(:wgs84).should be(@wgs84)
+    end
+  end
+end

data/spec/geoutm_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+require 'yaml'
+
+module GeoUtm
+  # http://rspec.info/
+  describe GeoUtm do
+    before :each do
+      @testdata = nil
+      File.open(File.join(File.dirname(__FILE__), 'testdata.yaml')) {|f| @testdata = YAML::load f }
+    end
+    
+    it "should return an ellipsoid for every test sample" do
+      @testdata.each do |sample|
+        Ellipsoid::lookup(sample[:ellipsoid]).should be_a_kind_of(Ellipsoid)
+      end
+    end
+    
+    it "should convert from lat/lon to UTM" do
+      @testdata.each do |sample|
+        latlon = LatLon.new sample[:latitude].to_f, sample[:longitude].to_f
+        utm = latlon.to_utm Ellipsoid::lookup(sample[:ellipsoid])
+        utm.n.should be_close(sample[:northing].to_f, 0.01)
+        utm.e.should be_close(sample[:easting].to_f, 0.01)
+        utm.zone.should == sample[:zone]
+      end
+    end
+
+    it "should convert from UTM to lat/lon" do
+      @testdata.each do |sample|
+        utm = UTM.new sample[:zone], sample[:easting].to_f, sample[:northing].to_f, 
+          Ellipsoid::lookup(sample[:ellipsoid])
+        latlon = utm.to_lat_lon
+        latlon.lat.should be_close(sample[:latitude].to_f, 0.01)
+        latlon.lon.should be_close(sample[:longitude].to_f, 0.01)
+      end
+    end
+  end
+end

data/spec/latlon_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+module GeoUtm
+  # http://rspec.info/
+  describe LatLon do
+    before :each do
+      # some random points
+      @p1 = LatLon.new -25.9668774017417, 176.847283481794
+      @p2 = LatLon.new 62.6643472980663, -18.1318011641218
+    end
+
+    it 'should format as string' do
+      @p1.to_s.should == '25.966877S 176.847283E'
+      @p2.to_s.should == '62.664347N 18.131801W'
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'geoutm'