osgb_convert 0.0.4

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in osgb_convert.gemspec
+gemspec

data/README

@@ -0,0 +1,44 @@
+Some UK Ordnance Survey coordinate conversions in pure Ruby.
+
+WGS84 lat/lons -> OSGB36 lat/lons-> OS Eastings & Northings 
+
+A tidied-into-a-module-and-gem tweak of Harry Wood's port of Chris Veness' 
+http://www.movable-type.co.uk/scripts/latlong-convert-coords.html
+
+
+Originally ported to Ruby by Harry Wood:
+http://www.harrywood.co.uk/blog/2010/06/29/ruby-code-for-converting-to-uk-ordnance-survey-coordinate-systems-from-wgs84/
+
+(c) Chris Veness 2005-2010, (c) Harry Wood 2010-2011
+Teeny portions (c) Matt Patterson 2011
+
+Released under an LGPL license
+http://www.fsf.org/licensing/licenses/lgpl.html
+
+
+Examples:
+
+WGS84 lat/lon:
+
+lon = -0.10322
+lat = 51.52237
+height = 0
+
+wgs84_point = OsgbConvert::WGS84.new(lat, lon, height)
+
+
+osgb36_point = wgs84_point.osgb36
+
+osUKgridPoint = OsgbConvert::OSGrid.from_osgb36(osgb36_point)
+# alternatively
+osUKgridPoint = OsgbConvert::OSGrid.from_wgs84(wgs84_point)
+easting  = osUKgridPoint.easting
+northing = osUKgridPoint.northing
+
+gridrefLetters = osUKgridPoint.grid_ref(8) # 8 is also the default so osUKgridPoint.grid_ref would work just as well
+
+puts "wgs84 lat: #{wgs84_point.lat}, wgs84 lon: #{wgs84_point.long}"
+puts "http://www.openstreetmap.org/?mlat=#{wgs84_point.lat}&mlon=#{wgs84_point.long}&zoom=16"
+puts "osgb36 lat: #{osgb36_point.lat}, osgb36 lon: #{osgb36_point.long}"
+puts "easting: #{osUKgridPoint.easting}, northing: #{osUKgridPoint.northing}. As a grid ref: #{osUKgridPoint.grid_ref}"
+puts "http://streetmap.co.uk/grid/#{osUKgridPoint.easting}_#{osUKgridPoint.northing}_106"

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/osgb_convert.rb

@@ -0,0 +1,108 @@
+module OsgbConvert
+  def self.degrees_to_rads(degrees)
+    degrees * Math::PI / 180
+  end
+
+  def self.rads_to_degrees(rads)
+    rads * 180 / Math::PI 
+  end
+
+  module Converter
+    #ellipse parameters
+    ELLIPSE = { 
+      :wgs84 =>    { :a=> 6378137,     :b=> 6356752.3142, :f=> 1 / 298.257223563 },
+      :airy1830 => { :a=> 6377563.396, :b=> 6356256.910,  :f=> 1 / 299.3249646   } 
+    }
+
+    #helmert transform parameters
+    HELMERT = { 
+      :wgs84toOSGB36 => { 
+        :tx=> -446.448,  :ty=>  125.157,  :tz=> -542.060,  # m
+        :rx=>  -0.1502,  :ry=>   -0.2470, :rz=>  -0.8421,  # sec
+        :s=>   20.4894                                     # ppm
+      },
+      :osgb36toWGS84 => { 
+        :tx=>  446.448,  :ty=> -125.157,  :tz=>  542.060,
+        :rx=>    0.1502, :ry=>    0.2470, :rz=>    0.8421,
+        :s=>   -20.4894
+      }
+    }
+
+    def convert(p1lat, p1lon, p1height, e1, t, e2)
+       # -- convert polar to cartesian coordinates (using ellipse 1)
+
+       p1lat = OsgbConvert.degrees_to_rads(p1lat); p1lon = OsgbConvert.degrees_to_rads(p1lon); 
+
+       a = e1[:a]; b = e1[:b];
+
+       sinPhi = Math.sin(p1lat); cosPhi = Math.cos(p1lat);
+       sinLambda = Math.sin(p1lon); cosLambda = Math.cos(p1lon);
+       h = p1height;
+
+       eSq = (a*a - b*b) / (a*a);
+       nu = a / Math.sqrt(1 - eSq*sinPhi*sinPhi);
+
+       x1 = (nu+h) * cosPhi * cosLambda;
+       y1 = (nu+h) * cosPhi * sinLambda;
+       z1 = ((1-eSq)*nu + h) * sinPhi;
+
+       # -- apply helmert transform using appropriate params
+
+       tx = t[:tx]; ty = t[:ty]; tz = t[:tz];
+       rx = t[:rx] / 3600 * Math::PI/180;  #normalise seconds to radians
+       ry = t[:ry] / 3600 * Math::PI/180;
+       rz = t[:rz] / 3600 * Math::PI/180;
+       s1 = t[:s] / 1e6 + 1;              #normalise ppm to (s+1)
+
+       #apply transform
+       x2 = tx + x1*s1 - y1*rz + z1*ry;
+       y2 = ty + x1*rz + y1*s1 - z1*rx;
+       z2 = tz - x1*ry + y1*rx + z1*s1;
+
+       # -- convert cartesian to polar coordinates (using ellipse 2)
+
+       a = e2[:a]; b = e2[:b];
+       precision = 4 / a;  # results accurate to around 4 metres
+
+       eSq = (a*a - b*b) / (a*a);
+       p = Math.sqrt(x2*x2 + y2*y2);
+       phi = Math.atan2(z2, p*(1-eSq)); phiP = 2 * Math::PI;
+       while ( (phi-phiP).abs > precision) do
+          nu = a / Math.sqrt(1 - eSq*Math.sin(phi)*Math.sin(phi));
+          phiP = phi;
+          phi = Math.atan2(z2 + eSq*nu*Math.sin(phi), p);
+       end
+       lambda = Math.atan2(y2, x2);
+       h = p/Math.cos(phi) - nu;
+
+       #return array [lat,lon,height]
+       return [ OsgbConvert.rads_to_degrees(phi), OsgbConvert.rads_to_degrees(lambda), h ]; 
+    end
+  end
+  
+  class Coordinate
+    include Converter
+    
+    attr_reader :lat, :long, :height
+    
+    def initialize(lat, long, height)
+      @lat = lat
+      @long = long
+      @height = height
+    end
+  end
+  
+  class WGS84 < Coordinate
+    def osgb36
+      OSGB36.new(*convert(lat, long, height, ELLIPSE[:wgs84], HELMERT[:wgs84toOSGB36], ELLIPSE[:airy1830]))
+    end
+  end
+  
+  class OSGB36 < Coordinate
+    def wgs84
+      WGS84.new(*convert(lat, long, height, ELLIPSE[:airy1830], HELMERT[:osgb36toWGS84], ELLIPSE[:wgs84]))
+    end
+  end
+end
+
+require 'osgb_convert/os_grid'

data/lib/osgb_convert/os_grid.rb

@@ -0,0 +1,200 @@
+module OsgbConvert
+  class OSGrid
+    GRID_LETTERS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
+                    'L', 'M', 'N', 'O', 'P', 'Q', 'S', 'T', 'U', 'V', 
+                    'W', 'X', 'Y', 'Z']
+
+    attr_reader :easting, :northing
+
+    def self.from_wgs84(wgs84)
+      from_osgb36(wgs84.osgb36)
+    end
+
+    # http://www.movable-type.co.uk/scripts/latlong-gridref.html
+    # (c) Chris Veness 2005-2010  Released under an LGPL license
+    # http://www.fsf.org/licensing/licenses/lgpl.html
+    # Ported to ruby by Harry Wood
+
+    # OSGB36 coordinates to OS UK grid eastings & northings
+    def self.from_osgb36(osgb36)
+      lat = OsgbConvert.degrees_to_rads(osgb36.lat);
+      lon = OsgbConvert.degrees_to_rads(osgb36.long);
+
+      a = 6377563.396; b = 6356256.910          # Airy 1830 major & minor semi-axes
+      f0 = 0.9996012717                         # NatGrid scale factor on central meridian
+      lat0 = OsgbConvert.degrees_to_rads(49); lon0 = OsgbConvert.degrees_to_rads(-2)        # NatGrid true origin
+      n0 = -100000; e0 = 400000;                # northing & easting of true origin, metres
+      e2 = 1 - (b*b) / (a*a);                   # eccentricity squared
+      n = (a-b) / (a+b); n2 = n*n; n3 = n*n*n;
+
+      cos_lat = Math.cos(lat); sinLat = Math.sin(lat);
+      nu = a*f0/Math.sqrt(1-e2*sinLat*sinLat);              # transverse radius of curvature
+      rho = a*f0*(1-e2) / ( (1-e2*sinLat*sinLat) ** 1.5);  # meridional radius of curvature
+      eta2 = nu/rho-1;
+
+      ma = (1 + n + (5/4)*n2 + (5/4)*n3) * (lat-lat0);
+      mb = (3*n + 3*n*n + (21/8)*n3) * Math.sin(lat-lat0) * Math.cos(lat+lat0);
+      mc = ((15/8)*n2 + (15/8)*n3) * Math.sin(2*(lat-lat0)) * Math.cos(2*(lat+lat0));
+      md = (35/24)*n3 * Math.sin(3*(lat-lat0)) * Math.cos(3*(lat+lat0));
+      m = b * f0 * (ma - mb + mc - md)              # meridional arc
+
+      cos3lat = cos_lat*cos_lat*cos_lat
+      cos5lat = cos3lat*cos_lat*cos_lat
+      tan2lat = Math.tan(lat)*Math.tan(lat);
+      tan4lat = tan2lat*tan2lat;
+
+      i = m + n0
+      ii = (nu/2)*sinLat*cos_lat;
+      iii = (nu/24)*sinLat*cos3lat*(5-tan2lat+9*eta2);
+      iiiA = (nu/720)*sinLat*cos5lat*(61-58*tan2lat+tan4lat);
+      iv = nu*cos_lat;
+      v = (nu/6)*cos3lat*(nu/rho-tan2lat);
+      vi = (nu/120) * cos5lat * (5 - 18*tan2lat + tan4lat + 14*eta2 - 58*tan2lat*eta2);
+
+      dLon = lon-lon0;
+      dLon2 = dLon*dLon
+      dLon3 = dLon2*dLon
+      dLon4 = dLon3*dLon
+      dLon5 = dLon4*dLon
+      dLon6 = dLon5*dLon
+
+      n = i + ii*dLon2 + iii*dLon4 + iiiA*dLon6;
+      e = e0 + iv*dLon + v*dLon3 + vi*dLon5;
+
+      new(e, n) # return new OSGrid instance using the raw easting and northings
+    end
+
+    # convert standard grid reference ('SU387148') to fully numeric ref ([438700,114800])
+    # returned co-ordinates are in metres, centred on grid square for conversion to lat/long
+    # 
+    # note that northern-most grid squares will give 7-digit northings
+    # no error-checking is done on gridref (bad input will give bad results or NaN)
+    def self.from_standard_ref(grid_ref)
+      # get numeric values of letter references, mapping A->0, B->1, C->2, etc:
+      first_letter  = GRID_LETTERS.index(grid_ref[0..0].upcase)
+      second_letter = GRID_LETTERS.index(grid_ref[1..1].upcase)
+
+      # convert grid letters into 100km-square indexes from false origin (grid square SV):
+      easting  = ((first_letter - 2) % 5) * 5 + (second_letter % 5)
+      northing = (19 - (first_letter / 5).floor * 5) - (second_letter / 5).floor
+
+      # skip grid letters to get numeric part of ref, stripping any spaces:
+      numeric_ref = grid_ref[2..-1].gsub(/\s/, '')
+
+      # append numeric part of references to grid index:
+      easting  += numeric_ref[0..(numeric_ref.length / 2)]
+      northing += numeric_ref[(numeric_ref.length / 2)..-1]
+
+      # normalise to 1m grid, rounding up to centre of grid square:
+      case numeric_ref.length
+      when 6
+        easting  += '50'
+        northing += '50'
+      when 8
+        easting  += '5'
+        northing += '5'
+      end
+      # 10-digit refs are already 1m
+
+      new(e, n)
+    end
+
+    def initialize(easting, northing)
+      @easting = easting
+      @northing = northing
+    end
+
+    #
+    # convert OS grid reference to geodesic co-ordinates
+    #
+    def osgb36
+      # Airy 1830 major & minor semi-axes
+      a = Converter::ELLIPSE[:airy1830][:a]
+      b = Converter::ELLIPSE[:airy1830][:b]
+      f0 = 0.9996012717;                      # NatGrid scale factor on central meridian
+      lat0 = 49 * Math::PI / 180              # NatGrid true origin
+      lon0 = -2 * Math::PI / 180
+      n0 = -100000                            # northing of true origin, metres
+      e0 = 400000                             # easting of true origin, metres
+      e2 = 1 - (b * b) / (a * a)              # eccentricity squared
+      n = (a - b) / (a + b)
+      n2 = n * n 
+      n3 = n * n * n
+
+      lat = lat0
+      m = 0
+
+      while (northing - n0 - m) >= 0.00001 # ie until < 0.01mm
+        lat = (northing - n0 - m) / (a * f0) + lat
+
+        ma = (1 + n + ((5 / 4) * n2) + ((5 / 4) * n3)) * (lat - lat0)
+        mb = (3 * n + 3 * n * n + (21 / 8) * n3) * Math.sin(lat - lat0) * Math.cos(lat + lat0)
+        mc = ((15 / 8) * n2 + (15 / 8) * n3) * Math.sin(2 * (lat - lat0)) * Math.cos(2 * (lat + lat0))
+        md = (35 / 24) * n3 * Math.sin(3 * (lat - lat0)) * Math.cos(3 * (lat + lat0))
+        m = b * f0 * (ma - mb + mc - md) # meridional arc
+      end
+
+      cos_lat = Math.cos(lat)
+      sin_lat = Math.sin(lat)
+      nu = a * f0 / Math.sqrt(1 - e2 * sin_lat * sin_lat)           # transverse radius of curvature
+      rho = a * f0 * (1 - e2) / (1 - e2 * sin_lat * sin_lat) ** 1.5 # meridional radius of curvature
+      eta2 = nu / rho - 1
+
+      tan_lat = Math.tan(lat)
+      tan2lat = tan_lat*tan_lat
+      tan4lat = tan2lat*tan2lat
+      tan6lat = tan4lat*tan2lat
+      sec_lat = 1/cos_lat
+      nu3 = nu*nu*nu
+      nu5 = nu3*nu*nu
+      nu7 = nu5*nu*nu
+      vii = tan_lat/(2*rho*nu)
+      viii = tan_lat/(24*rho*nu3)*(5+3*tan2lat+eta2-9*tan2lat*eta2)
+      ix = tan_lat/(720*rho*nu5)*(61+90*tan2lat+45*tan4lat)
+      x = sec_lat/nu
+      xi = sec_lat/(6*nu3)*(nu/rho+2*tan2lat)
+      xii = sec_lat/(120*nu5)*(5+28*tan2lat+24*tan4lat)
+      xiia = sec_lat/(5040*nu7)*(61+662*tan2lat+1320*tan4lat+720*tan6lat)
+
+      dE = (easting - e0)
+      dE2 = dE*dE
+      dE3 = dE2*dE
+      dE4 = dE2*dE2
+      dE5 = dE3*dE2
+      dE6 = dE4*dE2
+      dE7 = dE5*dE2
+      lat = OsgbConvert.rads_to_degrees(lat - vii*dE2 + viii*dE4 - ix*dE6)
+      lon = OsgbConvert.rads_to_degrees(lon0 + x*dE - xi*dE3 + xii*dE5 - xiia*dE7)
+      
+      OSGB36.new(lat, lon, 0)
+    end
+
+    def wgs84
+      osgb36.wgs84
+    end
+
+    # convert numeric grid reference (in metres) to standard-form grid ref
+    # [defaults to 8 digits (because this was in the example, not because I know better)]
+    def grid_ref(digits = 8)
+      return @grid_ref if @grid_ref
+      #get the 100km-grid indices
+      e100k = (easting / 100000).floor
+      n100k = (northing / 100000).floor
+
+      return '' if (e100k < 0 or e100k > 6 or n100k < 0 or n100k > 12)
+
+      #translate those into numeric equivalents of the grid letters
+      first_letter  = (19 - n100k) - (19 - n100k) % 5 + ((e100k + 10) / 5).floor;
+      second_letter = (19 - n100k) * 5 % 25 + e100k % 5;
+
+      # letter - 1 to ensure we have 0-indexed the array and aren't off-by-one
+      grid_name =  GRID_LETTERS[first_letter - 1] + GRID_LETTERS[second_letter - 1]
+
+      # strip 100km-grid indices from easting & northing, and reduce precision
+      reduced_precision_easting = ( (easting  % 100000) / (10 ** (5 - digits / 2)) ).floor
+      reduced_precision_northing = ( (northing % 100000) / (10 ** (5 - digits / 2)) ).floor
+
+      @grid_ref = grid_name + reduced_precision_easting.to_s.rjust(digits / 2) + reduced_precision_northing.to_s.rjust(digits / 2)
+    end
+  end
+end

data/lib/osgb_convert/version.rb

@@ -0,0 +1,3 @@
+module OsgbConvert
+  VERSION = "0.0.4"
+end

data/osgb_convert.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "osgb_convert/version"
+
+Gem::Specification.new do |s|
+  s.name        = "osgb_convert"
+  s.version     = OsgbConvert::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Matt Patterson"]
+  s.email       = ["matt@reprocessed.org"]
+  s.homepage    = "http://github.com/fidothe/osgb_convert"
+  s.summary     = %q{Geo coordinate transformation between WGS84 (GPS) and OSGB36 (UK Ordnance Survey mapping)}
+  s.description = %q{Provides a simple interface to transform Geographic coordinates between WGS84 (GPS) and OSGB36 (UK Ordnance Survey mapping)}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: osgb_convert
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Matt Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-03 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Provides a simple interface to transform Geographic coordinates between WGS84 (GPS) and OSGB36 (UK Ordnance Survey mapping)
+email: 
+- matt@reprocessed.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/osgb_convert.rb
+- lib/osgb_convert/os_grid.rb
+- lib/osgb_convert/version.rb
+- osgb_convert.gemspec
+has_rdoc: true
+homepage: http://github.com/fidothe/osgb_convert
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Geo coordinate transformation between WGS84 (GPS) and OSGB36 (UK Ordnance Survey mapping)
+test_files: []
+