proj4rb 1.0.0 → 2.0.0

data/lib/projection.rb

@@ -0,0 +1,207 @@
+# encoding: UTF-8
+
+module Proj
+  # @deprecated This class is *DEPRECATED.* It will be removed when Proj 7 is released and removes the
+  #   underlying API's this class uses. Code should be ported to use Crs and Transformation objects.
+  class Projection
+    def self.parse(value)
+      values = case value
+                 when Array
+                   value
+                 when String
+                   value.strip.split(' ')
+                 when Hash
+                   array = []
+                   value.each_pair do |key, value|
+                     key = "+#{key}"
+                     array << (value.nil? ? key : "#{key}=#{value}")
+                   end
+                   array
+                 when Projection
+                   value.getDef.split(' ')
+                 else
+                   raise ArgumentError, "Unknown type #{value.class} for projection definition"
+               end
+    end
+
+    def self.finalize(pointer)
+      proc do
+        Api.pj_free(pointer)
+      end
+    end
+
+    # Projection classes are created using Proj4 strings which consist of a number of parameters.
+    # For more information please see the +opt arguments section at https://proj.org/apps/proj.html.
+    #
+    # @param value [string, array, hash] Parameters can be specified as strings, arrays or hashes.
+    #
+    # @example
+    #   proj = Projection.new("+proj=utm +zone=21 +units=m")
+    #   proj = Projection.new ["+proj=utm", "+zone=21", "+units=m"]
+    #   proj = Projection.new("proj" => "utm", "zone" => "21", "units" => "m")
+    #
+    # With all variants the plus sign in front of the keys is optional.
+    def initialize(value)
+      params = self.class.parse(value)
+      p_params = FFI::MemoryPointer.new(:pointer, params.length)
+      params.each_with_index do |param, i|
+        p_param = FFI::MemoryPointer.from_string(param)
+        p_params[i].write_pointer(p_param)
+      end
+
+      @pointer = Api.pj_init(params.count, p_params)
+      self.check_error
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+    end
+
+    def check_error
+      ptr = Api.pj_get_errno_ref
+      errno = ptr.read_int
+      if errno != 0
+        # If we don't reset the error code it hangs around. This doesn't seem documented anyplace?
+        ptr.write_int(0)
+        Error.check(errno)
+      end
+    end
+
+
+    def to_ptr
+      @pointer
+    end
+
+    # Returns projection definitions
+    #
+    # @return [String]
+    def getDef
+      Api.pj_get_def(self, 0)
+    end
+
+    # Returns if this is a geocentric projection
+    #
+    # @return [Boolean]
+    def isGeocent?
+      Api::pj_is_geocent(self)
+    end
+    alias :isGeocentric? :isGeocent?
+
+    # Returns if this is a lat/long projection
+    #
+    # @return [Boolean]
+    def isLatLong?
+      Api::pj_is_latlong(self)
+    end
+
+    # Get the ID of this projection.
+    #
+    # @return [String]
+    def projection
+      getDef =~ /\+proj=(.+?) / ?  $1 : nil
+    end
+
+    # Get the ID of the datum used in this projection.
+    #
+    # @return [String]
+    def datum
+      getDef =~ /\+datum=(.+?) / ? $1 : nil
+    end
+
+    # Get definition of projection in typical inspect format (#<Proj::Projection +init=... +proj=... ...>).
+    #
+    # @return [String]
+    def to_s
+      "#<#{self.class.name}#{getDef}>"
+    end
+
+    # Forward projection of a point. Returns a copy of the point object with coordinates projected.
+    #
+    # @param point [Point] in radians
+    # @return [Point] in cartesian coordinates
+    def forward(point)
+      struct = Api.pj_fwd(point, self)
+      self.check_error
+      Point.from_pointer(struct)
+    end
+
+    # Convenience function for calculating a forward projection with degrees instead of radians.
+    #
+    # @param point [Point] in degrees
+    # @return [Point] in cartesian coordinates
+    def forwardDeg(point)
+      forward(point.to_radians)
+    end
+
+    # Projects all points in a collection.
+    #
+    # @param collection [Enumerable<Point>] Points specified in radians
+    # @return [Enumerable<Point>] Points specified in cartesian coordinates
+    def forward_all(collection)
+      collection.map do |point|
+        forward(point)
+      end
+    end
+
+    # Inverse projection of a point. Returns a copy of the point object with coordinates projected.
+    #
+    # @param point [Point] in cartesian coordinates
+    # @return [Point] in radians
+    def inverse(point)
+      struct = Api.pj_inv(point, self)
+      self.check_error
+      Point.from_pointer(struct)
+    end
+
+    # Convenience function for calculating an inverse projection with the result in degrees instead of radians.
+    #
+    # @param point [Point] in cartesian coordinates
+    # @return [Point] in degrees
+    def inverseDeg(point)
+      result = inverse(point)
+      result.to_degrees
+    end
+
+    # Inverse projection of all points in a collection.
+    #
+    # @param collection [Enumerable<Point>] Points specified in cartesian coordinates
+    # @return [Enumerable<Point>] Points specified in radians
+    def inverse_all(collection)
+      collection.map do |point|
+        inverse(point)
+      end
+    end
+
+    # Transforms a point from one projection to another.
+    #
+    # @param other [Projection]
+    # @param point [Point]
+    # @return [Point]
+    def transform(other, point)
+      p_x = FFI::MemoryPointer.new(:double, 1)
+      p_x.write_double(point.x)
+
+      p_y = FFI::MemoryPointer.new(:double, 1)
+      p_y.write_double(point.y)
+
+      p_z = FFI::MemoryPointer.new(:double, 1)
+      p_z.write_double(0)
+
+      a = Api.pj_transform(self, other, 1, 1, p_x, p_y, p_z)
+      self.check_error
+
+      Point.new(p_x.read_double, p_y.read_double)
+    end
+
+    # Transforms all points in a collection from one projection to
+    # another. The +collection+ object must implement the +each+,
+    # +clear+, and << methods (just like an Array) for this to work.
+    #
+    # @param other [Projection]
+    # @param collection [Enumerable, Point]
+    # @return [Enumerable, Point]
+    def transform_all(other, collection)
+      collection.map do |point|
+        transform(other, point)
+      end
+    end
+  end
+end

data/lib/transformation.rb

@@ -0,0 +1,61 @@
+module Proj
+  # Transformation objects convert {Coordinate Coordinates} from one {Crs} to another.
+  class Transformation < PjObject
+    # Transforms a {Coordinate} from the source {Crs} to the target {Crs}. Coordinates should be expressed in
+    # the units and axis order of the definition of the source CRS. The returned transformed coordinate will
+    # be in the units and axis order of the definition of the target CRS.
+    #
+    # For most geographic Crses, the units will be in degrees. For geographic CRS defined by the EPSG authority,
+    # the order of coordinates is latitude first, longitude second. When using a PROJ initialization string,
+    # on contrary, the order will be longitude first, latitude second.
+    #
+    # For projected CRS, the units may vary (metre, us-foot, etc..).
+    #
+    # For projected CRS defined by the EPSG authority, and with EAST / NORTH directions, the axis order might be
+    # easting first, northing second, or the reverse. When using a PROJ string, the order will be
+    # easting first, northing second, except if the +axis parameter modifies it.
+    #
+    # @param source [Crs | String] - The source Crs. See the Crs documentation for the string format
+    # @param target [Crs | String] - The target Crs. See the Crs documentation for the string format
+    # @param context [Context]
+    def initialize(source, target, context=nil)
+      pointer = if source.is_a?(Crs) && target.is_a?(Crs)
+                  if Api.method_defined?(:proj_create_crs_to_crs_from_pj)
+                    Api.proj_create_crs_to_crs_from_pj(self.context, source, target, nil, nil)
+                  else
+                    Api.proj_create_crs_to_crs(self.context, source.definition, target.definition, nil)
+                  end
+                else
+                  Api.proj_create_crs_to_crs(self.context, source, target, nil)
+                end
+
+      if pointer.null?
+        Error.check
+      end
+
+      super(pointer, context)
+    end
+
+    # Transforms a {Coordinate} from the source {Crs} to the target {Crs}. Coordinates should be expressed in
+    # the units and axis order of the definition of the source CRS. The returned transformed coordinate will
+    # be in the units and axis order of the definition of the target CRS.
+    #
+    # @param coord [Coordinate]
+    # @return [Coordinate]
+    def forward(coord)
+      struct = Api.proj_trans(self, :PJ_FWD, coord)
+      Coordinate.from_coord(struct)
+    end
+
+    # Transforms a {Coordinate} from the target {Crs} to the source {Crs}. Coordinates should be expressed in
+    # the units and axis order of the definition of the source CRS. The returned transformed coordinate will
+    # be in the units and axis order of the definition of the target CRS.
+    #
+    # @param coord [Coordinate]
+    # @return [Coordinate]
+    def inverse(coord)
+      struct = Api.proj_trans(self, :PJ_INV, coord)
+      Coordinate.from_coord(struct)
+    end
+  end
+end

data/lib/unit.rb

@@ -0,0 +1,54 @@
+module Proj
+  class Unit
+    attr_reader :id, :to_meter, :factor, :name
+
+    def self.list
+      # First get linear units
+      pointer_to_array = FFI::Pointer.new(Api::PJ_UNITS, Api.proj_list_units)
+      result = Array.new
+      0.step do |i|
+        ellipse_info = Api::PJ_UNITS.new(pointer_to_array[i])
+        break if ellipse_info[:id].nil?
+        result << self.new(ellipse_info[:id], ellipse_info[:to_meter], ellipse_info[:factor], ellipse_info[:name])
+      end
+
+      # Now get angular linear units
+      if Api.method_defined?(:proj_list_angular_units)
+        pointer_to_array = FFI::Pointer.new(Api::PJ_UNITS, Api.proj_list_angular_units)
+        0.step do |i|
+          ellipse_info = Api::PJ_UNITS.new(pointer_to_array[i])
+          break result if ellipse_info[:id].nil?
+          result << self.new(ellipse_info[:id], ellipse_info[:to_meter], ellipse_info[:factor], ellipse_info[:name])
+        end
+      end
+      result
+    end
+
+    def self.get(id)
+      self.list.find {|ellipsoid| ellipsoid.id == id}
+    end
+
+    def initialize(id, to_meter, factor, name)
+      @id = id
+      @to_meter = to_meter
+      @factor = factor
+      @name = name
+    end
+
+    def <=>(other)
+      self.id <=> other.id
+    end
+
+    def ==(other)
+      self.id == other.id
+    end
+
+    def to_s
+      self.id
+    end
+    
+    def inspect
+      "#<#{self.class} id=\"#{id}\", to_meter=\"#{to_meter}\", factor=\"#{factor}\", name=\"#{name}\">"
+    end
+  end
+end

data/proj4rb.gemspec

@@ -0,0 +1,31 @@
+Gem::Specification.new do |spec|
+  spec.name = 'proj4rb'
+  spec.version = '2.0.0'
+  spec.summary = 'Ruby bindings for the Proj.4 Carthographic Projection library'
+  spec.description = <<-EOF
+    Proj4rb is a ruby binding for the Proj.4 Carthographic Projection library, that supports conversions between a very large number of geographic coordinate systems and datumspec.
+  EOF
+  spec.platform = Gem::Platform::RUBY
+  spec.authors = ['Guilhem Vellut', 'Jochen Topf', 'Charlie Savage']
+  spec.homepage = 'https://github.com/cfis/proj4rb'
+  spec.required_ruby_version = '>= 2.4.9'
+  spec.license = 'MIT'
+
+  spec.requirements << 'Proj (Proj4) Library'
+  spec.require_path = 'lib'
+  spec.files = Dir['ChangeLog',
+                   'Gemfile',
+                   'MIT-LICENSE',
+                   'proj4rb.gemspec',
+                   'Rakefile',
+                   'README.rdoc',
+                   'lib/*.rb',
+                   'test/*.rb']
+
+  spec.test_files = Dir["test/test_*.rb"]
+
+  spec.add_dependency "ffi"
+
+  spec.add_development_dependency('minitest')
+  spec.add_development_dependency('yard')
+end

data/test/abstract_test.rb

@@ -0,0 +1,7 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'proj'
+
+class AbstractTest < Minitest::Test
+end
+

data/test/context_test.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class ContextTest < AbstractTest
+  def test_create
+    context = Proj::Context.new
+    assert(context.to_ptr)
+  end
+
+  def test_finalize
+    500.times do
+      context = Proj::Context.new
+      assert(context.to_ptr)
+      GC.start
+    end
+    assert(true)
+  end
+
+  def test_one_per_thread
+    context_1 = Proj::Context.current
+    context_2 = Proj::Context.current
+    assert_same(context_1, context_2)
+  end
+
+  def test_database_path
+    refute_nil(Proj::Context.current.database_path)
+  end
+
+  def test_log_level
+    assert_equal(:PJ_LOG_NONE, Proj::Context.current.log_level)
+  end
+
+  def test_set_log_level
+    context = Proj::Context.new
+    context.log_level = :PJ_LOG_ERROR
+    assert_equal(:PJ_LOG_ERROR, context.log_level)
+  end
+
+  def test_invalid_database_path
+    path = '/wrong'
+    error = assert_raises(Proj::Error) do
+      Proj::Context.current.database_path = path
+    end
+    # TODO - if you run this test on its own you get a useful error message, if you run all tests
+    # at once you get a useless error message. Not sure what is causing the difference
+    assert_match(/No such file or directory|generic error of unknown origin/, error.to_s)
+  end
+
+  def test_set_log_function
+    context = Proj::Context.new
+    called = false
+
+    data = FFI::MemoryPointer.new(:int)
+    data.write_int(5)
+
+    context.set_log_function(data) do |pointer, int, message|
+      called = true
+      refute(pointer.null?)
+      assert_equal(5, pointer.read_int)
+      assert_equal(1, int)
+      assert_equal('proj_context_set_database_path: Open of /wrong failed', message)
+    end
+
+    begin
+      context.database_path = '/wrong'
+    rescue
+    end
+
+    assert(called)
+  end
+
+  def test_use_proj4_init_rules
+    refute(Proj::Context.current.use_proj4_init_rules)
+
+    Proj::Context.current.use_proj4_init_rules = true
+    assert(Proj::Context.current.use_proj4_init_rules)
+
+    Proj::Context.current.use_proj4_init_rules = false
+    refute(Proj::Context.current.use_proj4_init_rules)
+  end
+end