rgeo-proj4 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9c7651625154609a01979271df45bd5229be4c1c78b10834540981408bf8240
+  data.tar.gz: 53a6f93a200983b08020f8bea256c575a27e061b78f172a03d51caba53852442
+SHA512:
+  metadata.gz: 24b00ed0eb17c8e77ea5fa1efd0eedc91468c6c79ee89d06ee0940cd613a3c382942e2f881c42d66a00281c3653f566d94524a05af6de388021631e06e04a376
+  data.tar.gz: 16e019ec27581cc9bca711beca05558339c43a2e919847861be79e96fd4a8c88cf592a3ddf91490dc47ab06099c1508cb26f695d3a535759371ae325fdb0788b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Tee Parham, Daniel Azuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/ext/proj4_c_impl/extconf.rb

@@ -0,0 +1,62 @@
+# -----------------------------------------------------------------------------
+#
+# Makefile builder for Proj4 wrapper
+#
+# -----------------------------------------------------------------------------
+
+if ::RUBY_DESCRIPTION =~ /^jruby\s/
+
+  ::File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
+
+else
+
+  require "mkmf"
+
+  header_dirs_ =
+    [
+      ::RbConfig::CONFIG["includedir"],
+      "/usr/local/include",
+      "/usr/local/proj/include",
+      "/usr/local/proj4/include",
+      "/opt/local/include",
+      "/opt/proj/include",
+      "/opt/proj4/include",
+      "/opt/include",
+      "/Library/Frameworks/PROJ.framework/unix/include",
+      "/usr/include"
+    ]
+  lib_dirs_ =
+    [
+      ::RbConfig::CONFIG["libdir"],
+      "/usr/local/lib",
+      "/usr/local/lib64",
+      "/usr/local/proj/lib",
+      "/usr/local/proj4/lib",
+      "/opt/local/lib",
+      "/opt/proj/lib",
+      "/opt/proj4/lib",
+      "/opt/lib",
+      "/Library/Frameworks/PROJ.framework/unix/lib",
+      "/usr/lib",
+      "/usr/lib64"
+    ]
+  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_)
+  if have_header("proj_api.h")
+    $libs << " -lproj"
+    if have_func("pj_init_plus", "proj_api.h")
+      found_proj_ = true
+    else
+      $libs.gsub!(" -lproj", "")
+    end
+  end
+  unless found_proj_
+    puts "**** WARNING: Unable to find Proj headers or Proj version is too old."
+    puts "**** Compiling without Proj support."
+  end
+  create_makefile("rgeo/coord_sys/proj4_c_impl")
+
+end

data/ext/proj4_c_impl/main.c

@@ -0,0 +1,315 @@
+/*
+  Main initializer for Proj4 wrapper
+*/
+
+#ifdef HAVE_PROJ_API_H
+#ifdef HAVE_PJ_INIT_PLUS
+#define RGEO_PROJ4_SUPPORTED
+#endif
+#endif
+
+#ifdef __cplusplus
+#define RGEO_BEGIN_C extern "C" {
+#define RGEO_END_C }
+#else
+#define RGEO_BEGIN_C
+#define RGEO_END_C
+#endif
+
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+#include <ruby.h>
+#include <proj_api.h>
+
+#endif
+
+
+RGEO_BEGIN_C
+
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+
+typedef struct {
+  projPJ pj;
+  VALUE original_str;
+  char uses_radians;
+} RGeo_Proj4Data;
+
+
+#define RGEO_PROJ4_DATA_PTR(obj) ((RGeo_Proj4Data*)DATA_PTR(obj))
+
+
+// Destroy function for proj data.
+
+static void destroy_proj4_func(RGeo_Proj4Data* data)
+{
+  if (data->pj) {
+    pj_free(data->pj);
+  }
+  free(data);
+}
+
+
+static void mark_proj4_func(RGeo_Proj4Data* data)
+{
+  if (!NIL_P(data->original_str)) {
+    rb_gc_mark(data->original_str);
+  }
+}
+
+
+static VALUE alloc_proj4(VALUE klass)
+{
+  VALUE result;
+  RGeo_Proj4Data* data;
+
+  result = Qnil;
+  data = ALLOC(RGeo_Proj4Data);
+  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);
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
+{
+  RGeo_Proj4Data* self_data;
+  projPJ pj;
+  RGeo_Proj4Data* orig_data;
+  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;
+  }
+
+  // Copy value from orig
+  orig_data = RGEO_PROJ4_DATA_PTR(orig);
+  if (!NIL_P(orig_data->original_str)) {
+    self_data->pj = pj_init_plus(RSTRING_PTR(orig_data->original_str));
+  }
+  else {
+    str = pj_get_def(orig_data->pj, 0);
+    self_data->pj = pj_init_plus(str);
+    pj_dalloc(str);
+  }
+  self_data->original_str = orig_data->original_str;
+  self_data->uses_radians = orig_data->uses_radians;
+
+  return self;
+}
+
+
+static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
+{
+  RGeo_Proj4Data* self_data;
+  projPJ pj;
+
+  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;
+  }
+
+  // Set new data
+  self_data->pj = pj_init_plus(RSTRING_PTR(str));
+  self_data->original_str = str;
+  self_data->uses_radians = RTEST(uses_radians) ? 1 : 0;
+
+  return self;
+}
+
+
+static VALUE method_proj4_get_geographic(VALUE self)
+{
+  VALUE result;
+  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);
+    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);
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_original_str(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->original_str;
+}
+
+
+static VALUE method_proj4_uses_radians(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->uses_radians ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_proj4_canonical_str(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+  char* str;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    str = pj_get_def(pj, 0);
+    if (str) {
+      result = rb_str_new2(str);
+      pj_dalloc(str);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_geographic(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    result = pj_is_latlong(pj) ? Qtrue : Qfalse;
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_geocentric(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    result = pj_is_geocent(pj) ? Qtrue : Qfalse;
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_valid(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->pj ? Qtrue : Qfalse;
+}
+
+
+static VALUE cmethod_proj4_version(VALUE module)
+{
+  return INT2NUM(PJ_VERSION);
+}
+
+
+static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
+{
+  VALUE result;
+  projPJ from_pj;
+  projPJ to_pj;
+  double xval, yval, zval;
+  int err;
+
+  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));
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
+{
+  VALUE result;
+  RGeo_Proj4Data* data;
+
+  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);
+  }
+  return result;
+}
+
+
+static void rgeo_init_proj4()
+{
+  VALUE rgeo_module;
+  VALUE coordsys_module;
+  VALUE proj4_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);
+  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, "_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);
+}
+
+
+#endif
+
+
+void Init_proj4_c_impl()
+{
+#ifdef RGEO_PROJ4_SUPPORTED
+  rgeo_init_proj4();
+#endif
+}
+
+
+RGEO_END_C

data/lib/rgeo/coord_sys/proj4.rb

@@ -0,0 +1,293 @@
+# -----------------------------------------------------------------------------
+#
+# Proj4 wrapper for RGeo
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module CoordSys
+    # This is a Ruby wrapper around a Proj4 coordinate system.
+    # It represents a single geographic coordinate system, which may be
+    # a flat projection, a geocentric (3-dimensional) coordinate system,
+    # or a geographic (latitude-longitude) coordinate system.
+    #
+    # Generally, these are used to define the projection for a
+    # Feature::Factory. You can then convert between coordinate systems
+    # by casting geometries between such factories using the :project
+    # option. You may also use this object directly to perform low-level
+    # coordinate transformations.
+
+    class Proj4
+      def inspect # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{canonical_str.inspect}>"
+      end
+
+      def to_s  # :nodoc:
+        canonical_str
+      end
+
+      def hash  # :nodoc:
+        @hash ||= canonical_hash.hash
+      end
+
+      # Returns true if this Proj4 is equivalent to the given Proj4.
+      #
+      # Note: this tests for equivalence by comparing only the hash
+      # definitions of the Proj4 objects, and returning true if those
+      # definitions are equivalent. In some cases, this may still return
+      # false even if the actual coordinate systems are identical, since
+      # 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?
+      end
+      alias_method :==, :eql?
+
+      # Marshal support
+
+      def marshal_dump # :nodoc:
+        { "rad" => radians?, "str" => original_str || canonical_str }
+      end
+
+      def marshal_load(data_) # :nodoc:
+        _set_value(data_["str"], data_["rad"])
+      end
+
+      # Psych support
+
+      def encode_with(coder_) # :nodoc:
+        coder_["proj4"] = original_str || canonical_str
+        coder_["radians"] = radians?
+      end
+
+      def init_with(coder_) # :nodoc:
+        if coder_.type == :scalar
+          _set_value(coder_.scalar, false)
+        else
+          _set_value(coder_["proj4"], coder_["radians"])
+        end
+      end
+
+      # Returns the "canonical" string definition for this coordinate
+      # system, as reported by Proj4. This may be slightly different
+      # from the definition used to construct this object.
+
+      def canonical_str
+        unless defined?(@canonical_str)
+          @canonical_str = _canonical_str
+          if @canonical_str.respond_to?(:force_encoding)
+            @canonical_str.force_encoding("US-ASCII")
+          end
+        end
+        @canonical_str
+      end
+
+      # Returns the "canonical" hash definition for this coordinate
+      # system, as reported by Proj4. This may be slightly different
+      # from the definition used to construct this object.
+
+      def canonical_hash
+        unless defined?(@canonical_hash)
+          @canonical_hash = {}
+          canonical_str.strip.split(/\s+/).each do |elem_|
+            @canonical_hash[Regexp.last_match(1)] = Regexp.last_match(3) if elem_ =~ /^\+(\w+)(=(\S+))?$/
+          end
+        end
+        @canonical_hash
+      end
+
+      # Returns the string definition originally used to construct this
+      # object. Returns nil if this object wasn't created by a string
+      # definition; i.e. if it was created using get_geographic.
+
+      def original_str
+        _original_str
+      end
+
+      # Returns true if this Proj4 object is a geographic (lat-long)
+      # coordinate system.
+
+      def geographic?
+        _geographic?
+      end
+
+      # Returns true if this Proj4 object is a geocentric (3dz)
+      # coordinate system.
+
+      def geocentric?
+        _geocentric?
+      end
+
+      # Returns true if this Proj4 object uses radians rather than degrees
+      # if it is a geographic coordinate system.
+
+      def radians?
+        _radians?
+      end
+
+      # Get the geographic (unprojected lat-long) coordinate system
+      # corresponding to this coordinate system; i.e. the one that uses
+      # the same ellipsoid and datum.
+
+      def get_geographic
+        _get_geographic
+      end
+
+      class << self
+        # Returns true if Proj4 is supported in this installation.
+        # If this returns false, the other methods such as create
+        # will not work.
+
+        def supported?
+          respond_to?(:_create)
+        end
+
+        # Returns the Proj library version as an integer (example: 493).
+        # TODO: return as string of the format "x.y.z".
+        def version
+          _proj_version
+        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.
+        #
+        # Recognized options include:
+        #
+        # [<tt>:radians</tt>]
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
+
+        def create(defn_, opts_ = {})
+          result_ = nil
+          if supported?
+            if defn_.is_a?(::Hash)
+              defn_ = defn_.map { |k_, v_| v_ ? "+#{k_}=#{v_}" : "+#{k_}" }.join(" ")
+            end
+            unless defn_ =~ /^\s*\+/
+              defn_ = defn_.sub(/^(\s*)/, '\1+').gsub(/(\s+)([^+\s])/, '\1+\2')
+            end
+            result_ = _create(defn_, opts_[:radians])
+            result_ = nil unless result_._valid?
+          end
+          result_
+        end
+
+        # Create a new Proj4 object, given a definition, which may be
+        # either a string or a hash. Raises Error::UnsupportedOperation
+        # if the given definition is invalid or Proj4 is not supported.
+        #
+        # Recognized options include:
+        #
+        # [<tt>:radians</tt>]
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
+
+        def new(defn_, opts_ = {})
+          result_ = create(defn_, opts_)
+          unless result_
+            raise Error::UnsupportedOperation, "Proj4 not supported in this installation"
+          end
+          result_
+        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(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_
+        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_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
+
+        def _transform_point(from_proj_, from_point_, to_proj_, to_factory_) # :nodoc:
+          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)
+          if 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_
+            extras_ << from_has_m_ ? from_point_.m : 0.0 if to_has_m_
+            to_factory_.point(coords_[0], coords_[1], *extras_)
+          end
+        end
+
+        def _transform_linear_ring(from_proj_, from_ring_, to_proj_, to_factory_) # :nodoc:
+          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_) # :nodoc:
+          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_)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# -----------------------------------------------------------------------------
+#
+# 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 && @cache.include?(ident_)
+          result_ = nil
+          if @populate_state == 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
+            _search_file(nil)
+            result_ = @cache[ident_]
+            @populate_state = 2
+          end
+          result_
+        end
+
+        # Clear the cache if one exists.
+
+        def clear_cache
+          @cache.clear if @cache
+          @populate_state = 1 if @populate_state == 2
+        end
+
+        def _search_file(ident_) # :nodoc:
+          ::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
+              unless cur_ident_
+                if line_ =~ /^<(\w+)>(.*)/
+                  cur_ident_ = Regexp.last_match(1)
+                  cur_text_ = []
+                  line_ = Regexp.last_match(2).strip
+                end
+              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

data/lib/rgeo/proj4.rb

@@ -0,0 +1,5 @@
+require "rgeo"
+require "rgeo/proj4/version"
+require "rgeo/coord_sys/proj4"
+require "rgeo/coord_sys/srs_database/proj4_data"
+require "rgeo/coord_sys/proj4_c_impl"

data/lib/rgeo/proj4/version.rb

@@ -0,0 +1,5 @@
+module RGeo
+  module Proj4
+    VERSION = "1.0.0.rc1"
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rgeo-proj4
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Tee Parham, Daniel Azuma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rgeo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Proj4 extension for rgeo.
+email:
+- parhameter@gmail.com, dazuma@gmail.com
+executables: []
+extensions:
+- ext/proj4_c_impl/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- ext/proj4_c_impl/extconf.rb
+- ext/proj4_c_impl/main.c
+- lib/rgeo/coord_sys/proj4.rb
+- lib/rgeo/coord_sys/srs_database/proj4_data.rb
+- lib/rgeo/proj4.rb
+- lib/rgeo/proj4/version.rb
+homepage: https://github.com/rgeo/rgeo-proj4
+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.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.0
+signing_key: 
+specification_version: 4
+summary: Proj4 extension for rgeo.
+test_files: []