rgeo 0.6.0 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0b118363a5e851576b03d15095fc20d43e9e4c29
-  data.tar.gz: 878518023c981c1b0c7200b81bc183120d93c2cd
+SHA256:
+  metadata.gz: 1f829053838d792cf1148bc149d0bb29cca53437f1aa41bb10fa403c666c57b9
+  data.tar.gz: 01e39842598a32bf2deddde8b4d6430abd24f1fb6aaf92c954c18a5d9c316105
 SHA512:
-  metadata.gz: b9731327e808aeafd48276409f2a7432536ba723c11dff9f5faf739b31d0731fb71b3c01f224c5663b55f1b088f564b7bd5004663238d7269adc77763a04c383
-  data.tar.gz: 82dd3124fd0e669bfafd256abc7ff181f4e4c8f3381cbee492c7948adf244b28d0c664ba15413228cd34f67ac44e80b1105372253b7a8020bae0c4425f93f37c
+  metadata.gz: 8088804b587c0ae34d946f76d09360641d05ce5d608eebe3bc7a91ddf68e0082068bcd53ab1b2142b5ff7971ec488ea74140d8f1f39c06e551a2062f66de9884
+  data.tar.gz: 8a233f6ed24ec95d2eb72f5236af574cbdfbfa706a98cfecaa4f9f4bc27a4e341043cb523eacde2df25eb9a41284a8835e3cf98b27e443f160c3027a4133ad60

data/ext/geos_c_impl/geometry_collection.c

@@ -363,6 +363,23 @@ static VALUE method_multi_line_string_hash(VALUE self)
   return LONG2FIX(rb_hash_end(hash));
 }
 
+static VALUE method_geometry_collection_node(VALUE self)
+{
+  VALUE result = Qnil;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* noded;
+  GEOSContextHandle_t context;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  context = self_data->geos_context;
+
+  noded = GEOSNode_r(context, self_geom);
+  result = rgeo_wrap_geos_geometry(self_data->factory, noded, Qnil);
+
+  return result;
+}
 
 static VALUE method_multi_line_string_coordinates(VALUE self)
 {
@@ -609,6 +626,7 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   rb_define_method(geos_geometry_collection_methods, "geometry_n", method_geometry_collection_geometry_n, 1);
   rb_define_method(geos_geometry_collection_methods, "[]", method_geometry_collection_brackets, 1);
   rb_define_method(geos_geometry_collection_methods, "each", method_geometry_collection_each, 0);
+  rb_define_method(geos_geometry_collection_methods, "node", method_geometry_collection_node, 0);
 
 
   // Methods for MultiPointImpl

data/ext/geos_c_impl/line_string.c

@@ -247,6 +247,54 @@ static VALUE method_line_string_end_point(VALUE self)
   return result;
 }
 
+static VALUE method_line_string_project_point(VALUE self, VALUE point)
+{
+  RGeo_FactoryData* factory_data;
+  VALUE result = Qnil;
+  VALUE factory;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry *geos_point;
+
+  double location;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  self_geom = self_data->geom;
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+
+  if(self_geom && point) {
+    geos_point = rgeo_convert_to_geos_geometry(factory, point, factory_data->globals->geos_point);
+    location = GEOSProject_r(self_data->geos_context, self_geom, geos_point);
+    result = DBL2NUM(location);
+  }
+  return result;
+}
+
+static VALUE method_line_string_interpolate_point(VALUE self, VALUE loc_num)
+{
+  RGeo_FactoryData* factory_data;
+  VALUE result = Qnil;
+  VALUE factory;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* geos_point;
+
+  double location;
+
+  location = NUM2DBL(loc_num);
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  factory = self_data->factory;
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  self_geom = self_data->geom;
+
+  if(self_geom) {
+    geos_point = GEOSInterpolate_r(self_data->geos_context, self_geom, location);
+    result = rgeo_wrap_geos_geometry(factory, geos_point, factory_data->globals->geos_point);
+  }
+
+  return result;
+}
 
 static VALUE method_line_string_is_closed(VALUE self)
 {
@@ -613,6 +661,8 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_define_method(geos_line_string_methods, "points", method_line_string_points, 0);
   rb_define_method(geos_line_string_methods, "start_point", method_line_string_start_point, 0);
   rb_define_method(geos_line_string_methods, "end_point", method_line_string_end_point, 0);
+  rb_define_method(geos_line_string_methods, "project_point", method_line_string_project_point, 1);
+  rb_define_method(geos_line_string_methods, "interpolate_point", method_line_string_interpolate_point, 1);
   rb_define_method(geos_line_string_methods, "is_closed?", method_line_string_is_closed, 0);
   rb_define_method(geos_line_string_methods, "is_ring?", method_line_string_is_ring, 0);
   rb_define_method(geos_line_string_methods, "coordinates", method_line_string_coordinates, 0);

data/lib/rgeo/cartesian/factory.rb

@@ -20,12 +20,10 @@ module RGeo
         @has_z = opts_[:has_z_coordinate] ? true : false
         @has_m = opts_[:has_m_coordinate] ? true : false
         @proj4 = opts_[:proj4]
-        if CoordSys::Proj4.supported?
+        if @proj4 && CoordSys.check!(:proj4)
           if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
-        else
-          @proj4 = nil
         end
         srid_ = opts_[:srid]
         @coord_sys = opts_[:coord_sys]
@@ -115,7 +113,7 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
+        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
@@ -161,7 +159,7 @@ module RGeo
       end
 
       def init_with(coder_) # :nodoc:
-        if (proj4_data_ = coder_["proj4"])
+        if (proj4_data_ = coder_["proj4"]) && CoordSys.check!(:proj4)
           if proj4_data_.is_a?(::Hash)
             proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else

data/lib/rgeo/coord_sys.rb

@@ -26,18 +26,22 @@ module RGeo
   # such as those provided by spatialreference.org.
 
   module CoordSys
+    # The only valid key is :proj4
+    def self.supported?(key)
+      raise(Error::UnsupportedOperation, "Invalid key. The only valid key is :proj4.") unless key == :proj4
+      defined?(Proj4) && Proj4.supported?
+    end
+
+    def self.check!(key)
+      supported?(key) || raise(Error::UnsupportedOperation, "Coordinate system '#{key}' is not supported.")
+    end
   end
 end
 
 # Implementation files
-begin
-  require "rgeo/coord_sys/proj4_c_impl"
-rescue ::LoadError; end
-require "rgeo/coord_sys/proj4"
 require "rgeo/coord_sys/cs/factories"
 require "rgeo/coord_sys/cs/entities"
 require "rgeo/coord_sys/cs/wkt_parser"
 require "rgeo/coord_sys/srs_database/interface.rb"
-require "rgeo/coord_sys/srs_database/proj4_data.rb"
 require "rgeo/coord_sys/srs_database/url_reader.rb"
 require "rgeo/coord_sys/srs_database/sr_org.rb"

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

@@ -75,12 +75,10 @@ module RGeo
             @coord_sys = CS.create_from_wkt(@coord_sys)
           end
           @proj4 = data_[:proj4]
-          if Proj4.supported?
+          if @proj4 && CoordSys.check!(:proj4)
             if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
               @proj4 = Proj4.create(@proj4)
             end
-          else
-            @proj4 = nil
           end
           if @coord_sys
             @name = @coord_sys.name unless @name

data/lib/rgeo/feature/geometry.rb

@@ -403,12 +403,6 @@ module RGeo
         raise Error::UnsupportedOperation, "Method Geometry#relate not defined."
       end
 
-      # Deprecated alias of Geometry#relate?
-
-      def relate(another_geometry_, intersection_pattern_matrix_)
-        relate?(another_geometry_, intersection_pattern_matrix_)
-      end
-
       # === SFS 1.1 Description
       #
       # Returns the shortest distance between any two Points in the two

data/lib/rgeo/feature/geometry_collection.rb

@@ -80,6 +80,12 @@ module RGeo
         raise Error::UnsupportedOperation, "Method GeometryCollection#[] not defined."
       end
 
+      # Nodes the linework in a list of Geometries
+      #
+      def node
+        raise Error::UnsupportedOperation, "Method GeometryCollection#node not defined."
+      end
+
       # Iterates over the geometries of this GeometryCollection.
       #
       # This is not a standard SFS method, but is provided so that a

data/lib/rgeo/feature/types.rb

@@ -49,9 +49,6 @@ module RGeo
     #   ::RGeo::Feature::Type === object.geometry_type  # true
 
     module Type
-      # Deprecated alias for RGeo::Feature::Instance
-      Instance = Feature::Instance
-
       # Returns true if the given object is this type or a subtype
       # thereof, or if it is a feature object whose geometry_type is
       # this type or a subtype thereof.
@@ -202,7 +199,7 @@ module RGeo
               end
               hasz_ = factory_.property(:has_z_coordinate)
               nhasz_ = nfactory_.property(:has_z_coordinate)
-              if proj_ && nproj_
+              if proj_ && nproj_ && CoordSys.check!(:proj4)
                 coords_ = CoordSys::Proj4.transform_coords(proj_, nproj_, obj_.x, obj_.y, hasz_ ? obj_.z : nil)
                 coords_ << (hasz_ ? obj_.z : 0.0) if nhasz_ && coords_.size < 3
               else

data/lib/rgeo/geographic/factory.rb

@@ -28,12 +28,10 @@ module RGeo
         @support_m = opts_[:has_m_coordinate] ? true : false
         @srid = (opts_[:srid] || 4326).to_i
         @proj4 = opts_[:proj4]
-        if CoordSys::Proj4.supported?
+        if @proj4 && CoordSys.check!(:proj4)
           if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
-        else
-          @proj4 = nil
         end
         @coord_sys = opts_[:coord_sys]
         if @coord_sys.is_a?(::String)
@@ -124,7 +122,7 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
+        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
@@ -188,6 +186,7 @@ module RGeo
 
       def init_with(coder_) # :nodoc:
         if (proj4_data_ = coder_["proj4"])
+          CoordSys.check!(:proj4)
           if proj4_data_.is_a?(::Hash)
             proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else

data/lib/rgeo/geographic/interface.rb

@@ -344,9 +344,7 @@ module RGeo
       # more details.
 
       def projected_factory(opts_ = {})
-        unless CoordSys::Proj4.supported?
-          raise Error::UnsupportedOperation, "Proj4 is not supported because the proj4 library was not found at install time."
-        end
+        CoordSys.check!(:proj4)
         db_ = opts_[:srs_database]
         if (projection_factory_ = opts_[:projection_factory])
           # Get the projection coordinate systems from the given factory
@@ -459,7 +457,7 @@ module RGeo
 
       def _proj4_4055 # :nodoc:
         unless defined?(@proj4_4055)
-          @proj4_4055 = CoordSys::Proj4.create("+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs")
+          @proj4_4055 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +no_defs")
         end
         @proj4_4055
       end
@@ -473,7 +471,7 @@ module RGeo
 
       def _proj4_4326 # :nodoc:
         unless defined?(@proj4_4326)
-          @proj4_4326 = CoordSys::Proj4.create("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
+          @proj4_4326 = CoordSys.supported?(:proj4) && CoordSys::Proj4.create("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
         end
         @proj4_4326
       end

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -93,6 +93,7 @@ module RGeo
       end
 
       def self._proj4_3857 # :nodoc:
+        return unless CoordSys.supported?(:proj4)
         unless defined?(@proj4_3857)
           @proj4_3857 = CoordSys::Proj4.create("+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +a=6378137 +b=6378137 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs")
         end

data/lib/rgeo/geos/capi_factory.rb

@@ -58,7 +58,7 @@ module RGeo
           # Coordinate system (srid, proj4, and coord_sys)
           srid_ = opts_[:srid]
           proj4_ = opts_[:proj4]
-          if CoordSys::Proj4.supported?
+          if proj4_ && CoordSys.check!(:proj4)
             if proj4_.is_a?(::String) || proj4_.is_a?(::Hash)
               proj4_ = CoordSys::Proj4.create(proj4_)
             end
@@ -159,7 +159,7 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
+        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
@@ -210,6 +210,7 @@ module RGeo
 
       def init_with(coder_) # :nodoc:
         if (proj4_data_ = coder_["proj4"])
+          CoordSys.check!(:proj4)
           if proj4_data_.is_a?(::Hash)
             proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else
@@ -462,9 +463,5 @@ module RGeo
 
       # :startdoc:
     end
-
-    # Deprecated alias of CAPIFactory.
-    # Defined primarily to support old YAML serializations.
-    Factory = CAPIFactory
   end
 end

data/lib/rgeo/geos/ffi_factory.rb

@@ -59,7 +59,7 @@ module RGeo
         # Coordinate system (srid, proj4, and coord_sys)
         @srid = opts_[:srid]
         @proj4 = opts_[:proj4]
-        if CoordSys::Proj4.supported?
+        if @proj4 && CoordSys.check!(:proj4)
           if @proj4.is_a?(::String) || @proj4.is_a?(::Hash)
             @proj4 = CoordSys::Proj4.create(@proj4)
           end
@@ -155,7 +155,7 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
+        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
@@ -204,6 +204,7 @@ module RGeo
 
       def init_with(coder_) # :nodoc:
         if (proj4_data_ = coder_["proj4"])
+          CoordSys.check!(:proj4)
           if proj4_data_.is_a?(::Hash)
             proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else

data/lib/rgeo/geos/zm_factory.rb

@@ -118,7 +118,7 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if CoordSys::Proj4.supported? && (proj4_data_ = data_["proj4"])
+        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(:proj4)
           proj4_ = CoordSys::Proj4.allocate
           proj4_.marshal_load(proj4_data_)
         else
@@ -169,6 +169,7 @@ module RGeo
 
       def init_with(coder_) # :nodoc:
         if (proj4_data_ = coder_["proj4"])
+          CoordSys.check!(:proj4)
           if proj4_data_.is_a?(::Hash)
             proj4_ = CoordSys::Proj4.create(proj4_data_["proj4"], radians: proj4_data_["radians"])
           else

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -301,8 +301,13 @@ module RGeo
       alias_method :[], :geometry_n
 
       def each
-        num_geometries.times do |i_|
-          yield geometry_n(i_)
+        if block_given?
+          num_geometries.times do |i_|
+            yield geometry_n(i_)
+          end
+          self
+        else
+          enum_for
         end
       end
 

data/lib/rgeo/version.rb

@@ -1,3 +1,3 @@
 module RGeo
-  VERSION = "0.6.0".freeze
+  VERSION = "1.0.0.rc1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Daniel Azuma, Tee Parham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -103,7 +103,6 @@ email: dazuma@gmail.com, parhameter@gmail.com
 executables: []
 extensions:
 - ext/geos_c_impl/extconf.rb
-- ext/proj4_c_impl/extconf.rb
 extra_rdoc_files: []
 files:
 - LICENSE.txt
@@ -124,8 +123,6 @@ files:
 - ext/geos_c_impl/polygon.c
 - ext/geos_c_impl/polygon.h
 - ext/geos_c_impl/preface.h
-- ext/proj4_c_impl/extconf.rb
-- ext/proj4_c_impl/main.c
 - lib/rgeo.rb
 - lib/rgeo/cartesian.rb
 - lib/rgeo/cartesian/analysis.rb
@@ -139,9 +136,7 @@ files:
 - lib/rgeo/coord_sys/cs/entities.rb
 - lib/rgeo/coord_sys/cs/factories.rb
 - lib/rgeo/coord_sys/cs/wkt_parser.rb
-- lib/rgeo/coord_sys/proj4.rb
 - lib/rgeo/coord_sys/srs_database/interface.rb
-- lib/rgeo/coord_sys/srs_database/proj4_data.rb
 - lib/rgeo/coord_sys/srs_database/sr_org.rb
 - lib/rgeo/coord_sys/srs_database/url_reader.rb
 - lib/rgeo/error.rb
@@ -214,12 +209,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.7.0
 signing_key: 
 specification_version: 4
 summary: RGeo is a geospatial data library for Ruby.

data/ext/proj4_c_impl/extconf.rb

@@ -1,62 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,315 +0,0 @@
-/*
-  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

@@ -1,293 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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 a string of the format "x.y.z".
-
-        def version
-          ::RGeo::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

@@ -1,140 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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