geodesic_wgs84 1.32.1

data/ext/geodesic_wgs84/geodesic_wgs84.c

@@ -0,0 +1,192 @@
+/*
+ * Ruby wrapper code for geodesic functions
+ *
+ * Copyright (c) 2014 Volker Wiegand <volker.wiegand@cvw.de>
+ */
+
+#include <ruby.h>
+#include "geodesic.h"
+
+
+static VALUE cWGS84;
+static struct geod_geodesic g;
+
+
+static VALUE
+wgs84_init(VALUE klass)
+{
+  double a = 6378137, f = 1/298.257223563; /* WGS84 */
+
+  geod_init(&g, a, f);
+
+  return klass;
+}
+
+
+static double
+wgs84_get_value(VALUE arg)
+{
+  char buf[64];
+  int dd, mm, ss, ff;
+  double dbl;
+
+  if (TYPE(arg) == T_FLOAT)
+    return NUM2DBL(arg);
+
+  if (TYPE(arg) == T_FIXNUM)
+    return (double) NUM2INT(arg);
+
+  if (TYPE(arg) == T_STRING && RSTRING_LEN(arg) < 60) {
+    memset(buf, 0, sizeof(buf));
+    memcpy(buf, RSTRING_PTR(arg), RSTRING_LEN(arg));
+
+    if (sscanf(buf, "%d.%d.%d,%d", &dd, &mm, &ss, &ff) == 4) {
+      // Round number to 6 digits
+      dbl = ((double) dd + ((((double) mm * 600.0) + ((double) ss * 10.0) + (double) ff) / 36000.0)) * 1000000.0;
+      return round(dbl) / 1000000.0;
+    }
+
+    if (sscanf(buf, "%d.%d", &dd, &ff) == 2) {
+      sscanf(buf, "%lf", &dbl);
+      return dbl;
+    }
+
+    if (sscanf(buf, "%d,%d", &dd, &ff) == 2) {
+      *strchr(buf, ',') = '.';
+      sscanf(buf, "%lf", &dbl);
+      return dbl;
+    }
+  }
+
+  rb_raise(rb_eArgError, "invalid (lat/lon) argument");
+}
+
+
+static VALUE
+wgs84_lat_lon(int argc, VALUE *argv, VALUE klass)
+{
+  double lat, lon;
+  VALUE tmp;
+
+  if (argc == 2) {
+    lat = wgs84_get_value(argv[0]);
+    lon = wgs84_get_value(argv[1]);
+    return rb_ary_new3(2L, rb_float_new(lat), rb_float_new(lon));
+  }
+
+  if (argc == 1 && TYPE(*argv) == T_ARRAY && RARRAY_LEN(*argv) == 2) {
+    lat = wgs84_get_value(rb_ary_entry(*argv, 0));
+    lon = wgs84_get_value(rb_ary_entry(*argv, 1));
+    return rb_ary_new3(2L, rb_float_new(lat), rb_float_new(lon));
+  }
+
+  if (argc == 1 && !NIL_P(tmp = rb_check_array_type(*argv))) {
+    lat = wgs84_get_value(rb_ary_entry(tmp, 0));
+    lon = wgs84_get_value(rb_ary_entry(tmp, 1));
+    return rb_ary_new3(2L, rb_float_new(lat), rb_float_new(lon));
+  }
+
+  rb_raise(rb_eArgError, "wrong number of arguments");
+  return Qnil;
+}
+
+
+static VALUE
+wgs84_distance(int argc, VALUE *argv, VALUE klass)
+{
+  int i;
+  double dbl[4], azi1, azi2, s12;
+  VALUE tmp1, tmp2;
+
+  if (argc == 4) {
+    for (i = 0; i < 4; i++)
+      dbl[i] = wgs84_get_value(argv[i]);
+    geod_inverse(&g, dbl[0], dbl[1], dbl[2], dbl[3], &s12, &azi1, &azi2);
+    return rb_ary_new3(2L, INT2NUM((int) round(s12)), INT2NUM((int) azi1));
+  }
+
+  if (argc == 1 && TYPE(*argv) == T_ARRAY && RARRAY_LEN(*argv) == 4) {
+    for (i = 0; i < 4; i++)
+      dbl[i] = wgs84_get_value(rb_ary_entry(*argv, i));
+    geod_inverse(&g, dbl[0], dbl[1], dbl[2], dbl[3], &s12, &azi1, &azi2);
+    return rb_ary_new3(2L, INT2NUM((int) round(s12)), INT2NUM((int) azi1));
+  }
+
+  if (argc == 2) {
+    tmp1 = rb_check_array_type(argv[0]);
+    tmp2 = rb_check_array_type(argv[1]);
+    if (!NIL_P(tmp1) && !NIL_P(tmp2)) {
+      dbl[0] = wgs84_get_value(rb_ary_entry(tmp1, 0));
+      dbl[1] = wgs84_get_value(rb_ary_entry(tmp1, 1));
+      dbl[2] = wgs84_get_value(rb_ary_entry(tmp2, 0));
+      dbl[3] = wgs84_get_value(rb_ary_entry(tmp2, 1));
+      geod_inverse(&g, dbl[0], dbl[1], dbl[2], dbl[3], &s12, &azi1, &azi2);
+      return rb_ary_new3(2L, INT2NUM((int) round(s12)), INT2NUM((int) azi1));
+    }
+  }
+
+  if (argc == 1 && TYPE(*argv) == T_ARRAY && RARRAY_LEN(*argv) == 2) {
+    tmp1 = rb_check_array_type(rb_ary_entry(*argv, 0));
+    tmp2 = rb_check_array_type(rb_ary_entry(*argv, 1));
+    if (!NIL_P(tmp1) && !NIL_P(tmp2)) {
+      dbl[0] = wgs84_get_value(rb_ary_entry(tmp1, 0));
+      dbl[1] = wgs84_get_value(rb_ary_entry(tmp1, 1));
+      dbl[2] = wgs84_get_value(rb_ary_entry(tmp2, 0));
+      dbl[3] = wgs84_get_value(rb_ary_entry(tmp2, 1));
+      geod_inverse(&g, dbl[0], dbl[1], dbl[2], dbl[3], &s12, &azi1, &azi2);
+      return rb_ary_new3(2L, INT2NUM((int) round(s12)), INT2NUM((int) azi1));
+    }
+  }
+
+  rb_raise(rb_eArgError, "wrong number of arguments");
+  return Qnil;
+}
+
+
+static VALUE
+wgs84_average(VALUE klass, VALUE array, VALUE target)
+{
+  VALUE tmp, arr_val;
+  double dst_lat, dst_lon, arr_lat, arr_lon, azi1, azi2, s12;
+  double arr_min = 0.0, arr_max = 0.0, arr_sum = 0.0;
+  int cnt, arr_azi = 0;
+
+  tmp = rb_check_array_type(target);
+  if (NIL_P(tmp))
+    rb_raise(rb_eArgError, "invalid (target) argument");
+  dst_lat = wgs84_get_value(rb_ary_entry(tmp, 0));
+  dst_lon = wgs84_get_value(rb_ary_entry(tmp, 1));
+
+  arr_val = rb_check_convert_type(array, T_ARRAY, "Array", "to_a");
+  for (cnt = 0; cnt < RARRAY_LEN(arr_val); cnt++) {
+    tmp = rb_check_array_type(rb_ary_entry(arr_val, cnt));
+    if (NIL_P(tmp))
+      rb_raise(rb_eArgError, "invalid (array) argument");
+    arr_lat = wgs84_get_value(rb_ary_entry(tmp, 0));
+    arr_lon = wgs84_get_value(rb_ary_entry(tmp, 1));
+    geod_inverse(&g, arr_lat, arr_lon, dst_lat, dst_lon, &s12, &azi1, &azi2);
+    s12 = round(s12);
+    if (arr_min == 0.0 || s12 < arr_min)
+      arr_min = s12;
+    if (arr_max == 0.0 || s12 > arr_max)
+      arr_max = s12;
+    arr_sum += s12;
+    arr_azi += (int) azi1;
+  }
+  s12  = round(round(arr_sum / (double) cnt) / 1000.0);
+  azi1 = round(round((arr_min + arr_max) / 2.0) / 1000.0);
+
+  return rb_ary_new3(3L, INT2NUM((int) s12), INT2NUM((int) azi1), INT2NUM(arr_azi / cnt));
+}
+
+
+void
+Init_geodesic_wgs84(void)
+{
+  cWGS84 = rb_define_class("Wgs84", rb_cObject);
+  rb_define_method(cWGS84, "initialize", wgs84_init,      0);
+  rb_define_method(cWGS84, "lat_lon",    wgs84_lat_lon,  -1);
+  rb_define_method(cWGS84, "distance",   wgs84_distance, -1);
+  rb_define_method(cWGS84, "average",    wgs84_average,   2);
+}
+

data/geodesic_wgs84.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geodesic_wgs84/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "geodesic_wgs84"
+  spec.version       = GeodesicWgs84::VERSION
+  spec.date          = "2014-03-06"
+  spec.authors       = ["Volker Wiegand"]
+  spec.email         = ["volker.wiegand@cvw.de"]
+  spec.summary       = "Calculate distances on Earth using WGS84"
+  spec.description   = "Geodesic functions based on http://geographiclib.sourceforge.net/"
+  spec.homepage      = "http://github.com/volkerwiegand/geodesic_wgs84"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.1"
+
+  spec.extensions    = %w[ext/geodesic_wgs84/extconf.rb]
+end

data/lib/geodesic_wgs84/version.rb

@@ -0,0 +1,3 @@
+module GeodesicWgs84
+  VERSION = "1.32.1"
+end

data/lib/geodesic_wgs84.rb

@@ -0,0 +1,9 @@
+require "geodesic_wgs84/version"
+
+module GeodesicWgs84
+  def self.hi
+    puts "Hello from geodesic_wgs84"
+  end
+end
+
+require "geodesic_wgs84/geodesic_wgs84"

data/spec/geodesic_wgs84_spec.rb

@@ -0,0 +1,25 @@
+require 'minitest/autorun'
+require 'geodesic_wgs84'
+
+class TestGeodesicWgs84 < MiniTest::Test
+  def setup
+    @wgs84 = Wgs84.new
+  end
+
+  def test_lat_lon_two_doubles
+    assert_equal [1.0, 2.0], @wgs84.lat_lon(1.0, 2.0)
+  end
+
+  def test_lat_lon_array_of_doubles
+    assert_equal [3.5, 4.123], @wgs84.lat_lon([3.5, 4.123])
+  end
+
+  def test_lat_lon_array_of_strings
+    assert_equal [3.5, 4.123], @wgs84.lat_lon(["3.5", "4.123"])
+  end
+
+  def test_lat_lon_doubles_with_comma
+    assert_equal [1.0, 2.0], @wgs84.lat_lon("1,0", "2,0")
+  end
+end
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: geodesic_wgs84
+version: !ruby/object:Gem::Version
+  version: 1.32.1
+platform: ruby
+authors:
+- Volker Wiegand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+description: Geodesic functions based on http://geographiclib.sourceforge.net/
+email:
+- volker.wiegand@cvw.de
+executables: []
+extensions:
+- ext/geodesic_wgs84/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- ext/geodesic_wgs84/extconf.rb
+- ext/geodesic_wgs84/geodesic.c
+- ext/geodesic_wgs84/geodesic.h
+- ext/geodesic_wgs84/geodesic_wgs84.c
+- geodesic_wgs84.gemspec
+- lib/geodesic_wgs84.rb
+- lib/geodesic_wgs84/version.rb
+- spec/geodesic_wgs84_spec.rb
+homepage: http://github.com/volkerwiegand/geodesic_wgs84
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Calculate distances on Earth using WGS84
+test_files:
+- spec/geodesic_wgs84_spec.rb