simple-proj 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e3c3bb3834d7d494e1e0dc220c5ca30e6a9387e0cfea7a30223535ad44e6ec9
+  data.tar.gz: 96148f842f3f3334424705f1256acbd46699cbe3a11f4c492033f371967a7b70
+SHA512:
+  metadata.gz: 9359cd9bf7da8619a17d04ad615e713e70c89ccf56bf44f1f967b9324343481294de4dc5ba707a277f380784862cffce79dcb91d2bc466b75b0d938fb14fb4bb
+  data.tar.gz: e384f056f0a3a919dbc5e2d63d441a2c1222eff579583a442bbd327c974de1afcad4f4c2a88899f8b101268fb318b72edef5d32b99b49a3f65aa93b51c8550d4

data/API.md

@@ -0,0 +1,111 @@
+PROJ4R
+=======
+
+Notes for the forward or inverse transformations
+
+    Proj
+      forward : (lon, lat) -> (x, y)
+      inverse : (x, y) -> (lon, lat)
+    
+    Proj.transform 
+      forward : (src, dst, x, y, z) -> (x', y', z')
+      inverse : (dst, src, x, y, z) -> (x', y', z')
+    
+        If src = latlong, dst = projection, they work like Proj#forward, Proj#inverse.
+        In the cases, use lon as x, lat as y.
+    
+    Geod
+      forward : (lat1, lon1, az12, dist) -> (lat2, lon2, az21)
+      inverse : (lat1, lon1, lat2, lon2) -> (dist, az12, az21)
+
+Notes for the order of geographic coordinate (lon,lat) or (lat,lon)
+
+    PROJ4::Proj     -> (lon, lat) 
+    PROJ4.transform -> (lon, lat) 
+    PROJ4::Geod     -> (lat, lon) 
+
+These differences originate from Proj.4 C API.
+
+Proj
+----
+
+### Constructor
+
+    pj = PROJ4::Proj.new("+proj=latlon +ellps=WGS84 units=km")
+
+### Attributes
+
+    pj.definition
+    pj.latlong?
+    pj.geocent?
+
+### Replication
+
+    pj.to_latlong
+
+### forward
+
+    x, y = pj.forward(lon, lat)
+    
+### inverse
+
+    lon, lat = *pj.inverse(x, y)
+
+p pj.to_latlong.definition
+
+Transformation
+--------------
+
+
+Geod
+----
+
+### Constructor
+
+    geod = PROJ4::Geod.new()                           ### [+ellps=WGS84, units=m]
+    geod = PROJ4::Geod.new(6378137.0, 1/298.257223563) ### [+ellps=WGS84, units=m]
+    geod = PROJ4::Geod.new("+ellps=WGS84 units=m")
+
+### forward
+
+    lat2, lon2, az21 = *geod.forward(lat1, lon1, az12, dist)
+    
+    input: 
+      lat1: latitude of original point in degree
+      lon1: longitudde of original point in degree
+      az12: azimuth point to target point at origninal point in degree
+      dist: distance from original point to target point in units defined in constructor
+    
+    output: 
+      lat2: latitude of target point in degree
+      lon1: longitude of target point in degree
+      az21: azimuth point to original point at target point in degree
+
+### inverse
+
+    dist, az12, az21 = *geod.inverse(lat1, lon1, lat2, lon2)
+     
+    input:
+      lat1: latitude of original point in degree
+      lon1: longitude of original point in degree
+      lat2: latitude of target point in degree
+      lon2: longitude of target point in degree
+     
+    output: 
+      dist: distance between original and target points in units defined in constructor 
+      az12: azimuth point to target point at origninal point in degree
+      az21: azimuth point to original point at target point in degree
+
+### distance
+ 
+    dist = *geod.distance(lat1, lon1, lat2, lon2)
+    
+    input:
+      lat1: latitude of original point in degree
+      lon1: longitude of original point in degree
+      lat2: latitude of target point in degree
+      lon2: longitude of target point in degree
+    
+    output: 
+      dist: distance between original and target points in units defined in constructor 
+  

data/README.md

@@ -0,0 +1,120 @@
+Simple PROJ
+===========
+
+This is a ruby extension library for map projection conversion using PROJ.
+Note that this library is not a verbatim wrapper for all functions in PROJ.
+
+Installation
+------------
+
+    gem install simple-proj
+
+### Requirement
+
+* PROJ version 6 or 7
+
+Features
+--------
+
+* Conversion of latitude and longitude to map projection coordinates (forward transformation)
+* Conversion of map projection coordinates to latitude and longitude (inverse transformation)
+* Transformation a map projection coordinate to another map projection coordinate
+
+
+Usage
+-----
+
+### Constructor
+
+    PROJ.new(PROJ_STRING)  ### transform defined by proj-string
+    PROJ.new(CRS1, CRS2)   ### transform from CRS1 to CRS2
+    PROJ.new(CRS2)         ### CRS1 is assumed to be "+proj=latlong +type=crs"
+
+The arguments should be String objects one of 
+
+* a proj-string,
+* a WKT string,
+* an object code (like 'EPSG:4326', 'urn:ogc:def:crs:EPSG::4326', 
+  'urn:ogc:def:coordinateOperation:EPSG::1671'),
+* a OGC URN combining references for compound coordinate reference 
+  systems (e.g 'urn:ogc:def:crs,crs:EPSG::2393,crs:EPSG::5717' or 
+  custom abbreviated syntax 'EPSG:2393+5717'),
+* a OGC URN combining references for concatenated operations (e.g. 
+  'urn:ogc:def:coordinateOperation,coordinateOperation:EPSG::3895,
+  coordinateOperation:EPSG::1618')
+
+### Transformation
+
+Forward transformation.
+
+    PROJ#transform(x1, y1, z1=nil)  =>  x2, y2[, z2]
+    PROJ#transform_forward(x1, y1, z1=nil)  =>  x2, y2[, z2]   ### alias of #transform
+
+Inverse transformation.
+
+    PROJ#transform_inverse(x1, y1, z1=nil)  =>  x2, y2[, z2]
+
+
+### Special methods for transformation from geodetic coordinates and other coordinates.
+
+These are special methods provided to avoid converting 
+between latitude and longitude units between degrees and radians.
+
+    PROJ#forward(lon1, lat1, z1=nil)        =>  x2, y2[, z2]
+    PROJ#inverse(x1, y1, z1=nil)            =>  lon2, lat2[, z2]
+
+The units of input parameters for PROJ#forward are degrees.
+Internally, these units are converted to radians and passed to proj_trans().
+Similarly, the units of output parameters for PROJ#inverse are degrees.
+
+```ruby
+proj = PROJ.new("+proj=webmerc")
+
+x, y = proj.forward(135, 35)
+p [x, y]     ### => [15028131.257091932, 4163881.144064294]
+
+lon, lat = proj.inverse(x, y)
+p [lon, lat] ### => [135.0, 35.000000000000014]
+
+```
+
+Note: 
+This method should not be used for the PROJ object initialized with the proj-string that do not expect geodetic coordinates in radians for the source CRS. In such case, use  #transform_forward and #transform_inverse instead of #forward and #inverse. 
+This is an example for *invalid* usage. 
+
+```ruby
+pj = PROJ.new("+proj=unitconvert +xy_in=deg +xy_out=rad")
+
+p pj.forward(135, 35)    ### does not work as expected
+# => [0.041123351671205656, 0.0106616096925348]
+
+p pj.transform(135, 35)  ### works as expected
+# => [2.356194490192345, 0.6108652381980153]
+```
+
+Examples
+--------
+
+### Conversion between 'EPSG:4326' and 'EPSG:3857'
+
+For EPSG:4326 (in PROJ), the geographic coordinates are in the order of latitude and longitude.
+Then, the transformation from EPSG:4326 requires the arguments in the order of latitude and longitude.
+
+```ruby
+#########################################
+# EPSG:4326 <-> EPSG:3857
+#########################################
+
+proj = PROJ.new("EPSG:4326", "EPSG:3857")
+
+x, y = proj.transform(35, 135)
+
+p [x, y]     ### => [15028131.257091932, 4163881.144064294]
+
+lat, lon = proj.transform_inverse(x, y)
+
+p [lat, lon] ### => [35.00000000000001, 135.0]
+```
+
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+GEMSPEC = "simple-proj.gemspec"
+
+task :install do
+  spec = eval File.read(GEMSPEC)
+  system %{
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+  }
+end

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+require 'carray/mkmf'
+require "open-uri"
+
+dir_config("proj", possible_includes, possible_libs)
+
+if have_header("proj.h") and have_library("proj")
+  have_carray()
+  create_makefile("simple_proj")
+end
+
+

data/ext/rb_proj.c

@@ -0,0 +1,832 @@
+#include "ruby.h"
+#include "rb_proj.h"
+
+VALUE rb_cProj;
+VALUE rb_cCrs;
+VALUE rb_mCommon;
+
+ID id_forward;
+ID id_inverse;
+
+static VALUE
+rb_proj_info (VALUE klass)
+{
+  volatile VALUE vout;
+  PJ_INFO info;
+
+  info = proj_info();
+
+  vout = rb_hash_new();
+  rb_hash_aset(vout, rb_str_new2("major"), INT2NUM(info.major));
+  rb_hash_aset(vout, rb_str_new2("minor"), INT2NUM(info.minor));
+  rb_hash_aset(vout, rb_str_new2("patch"), INT2NUM(info.patch));
+  rb_hash_aset(vout, rb_str_new2("release"), rb_str_new2(info.release));
+  rb_hash_aset(vout, rb_str_new2("version"), rb_str_new2(info.version));
+  rb_hash_aset(vout, rb_str_new2("searchpath"), rb_str_new2(info.searchpath));
+
+  return vout;
+}
+
+static void 
+free_proj (Proj *proj)
+{
+  if ( proj->ref ) {
+    proj_destroy(proj->ref);
+  }
+  free(proj);
+}
+
+static VALUE
+rb_proj_s_allocate (VALUE klass)
+{
+  Proj *proj;
+  return Data_Make_Struct(klass, Proj, 0, free_proj, proj);
+}
+
+/*
+Constructs a transformation object with one or two arguments.
+The arguments should be PROJ::CRS objects or String objects one of 
+
+ * a proj-string,
+ * a WKT string,
+ * an object code (like “EPSG:4326”, “urn:ogc:def:crs:EPSG::4326”, 
+   “urn:ogc:def:coordinateOperation:EPSG::1671”),
+ * a OGC URN combining references for compound coordinate reference 
+   systems (e.g “urn:ogc:def:crs,crs:EPSG::2393,crs:EPSG::5717” or 
+   custom abbreviated syntax “EPSG:2393+5717”),
+ * a OGC URN combining references for concatenated operations (e.g. 
+   “urn:ogc:def:coordinateOperation,coordinateOperation:EPSG::3895,
+   coordinateOperation:EPSG::1618”)
+
+If two arguments are given, the first is the source CRS definition and the
+second is the target CRS definition. If only one argument is given, the
+following two cases are possible. 
+
+ * a proj-string, which represents a transformation. 
+ * a CRS defintion, in which case the latlong coordinates are implicitly 
+   used as the source CRS definition.
+ * a PROJ::CRS object
+
+@overload initialize(def1, def2=nil)
+  @param def1 [String] proj-string or other CRS definition (see above description).
+  @param def2 [String, nil] proj-string or other CRS definition (see above description).
+
+@example
+  # Transformation from EPSG:4326 to EPSG:3857
+  pj = PROJ.new("EPSG:4326", "EPSG:3857")
+
+  # Transformation from (lat,lon) to WEB Mercator.
+  pj = PROJ.new("+proj=webmerc")
+
+  # Transformation from (lat,lon) to EPSG:3857
+  pj = PROJ.new("EPSG:3857")
+
+  # Using PROJ::CRS objects
+  epsg_3857 = PROJ::CRS.new("EPSG:3857")
+  pj = PROJ.new(epsg_3857)
+  pj = PROJ.new("EPSG:4326", epsg_3857)
+  pj = PROJ.new(epsg_3857, "EPSG:4326")
+
+*/
+
+static VALUE
+rb_proj_initialize (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vdef1, vdef2;
+  Proj *proj, *crs;
+  PJ *ref, *src;
+  PJ_TYPE type;
+  int errno;
+
+  rb_scan_args(argc, argv, "11", (VALUE *)&vdef1, (VALUE *)&vdef2);
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( NIL_P(vdef2) ) {
+    if ( rb_obj_is_kind_of(vdef1, rb_cCrs) ) {
+      Data_Get_Struct(vdef1, Proj, crs);
+      vdef1 = rb_str_new2(proj_as_proj_string(PJ_DEFAULT_CTX, crs->ref, PJ_PROJ_5, NULL));
+    }
+    else {
+      Check_Type(vdef1, T_STRING);
+    }
+    ref = proj_create(PJ_DEFAULT_CTX, StringValuePtr(vdef1));      
+    if ( proj_is_crs(ref) ) {
+      proj_destroy(ref);
+      ref = proj_create_crs_to_crs(PJ_DEFAULT_CTX, "+proj=latlong +type=crs", StringValuePtr(vdef1), NULL);    
+      proj->ref = ref;
+      proj->is_src_latlong = 2;      
+    }
+    else {
+      proj->ref = ref;
+      proj->is_src_latlong = 1;      
+    }
+  }
+  else {
+    if ( rb_obj_is_kind_of(vdef1, rb_cCrs) ) {
+      Data_Get_Struct(vdef1, Proj, crs);
+      vdef1 = rb_str_new2(proj_as_proj_string(PJ_DEFAULT_CTX, crs->ref, PJ_PROJ_5, NULL));
+    }
+    else {
+      Check_Type(vdef1, T_STRING);
+    }
+    if ( rb_obj_is_kind_of(vdef2, rb_cCrs) ) {
+      Data_Get_Struct(vdef2, Proj, crs);
+      vdef2 = rb_str_new2(proj_as_proj_string(PJ_DEFAULT_CTX, crs->ref, PJ_PROJ_5, NULL));
+    }
+    else {
+      Check_Type(vdef2, T_STRING);
+    }
+    ref = proj_create_crs_to_crs(PJ_DEFAULT_CTX, StringValuePtr(vdef1), StringValuePtr(vdef2), NULL);    
+    proj->ref = ref;
+    src = proj_get_source_crs(PJ_DEFAULT_CTX, ref);
+    type = proj_get_type(src);
+    if ( type == PJ_TYPE_GEOGRAPHIC_2D_CRS ||
+         type == PJ_TYPE_GEOGRAPHIC_3D_CRS ) {
+      proj->is_src_latlong = 2;      
+    }
+    else {
+      proj->is_src_latlong = 0;      
+    }
+  }
+  
+  if ( ! ref ) {
+    errno = proj_context_errno(PJ_DEFAULT_CTX);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+  
+  return Qnil;
+}
+
+/*
+Normalizes the axis order which is the one expected for visualization purposes.
+If the axis order of its source or target CRS is
+northing, easting, then an axis swap operation will be inserted.
+
+@return [self]
+*/
+static VALUE
+rb_proj_normalize_for_visualization (VALUE self)
+{
+  Proj *proj;
+  PJ *ref, *orig;
+  int errno;
+
+  Data_Get_Struct(self, Proj, proj);
+  orig = proj->ref;
+
+  ref = proj_normalize_for_visualization(PJ_DEFAULT_CTX, orig);
+  if ( ! ref ) {
+    errno = proj_context_errno(PJ_DEFAULT_CTX);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+
+  proj->ref = ref;
+
+  proj_destroy(orig);
+    
+  return self;  
+}
+
+/*
+Returns source CRS as PROJ::CRS object.
+
+@return [PROJ, nil]
+*/
+static VALUE
+rb_proj_source_crs (VALUE self)
+{
+  Proj *proj;
+  PJ *crs;
+
+  Data_Get_Struct(self, Proj, proj);
+  crs = proj_get_source_crs(PJ_DEFAULT_CTX, proj->ref);
+
+  if ( ! crs ) {
+    return Qnil;
+  }
+
+  return rb_crs_new(crs);
+}
+
+/*
+Returns target CRS as PROJ::CRS object.
+
+@return [PROJ, nil]
+*/
+static VALUE
+rb_proj_target_crs (VALUE self)
+{
+  Proj *proj;
+  PJ *crs;
+
+  Data_Get_Struct(self, Proj, proj);
+  crs = proj_get_target_crs(PJ_DEFAULT_CTX, proj->ref);
+
+  if ( ! crs ) {
+    return Qnil;
+  }
+  
+  return rb_crs_new(crs);
+}
+
+/*
+Checks if a operation expects input in radians or not.
+
+@return [Boolean]
+*/
+
+static VALUE
+rb_proj_angular_input (VALUE self, VALUE direction)
+{
+  Proj *proj;
+
+  Data_Get_Struct(self, Proj, proj);
+  
+  if ( rb_to_id(direction) == id_forward ) {
+    return proj_angular_input(proj->ref, PJ_FWD) == 1 ? Qtrue : Qfalse;
+  }
+  else if ( rb_to_id(direction) == id_inverse ) {
+    return proj_angular_input(proj->ref, PJ_INV) == 1 ? Qtrue : Qfalse;    
+  }
+  else {
+    rb_raise(rb_eArgError, "invalid direction");
+  }
+}
+
+/*
+Checks if an operation returns output in radians or not.
+
+@return [Boolean]
+*/
+
+static VALUE
+rb_proj_angular_output (VALUE self, VALUE direction)
+{
+  Proj *proj;
+
+  Data_Get_Struct(self, Proj, proj);
+  
+  if ( rb_to_id(direction) == id_forward ) {
+    return proj_angular_output(proj->ref, PJ_FWD) == 1 ? Qtrue : Qfalse;
+  }
+  else if ( rb_to_id(direction) == id_inverse ) {
+    return proj_angular_output(proj->ref, PJ_INV) == 1 ? Qtrue : Qfalse;    
+  }
+  else {
+    rb_raise(rb_eArgError, "invalid direction");
+  }
+}
+
+static VALUE
+rb_proj_pj_info (VALUE self)
+{
+  volatile VALUE vout;
+  Proj *proj;
+  PJ_PROJ_INFO info;
+
+  Data_Get_Struct(self, Proj, proj);
+  info = proj_pj_info(proj->ref);
+
+  vout = rb_hash_new();
+  rb_hash_aset(vout, rb_str_new2("id"), (info.id) ? rb_str_new2(info.id) : Qnil);
+  rb_hash_aset(vout, rb_str_new2("description"), rb_str_new2(info.description));
+  rb_hash_aset(vout, rb_str_new2("definition"), rb_str_new2(info.definition));
+  rb_hash_aset(vout, rb_str_new2("has_inverse"), INT2NUM(info.has_inverse));
+  rb_hash_aset(vout, rb_str_new2("accuracy"), rb_float_new(info.accuracy));
+
+  return vout;
+}
+
+
+static VALUE
+rb_proj_factors (VALUE self, VALUE vlon, VALUE vlat)
+{
+  Proj *proj;
+  PJ_COORD pos;
+  PJ_FACTORS factors;
+  
+  Data_Get_Struct(self, Proj, proj);
+
+  pos.lp.lam = proj_torad(NUM2DBL(vlon));
+  pos.lp.phi = proj_torad(NUM2DBL(vlat));
+  
+  factors = proj_factors(proj->ref, pos);
+
+  return rb_str_new((const char *) &factors, sizeof(PJ_FACTORS));
+}
+
+
+/*
+Transforms coordinates forwardly from (lat1, lon1, z1) to (x1, y2, z2).
+The order of coordinates arguments should be longitude, latitude, and height.
+The input longitude and latitude should be in units 'degrees'.
+
+@overload forward(lon1, lat1, z1 = nil)
+  @param lon1 [Numeric] longitude in degrees.
+  @param lat1 [Numeric] latitude in degrees.
+  @param z1 [Numeric, nil] vertical coordinate.
+
+@return x2, y2[, z2]
+
+@example
+  x2, y2 = pj.forward(lon1, lat1)
+  x2, y2, z2 = pj.forward(lon1, lat1, z1)
+
+*/
+static VALUE
+rb_proj_forward (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vlon, vlat, vz;
+  Proj *proj;
+  PJ_COORD data_in, data_out;
+  int errno;
+
+  rb_scan_args(argc, argv, "21", (VALUE*) &vlon, (VALUE*) &vlat, (VALUE*) &vz);
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( ! proj->is_src_latlong ) {
+    rb_raise(rb_eRuntimeError, "requires latlong src crs. use #transform_forward instead of #forward.");
+  }
+
+  if ( proj_angular_input(proj->ref, PJ_FWD) == 1 ) {
+    data_in.lpz.lam = proj_torad(NUM2DBL(vlon));
+    data_in.lpz.phi = proj_torad(NUM2DBL(vlat));
+    data_in.lpz.z   = NIL_P(vz) ? 0.0 : NUM2DBL(vz);
+  }
+  else {
+    data_in.xyz.x = NUM2DBL(vlon);
+    data_in.xyz.y = NUM2DBL(vlat);
+    data_in.xyz.z = NIL_P(vz) ? 0.0 : NUM2DBL(vz);    
+  }
+
+  data_out = proj_trans(proj->ref, PJ_FWD, data_in);
+
+  if ( data_out.xyz.x == HUGE_VAL ) {
+    errno = proj_context_errno(PJ_DEFAULT_CTX);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+
+  if ( NIL_P(vz) ) {
+    return rb_assoc_new(rb_float_new(data_out.xyz.x), 
+                        rb_float_new(data_out.xyz.y));    
+  } else {
+    return rb_ary_new3(3, rb_float_new(data_out.xyz.x), 
+                          rb_float_new(data_out.xyz.y),
+                          rb_float_new(data_out.xyz.z));        
+  }
+}
+
+/*
+Transforms coordinates inversely from (x1, y1, z1) to (lon2, lat2, z2).
+The order of output coordinates is longitude, latitude and height.
+The returned longitude and latitude are in units 'degrees'.
+
+@overload inverse(x1, y1, z1 = nil)
+  @param x1 [Numeric] 
+  @param y1 [Numeric]
+  @param z1 [Numeric, nil]
+
+@return lon2, lat2, [, z2]
+
+@example
+  lon2, lat2 = pj.inverse(x1, y1)
+  lon2, lat2, z2 = pj.inverse(x1, y1, z1)
+
+*/
+static VALUE
+rb_proj_inverse (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vx, vy, vz;
+  Proj *proj;
+  PJ_COORD data_in, data_out;
+  int errno;
+
+  rb_scan_args(argc, argv, "21", (VALUE *)&vx, (VALUE *)&vy, (VALUE *)&vz);
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( ! proj->is_src_latlong ) {
+    rb_raise(rb_eRuntimeError, "requires latlong src crs. use #transform_inverse instead of #inverse.");
+  }
+
+  data_in.xyz.x = NUM2DBL(vx);
+  data_in.xyz.y = NUM2DBL(vy);
+  data_in.xyz.z = NIL_P(vz) ? 0.0 : NUM2DBL(vz);
+
+  data_out = proj_trans(proj->ref, PJ_INV, data_in);
+
+  if ( data_out.lpz.lam == HUGE_VAL ) {
+    errno = proj_errno(proj->ref);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+
+  if (  proj_angular_output(proj->ref, PJ_INV) == 1 ) {    
+    if ( NIL_P(vz) ) {
+      return rb_assoc_new(rb_float_new(proj_todeg(data_out.lpz.lam)), 
+                          rb_float_new(proj_todeg(data_out.lpz.phi)));
+    } else {
+      return rb_ary_new3(3, rb_float_new(proj_todeg(data_out.lpz.lam)), 
+                            rb_float_new(proj_todeg(data_out.lpz.phi)),
+                            rb_float_new(data_out.lpz.z));
+    }
+  }
+  else {
+    if ( NIL_P(vz) ) {
+      return rb_assoc_new(rb_float_new(data_out.xyz.x), 
+                          rb_float_new(data_out.xyz.y));
+    } else {
+      return rb_ary_new3(3, rb_float_new(data_out.xyz.x), 
+                            rb_float_new(data_out.xyz.y),
+                            rb_float_new(data_out.xyz.z));
+    }    
+  }
+}
+
+static VALUE
+rb_proj_transform_i (int argc, VALUE *argv, VALUE self, PJ_DIRECTION direction)
+{
+  VALUE vx, vy, vz;
+  Proj *trans;
+  PJ_COORD c_in, c_out;
+  int errno;
+
+  rb_scan_args(argc, argv, "21", (VALUE*)&vx, (VALUE*)&vy, (VALUE*)&vz);
+
+  Data_Get_Struct(self, Proj, trans);
+
+  c_in.xyz.x = NUM2DBL(vx);
+  c_in.xyz.y = NUM2DBL(vy);
+  c_in.xyz.z = NIL_P(vz) ? 0.0 : NUM2DBL(vz);      
+
+  c_out = proj_trans(trans->ref, direction, c_in);
+
+  if ( c_out.xyz.x == HUGE_VAL ) {
+    errno = proj_errno(trans->ref);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+  
+  if ( NIL_P(vz) ) {
+    return rb_ary_new3(2, 
+    	     rb_float_new(c_out.xyz.x),
+	         rb_float_new(c_out.xyz.y));      
+  }
+  else {
+    return rb_ary_new3(3, 
+    	     rb_float_new(c_out.xyz.x),
+	         rb_float_new(c_out.xyz.y),
+	         rb_float_new(c_out.xyz.z));
+  }      
+  
+}
+
+/*
+Transforms coordinates forwardly from (x1, y1, z1) to (x1, y2, z2).
+The order of coordinates arguments are according to source and target CRSs.
+
+@overload transform_forward(x1, y1, z1 = nil)
+  @param x1 [Numeric]
+  @param y1 [Numeric]
+  @param z1 [Numeric, nil]
+
+@return x2, y2[, z2] (Numeric)
+
+@example
+  x2, y2 = pj.transform(x1, y1)
+  x2, y2, z2 = pj.transform(x1, y1, z1)
+
+*/
+static VALUE
+rb_proj_transform_forward (int argc, VALUE *argv, VALUE self)
+{
+  return rb_proj_transform_i(argc, argv, self, PJ_FWD);
+}
+
+/*
+Transforms coordinates inversely from (x1, y1, z1) to (x1, y2, z2).
+The order of coordinates arguments are according to source and target CRSs.
+
+@overload transform_inverse(x1, y1, z1 = nil)
+  @param x1 [Numeric]
+  @param y1 [Numeric]
+  @param z1 [Numeric]
+@return x2, y2[, z2] (Numeric)
+
+@example
+  x2, y2 = pj.transform_inverse(x1, y1)
+  x2, y2, z2 = pj.transform_inverse(x1, y1, z1)
+
+*/
+static VALUE
+rb_proj_transform_inverse (int argc, VALUE *argv, VALUE self)
+{
+  return rb_proj_transform_i(argc, argv, self, PJ_INV);
+}
+
+/*
+Constructs a CRS object with an argument.
+The argument should be a String object one of 
+
+ * a proj-string,
+ * a WKT string,
+ * an object code (like “EPSG:4326”, “urn:ogc:def:crs:EPSG::4326”, 
+   “urn:ogc:def:coordinateOperation:EPSG::1671”),
+ * a OGC URN combining references for compound coordinate reference 
+   systems (e.g “urn:ogc:def:crs,crs:EPSG::2393,crs:EPSG::5717” or 
+   custom abbreviated syntax “EPSG:2393+5717”),
+ * a OGC URN combining references for concatenated operations (e.g. 
+   “urn:ogc:def:coordinateOperation,coordinateOperation:EPSG::3895,
+   coordinateOperation:EPSG::1618”)
+
+@overload initialize(definition)
+  @param definition [String] proj-string or other CRS definition (see above description).
+
+@example
+  # Create a PROJ::CRS object
+  epsg_3857 = PROJ::CRS.new("EPSG:3857")
+
+*/
+
+static VALUE
+rb_crs_initialize (VALUE self, VALUE vdef1)
+{
+  Proj *proj;
+  PJ *ref;
+  int errno;
+
+  Data_Get_Struct(self, Proj, proj);
+
+  ref = proj_create(PJ_DEFAULT_CTX, StringValuePtr(vdef1));
+
+  if ( ! ref ) {
+    errno = proj_context_errno(PJ_DEFAULT_CTX);
+    rb_raise(rb_eRuntimeError, "%s", proj_errno_string(errno));
+  }
+
+  if ( proj_is_crs(ref) ) {
+    proj->ref = ref;
+  }
+  else {
+    rb_raise(rb_eRuntimeError, "should be crs definition");
+  }
+    
+  return Qnil;
+}
+
+VALUE 
+rb_crs_new (PJ *ref) 
+{
+  volatile VALUE vcrs;
+  Proj *proj;
+  
+  vcrs = rb_proj_s_allocate(rb_cCrs);
+  Data_Get_Struct(vcrs, Proj, proj);
+  
+  proj->ref = ref;
+  
+  return vcrs;
+}
+
+
+static VALUE
+rb_proj_initialize_copy (VALUE self, VALUE obj)
+{
+  Proj *proj, *other;
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( rb_obj_is_kind_of(obj, rb_cProj) || rb_obj_is_kind_of(obj, rb_cCrs) ) {
+    Data_Get_Struct(obj, Proj, other);
+    proj->ref = proj_clone(PJ_DEFAULT_CTX, other->ref);    
+  }
+  else {
+    rb_raise(rb_eArgError, "invalid class of argument object");
+  }
+
+  return self;
+}
+
+/*
+Gets the name of the object.
+
+@return [String]
+*/
+static VALUE
+rb_proj_get_name (VALUE self)
+{
+  Proj *proj;
+
+  Data_Get_Struct(self, Proj, proj);
+
+  return rb_str_new2(proj_get_name(proj->ref));  
+}
+
+/*
+Gets the authority name / codespace of an identifier of the object.
+
+@overload id_auth_name (index=nil)
+  @param index [Integer] index of the identifier (0 = first identifier)
+
+@return [String, nil]
+*/
+
+static VALUE
+rb_proj_get_id_auth_name (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vidx;
+  Proj *proj;
+  const char *string;
+
+  rb_scan_args(argc, argv, "01", (VALUE *)&vidx);
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( NIL_P(vidx) ) {
+    string = proj_get_id_auth_name(proj->ref, 0);
+  }
+  else {
+    string = proj_get_id_auth_name(proj->ref, NUM2INT(vidx));
+  }
+
+  return (string) ? rb_str_new2(string) : Qnil;
+}
+
+/*
+Gets the code of an identifier of the object.
+
+@overload id_code (index=nil)
+  @param index [Integer] index of the identifier (0 = first identifier)
+
+@return [String, nil]
+*/
+
+static VALUE
+rb_proj_get_id_code (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vidx;
+  Proj *proj;
+  const char *string;
+
+  rb_scan_args(argc, argv, "01", (VALUE *)&vidx);
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( NIL_P(vidx) ) {
+    string = proj_get_id_code(proj->ref, 0);    
+  }
+  else {
+    string = proj_get_id_code(proj->ref, NUM2INT(vidx));        
+  }
+
+  return (string) ? rb_str_new2(string) : Qnil;
+}
+
+/*
+Gets a PROJJSON string representation of the object.
+
+This method may return nil if the object is not compatible 
+with an export to the requested type.
+
+@return [String,nil]
+*/
+static VALUE
+rb_proj_as_projjson (VALUE self)
+{
+  Proj *proj;
+  const char *json;
+
+  Data_Get_Struct(self, Proj, proj);
+  json = proj_as_projjson(PJ_DEFAULT_CTX, proj->ref, NULL);
+  if ( ! json ) {
+    return Qnil;
+  }
+  return rb_str_new2(json);
+}
+
+
+/*
+Gets a PROJ string representation of the object.
+This method may return nil if the object is not compatible with 
+an export to the requested type.
+
+@return [String,nil]
+*/
+static VALUE
+rb_proj_as_proj_string (VALUE self)
+{
+  Proj *proj;
+  const char *string;
+
+  Data_Get_Struct(self, Proj, proj);
+  string = proj_as_proj_string(PJ_DEFAULT_CTX, proj->ref, PJ_PROJ_5, NULL);
+  if ( ! string ) {
+    return Qnil;
+  }
+  return rb_str_new2(string);
+}
+
+static VALUE
+rb_proj_ellipsoid_get_parameters (VALUE self)
+{
+  Proj *proj;
+  PJ *ellps;
+  double a, b, invf;
+  int computed;
+
+  Data_Get_Struct(self, Proj, proj);
+  ellps = proj_get_ellipsoid(PJ_DEFAULT_CTX, proj->ref);
+  proj_ellipsoid_get_parameters(PJ_DEFAULT_CTX, ellps, &a, &b, &computed, &invf);
+  return rb_ary_new3(4,
+                     rb_float_new(a),
+                     rb_float_new(b),
+                     INT2NUM(computed),
+                     rb_float_new(invf));
+}
+
+/*
+Gets a WKT expression of CRS definition of the object.
+
+@return [String]
+*/
+static VALUE
+rb_proj_as_wkt (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE vidx;
+  Proj *proj;
+  const char *wkt;
+
+  rb_scan_args(argc, argv, "01", (VALUE *)&vidx);
+
+  Data_Get_Struct(self, Proj, proj);
+
+  if ( NIL_P(vidx) ) {
+    wkt = proj_as_wkt(PJ_DEFAULT_CTX, proj->ref, PJ_WKT2_2018, NULL);    
+  }
+  else {
+    wkt = proj_as_wkt(PJ_DEFAULT_CTX, proj->ref, NUM2INT(vidx), NULL);        
+  }
+
+  if ( ! wkt ) {
+    return Qnil;
+  }
+  else {
+    return rb_str_new2(wkt);    
+  }
+}
+
+
+void
+Init_simple_proj ()
+{
+  id_forward = rb_intern("forward");
+  id_inverse = rb_intern("inverse");
+
+  rb_cProj = rb_define_class("PROJ", rb_cObject);
+  rb_cCrs = rb_define_class_under(rb_cProj, "CRS", rb_cObject);
+  rb_mCommon = rb_define_module_under(rb_cProj, "Common");
+
+  rb_include_module(rb_cProj, rb_mCommon);
+  rb_include_module(rb_cCrs,  rb_mCommon);
+
+  rb_define_singleton_method(rb_cProj, "_info", rb_proj_info, 0);
+
+  rb_define_alloc_func(rb_cProj, rb_proj_s_allocate);
+  rb_define_method(rb_cProj, "initialize", rb_proj_initialize, -1);
+  rb_define_method(rb_cProj, "source_crs", rb_proj_source_crs, 0);
+  rb_define_method(rb_cProj, "target_crs", rb_proj_target_crs, 0);
+  rb_define_method(rb_cProj, "angular_input?", rb_proj_angular_input, 1);
+  rb_define_method(rb_cProj, "angular_output?", rb_proj_angular_output, 1);
+  rb_define_method(rb_cProj, "normalize_for_visualization", rb_proj_normalize_for_visualization, 0);
+  rb_define_method(rb_cProj, "forward", rb_proj_forward, -1);
+  rb_define_method(rb_cProj, "inverse", rb_proj_inverse, -1);
+  rb_define_method(rb_cProj, "transform", rb_proj_transform_forward, -1);
+  rb_define_method(rb_cProj, "transform_inverse", rb_proj_transform_inverse, -1);
+  rb_define_private_method(rb_cProj, "_pj_info", rb_proj_pj_info, 0);
+  rb_define_private_method(rb_cProj, "_factors", rb_proj_factors, 2);
+  
+  rb_define_alloc_func(rb_cCrs, rb_proj_s_allocate);
+  rb_define_method(rb_cCrs, "initialize", rb_crs_initialize, 1);
+  rb_define_method(rb_cCrs, "normalize_for_visualization", rb_proj_normalize_for_visualization, 0);
+
+  rb_define_method(rb_mCommon, "initialize_copy", rb_proj_initialize_copy, 1);
+  rb_define_method(rb_mCommon, "name", rb_proj_get_name, 0);
+  rb_define_method(rb_mCommon, "id_auth_name", rb_proj_get_id_auth_name, -1);
+  rb_define_method(rb_mCommon, "id_code", rb_proj_get_id_code, -1);
+  rb_define_method(rb_mCommon, "to_proj_string", rb_proj_as_proj_string, 0);
+  rb_define_method(rb_mCommon, "to_projjson", rb_proj_as_projjson, 0);
+  rb_define_method(rb_mCommon, "ellipsoid_parameters", rb_proj_ellipsoid_get_parameters, 0);
+  rb_define_method(rb_mCommon, "to_wkt", rb_proj_as_wkt, -1);
+
+  rb_define_const(rb_cProj, "WKT2_2015", INT2NUM(PJ_WKT2_2015));
+  rb_define_const(rb_cProj, "WKT2_2015_SIMPLIFIED", INT2NUM(PJ_WKT2_2015_SIMPLIFIED));
+#ifdef WKT2_2018
+  rb_define_const(rb_cProj, "WKT2_2018", INT2NUM(PJ_WKT2_2018));
+  rb_define_const(rb_cProj, "WKT2_2018_SIMPLIFIED", INT2NUM(PJ_WKT2_2018_SIMPLIFIED));
+#endif
+#ifdef WKT2_2019
+  rb_define_const(rb_cProj, "WKT2_2019", INT2NUM(PJ_WKT2_2019));
+  rb_define_const(rb_cProj, "WKT2_2019_SIMPLIFIED", INT2NUM(PJ_WKT2_2019_SIMPLIFIED));
+#endif
+  rb_define_const(rb_cProj, "WKT1_GDAL", INT2NUM(PJ_WKT1_GDAL));
+  rb_define_const(rb_cProj, "WKT1_ESRI", INT2NUM(PJ_WKT1_ESRI));
+}

data/ext/rb_proj.h

@@ -0,0 +1,18 @@
+#ifndef RB_PROJ_H
+#define RB_PROJ_H
+
+#include <proj.h>
+
+typedef struct {
+  PJ *ref;
+  int is_src_latlong;
+} Proj;
+
+extern PJ* PJ_DEFAULT_LONGLAT;
+
+extern VALUE rb_cProj;
+extern VALUE rb_cCrs;
+
+VALUE rb_crs_new(PJ *);
+
+#endif

data/lib/simple-proj.rb

@@ -0,0 +1,165 @@
+require 'simple_proj.so'
+require 'json'
+require 'bindata'
+require 'ostruct'
+
+class PROJ
+
+  # Returns PROJ info
+  #
+  # @return [OpenStruct]
+  def self.info
+    return OpenStruct.new(_info)
+  end
+
+  alias transform_forward transform
+  
+  alias forward_lonlat forward
+  
+  # A variant of #forward which accept the axis order as (lat, lon).
+  def forward_latlon (lat, lon, z = nil)
+    return forward(lon, lat, z)
+  end
+
+  alias inverse_lonlat inverse
+  
+  # A variant of #inverse which return the output with the axis order in (lat, lon).
+  def inverse_latlon (x, y, z = nil)
+    return inverse_latlon(x, y, z)
+  end
+
+  # Returns a internal information of the object
+  #
+  # @return [OpenStruct]
+  def pj_info
+    info = _pj_info
+    if info["id"] == "unknown"
+      transform(0,0)
+      info = _pj_info
+      if info["id"] == "unknown"
+        return OpenStruct.new(info)
+      else
+        return pj_info
+      end
+    else
+      info["definition"] = info["definition"].strip.split(/\s+/).map{|s| "+"+s}.join(" ")
+      return OpenStruct.new(info)
+    end
+  end
+
+  # Returns a definition of the object
+  #
+  # @return [OpenStruct]
+  def definition
+    return pj_info.definition
+  end
+
+  ENDIAN = ( [1].pack("I") == [1].pack("N") ) ? :big : :little
+  
+  # A class represents PJ_FACTORS structure defined using BinData::Record
+  # 
+  # This structure has members, 
+  # 
+  # * meridional_scale
+  # * parallel_scale
+  # * areal_scale
+  # * angular_distortion
+  # * meridian_parallel_angle
+  # * meridian_convergence
+  # * tissot_semimajor
+  # * tissot_semiminor
+  # * dx_dlam
+  # * dx_dphi
+  # * dy_dlam
+  # * dy_dphi
+  #
+  class FACTORS < BinData::Record
+    endian ENDIAN
+    double :meridional_scale
+    double :parallel_scale
+    double :areal_scale
+    double :angular_distortion
+    double :meridian_parallel_angle
+    double :meridian_convergence
+    double :tissot_semimajor
+    double :tissot_semiminor
+    double :dx_dlam
+    double :dx_dphi
+    double :dy_dlam
+    double :dy_dphi
+  end
+
+  # Returns PROJ::FACTORS object
+  #
+  # @retrun [PROJ::FACTORS]
+  def factors (lon, lat)
+    return FACTORS.read(_factors(lon, lat))
+  end
+
+end
+
+class PROJ
+  
+  module Common
+
+    # Gets a EPSG code of the object
+    #
+    # @return [String, nil]
+    def to_epsg_code
+      auth = id_auth_name
+      code = id_code
+      if auth and code
+        return auth + ":" + code
+      else
+        return nil
+      end
+    end
+
+    # Gets a Hash object parsed from the PROJJSON expression of the object 
+    #
+    # @return [Hash, nil]
+    def to_projjson_as_hash
+      json = to_projjson
+      if json
+        return JSON.parse(json)
+      else
+        return nil
+      end      
+    end
+
+    def to_wkt2_2015
+      return to_wkt(WKT2_2015)
+    end
+
+    def to_wkt2_2015_simplified
+      return to_wkt(WKT2_2015_SIMPLIFIED)
+    end
+
+    def to_wkt2_2018
+      return to_wkt(WKT2_2018)
+    end
+    
+    def to_wkt2_2018_simplified
+      if defined? WKT2_2018_SIMPLIFIED
+        return to_wkt(WKT2_2018_SIMPLIFIED)
+      else
+        raise "WKT2_2018 not defined. Check PROJ version."
+      end
+    end
+
+    def to_wkt_gdal
+      return to_wkt(WKT1_GDAL)
+    end
+
+    def to_wkt_esri
+      return to_wkt(WKT1_ESRI)
+    end
+ 
+  end
+
+end
+
+begin
+  require "simple-proj-carray"
+rescue LoadError
+end

data/simple-proj.gemspec

@@ -0,0 +1,25 @@
+
+Gem::Specification::new do |s|
+  version = "1.0.0"
+
+  files = Dir.glob("**/*") - [ 
+                               Dir.glob("simple-proj-*.gem"), 
+                               Dir.glob("doc/**/*"), 
+                               Dir.glob("examples/**/*"), 
+                             ].flatten
+
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "simple-proj"
+  s.summary     = "Ruby extension library for PROJ 7"
+  s.description = <<-HERE
+    Ruby extension library for PROJ 7
+  HERE
+  s.version     = version
+  s.license     = 'MIT'
+  s.author      = "Hiroki Motoyoshi"
+  s.email       = ""
+  s.homepage    = 'https://github.com/himotoyoshi/simple-proj'
+  s.files       = files
+  s.extensions  = [ "ext/extconf.rb" ]
+  s.required_ruby_version = ">= 2.4.0"
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: simple-proj
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Hiroki Motoyoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-22 00:00:00.000000000 Z
+dependencies: []
+description: "    Ruby extension library for PROJ 7\n"
+email: ''
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- API.md
+- README.md
+- Rakefile
+- ext/extconf.rb
+- ext/rb_proj.c
+- ext/rb_proj.h
+- lib/simple-proj.rb
+- simple-proj.gemspec
+homepage: https://github.com/himotoyoshi/simple-proj
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby extension library for PROJ 7
+test_files: []