geoprojection 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8560b474f5efac958d7e5296dae0fc6c122d9fc6ea605a8ae406101717a46d06
-  data.tar.gz: 66c955de7126b71538d6d019ad43d767cbed22719929b631bbd0987420070d96
+  metadata.gz: f5ed2077814688af2c2731b2c9a6d9320d112b7a08d7f77e983038f43492fdb8
+  data.tar.gz: 9fa634a0b969585b9d18a302b586912e6fe679fdf6e1bb1d1cced4d705d3aa6f
 SHA512:
-  metadata.gz: efee6e93050df75436a04773199c6721fcfd8b39f979ecbc8092df3717ba5b88086e0351ebf5a8def6b21e0adbaf991002a33748f473134cb7e95361ffea4809
-  data.tar.gz: 720fa6125c7ac803473e0c604c37ca6829ba68ca89bcb539821d5b660e7c81828c72f01726e1c21307b63552bb36e05477c4fc973999583e2e19629fd086631e
+  metadata.gz: aea7ad9252cfbfc652f9b8c9d2b7295e6e1b7f6ecb72748326a06dac21896b633e94e2f7aee49eeee1117d7819c852770ba881805ec19894ee684eb34a68c7b6
+  data.tar.gz: e2cf4b75a12eea14e1d40b83a279fb67294fb25449c5fc137b3c582e3e1668a4dd7c4962805b381a5d2ad19dda64d0136a18dea6cf852efc36d015e8352840ff

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    geoprojection (0.1.1)
+    geoprojection (0.1.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,6 +1,6 @@
 # Geoprojection
 
-Toolkit for translating distances (kilometers) from co-ordinates (latitude, longitude) onto geographically-precise (within reason) projections.
+Toolkit for translating distances (kilometers) from co-ordinates (latitude, longitude) onto geographically-precise (within reason) projections and calculating distances between pairs of co-ordinates.
 
 ## Installation
 
@@ -21,12 +21,30 @@ Provide a center point (latitude, longitude) and a distance (kilometers) to calc
 The default number of points is `36`. This can be overridden with the `points` parameter to `Geoprojection::Ellipse.new`.
 
 ```ruby
-ellipse = Geoprojection::Ellipse.new(latitude: 50.8169, longitude: 0.1367, distance: 10, points: 36)
+ellipse = Geoprojection::Ellipse.new(latitude: 50.8169, longitude: 0.1367, distance: 10, points: 6)
 ellipse.points
+
+# => [[0.2788814046153052, 50.8169], [0.20779070230765262, 50.968049947019516], [0.0656092976923474, 50.968049947019516], [-0.0054814046153052465, 50.8169], [0.0656092976923473, 50.66575005298048], [0.20779070230765262, 50.66575005298048], [0.2788814046153052, 50.8169]]
 ```
 
 The actual returned points will be N+1, as the start and end point are identical to provide a complete polygon.
 
+### Distance
+
+Calculate the [Vincenty distance](https://en.wikipedia.org/wiki/Vincenty%27s_formulae) between two pairs of co-ordinates (latitude, longitude) in miles or kilometers:
+
+```ruby
+distance = Geoprojection::Distance.new(
+  { latitude: 50.8169, longitude: 0.1367 },
+  { latitude: 51.2341, longitude: 1.4231 }
+)
+
+distance.kilometers
+# => 148.2691075520691
+distance.miles
+# => 92.13012362873673
+```
+
 ## Contributing
 
 Make changes, run `make test`, create a pull request.

data/lib/geoprojection/distance.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Geoprojection
+  # Vincenty distance calculation for a pair of latitude/longitude co-ordinates.
+  class Distance
+    # rubocop:disable Metrics/AbcSize
+    def initialize(point1, point2)
+      @latitude1 = degrees_to_radians(point1.fetch(:latitude))
+      @longitude1 = degrees_to_radians(point1.fetch(:longitude))
+      @latitude2 = degrees_to_radians(point2.fetch(:latitude))
+      @longitude2 = degrees_to_radians(point2.fetch(:longitude))
+      @tan_geo_latitude1 = (1 - FLATTENING) * Math.tan(@longitude1)
+      @tan_geo_latitude2 = (1 - FLATTENING) * Math.tan(@longitude2)
+      @cos_geo_latitude1 = 1 / Math.sqrt(1 + (@tan_geo_latitude1**2))
+      @cos_geo_latitude2 = 1 / Math.sqrt(1 + (@tan_geo_latitude2**2))
+      @sin_geo_latitude1 = @tan_geo_latitude1 * @cos_geo_latitude1
+      @sin_geo_latitude2 = @tan_geo_latitude2 * @cos_geo_latitude2
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def miles
+      meters * METERS_PER_MILE
+    end
+
+    def kilometers
+      meters / 1000.0
+    end
+
+    def meters
+      distance(*computed_variables)
+    end
+
+    private
+
+    def degrees_to_radians(val)
+      val * DEGREES_PER_RADIAN
+    end
+
+    def distance(theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m)
+      r_square = reduced_square(cos_sq_alpha)
+      vertex_b = r_square / 1024 * (256 + (r_square * (-128 + (r_square * (74 - (47 * r_square))))))
+      WGS84_MINOR_AXIS * vertex_a(r_square) * (theta - delta_theta(vertex_b, sin_theta, cos2_theta_m, cos_theta))
+    end
+
+    def reduced_square(cos_sq_alpha)
+      cos_sq_alpha * ((WGS84_MAJOR_AXIS**2) - (WGS84_MINOR_AXIS**2)) / (WGS84_MINOR_AXIS**2)
+    end
+
+    def vertex_a(r_square)
+      1 + (r_square / 16_384 * (4096 + (r_square * (-768 + (r_square * (320 - (175 * r_square)))))))
+    end
+
+    def sine_theta(lambda1)
+      Math.sqrt(
+        ((@cos_geo_latitude2 * Math.sin(lambda1))**2) +
+        (((@cos_geo_latitude1 * @sin_geo_latitude2) -
+        (@sin_geo_latitude1 * @cos_geo_latitude2 * Math.cos(lambda1)))**2)
+      )
+    end
+
+    def delta_theta(vertex_b, sin_theta, cos2_theta_m, cos_theta)
+      vertex_b * sin_theta * (
+        delta_theta1(cos2_theta_m, vertex_b, cos_theta) +
+        delta_theta2(cos2_theta_m, vertex_b) +
+        delta_theta3(sin_theta, cos2_theta_m)
+      )
+    end
+
+    def delta_theta1(cos2_theta_m, vertex_b, cos_theta)
+      cos2_theta_m + ((vertex_b / 4 * cos_theta * -1))
+    end
+
+    def delta_theta2(cos2_theta_m, vertex_b)
+      (2 * (cos2_theta_m**2)) - ((vertex_b / 6 * cos2_theta_m * -3))
+    end
+
+    def delta_theta3(sin_theta, cos2_theta_m)
+      (4 * (sin_theta**2) * -3) + (4 * (cos2_theta_m**2))
+    end
+
+    def computed_variables
+      lambda1 = latitude_distance
+
+      precision = VINCENTY_PRECISION * 2
+
+      while precision > VINCENTY_PRECISION
+        theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m, lambda1, precision = iteration_variables(lambda1)
+      end
+      [theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m]
+    end
+
+    def iteration_variables(lambda1)
+      sin_theta = sine_theta(lambda1)
+      cos_theta = calculated_cos_theta(lambda1)
+      theta = Math.atan2(sin_theta, cos_theta)
+      sin_alpha = @cos_geo_latitude1 * @cos_geo_latitude2 * Math.sin(lambda1) / sin_theta
+      cos_sq_alpha = 1 - (sin_alpha**2)
+      cos2_theta_m = calculated_cos2_theta_m(cos_theta, cos_sq_alpha)
+      lambda2 = iteration_lambda(sin_alpha, theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m)
+      [theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m, lambda2, (lambda2 - lambda1).abs]
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+    def iteration_lambda(sin_alpha, theta, sin_theta, cos_theta, cos_sq_alpha, cos2_theta_m)
+      c = calculated_c(cos_sq_alpha)
+      latitude_distance + (
+        (1 - c) * FLATTENING * sin_alpha *
+        (theta + (c * sin_theta * (cos2_theta_m + c + ((cos_theta * -1) + (2 * (cos2_theta_m**2))))))
+      )
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def calculated_cos_theta(lambda_)
+      (@sin_geo_latitude1 * @sin_geo_latitude2) + (@cos_geo_latitude1 * @cos_geo_latitude2 * Math.cos(lambda_))
+    end
+
+    def calculated_c(cos_sq_alpha)
+      (FLATTENING / 16) * cos_sq_alpha * (4 + (FLATTENING * (4 - (3 * cos_sq_alpha))))
+    end
+
+    def calculated_cos2_theta_m(cos_theta, cos_sq_alpha)
+      cos_theta - (2 * @sin_geo_latitude1 * @sin_geo_latitude2 / cos_sq_alpha)
+    end
+
+    def latitude_distance
+      @latitude_distance ||= @latitude2 - @latitude1
+    end
+  end
+end

data/lib/geoprojection/ellipse.rb

@@ -3,10 +3,6 @@
 module Geoprojection
   # Elliptical projection of a center point (lat, long) with a provided distance from the center.
   class Ellipse
-    DEGREES_PER_RADIAN = Math::PI / 180
-    EQUATOR_KM_PER_LATITUDE_RADIAN = 110.567 * DEGREES_PER_RADIAN
-    EQUATOR_KM_PER_LONGITUDE_RADIAN = 111.321 * DEGREES_PER_RADIAN
-
     def initialize(latitude:, longitude:, distance:, points: 36)
       @latitude = latitude
       @longitude = longitude

data/lib/geoprojection/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geoprojection
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/geoprojection.rb

@@ -1,8 +1,18 @@
 # frozen_string_literal: true
 
 require_relative 'geoprojection/version'
+require_relative 'geoprojection/distance'
 require_relative 'geoprojection/ellipse'
 
 module Geoprojection
   class Error < StandardError; end
+
+  DEGREES_PER_RADIAN = Math::PI / 180
+  EQUATOR_KM_PER_LATITUDE_RADIAN = 110.567 * DEGREES_PER_RADIAN
+  EQUATOR_KM_PER_LONGITUDE_RADIAN = 111.321 * DEGREES_PER_RADIAN
+  METERS_PER_MILE = 0.000621371
+  WGS84_MAJOR_AXIS = 6_378_137.0
+  WGS84_MINOR_AXIS = 6_356_752.314245
+  FLATTENING = (WGS84_MAJOR_AXIS - WGS84_MINOR_AXIS) / WGS84_MAJOR_AXIS
+  VINCENTY_PRECISION = 1e-12
 end

data/test.js

@@ -0,0 +1,50 @@
+const λ1 = 51.8169 * (Math.PI / 180);
+const λ2 = 50.8169 * (Math.PI / 180);
+const φ1 = -0.1367 * (Math.PI / 180);
+const φ2 = -0.4367 * (Math.PI / 180);
+const a = 6378137;
+const b = 6356752.314245;
+// const f = 1 / 298.257223563;
+const f = (a - b) / a;
+const L = λ2 - λ1; // L = difference in longitude, U = reduced latitude, defined by tan U = (1-f)·tanφ.
+const tanU1 = (1-f) * Math.tan(φ1), cosU1 = 1 / Math.sqrt((1 + tanU1*tanU1)), sinU1 = tanU1 * cosU1;
+const tanU2 = (1-f) * Math.tan(φ2), cosU2 = 1 / Math.sqrt((1 + tanU2*tanU2)), sinU2 = tanU2 * cosU2;
+
+let λ = L, sinλ = null, cosλ = null;    // λ = difference in longitude on an auxiliary sphere
+let σ = null, sinσ = null, cosσ = null; // σ = angular distance P₁ P₂ on the sphere
+let cos2σₘ = null;                      // σₘ = angular distance on the sphere from the equator to the midpoint of the line
+let cosSqα = null;                      // α = azimuth of the geodesic at the equator
+
+let λʹ = null;
+do {
+    console.log(λ);
+    sinλ = Math.sin(λ);
+    cosλ = Math.cos(λ);
+    console.log(sinλ);
+    console.log(cosλ);
+    console.log((cosU2*sinλ) * (cosU2*sinλ))
+    console.log((cosU1*sinU2-sinU1*cosU2*cosλ)**2);
+    const sinSqσ = (cosU2*sinλ) * (cosU2*sinλ) + (cosU1*sinU2-sinU1*cosU2*cosλ)**2;
+    sinσ = Math.sqrt(sinSqσ);
+    cosσ = sinU1*sinU2 + cosU1*cosU2*cosλ;
+    σ = Math.atan2(sinσ, cosσ);
+    const sinα = cosU1 * cosU2 * sinλ / sinσ;
+    cosSqα = 1 - sinα*sinα;
+    cos2σₘ = cosσ - 2*sinU1*sinU2/cosSqα;
+    const C = f/16*cosSqα*(4+f*(4-3*cosSqα));
+    λʹ = λ;
+    λ = L + (1-C) * f * sinα * (σ + C*sinσ*(cos2σₘ+C*cosσ*(-1+2*cos2σₘ*cos2σₘ)));
+} while (Math.abs(λ-λʹ) > 1e-12);
+
+const uSq = cosSqα * (a*a - b*b) / (b*b);
+const A = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)));
+const B = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)));
+const Δσ = B*sinσ*(cos2σₘ+B/4*(cosσ*(-1+2*cos2σₘ*cos2σₘ)-B/6*cos2σₘ*(-3+4*sinσ*sinσ)*(-3+4*cos2σₘ*cos2σₘ)));
+
+const s = b*A*(σ-Δσ); // s = length of the geodesic
+
+console.log(s);
+const α1 = Math.atan2(cosU2*sinλ,  cosU1*sinU2-sinU1*cosU2*cosλ); // initial bearing
+const α2 = Math.atan2(cosU1*sinλ, -sinU1*cosU2+cosU1*sinU2*cosλ); // final bearin
+console.log(α1)
+console.log(α2 * (Math.PI / 180))

data/test2.js

@@ -0,0 +1,17 @@
+const lat1 = 50.8169;
+const lat2 = 51.8169;
+const lon1 = -0.1367;
+const lon2 = -0.4367;
+const R = 6371e3; // metres
+const φ1 = lat1 * Math.PI/180; // φ, λ in radians
+const φ2 = lat2 * Math.PI/180;
+const Δφ = (lat2-lat1) * Math.PI/180;
+const Δλ = (lon2-lon1) * Math.PI/180;
+
+const a = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
+          Math.cos(φ1) * Math.cos(φ2) *
+          Math.sin(Δλ/2) * Math.sin(Δλ/2);
+const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+
+const d = R * c;
+console.log(d);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geoprojection
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Bob Farrell
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-11 00:00:00.000000000 Z
+date: 2022-06-06 00:00:00.000000000 Z
 dependencies: []
 description: Write a longer description or delete this line.
 email:
@@ -27,10 +27,13 @@ files:
 - Rakefile
 - doc/example.rb
 - lib/geoprojection.rb
+- lib/geoprojection/distance.rb
 - lib/geoprojection/ellipse.rb
 - lib/geoprojection/version.rb
 - sig/geoprojection.rbs
+- test.js
 - test.rb
+- test2.js
 homepage: https://github.com/bobf/geoprojection
 licenses: []
 metadata: