rgeo-proj4 2.0.1 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05e81871744567d55f6b9d11e115954040f5262e9d3317b9792973f1806f655a
-  data.tar.gz: 0a3f2943bf7c80eb4c9d0680b382ab0c9eed83543ef1f4383326e4bdfb6da250
+  metadata.gz: b578b226ebc3b376a92f58cf080d34f237b5929751e6b856e493d9b6a6daa1ae
+  data.tar.gz: 84f4953ac2aea3783e7a807542c7aaf102b265dc454a9de97c340d70f04685c1
 SHA512:
-  metadata.gz: 74ad26d2f7f983b9415b1b301180fe0352a09d4df7425227c2d012220468e147d9b1787c41de2b13f2db9cb5bf9e8a35038beee362393427911854cbff4c49f8
-  data.tar.gz: bcd150775bfa449dad65dd8035f9ceb4e23192dac1f258de2c0b3edf58362e6c48a4b7da7c710bcf3b43de61c92ca64b159f7b6eec2cdaa1ca0cda7a1a1a5ff0
+  metadata.gz: bb2bddfdc101da5c0a4b2af5d5445ce7e57f8d49505b5bb2f53376e81b5ed392d4d2183c11e6cc1e0d86fc5b2fc83cc1afe1d6a3c72fcf8924d779fbd04fdffb
+  data.tar.gz: 3f21328f3beff54191cf496f784a432185f9999d4b71ddeab91d772627f26bbc97deb1882cab9d9f997d16432993d2c742c3d2638005d2f372959428201f4e05

data/ext/proj4_c_impl/extconf.rb

@@ -22,6 +22,7 @@ else
       "/opt/proj/include",
       "/opt/proj4/include",
       "/opt/include",
+      "/opt/homebrew/include",
       "/Library/Frameworks/PROJ.framework/unix/include",
       "/usr/include"
     ]
@@ -36,6 +37,7 @@ else
       "/opt/proj/lib",
       "/opt/proj4/lib",
       "/opt/lib",
+      "/opt/homebrew/lib",
       "/Library/Frameworks/PROJ.framework/unix/lib",
       "/usr/lib",
       "/usr/lib64"
@@ -45,15 +47,19 @@ else
 
   found_proj_ = false
   header_dirs_, lib_dirs_ = dir_config("proj", header_dirs_, lib_dirs_)
-  dflag = "-DACCEPT_USE_OF_DEPRECATED_PROJ_API_H"
-  if have_header("proj_api.h", nil, dflag)
+  if have_header("proj.h")
     $libs << " -lproj"
-    if have_func("pj_init_plus", "proj_api.h", dflag)
+
+    if have_func("proj_create", "proj.h")
       found_proj_ = true
+      have_func("proj_create_crs_to_crs_from_pj", "proj.h")
+      have_func("proj_normalize_for_visualization", "proj.h")
     else
       $libs.gsub!(" -lproj", "")
     end
   end
+  have_func("rb_gc_mark_movable")
+
   unless found_proj_
     puts "**** WARNING: Unable to find Proj headers or Proj version is too old."
     puts "**** Compiling without Proj support."

data/ext/proj4_c_impl/main.c

@@ -1,12 +1,21 @@
 /*
   Main initializer for Proj4 wrapper
 */
-#ifdef HAVE_PROJ_API_H
-#ifdef HAVE_PJ_INIT_PLUS
-#define ACCEPT_USE_OF_DEPRECATED_PROJ_API_H
+#ifdef HAVE_PROJ_H
+#ifdef HAVE_PROJ_CREATE
+#ifdef HAVE_PROJ_CREATE_CRS_TO_CRS_FROM_PJ
+#ifdef HAVE_PROJ_NORMALIZE_FOR_VISUALIZATION
 #define RGEO_PROJ4_SUPPORTED
 #endif
 #endif
+#endif
+#endif
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define mark rb_gc_mark_movable
+#else
+#define mark rb_gc_mark
+#endif
 
 #ifdef __cplusplus
 #define RGEO_BEGIN_C extern "C" {
@@ -20,7 +29,7 @@
 #ifdef RGEO_PROJ4_SUPPORTED
 
 #include <ruby.h>
-#include <proj_api.h>
+#include <proj.h>
 
 #endif
 
@@ -30,78 +39,159 @@ RGEO_BEGIN_C
 
 #ifdef RGEO_PROJ4_SUPPORTED
 
+#if PROJ_VERSION_MAJOR == 6 && PROJ_VERSION_MINOR < 3
+#define WKT_TYPE PJ_WKT2_2018
+#else
+#define WKT_TYPE PJ_WKT2_2019
+#endif
 
 typedef struct {
-  projPJ pj;
+  PJ *pj;
   VALUE original_str;
   char uses_radians;
 } RGeo_Proj4Data;
 
-
-#define RGEO_PROJ4_DATA_PTR(obj) ((RGeo_Proj4Data*)DATA_PTR(obj))
+typedef struct {
+  PJ *crs_to_crs;
+} RGeo_CRSToCRSData;
 
 
 // Destroy function for proj data.
+static void rgeo_proj4_free(void *ptr)
+{
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(data->pj){
+    proj_destroy(data->pj);
+  }
+  free(data);
+}
 
-static void destroy_proj4_func(RGeo_Proj4Data* data)
+// Destroy function for crs_to_crs data.
+static void rgeo_crs_to_crs_free(void *ptr)
 {
-  if (data->pj) {
-    pj_free(data->pj);
+  RGeo_CRSToCRSData *data = (RGeo_CRSToCRSData *)ptr;
+  if(data->crs_to_crs){
+    proj_destroy(data->crs_to_crs);
   }
   free(data);
 }
 
 
-static void mark_proj4_func(RGeo_Proj4Data* data)
+static size_t rgeo_proj4_memsize(const void *ptr)
 {
-  if (!NIL_P(data->original_str)) {
-    rb_gc_mark(data->original_str);
+  size_t size = 0;
+  const RGeo_Proj4Data *data = (const RGeo_Proj4Data *)ptr;
+
+  size += sizeof(*data);
+  if(data->pj){
+    size += sizeof(data->pj);
   }
+  return size;
 }
 
+static size_t rgeo_crs_to_crs_memsize(const void *ptr)
+{
+  size_t size = 0;
+  const RGeo_CRSToCRSData *data = (const RGeo_CRSToCRSData *)ptr;
+  size += sizeof(*data);
+  if(data->crs_to_crs){
+    size += sizeof(data->crs_to_crs);
+  }
+  return size;
+}
+
+static void rgeo_proj4_mark(void *ptr)
+{
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(!NIL_P(data->original_str)){
+    mark(data->original_str);
+  }
+}
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void rgeo_proj4_compact(void *ptr)
+{
+  RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
+  if(data && !NIL_P(data->original_str)){
+    data->original_str = rb_gc_location(data->original_str);
+  }
+}
+#endif
 
-static VALUE alloc_proj4(VALUE klass)
+static void rgeo_proj4_clear_struct(RGeo_Proj4Data *data)
+{
+  if(data->pj){
+    proj_destroy(data->pj);
+    data->pj = NULL;
+    data->original_str = Qnil;
+  }
+}
+
+static const rb_data_type_t rgeo_proj4_data_type = {
+    "RGeo::CoordSys::Proj4",
+    {rgeo_proj4_mark, rgeo_proj4_free, rgeo_proj4_memsize,
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+    rgeo_proj4_compact
+#endif
+    },
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
+static const rb_data_type_t rgeo_crs_to_crs_data_type = {
+    "RGeo::CoordSys::CRSToCRS",
+    {0, rgeo_crs_to_crs_free, rgeo_crs_to_crs_memsize},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE rgeo_proj4_data_alloc(VALUE self)
 {
   VALUE result;
-  RGeo_Proj4Data* data;
+  RGeo_Proj4Data *data = ALLOC(RGeo_Proj4Data);
 
   result = Qnil;
-  data = ALLOC(RGeo_Proj4Data);
-  if (data) {
+
+  if(data){
     data->pj = NULL;
     data->original_str = Qnil;
     data->uses_radians = 0;
-    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+    result = TypedData_Wrap_Struct(self, &rgeo_proj4_data_type, data);
   }
   return result;
 }
 
 
+static VALUE rgeo_crs_to_crs_data_alloc(VALUE self)
+{
+  VALUE result;
+  RGeo_CRSToCRSData *data = ALLOC(RGeo_CRSToCRSData);
+
+  result = Qnil;
+
+  if(data){
+    data->crs_to_crs = NULL;
+    result = TypedData_Wrap_Struct(self, &rgeo_crs_to_crs_data_type, data);
+  }
+  return result;
+}
+
 static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 {
-  RGeo_Proj4Data* self_data;
-  projPJ pj;
-  RGeo_Proj4Data* orig_data;
-  char* str;
+  RGeo_Proj4Data *self_data;
+  RGeo_Proj4Data *orig_data;
+  const char* str;
 
   // Clear out any existing value
-  self_data = RGEO_PROJ4_DATA_PTR(self);
-  pj = self_data->pj;
-  if (pj) {
-    pj_free(pj);
-    self_data->pj = NULL;
-    self_data->original_str = Qnil;
-  }
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+  rgeo_proj4_clear_struct(self_data);
 
   // Copy value from orig
-  orig_data = RGEO_PROJ4_DATA_PTR(orig);
+  TypedData_Get_Struct(orig, RGeo_Proj4Data, &rgeo_proj4_data_type, orig_data);
   if (!NIL_P(orig_data->original_str)) {
-    self_data->pj = pj_init_plus(RSTRING_PTR(orig_data->original_str));
+    self_data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(orig_data->original_str));
   }
   else {
-    str = pj_get_def(orig_data->pj, 0);
-    self_data->pj = pj_init_plus(str);
-    pj_dalloc(str);
+    str = proj_as_proj_string(PJ_DEFAULT_CTX, orig_data->pj, PJ_PROJ_4, NULL);
+    self_data->pj = proj_create(PJ_DEFAULT_CTX, str);
   }
   self_data->original_str = orig_data->original_str;
   self_data->uses_radians = orig_data->uses_radians;
@@ -112,22 +202,16 @@ static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 
 static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
 {
-  RGeo_Proj4Data* self_data;
-  projPJ pj;
+  RGeo_Proj4Data *self_data;
 
   Check_Type(str, T_STRING);
 
   // Clear out any existing value
-  self_data = RGEO_PROJ4_DATA_PTR(self);
-  pj = self_data->pj;
-  if (pj) {
-    pj_free(pj);
-    self_data->pj = NULL;
-    self_data->original_str = Qnil;
-  }
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+  rgeo_proj4_clear_struct(self_data);
 
   // Set new data
-  self_data->pj = pj_init_plus(RSTRING_PTR(str));
+  self_data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(str));
   self_data->original_str = str;
   self_data->uses_radians = RTEST(uses_radians) ? 1 : 0;
 
@@ -138,17 +222,18 @@ static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
 static VALUE method_proj4_get_geographic(VALUE self)
 {
   VALUE result;
-  RGeo_Proj4Data* new_data;
-  RGeo_Proj4Data* self_data;
+  RGeo_Proj4Data *new_data;
+  RGeo_Proj4Data *self_data;
 
   result = Qnil;
   new_data = ALLOC(RGeo_Proj4Data);
   if (new_data) {
-    self_data = RGEO_PROJ4_DATA_PTR(self);
-    new_data->pj = pj_latlong_from_proj(self_data->pj);
+    TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+
+    new_data->pj = proj_crs_get_geodetic_crs(PJ_DEFAULT_CTX, self_data->pj);
     new_data->original_str = Qnil;
     new_data->uses_radians = self_data->uses_radians;
-    result = Data_Wrap_Struct(CLASS_OF(self), mark_proj4_func, destroy_proj4_func, new_data);
+    result = TypedData_Wrap_Struct(CLASS_OF(self), &rgeo_proj4_data_type, new_data);
   }
   return result;
 }
@@ -156,44 +241,97 @@ static VALUE method_proj4_get_geographic(VALUE self)
 
 static VALUE method_proj4_original_str(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->original_str;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->original_str;
 }
 
 
 static VALUE method_proj4_uses_radians(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->uses_radians ? Qtrue : Qfalse;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->uses_radians ? Qtrue : Qfalse;
 }
 
 
 static VALUE method_proj4_canonical_str(VALUE self)
 {
   VALUE result;
-  projPJ pj;
-  char* str;
+  PJ *pj;
+  const char *str;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    str = pj_get_def(pj, 0);
+    str = proj_as_proj_string(PJ_DEFAULT_CTX, pj, PJ_PROJ_4, NULL);
     if (str) {
       result = rb_str_new2(str);
-      pj_dalloc(str);
     }
   }
   return result;
 }
 
+static VALUE method_proj4_wkt_str(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  const char *str;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj) {
+    const char *const options[] = {"MULTILINE=NO", NULL};
+    str = proj_as_wkt(PJ_DEFAULT_CTX, pj, WKT_TYPE, options);
+    if(str){
+      result = rb_str_new2(str);
+    }
+  }
+  return result;
+}
+
+static VALUE method_proj4_auth_name_str(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  const char *id;
+  const char *auth;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj) {
+    auth = proj_get_id_auth_name(pj, 0);
+    id = proj_get_id_code(pj, 0);
+    if(id && auth){
+      result = rb_sprintf("%s:%s", auth, id);
+    }
+  }
+  return result;
+}
 
 static VALUE method_proj4_is_geographic(VALUE self)
 {
   VALUE result;
-  projPJ pj;
+  PJ *pj;
+  PJ_TYPE proj_type;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    result = pj_is_latlong(pj) ? Qtrue : Qfalse;
+    proj_type = proj_get_type(pj);
+    if(proj_type == PJ_TYPE_GEOGRAPHIC_2D_CRS || proj_type == PJ_TYPE_GEOGRAPHIC_3D_CRS){
+      result = Qtrue;
+    } else {
+      result = Qfalse;
+    }
   }
   return result;
 }
@@ -202,12 +340,16 @@ static VALUE method_proj4_is_geographic(VALUE self)
 static VALUE method_proj4_is_geocentric(VALUE self)
 {
   VALUE result;
-  projPJ pj;
+  PJ *pj;
+  PJ_TYPE proj_type;
+  RGeo_Proj4Data *data;
 
   result = Qnil;
-  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
   if (pj) {
-    result = pj_is_geocent(pj) ? Qtrue : Qfalse;
+    proj_type = proj_get_type(pj);
+    result = proj_type == PJ_TYPE_GEOCENTRIC_CRS ? Qtrue : Qfalse;
   }
   return result;
 }
@@ -215,89 +357,130 @@ static VALUE method_proj4_is_geocentric(VALUE self)
 
 static VALUE method_proj4_is_valid(VALUE self)
 {
-  return RGEO_PROJ4_DATA_PTR(self)->pj ? Qtrue : Qfalse;
+  RGeo_Proj4Data *data;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  return data->pj ? Qtrue : Qfalse;
 }
 
 
 static VALUE cmethod_proj4_version(VALUE module)
 {
-  return INT2NUM(PJ_VERSION);
+  return rb_sprintf("%d.%d.%d", PROJ_VERSION_MAJOR, PROJ_VERSION_MINOR, PROJ_VERSION_PATCH);
 }
 
-
-static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
+static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
 {
   VALUE result;
-  projPJ from_pj;
-  projPJ to_pj;
-  double xval, yval, zval;
-  int err;
+  RGeo_Proj4Data* data;
 
   result = Qnil;
-  from_pj = RGEO_PROJ4_DATA_PTR(from)->pj;
-  to_pj = RGEO_PROJ4_DATA_PTR(to)->pj;
-  if (from_pj && to_pj) {
-    xval = rb_num2dbl(x);
-    yval = rb_num2dbl(y);
-    zval = 0.0;
-    if (!NIL_P(z)) {
-      zval = rb_num2dbl(z);
-    }
-    err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval);
-    if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) {
-      result = rb_ary_new2(NIL_P(z) ? 2 : 3);
-      rb_ary_push(result, rb_float_new(xval));
-      rb_ary_push(result, rb_float_new(yval));
-      if (!NIL_P(z)) {
-        rb_ary_push(result, rb_float_new(zval));
-      }
-    }
+  Check_Type(str, T_STRING);
+  data = ALLOC(RGeo_Proj4Data);
+  if (data) {
+    data->pj = proj_create(PJ_DEFAULT_CTX, StringValuePtr(str));
+    data->original_str = str;
+    data->uses_radians = RTEST(uses_radians) ? 1 : 0;
+    result = TypedData_Wrap_Struct(klass, &rgeo_proj4_data_type, data);
+  }
+  return result;
+}
+
+static VALUE cmethod_crs_to_crs_create(VALUE klass, VALUE from, VALUE to)
+{
+  VALUE result;
+  RGeo_Proj4Data *from_data;
+  RGeo_Proj4Data *to_data;
+  result = Qnil;
+  PJ *from_pj;
+  PJ *to_pj;
+  PJ *gis_pj;
+  PJ *crs_to_crs;
+  RGeo_CRSToCRSData* data;
+
+  TypedData_Get_Struct(from, RGeo_Proj4Data, &rgeo_proj4_data_type, from_data);
+  TypedData_Get_Struct(to, RGeo_Proj4Data, &rgeo_proj4_data_type, to_data);
+  from_pj = from_data->pj;
+  to_pj = to_data->pj;
+  crs_to_crs = proj_create_crs_to_crs_from_pj(PJ_DEFAULT_CTX, from_pj, to_pj, 0, NULL);
+
+  // necessary to use proj_normalize_for_visualization so that we
+  // do not have to worry about the order of coordinates in every
+  // coord system
+  gis_pj = proj_normalize_for_visualization(PJ_DEFAULT_CTX, crs_to_crs);
+  if(gis_pj){
+    proj_destroy(crs_to_crs);
+    crs_to_crs = gis_pj;
+  }
+  data = ALLOC(RGeo_CRSToCRSData);
+  if (data){
+    data->crs_to_crs = crs_to_crs;
+    result = TypedData_Wrap_Struct(klass, &rgeo_crs_to_crs_data_type, data);
   }
   return result;
 }
 
 
-static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
+static VALUE method_crs_to_crs_transform(VALUE self, VALUE x, VALUE y, VALUE z)
 {
   VALUE result;
-  RGeo_Proj4Data* data;
+  RGeo_CRSToCRSData *crs_to_crs_data;
+  PJ *crs_to_crs_pj;
+  double xval, yval, zval;
+  PJ_COORD input;
+  PJ_COORD output;
 
   result = Qnil;
-  Check_Type(str, T_STRING);
-  data = ALLOC(RGeo_Proj4Data);
-  if (data) {
-    data->pj = pj_init_plus(RSTRING_PTR(str));
-    data->original_str = str;
-    data->uses_radians = RTEST(uses_radians) ? 1 : 0;
-    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+  TypedData_Get_Struct(self, RGeo_CRSToCRSData, &rgeo_crs_to_crs_data_type, crs_to_crs_data);
+  crs_to_crs_pj = crs_to_crs_data->crs_to_crs;
+  if(crs_to_crs_pj){
+    xval = rb_num2dbl(x);
+    yval = rb_num2dbl(y);
+    zval = NIL_P(z) ? 0.0 : rb_num2dbl(z);
+
+    input = proj_coord(xval, yval, zval, HUGE_VAL);
+    output = proj_trans(crs_to_crs_pj, PJ_FWD, input);
+
+    result = rb_ary_new2(NIL_P(z) ? 2 : 3);
+    rb_ary_push(result, DBL2NUM(output.xyz.x));
+    rb_ary_push(result, DBL2NUM(output.xyz.y));
+    if(!NIL_P(z)){
+      rb_ary_push(result, DBL2NUM(output.xyz.z));
+    }
   }
   return result;
 }
 
-
 static void rgeo_init_proj4()
 {
   VALUE rgeo_module;
   VALUE coordsys_module;
   VALUE proj4_class;
+  VALUE crs_to_crs_class;
 
   rgeo_module = rb_define_module("RGeo");
   coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
-  proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
 
-  rb_define_alloc_func(proj4_class, alloc_proj4);
+  proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
+  rb_define_alloc_func(proj4_class, rgeo_proj4_data_alloc);
   rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 2);
   rb_define_method(proj4_class, "initialize_copy", method_proj4_initialize_copy, 1);
   rb_define_method(proj4_class, "_set_value", method_proj4_set_value, 2);
   rb_define_method(proj4_class, "_original_str", method_proj4_original_str, 0);
   rb_define_method(proj4_class, "_canonical_str", method_proj4_canonical_str, 0);
+  rb_define_method(proj4_class, "_as_text", method_proj4_wkt_str, 0);
+  rb_define_method(proj4_class, "_auth_name", method_proj4_auth_name_str, 0);
   rb_define_method(proj4_class, "_valid?", method_proj4_is_valid, 0);
   rb_define_method(proj4_class, "_geographic?", method_proj4_is_geographic, 0);
   rb_define_method(proj4_class, "_geocentric?", method_proj4_is_geocentric, 0);
   rb_define_method(proj4_class, "_radians?", method_proj4_uses_radians, 0);
   rb_define_method(proj4_class, "_get_geographic", method_proj4_get_geographic, 0);
-  rb_define_module_function(proj4_class, "_transform_coords", cmethod_proj4_transform, 5);
   rb_define_module_function(proj4_class, "_proj_version", cmethod_proj4_version, 0);
+
+
+  crs_to_crs_class = rb_define_class_under(coordsys_module, "CRSToCRS", rb_cObject);
+  rb_define_alloc_func(crs_to_crs_class, rgeo_crs_to_crs_data_alloc);
+  rb_define_module_function(crs_to_crs_class, "_create", cmethod_crs_to_crs_create, 2);
+  rb_define_method(crs_to_crs_class, "_transform_coords", method_crs_to_crs_transform, 3);
 }
 
 

data/lib/rgeo/coord_sys/crs_to_crs.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "singleton"
+module RGeo
+  module CoordSys
+    # This is a Ruby wrapper around a proj crs_to_crs
+    # A crs_to_crs transformation object is a pipeline between two known coordinate reference systems.
+    # https://proj.org/development/reference/functions.html#c.proj_create_crs_to_crs
+    class CRSToCRS
+      attr_writer :from, :to
+
+      class << self
+        def create(from, to)
+          crs_to_crs = _create(from, to)
+          crs_to_crs.from = from
+          crs_to_crs.to = to
+          crs_to_crs
+        end
+      end
+      # transform the coordinates from the initial CRS to the destination CRS
+      def transform_coords(x, y, z)
+        if @from._radians? && @from._geographic?
+          x *= ImplHelper::Math::DEGREES_PER_RADIAN
+          y *= ImplHelper::Math::DEGREES_PER_RADIAN
+        end
+        result = _transform_coords(x, y, z)
+        if result && @to._radians? && @to._geographic?
+          result[0] *= ImplHelper::Math::RADIANS_PER_DEGREE
+          result[1] *= ImplHelper::Math::RADIANS_PER_DEGREE
+        end
+        result
+      end
+
+      def transform(from_geometry, to_factory)
+        case from_geometry
+        when Feature::Point
+          transform_point(from_geometry, to_factory)
+        when Feature::Line
+          to_factory.line(from_geometry.points.map { |p| transform_point(p, to_factory) })
+        when Feature::LinearRing
+          transform_linear_ring(from_geometry, to_factory)
+        when Feature::LineString
+          to_factory.line_string(from_geometry.points.map { |p_| transform_point(p_, to_factory) })
+        when Feature::Polygon
+          transform_polygon(from_geometry, to_factory)
+        when Feature::MultiPoint
+          to_factory.multi_point(from_geometry.map { |p| transform_point(p, to_factory) })
+        when Feature::MultiLineString
+          to_factory.multi_line_string(from_geometry.map { |g| transform(g, to_factory) })
+        when Feature::MultiPolygon
+          to_factory.multi_polygon(from_geometry.map { |p| transform_polygon(p, to_factory) })
+        when Feature::GeometryCollection
+          to_factory.collection(from_geometry.map { |g| transform(g, to_factory) })
+        end
+      end
+
+      def transform_point(from_point, to_factory)
+        from_factory_ = from_point.factory
+        from_has_z_ = from_factory_.property(:has_z_coordinate)
+        from_has_m_ = from_factory_.property(:has_m_coordinate)
+        to_has_z_ = to_factory.property(:has_z_coordinate)
+        to_has_m_ = to_factory.property(:has_m_coordinate)
+        coords_ = transform_coords(from_point.x, from_point.y, from_has_z_ ? from_point.z : nil)
+        return unless coords_
+        extras_ = []
+        extras_ << coords_[2].to_f if to_has_z_
+        if to_has_m_
+          extras_ << from_has_m_ ? from_point.m : 0.0
+        end
+        to_factory.point(coords_[0], coords_[1], *extras_)
+      end
+
+      def transform_linear_ring(from_ring_, to_factory_)
+        to_factory_.linear_ring(from_ring_.points[0..-2].map { |p_| transform_point(p_, to_factory_) })
+      end
+
+      def transform_polygon(from_polygon_, to_factory_)
+        ext_ = transform_linear_ring(from_polygon_.exterior_ring, to_factory_)
+        int_ = from_polygon_.interior_rings.map { |r_| transform_linear_ring(r_, to_factory_) }
+        to_factory_.polygon(ext_, int_)
+      end
+    end
+
+    # Store of all the created CRSToCRS
+    class CRSStore
+      include Singleton
+      class << self
+        def get(from, to)
+          instance.get(from, to)
+        end
+      end
+
+      Key = Struct.new(:from, :to)
+
+      def initialize
+        @store = Hash.new { |h, k| h[k] = CRSToCRS.create(k.from, k.to) }
+        @semaphore = Mutex.new
+      end
+
+      def get(from, to)
+        @semaphore.synchronize do
+          @store[Key.new(from, to)]
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/coord_sys/proj4.rb

@@ -41,8 +41,8 @@ module RGeo
       # there are sometimes multiple ways to express a given coordinate
       # system.
 
-      def eql?(rhs_)
-        rhs_.class == self.class && rhs_.canonical_hash == canonical_hash && rhs_._radians? == _radians?
+      def eql?(other)
+        other.class == self.class && other.canonical_hash == canonical_hash && other._radians? == _radians?
       end
       alias == eql?
 
@@ -105,6 +105,21 @@ module RGeo
         _original_str
       end
 
+      # Returns the WKT representation of the CRS.
+
+      def as_text
+        _as_text
+      end
+
+      # Returns the string representing the authority and code of the
+      # CRS if it exists, nil otherwise.
+      #
+      # Ex. EPSG:4326
+
+      def auth_name
+        _auth_name
+      end
+
       # Returns true if this Proj4 object is a geographic (lat-long)
       # coordinate system.
 
@@ -172,7 +187,7 @@ module RGeo
             if defn_.is_a?(::Hash)
               defn_ = defn_.map { |k_, v_| v_ ? "+#{k_}=#{v_}" : "+#{k_}" }.join(" ")
             end
-            defn_ = defn_.sub(/^(\s*)/, '\1+').gsub(/(\s+)([^+\s])/, '\1+\2') unless defn_ =~ /^\s*\+/
+
             result_ = _create(defn_, opts_[:radians])
             result_ = nil unless result_._valid?
           end
@@ -206,18 +221,9 @@ module RGeo
         # Transforms the given coordinate (x, y, [z]) from one proj4
         # coordinate system to another. Returns an array with either two
         # or three elements.
-
         def transform_coords(from_proj_, to_proj_, x_, y_, z_ = nil)
-          if !from_proj_._radians? && from_proj_._geographic?
-            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-          end
-          result_ = _transform_coords(from_proj_, to_proj_, x_, y_, z_)
-          if result_ && !to_proj_._radians? && to_proj_._geographic?
-            result_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
-            result_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
-          end
-          result_
+          crs_to_crs = CRSStore.get(from_proj_, to_proj_)
+          crs_to_crs.transform_coords(x_, y_, z_)
         end
 
         # Low-level geometry transform method.
@@ -225,66 +231,9 @@ module RGeo
         # The resulting geometry is constructed using the to_factory.
         # Any projections associated with the factories themselves are
         # ignored.
-
         def transform(from_proj_, from_geometry_, to_proj_, to_factory_)
-          case from_geometry_
-          when Feature::Point
-            transform_point(from_proj_, from_geometry_, to_proj_, to_factory_)
-          when Feature::Line
-            to_factory_.line(from_geometry_.points.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
-          when Feature::LinearRing
-            transform_linear_ring(from_proj_, from_geometry_, to_proj_, to_factory_)
-          when Feature::LineString
-            to_factory_.line_string(from_geometry_.points.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
-          when Feature::Polygon
-            transform_polygon(from_proj_, from_geometry_, to_proj_, to_factory_)
-          when Feature::MultiPoint
-            to_factory_.multi_point(from_geometry_.map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
-          when Feature::MultiLineString
-            to_factory_.multi_line_string(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
-          when Feature::MultiPolygon
-            to_factory_.multi_polygon(from_geometry_.map { |p_| transform_polygon(from_proj_, p_, to_proj_, to_factory_) })
-          when Feature::GeometryCollection
-            to_factory_.collection(from_geometry_.map { |g_| transform(from_proj_, g_, to_proj_, to_factory_) })
-          end
-        end
-
-        private
-
-        def transform_point(from_proj_, from_point_, to_proj_, to_factory_)
-          from_factory_ = from_point_.factory
-          from_has_z_ = from_factory_.property(:has_z_coordinate)
-          from_has_m_ = from_factory_.property(:has_m_coordinate)
-          to_has_z_ = to_factory_.property(:has_z_coordinate)
-          to_has_m_ = to_factory_.property(:has_m_coordinate)
-          x_ = from_point_.x
-          y_ = from_point_.y
-          if !from_proj_._radians? && from_proj_._geographic?
-            x_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-            y_ *= ImplHelper::Math::RADIANS_PER_DEGREE
-          end
-          coords_ = _transform_coords(from_proj_, to_proj_, x_, y_, from_has_z_ ? from_point_.z : nil)
-          return unless coords_
-          if !to_proj_._radians? && to_proj_._geographic?
-            coords_[0] *= ImplHelper::Math::DEGREES_PER_RADIAN
-            coords_[1] *= ImplHelper::Math::DEGREES_PER_RADIAN
-          end
-          extras_ = []
-          extras_ << coords_[2].to_f if to_has_z_
-          if to_has_m_
-            extras_ << from_has_m_ ? from_point_.m : 0.0
-          end
-          to_factory_.point(coords_[0], coords_[1], *extras_)
-        end
-
-        def transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_)
-          to_factory_.linear_ring(from_ring_.points[0..-2].map { |p_| transform_point(from_proj_, p_, to_proj_, to_factory_) })
-        end
-
-        def transform_polygon(from_proj_, from_polygon_, to_proj_, to_factory_)
-          ext_ = transform_linear_ring(from_proj_, from_polygon_.exterior_ring, to_proj_, to_factory_)
-          int_ = from_polygon_.interior_rings.map { |r_| transform_linear_ring(from_proj_, r_, to_proj_, to_factory_) }
-          to_factory_.polygon(ext_, int_)
+          crs_to_crs = CRSStore.get(from_proj_, to_proj_)
+          crs_to_crs.transform(from_geometry_, to_factory_)
         end
       end
     end

data/lib/rgeo/coord_sys/srs_database/proj4_data.rb

@@ -81,11 +81,12 @@ module RGeo
           ident_ = ident_.to_s
           return @cache[ident_] if @cache&.include?(ident_)
           result_ = nil
-          if @populate_state == 0
+          case @populate_state
+          when 0
             data_ = search_file(ident_)
             result_ = Entry.new(ident_, authority: @authority, authority_code: @authority ? ident_ : nil, name: data_[1], proj4: data_[2]) if data_
             @cache[ident_] = result_ if @cache
-          elsif @populate_state == 1
+          when 1
             search_file(nil)
             result_ = @cache[ident_]
             @populate_state = 2
@@ -113,12 +114,10 @@ module RGeo
                 cur_name_ = line_[comment_delim_ + 1..-1].strip
                 line_ = line_[0..comment_delim_ - 1].strip
               end
-              unless cur_ident_
-                if line_ =~ /^<(\w+)>(.*)/
-                  cur_ident_ = Regexp.last_match(1)
-                  cur_text_ = []
-                  line_ = Regexp.last_match(2).strip
-                end
+              if !cur_ident_ && (line_ =~ /^<(\w+)>(.*)/)
+                cur_ident_ = Regexp.last_match(1)
+                cur_text_ = []
+                line_ = Regexp.last_match(2).strip
               end
               next unless cur_ident_
               if line_[-2..-1] == "<>"

data/lib/rgeo/proj4/version.rb

@@ -2,6 +2,6 @@
 
 module RGeo
   module Proj4
-    VERSION = "2.0.1"
+    VERSION = "3.1.1"
   end
 end

data/lib/rgeo/proj4.rb

@@ -2,6 +2,7 @@
 
 require "rgeo"
 require "rgeo/proj4/version"
+require "rgeo/coord_sys/crs_to_crs"
 require "rgeo/coord_sys/proj4"
 require "rgeo/coord_sys/srs_database/proj4_data"
 require "rgeo/coord_sys/proj4_c_impl"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-proj4
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.1.1
 platform: ruby
 authors:
 - Tee Parham, Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-09 00:00:00.000000000 Z
+date: 2021-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -30,28 +30,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.14'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
 description: Proj4 extension for rgeo.
 email:
 - parhameter@gmail.com, dazuma@gmail.com
@@ -77,6 +105,7 @@ files:
 - LICENSE.txt
 - ext/proj4_c_impl/extconf.rb
 - ext/proj4_c_impl/main.c
+- lib/rgeo/coord_sys/crs_to_crs.rb
 - lib/rgeo/coord_sys/proj4.rb
 - lib/rgeo/coord_sys/srs_database/proj4_data.rb
 - lib/rgeo/proj4.rb
@@ -93,14 +122,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Proj4 extension for rgeo.