rgeo-proj4 3.1.1 → 4.0.0.pre.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b578b226ebc3b376a92f58cf080d34f237b5929751e6b856e493d9b6a6daa1ae
-  data.tar.gz: 84f4953ac2aea3783e7a807542c7aaf102b265dc454a9de97c340d70f04685c1
+  metadata.gz: c0a179679b6f6471a9626bf6fbc08758a52b0d60f5ba81fa4ab5119456680470
+  data.tar.gz: 2a58dfbbf870d24ea9d4b2880444c1f331ba184dc38862af6b4347fb9cc96366
 SHA512:
-  metadata.gz: bb2bddfdc101da5c0a4b2af5d5445ce7e57f8d49505b5bb2f53376e81b5ed392d4d2183c11e6cc1e0d86fc5b2fc83cc1afe1d6a3c72fcf8924d779fbd04fdffb
-  data.tar.gz: 3f21328f3beff54191cf496f784a432185f9999d4b71ddeab91d772627f26bbc97deb1882cab9d9f997d16432993d2c742c3d2638005d2f372959428201f4e05
+  metadata.gz: a3f86ad3fd2ef994a74ebf0df1f6f4d87446f7a28055417d551822ed88384893f74e20d6803200083f129fe152170ae3d887b50769a5861391b3c0447d83c7a5
+  data.tar.gz: b41045b6502bd6172632021e942da3214b9de534ffd1461bb4969813c3fbcd60a8c0c7f3074c692609380f1179a1c9b600b99bba9a0c3a3f620ad99a8226b618

data/ext/proj4_c_impl/errors.c

@@ -0,0 +1,31 @@
+#ifndef RGEO_PROJ4_ERRORS_INCLUDED
+#define RGEO_PROJ4_ERRORS_INCLUDED
+
+#include <ruby.h>
+
+#include "preface.h"
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+#include "errors.h"
+
+RGEO_BEGIN_C
+
+VALUE error_module;
+VALUE rb_eRGeoError;
+VALUE rb_eRGeoInvalidProjectionError;
+
+void rgeo_init_proj_errors() {
+  VALUE rgeo_module;
+
+  rgeo_module = rb_define_module("RGeo");
+  error_module = rb_define_module_under(rgeo_module, "Error");
+  rb_eRGeoError = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
+  rb_eRGeoInvalidProjectionError = rb_define_class_under(error_module, "InvalidProjection", rb_eRGeoError);
+}
+
+RGEO_END_C
+
+#endif // RGEO_PROJ4_SUPPORTED
+
+#endif // RGEO_GEOS_ERROS_INCLUDED

data/ext/proj4_c_impl/errors.h

@@ -0,0 +1,22 @@
+#ifndef RGEO_PROJ4_ERRORS_INCLUDED
+#define RGEO_PROJ4_ERRORS_INCLUDED
+
+#include <ruby.h>
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+RGEO_BEGIN_C
+
+extern VALUE error_module;
+// Main rgeo error type
+extern VALUE rb_eRGeoError;
+// RGeo::Error::InvalidProjection
+extern VALUE rb_eRGeoInvalidProjectionError;
+
+void rgeo_init_proj_errors();
+
+RGEO_END_C
+
+#endif // RGEO_PROJ4_SUPPORTED
+
+#endif // RGEO_PROJ4_ERRORS_INCLUDED

data/ext/proj4_c_impl/extconf.rb

@@ -12,7 +12,7 @@ else
 
   require "mkmf"
 
-  header_dirs_ =
+  header_dirs =
     [
       ::RbConfig::CONFIG["includedir"],
       "/usr/local/include",
@@ -26,7 +26,7 @@ else
       "/Library/Frameworks/PROJ.framework/unix/include",
       "/usr/include"
     ]
-  lib_dirs_ =
+  lib_dirs =
     [
       ::RbConfig::CONFIG["libdir"],
       "/usr/local/lib",
@@ -42,28 +42,65 @@ else
       "/usr/lib",
       "/usr/lib64"
     ]
-  header_dirs_.delete_if { |path_| !::File.directory?(path_) }
-  lib_dirs_.delete_if { |path_| !::File.directory?(path_) }
+  header_dirs.delete_if { |path| !::File.directory?(path) }
+  lib_dirs.delete_if { |path| !::File.directory?(path) }
 
-  found_proj_ = false
-  header_dirs_, lib_dirs_ = dir_config("proj", header_dirs_, lib_dirs_)
+  found_proj = false
+  found_valid_proj_version = false
+  header_dirs, lib_dirs = dir_config("proj", header_dirs, lib_dirs)
   if have_header("proj.h")
     $libs << " -lproj"
+    found_proj = true
 
-    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", "")
+    required_proj_funcs = %w[
+      proj_create
+      proj_create_crs_to_crs_from_pj
+      proj_normalize_for_visualization
+    ]
+    found_valid_proj_version = required_proj_funcs.all? do |func|
+      have_func(func, "proj.h")
     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."
+  unless found_proj
+
+    install_text = case RUBY_PLATFORM
+                   when /linux/
+                     %(
+  Please install proj like so:
+    apt-get install libproj-dev proj-bin
+                     )
+                   when /darwin/
+                     %(
+  Please install proj like so:
+    brew install proj
+                     )
+                   else
+                     %(
+  Please install proj.
+                     )
+                   end
+    error_msg = %(
+**** WARNING: Unable to find Proj headers. Ensure that Proj is properly installed.
+
+#{install_text}
+
+or set the path manually using:
+ --with-proj-dir or with the --with-proj-include and --with-proj-lib options
+    )
+    warn error_msg
+    raise
+  end
+
+  unless found_valid_proj_version
+    error_msg = %(
+**** WARNING: The found Proj version is not new enough to be used for this version of rgeo-proj4.
+**** Proj 6.2+ is required.
+    )
+    warn error_msg
+    raise
   end
-  create_makefile("rgeo/coord_sys/proj4_c_impl")
 
+  create_makefile("rgeo/coord_sys/proj4_c_impl")
 end

data/ext/proj4_c_impl/main.c

@@ -1,35 +1,14 @@
 /*
   Main initializer for Proj4 wrapper
 */
-#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" {
-#define RGEO_END_C }
-#else
-#define RGEO_BEGIN_C
-#define RGEO_END_C
-#endif
 
+#include "preface.h"
 
 #ifdef RGEO_PROJ4_SUPPORTED
 
 #include <ruby.h>
 #include <proj.h>
+#include "errors.h"
 
 #endif
 
@@ -60,7 +39,7 @@ typedef struct {
 static void rgeo_proj4_free(void *ptr)
 {
   RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
-  if(data->pj){
+  if (data->pj){
     proj_destroy(data->pj);
   }
   free(data);
@@ -70,7 +49,7 @@ static void rgeo_proj4_free(void *ptr)
 static void rgeo_crs_to_crs_free(void *ptr)
 {
   RGeo_CRSToCRSData *data = (RGeo_CRSToCRSData *)ptr;
-  if(data->crs_to_crs){
+  if (data->crs_to_crs){
     proj_destroy(data->crs_to_crs);
   }
   free(data);
@@ -83,7 +62,7 @@ static size_t rgeo_proj4_memsize(const void *ptr)
   const RGeo_Proj4Data *data = (const RGeo_Proj4Data *)ptr;
 
   size += sizeof(*data);
-  if(data->pj){
+  if (data->pj){
     size += sizeof(data->pj);
   }
   return size;
@@ -94,7 +73,7 @@ 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){
+  if (data->crs_to_crs){
     size += sizeof(data->crs_to_crs);
   }
   return size;
@@ -103,7 +82,7 @@ static size_t rgeo_crs_to_crs_memsize(const void *ptr)
 static void rgeo_proj4_mark(void *ptr)
 {
   RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
-  if(!NIL_P(data->original_str)){
+  if (!NIL_P(data->original_str)){
     mark(data->original_str);
   }
 }
@@ -112,7 +91,7 @@ static void rgeo_proj4_mark(void *ptr)
 static void rgeo_proj4_compact(void *ptr)
 {
   RGeo_Proj4Data *data = (RGeo_Proj4Data *)ptr;
-  if(data && !NIL_P(data->original_str)){
+  if (data && !NIL_P(data->original_str)){
     data->original_str = rb_gc_location(data->original_str);
   }
 }
@@ -120,7 +99,7 @@ static void rgeo_proj4_compact(void *ptr)
 
 static void rgeo_proj4_clear_struct(RGeo_Proj4Data *data)
 {
-  if(data->pj){
+  if (data->pj){
     proj_destroy(data->pj);
     data->pj = NULL;
     data->original_str = Qnil;
@@ -150,7 +129,7 @@ static VALUE rgeo_proj4_data_alloc(VALUE self)
 
   result = Qnil;
 
-  if(data){
+  if (data){
     data->pj = NULL;
     data->original_str = Qnil;
     data->uses_radians = 0;
@@ -167,7 +146,7 @@ static VALUE rgeo_crs_to_crs_data_alloc(VALUE self)
 
   result = Qnil;
 
-  if(data){
+  if (data){
     data->crs_to_crs = NULL;
     result = TypedData_Wrap_Struct(self, &rgeo_crs_to_crs_data_type, data);
   }
@@ -224,13 +203,20 @@ static VALUE method_proj4_get_geographic(VALUE self)
   VALUE result;
   RGeo_Proj4Data *new_data;
   RGeo_Proj4Data *self_data;
+  PJ *geographic_proj;
 
   result = Qnil;
   new_data = ALLOC(RGeo_Proj4Data);
   if (new_data) {
     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);
+    geographic_proj = proj_crs_get_geodetic_crs(PJ_DEFAULT_CTX, self_data->pj);
+    if (geographic_proj == 0) {
+      xfree(new_data);
+      rb_raise(rb_eRGeoInvalidProjectionError, "Geographic CRS could not be created because the source projection is not a CRS");
+    }
+
+    new_data->pj = geographic_proj;
     new_data->original_str = Qnil;
     new_data->uses_radians = self_data->uses_radians;
     result = TypedData_Wrap_Struct(CLASS_OF(self), &rgeo_proj4_data_type, new_data);
@@ -287,7 +273,7 @@ static VALUE method_proj4_wkt_str(VALUE self)
   if (pj) {
     const char *const options[] = {"MULTILINE=NO", NULL};
     str = proj_as_wkt(PJ_DEFAULT_CTX, pj, WKT_TYPE, options);
-    if(str){
+    if (str){
       result = rb_str_new2(str);
     }
   }
@@ -308,13 +294,67 @@ static VALUE method_proj4_auth_name_str(VALUE self)
   if (pj) {
     auth = proj_get_id_auth_name(pj, 0);
     id = proj_get_id_code(pj, 0);
-    if(id && auth){
+    if (id && auth){
       result = rb_sprintf("%s:%s", auth, id);
     }
   }
   return result;
 }
 
+static VALUE method_proj4_axis_and_unit_info_str(VALUE self, VALUE dimension)
+{
+  VALUE result;
+  int dimension_index;
+  PJ *pj;
+  PJ *pj_cs;
+  const char *axis_info;
+  const char *unit_name;
+  RGeo_Proj4Data *data;
+
+  Check_Type(dimension, T_FIXNUM);
+
+  dimension_index = FIX2INT(dimension);
+  result = Qnil;
+
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj){
+    pj_cs = proj_crs_get_coordinate_system(PJ_DEFAULT_CTX, pj);
+    if (pj_cs) {
+      if (proj_cs_get_axis_info(PJ_DEFAULT_CTX, pj_cs, dimension_index, &axis_info, NULL, NULL, NULL, &unit_name, NULL, NULL)) {
+        result = rb_sprintf("%s:%s", axis_info, unit_name);
+      }
+
+      proj_destroy(pj_cs);
+    }
+  }
+  return result;
+}
+
+static VALUE method_proj4_axis_count(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  PJ *pj_cs;
+  int count;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj){
+    pj_cs = proj_crs_get_coordinate_system(PJ_DEFAULT_CTX, pj);
+    if (pj_cs) {
+      count = proj_cs_get_axis_count(PJ_DEFAULT_CTX, pj_cs);
+      result = INT2FIX(count);
+
+      proj_destroy(pj_cs);
+    }
+  }
+  return result;
+}
+
+
 static VALUE method_proj4_is_geographic(VALUE self)
 {
   VALUE result;
@@ -327,7 +367,7 @@ static VALUE method_proj4_is_geographic(VALUE self)
   pj = data->pj;
   if (pj) {
     proj_type = proj_get_type(pj);
-    if(proj_type == PJ_TYPE_GEOGRAPHIC_2D_CRS || proj_type == PJ_TYPE_GEOGRAPHIC_3D_CRS){
+    if (proj_type == PJ_TYPE_GEOGRAPHIC_2D_CRS || proj_type == PJ_TYPE_GEOGRAPHIC_3D_CRS){
       result = Qtrue;
     } else {
       result = Qfalse;
@@ -354,6 +394,23 @@ static VALUE method_proj4_is_geocentric(VALUE self)
   return result;
 }
 
+static VALUE method_proj4_is_projected(VALUE self)
+{
+  VALUE result;
+  PJ *pj;
+  PJ_TYPE proj_type;
+  RGeo_Proj4Data *data;
+
+  result = Qnil;
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, data);
+  pj = data->pj;
+  if (pj) {
+    proj_type = proj_get_type(pj);
+    result = proj_type == PJ_TYPE_PROJECTED_CRS ? Qtrue : Qfalse;
+  }
+  return result;
+}
+
 
 static VALUE method_proj4_is_valid(VALUE self)
 {
@@ -362,6 +419,14 @@ static VALUE method_proj4_is_valid(VALUE self)
   return data->pj ? Qtrue : Qfalse;
 }
 
+static VALUE method_proj4_is_crs(VALUE self)
+{
+  RGeo_Proj4Data *self_data;
+
+  TypedData_Get_Struct(self, RGeo_Proj4Data, &rgeo_proj4_data_type, self_data);
+  return proj_is_crs(self_data->pj) ? Qtrue : Qfalse;
+}
+
 
 static VALUE cmethod_proj4_version(VALUE module)
 {
@@ -403,11 +468,16 @@ static VALUE cmethod_crs_to_crs_create(VALUE klass, VALUE from, VALUE to)
   to_pj = to_data->pj;
   crs_to_crs = proj_create_crs_to_crs_from_pj(PJ_DEFAULT_CTX, from_pj, to_pj, 0, NULL);
 
+  // check for invalid transformation
+  if (crs_to_crs == 0) {
+    rb_raise(rb_eRGeoInvalidProjectionError, "CRSToCRS could not be created from input projections");
+  }
+
   // 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){
+  if (gis_pj){
     proj_destroy(crs_to_crs);
     crs_to_crs = gis_pj;
   }
@@ -432,7 +502,7 @@ static VALUE method_crs_to_crs_transform(VALUE self, VALUE x, VALUE y, VALUE z)
   result = Qnil;
   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){
+  if (crs_to_crs_pj){
     xval = rb_num2dbl(x);
     yval = rb_num2dbl(y);
     zval = NIL_P(z) ? 0.0 : rb_num2dbl(z);
@@ -443,24 +513,113 @@ static VALUE method_crs_to_crs_transform(VALUE self, VALUE x, VALUE y, VALUE z)
     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)){
+    if (!NIL_P(z)){
       rb_ary_push(result, DBL2NUM(output.xyz.z));
     }
   }
   return result;
 }
 
+static VALUE method_crs_to_crs_wkt_str(VALUE self)
+{
+  VALUE result;
+  RGeo_CRSToCRSData *crs_to_crs_data;
+  PJ *crs_to_crs_pj;
+  const char *str;
+
+  result = Qnil;
+  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) {
+    const char *const options[] = {"MULTILINE=NO", NULL};
+    str = proj_as_wkt(PJ_DEFAULT_CTX, crs_to_crs_pj, WKT_TYPE, options);
+    if (str){
+      result = rb_str_new2(str);
+    }
+  }
+  return result;
+}
+
+static VALUE method_crs_to_crs_area_of_use_str(VALUE self)
+{
+  VALUE result;
+  RGeo_CRSToCRSData *crs_to_crs_data;
+  PJ *crs_to_crs_pj;
+  const char *str;
+
+  result = Qnil;
+  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) {
+    if (proj_get_area_of_use(PJ_DEFAULT_CTX, crs_to_crs_pj, NULL, NULL, NULL, NULL, &str)){
+      result = rb_str_new2(str);
+    }
+  }
+  return result;
+}
+
+static VALUE method_crs_to_crs_proj_type(VALUE self)
+{
+  VALUE result;
+  RGeo_CRSToCRSData *crs_to_crs_data;
+  PJ *crs_to_crs_pj;
+  int proj_type;
+
+  result = Qnil;
+  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) {
+    proj_type = proj_get_type(crs_to_crs_pj);
+    result = INT2FIX(proj_type);
+  }
+  return result;
+}
+
+static VALUE method_crs_to_crs_identity(VALUE self, VALUE from, VALUE to)
+{
+  VALUE result;
+  RGeo_Proj4Data *from_data;
+  RGeo_Proj4Data *to_data;
+  result = Qnil;
+  PJ *from_pj;
+  PJ *to_pj;
+
+  result = Qfalse;
+
+  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;
+
+  if (from_pj && to_pj){
+    if (proj_is_equivalent_to(from_pj, to_pj, PJ_COMP_EQUIVALENT)){
+      result = Qtrue;
+    }
+  }
+
+  return result;
+}
+
 static void rgeo_init_proj4()
 {
   VALUE rgeo_module;
   VALUE coordsys_module;
+  VALUE cs_module;
   VALUE proj4_class;
   VALUE crs_to_crs_class;
+  VALUE cs_base_class;
+  VALUE cs_info_class;
+  VALUE coordinate_system_class;
+  VALUE coordinate_transform_class;
 
   rgeo_module = rb_define_module("RGeo");
   coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
+  cs_module = rb_define_module_under(coordsys_module, "CS");
+  cs_base_class = rb_define_class_under(cs_module, "Base", rb_cObject);
+  cs_info_class = rb_define_class_under(cs_module, "Info", cs_base_class);
 
-  proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
+  coordinate_system_class = rb_define_class_under(cs_module, "CoordinateSystem", cs_info_class);
+  proj4_class = rb_define_class_under(coordsys_module, "Proj4", coordinate_system_class);
   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);
@@ -472,15 +631,24 @@ static void rgeo_init_proj4()
   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, "_projected?", method_proj4_is_projected, 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_method(proj4_class, "_crs?", method_proj4_is_crs, 0);
+  rb_define_method(proj4_class, "_axis_and_unit_info", method_proj4_axis_and_unit_info_str, 1);
+  rb_define_method(proj4_class, "_axis_count", method_proj4_axis_count, 0);
   rb_define_module_function(proj4_class, "_proj_version", cmethod_proj4_version, 0);
 
+  coordinate_transform_class = rb_define_class_under(cs_module, "CoordinateTransform", cs_info_class);
 
-  crs_to_crs_class = rb_define_class_under(coordsys_module, "CRSToCRS", rb_cObject);
+  crs_to_crs_class = rb_define_class_under(coordsys_module, "CRSToCRS", coordinate_transform_class);
   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);
+  rb_define_method(crs_to_crs_class, "_as_text", method_crs_to_crs_wkt_str, 0);
+  rb_define_method(crs_to_crs_class, "_proj_type", method_crs_to_crs_proj_type, 0);
+  rb_define_method(crs_to_crs_class, "_area_of_use", method_crs_to_crs_area_of_use_str, 0);
+  rb_define_method(crs_to_crs_class, "_identity?", method_crs_to_crs_identity, 2);
 }
 
 
@@ -491,6 +659,7 @@ void Init_proj4_c_impl()
 {
 #ifdef RGEO_PROJ4_SUPPORTED
   rgeo_init_proj4();
+  rgeo_init_proj_errors();
 #endif
 }
 

data/ext/proj4_c_impl/preface.h

@@ -0,0 +1,23 @@
+#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" {
+#define RGEO_END_C }
+#else
+#define RGEO_BEGIN_C
+#define RGEO_END_C
+#endif

data/lib/rgeo/coord_sys/crs_to_crs.rb

@@ -6,25 +6,49 @@ module RGeo
     # 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
+    #
+    # It also inherits from the RGeo::CoordSys::CoordinateTransform abstract class.
+    class CRSToCRS < CS::CoordinateTransform
+      attr_accessor :source_cs, :target_cs
 
       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.source_cs = from
+          crs_to_crs.target_cs = to
           crs_to_crs
         end
       end
+
+      alias from source_cs
+      alias to target_cs
+      alias to_wkt _as_text
+
+      def wkt_typename
+        wkt_str = to_wkt
+        wkt_str[0, wkt_str.index("[")]
+      end
+
+      def transform_type
+        PROJ_TYPES[_proj_type]
+      end
+
+      def area_of_use
+        _area_of_use
+      end
+
+      def identity?
+        _identity?(source_cs, target_cs)
+      end
+
       # transform the coordinates from the initial CRS to the destination CRS
       def transform_coords(x, y, z)
-        if @from._radians? && @from._geographic?
+        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?
+        if result && to._radians? && to._geographic?
           result[0] *= ImplHelper::Math::RADIANS_PER_DEGREE
           result[1] *= ImplHelper::Math::RADIANS_PER_DEGREE
         end
@@ -79,6 +103,10 @@ module RGeo
         int_ = from_polygon_.interior_rings.map { |r_| transform_linear_ring(r_, to_factory_) }
         to_factory_.polygon(ext_, int_)
       end
+
+      def inspect
+        "#<#{self.class}:0x#{object_id.to_s(16)} @source_cs=#{source_cs.original_str} @target_cs=#{target_cs.original_str}>"
+      end
     end
 
     # Store of all the created CRSToCRS

data/lib/rgeo/coord_sys/proj4.rb

@@ -19,7 +19,9 @@ module RGeo
     # option. You may also use this object directly to perform low-level
     # coordinate transformations.
 
-    class Proj4
+    class Proj4 < CS::CoordinateSystem
+      attr_accessor :dimension
+
       def inspect # :nodoc:
         "#<#{self.class}:0x#{object_id.to_s(16)} #{canonical_str.inspect}>"
       end
@@ -110,6 +112,7 @@ module RGeo
       def as_text
         _as_text
       end
+      alias to_wkt as_text
 
       # Returns the string representing the authority and code of the
       # CRS if it exists, nil otherwise.
@@ -120,6 +123,18 @@ module RGeo
         _auth_name
       end
 
+      # Gets axis details for dimension within coordinate system. Each
+      # dimension in the coordinate system has a corresponding axis.
+      def get_axis(dimension)
+        _axis_and_unit_info(dimension).split(":")[0]
+      end
+
+      # Gets units for dimension within coordinate system. Each
+      # dimension in the coordinate system has corresponding units.
+      def get_units(dimension)
+        _axis_and_unit_info(dimension).split(":")[1]
+      end
+
       # Returns true if this Proj4 object is a geographic (lat-long)
       # coordinate system.
 
@@ -134,6 +149,13 @@ module RGeo
         _geocentric?
       end
 
+      # Returns true if this Proj4 object is a projected
+      # coordinate system
+
+      def projected?
+        _projected?
+      end
+
       # Returns true if this Proj4 object uses radians rather than degrees
       # if it is a geographic coordinate system.
 
@@ -148,6 +170,39 @@ module RGeo
       def get_geographic
         _get_geographic
       end
+      alias geographic_coordinate_system get_geographic
+
+      # Returns true if this Proj4 object represents a CRS.
+
+      def crs?
+        _crs?
+      end
+
+      # Sometimes used to assign SRIDs in factory creation
+      # Also in the base CS::Info class that CS::CoordinateSystem
+      # inherits from
+      #
+      # @return [Integer|NilClass] authority code if available
+      def authority_code
+        auth_name.split(":")[1].to_i if auth_name
+      end
+
+      # Low-level coordinate transform method.
+      # 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(to_proj, x, y, z = nil)
+        self.class.transform_coords(self, to_proj, x, y, z)
+      end
+
+      # Low-level geometry transform method.
+      # Transforms the given geometry between the given two projections.
+      # The resulting geometry is constructed using the to_factory.
+      # Any projections associated with the factories themselves are
+      # ignored.
+      def transform(from_geometry, to_proj, to_factory)
+        self.class.transform(self, from_geometry, to_proj, to_factory)
+      end
 
       class << self
         # Returns true if Proj4 is supported in this installation.
@@ -165,8 +220,9 @@ module RGeo
         end
 
         # Create a new Proj4 object, given a definition, which may be
-        # either a string or a hash. Returns nil if the given definition
-        # is invalid or Proj4 is not supported.
+        # either a string, hash, or integer. If an integer is given, it
+        # assumes that you are using the EPSG SRID that matches that code.
+        # Returns nil if the given definition is invalid or Proj4 is not supported.
         #
         # Recognized options include:
         #
@@ -188,11 +244,16 @@ module RGeo
               defn_ = defn_.map { |k_, v_| v_ ? "+#{k_}=#{v_}" : "+#{k_}" }.join(" ")
             end
 
+            defn_ = "EPSG:#{defn_}" if defn_.is_a?(Integer)
+
             result_ = _create(defn_, opts_[:radians])
-            result_ = nil unless result_._valid?
+            raise RGeo::Error::InvalidProjection unless result_._valid?
+
+            result_.dimension = result_._axis_count
           end
           result_
         end
+        alias create_from_wkt create
 
         # Create a new Proj4 object, given a definition, which may be
         # either a string or a hash. Raises Error::UnsupportedOperation
@@ -221,9 +282,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)
-          crs_to_crs = CRSStore.get(from_proj_, to_proj_)
-          crs_to_crs.transform_coords(x_, y_, z_)
+        def transform_coords(from_proj, to_proj, x, y, z = nil)
+          crs_to_crs = CRSStore.get(from_proj, to_proj)
+          crs_to_crs.transform_coords(x, y, z)
         end
 
         # Low-level geometry transform method.
@@ -231,9 +292,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_)
-          crs_to_crs = CRSStore.get(from_proj_, to_proj_)
-          crs_to_crs.transform(from_geometry_, to_factory_)
+        def transform(from_proj, from_geometry, to_proj, to_factory)
+          crs_to_crs = CRSStore.get(from_proj, to_proj)
+          crs_to_crs.transform(from_geometry, to_factory)
         end
       end
     end

data/lib/rgeo/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RGeo
+  # All RGeo errors are members of this namespace.
+
+  module Error
+    # Base class for all RGeo-related exceptions
+    class RGeoError < RuntimeError
+    end
+
+    # RGeo error specific to the PROJ library
+    class InvalidProjection < RGeoError
+    end
+  end
+end

data/lib/rgeo/proj4/version.rb

@@ -2,6 +2,6 @@
 
 module RGeo
   module Proj4
-    VERSION = "3.1.1"
+    VERSION = "4.0.0-rc.1"
   end
 end

data/lib/rgeo/proj4.rb

@@ -2,7 +2,46 @@
 
 require "rgeo"
 require "rgeo/proj4/version"
+require "rgeo/coord_sys/proj4_c_impl"
 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"
+require_relative "./errors"
+
+module RGeo
+  module CoordSys
+    # PROJ uses enums for types, some methods require us to return
+    # the name of the type. We will use this as a lookup.
+    PROJ_TYPES = %w[
+      PJ_TYPE_UNKNOWN
+      PJ_TYPE_ELLIPSOID
+      PJ_TYPE_PRIME_MERIDIAN
+      PJ_TYPE_GEODETIC_REFERENCE_FRAME
+      PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME
+      PJ_TYPE_VERTICAL_REFERENCE_FRAME
+      PJ_TYPE_DYNAMIC_VERTICAL_REFERENCE_FRAME
+      PJ_TYPE_DATUM_ENSEMBLE
+      PJ_TYPE_CRS
+      PJ_TYPE_GEODETIC_CRS
+      PJ_TYPE_GEOCENTRIC_CRS
+      PJ_TYPE_GEOGRAPHIC_CRS
+      PJ_TYPE_GEOGRAPHIC_2D_CRS
+      PJ_TYPE_GEOGRAPHIC_3D_CRS
+      PJ_TYPE_VERTICAL_CRS
+      PJ_TYPE_PROJECTED_CRS
+      PJ_TYPE_COMPOUND_CRS
+      PJ_TYPE_TEMPORAL_CRS
+      PJ_TYPE_ENGINEERING_CRS
+      PJ_TYPE_BOUND_CRS
+      PJ_TYPE_OTHER_CRS
+      PJ_TYPE_CONVERSION
+      PJ_TYPE_TRANSFORMATION
+      PJ_TYPE_CONCATENATED_OPERATION
+      PJ_TYPE_OTHER_COORDINATE_OPERATION
+      PJ_TYPE_TEMPORAL_DATUM
+      PJ_TYPE_ENGINEERING_DATUM
+      PJ_TYPE_PARAMETRIC_DATUM
+    ].freeze
+  end
+end
+
+RGeo::CoordSys::CONFIG.default_coord_sys_class = RGeo::CoordSys::Proj4 if RGeo::CoordSys::Proj4.supported?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo-proj4
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 4.0.0.pre.rc.1
 platform: ruby
 authors:
 - Tee Parham, Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-08 00:00:00.000000000 Z
+date: 2022-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -16,42 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 3.0.0.pre.rc.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 3.0.0.pre.rc.3
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: ffi-geos
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.14'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.14'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: '5.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -103,11 +103,14 @@ extensions:
 extra_rdoc_files: []
 files:
 - LICENSE.txt
+- ext/proj4_c_impl/errors.c
+- ext/proj4_c_impl/errors.h
 - ext/proj4_c_impl/extconf.rb
 - ext/proj4_c_impl/main.c
+- ext/proj4_c_impl/preface.h
 - 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/errors.rb
 - lib/rgeo/proj4.rb
 - lib/rgeo/proj4/version.rb
 homepage: https://github.com/rgeo/rgeo-proj4
@@ -125,9 +128,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.4
 signing_key: 

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

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-# -----------------------------------------------------------------------------
-#
-# SRS database interface
-#
-# -----------------------------------------------------------------------------
-
-module RGeo
-  module CoordSys
-    module SRSDatabase
-      # A spatial reference database implementation backed by coordinate
-      # system files installed as part of the proj4 library. For a given
-      # Proj4Data object, you specify a single file (e.g. the epsg data
-      # file), and you can retrieve records by ID number.
-
-      class Proj4Data
-        # Connect to one of the proj4 data files. You should provide the
-        # file name, optionally the installation directory if it is not
-        # in a typical location, and several additional options.
-        #
-        # These options are recognized:
-        #
-        # [<tt>:dir</tt>]
-        #   The path for the share/proj directory that contains the
-        #   requested data file. By default, the Proj4Data class will
-        #   try a number of directories for you, including
-        #   /usr/local/share/proj, /opt/local/share/proj, /usr/share/proj,
-        #   and a few other variants. However, if you have proj4 installed
-        #   elsewhere, you can provide an explicit directory using this
-        #   option. You may also pass nil as the value, in which case all
-        #   the normal lookup paths will be disabled, and you will have to
-        #   provide the full path as the file name.
-        # [<tt>:cache</tt>]
-        #   If set to true, this class caches previously looked up entries
-        #   so subsequent lookups do not have to reread the file. If set
-        #   to <tt>:read_all</tt>, then ALL values in the file are read in
-        #   and cached the first time a lookup is done. If set to
-        #   <tt>:preload</tt>, then ALL values in the file are read in
-        #   immediately when the database is created. Default is false,
-        #   indicating that the file will be reread on every lookup.
-        # [<tt>:authority</tt>]
-        #   If set, its value is taken as the authority name for all
-        #   entries. The authority code will be set to the identifier. If
-        #   not set, then the authority fields of entries will be blank.
-
-        def initialize(filename_, opts_ = {})
-          dir_ = nil
-          if opts_.include?(:dir)
-            dir_ = opts_[:dir]
-          else
-            ["/usr/local/share/proj", "/usr/local/proj/share/proj", "/usr/local/proj4/share/proj", "/opt/local/share/proj", "/opt/proj/share/proj", "/opt/proj4/share/proj", "/opt/share/proj", "/usr/share/proj"].each do |d_|
-              if ::File.directory?(d_) && ::File.readable?(d_)
-                dir_ = d_
-                break
-              end
-            end
-          end
-          @path = dir_ ? "#{dir_}/#{filename_}" : filename_
-          @authority = opts_[:authority]
-          if opts_[:cache]
-            @cache = {}
-            case opts_[:cache]
-            when :read_all
-              @populate_state = 1
-            when :preload
-              search_file(nil)
-              @populate_state = 2
-            else
-              @populate_state = 0
-            end
-          else
-            @cache = nil
-            @populate_state = 0
-          end
-        end
-
-        # Retrieve the Entry for the given ID number.
-
-        def get(ident_)
-          ident_ = ident_.to_s
-          return @cache[ident_] if @cache&.include?(ident_)
-          result_ = nil
-          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
-          when 1
-            search_file(nil)
-            result_ = @cache[ident_]
-            @populate_state = 2
-          end
-          result_
-        end
-
-        # Clear the cache if one exists.
-
-        def clear_cache
-          @cache&.clear
-          @populate_state = 1 if @populate_state == 2
-        end
-
-        private
-
-        def search_file(ident_)
-          ::File.open(@path) do |file_|
-            cur_name_ = nil
-            cur_ident_ = nil
-            cur_text_ = nil
-            file_.each do |line_|
-              line_.strip!
-              if (comment_delim_ = line_.index("#"))
-                cur_name_ = line_[comment_delim_ + 1..-1].strip
-                line_ = line_[0..comment_delim_ - 1].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] == "<>"
-                cur_text_ << line_[0..-3].strip
-                cur_text_ = cur_text_.join(" ")
-                if ident_.nil?
-                  @cache[ident_] = Entry.new(ident_, authority: @authority, authority_code: @authority ? id_ : nil, name: cur_name_, proj4: cur_text_)
-                end
-                return [ident_, cur_name_, cur_text_] if cur_ident_ == ident_
-                cur_ident_ = nil
-                cur_name_ = nil
-                cur_text_ = nil
-              else
-                cur_text_ << line_
-              end
-            end
-          end
-          nil
-        end
-      end
-    end
-  end
-end