proj4rb 2.2.2 → 4.0.0

data/lib/area.rb

@@ -1,32 +0,0 @@
-module Proj
-  class Area
-    attr_reader :name, :west_lon_degree, :south_lat_degree, :east_lon_degree, :north_lat_degree
-
-    def self.for_object(pj_object)
-      p_name = FFI::MemoryPointer.new(:pointer)
-      p_west_lon_degree = FFI::MemoryPointer.new(:double)
-      p_south_lat_degree = FFI::MemoryPointer.new(:double)
-      p_east_lon_degree = FFI::MemoryPointer.new(:double)
-      p_north_lat_degree = FFI::MemoryPointer.new(:double)
-
-      result = Api.proj_get_area_of_use(Context.current, pj_object,
-                                        p_west_lon_degree, p_south_lat_degree, p_east_lon_degree, p_north_lat_degree,
-                                        p_name)
-      unless result
-        Error.check
-      end
-
-      name = p_name.read_pointer.read_string_to_null.force_encoding('utf-8')
-      self.new(name,
-               p_west_lon_degree.read_double, p_south_lat_degree.read_double, p_east_lon_degree.read_double, p_north_lat_degree.read_double)
-    end
-
-    def initialize(name, west_lon_degree, south_lat_degree, east_lon_degree, north_lat_degree)
-      @name = name
-      @west_lon_degree = west_lon_degree
-      @south_lat_degree = south_lat_degree
-      @east_lon_degree = east_lon_degree
-      @north_lat_degree = north_lat_degree
-    end
-  end
-end

data/lib/config.rb

@@ -1,70 +0,0 @@
-require 'singleton'
-
-module Proj
-  class Config
-    include Singleton
-
-    def set_search_paths
-      p_paths = self.search_paths_pointer
-      items = p_paths.type_size/p_paths.size
-
-      # Set search paths on default context - any new contexts will inherit from this
-      if Api.method_defined?(:proj_context_set_search_paths)
-        Api.proj_context_set_search_paths(nil, items, p_paths)
-      end
-
-      if Api.method_defined?(:pj_set_searchpath)
-        Api.pj_set_searchpath(items, p_paths)
-      end
-    end
-
-    def search_paths
-      ['/usr/share/proj',
-       '/usr/local/share/proj',
-       '/opt/share/proj',
-       '/opt/local/share/proj',
-       'c:/msys64/mingw64/share/proj',
-       'c:/mingw64/share/proj',
-       '/opt/local/lib/proj6/share/proj',
-       '/opt/local/lib/proj5/share/proj',
-       '/opt/local/lib/proj49/share/proj']
-    end
-
-    def data_path
-      if ENV['PROJ_LIB'] && File.directory?(ENV['PROJ_LIB'])
-        ENV['PROJ_LIB']
-      else
-        result = self.search_paths.detect do |path|
-          File.directory?(path)
-        end
-
-        unless result
-          raise(Error, "Could not find Proj data directory. Please set the PROJ_LIB environmental variable to correct directory")
-        end
-
-        result
-      end
-    end
-
-    def search_paths_pointer
-      p_path = FFI::MemoryPointer.from_string(self.data_path)
-      p_paths = FFI::MemoryPointer.new(:pointer, 1)
-      p_paths[0].write_pointer(p_path)
-      p_paths
-    end
-
-    def db_path
-      result = self.search_paths.map do |path|
-        File.join(path, 'proj.db')
-      end.detect do |path|
-        File.exists?(path)
-      end
-
-      unless result
-        raise(Error, "Could not find Proj database (proj.db). Please set the PROJ_LIB environmental variable to directory that contains it")
-      end
-
-      result
-    end
-  end
-end

data/lib/context.rb

@@ -1,103 +0,0 @@
-module Proj
-  # Proj 4.8 introduced the concept of a thread context object to support multi-threaded programs. The bindings
-  # automatically create on context per thread (its stored in local thread storage).
-  class Context
-    # The context for the current thread
-    #
-    # @return [Context]
-    def self.current
-      Thread.current[:proj_context] ||= Context.new
-    end
-
-    def self.finalize(pointer)
-      proc do
-        Api.proj_context_destroy(pointer)
-      end
-    end
-
-    def initialize
-      @pointer = Api.proj_context_create
-      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
-
-      set_database_path
-    end
-
-    # Helper method that tries to locate the Proj coordinate database (proj.db)
-    def set_database_path
-      return unless Api.method_defined?(:proj_context_get_database_path)
-      return if database_path
-
-      self.database_path = Config.instance.db_path
-    end
-
-    def to_ptr
-      @pointer
-    end
-
-    # Get the last error number
-    #
-    # return [Integer]
-    def errno
-      Api.proj_context_errno(self)
-    end
-
-    # Gets the path the Proj database
-    #
-    # return [String]
-    def database_path
-      Api.proj_context_get_database_path(self)
-    end
-
-    # Sets the path to the Proj database
-    def database_path=(value)
-      result = Api.proj_context_set_database_path(self, value, nil, nil)
-      unless result == 1
-        Error.check(self.errno)
-      end
-    end
-
-    # Sets a custom log function
-    #
-    # @example
-    #   context.set_log_function(data) do |pointer, int, message|
-    #     ... do stuff...
-    #   end
-    #
-    # @param pointer [FFI::MemoryPointer] Optional pointer to custom data
-    # @param proc [Proc] Custom logging procedure
-    # @return [nil]
-    def set_log_function(pointer = nil, &proc)
-      Api.proj_log_func(self, pointer, proc)
-    end
-
-    # Gets the current log level
-    #
-    # @return [:PJ_LOG_LEVEL]
-    def log_level
-      Api.proj_log_level(self, :PJ_LOG_TELL)
-    end
-
-    # Sets the current log level
-    #
-    # @param value [:PJ_LOG_LEVEL]
-    # @return [nil]
-    def log_level=(value)
-      Api.proj_log_level(self, value)
-    end
-
-    # Gets if proj4 init rules are being used (i.e., support +init parameters)
-    #
-    # @return [Boolean]
-    def use_proj4_init_rules
-      Api.proj_context_get_use_proj4_init_rules(self, 0)
-    end
-
-    # Sets if proj4 init rules should be used
-    #
-    # @param value [Boolean]
-    # @return [nil]
-    def use_proj4_init_rules=(value)
-      Api.proj_context_use_proj4_init_rules(self, value ? 1 : 0)
-    end
-  end
-end

data/lib/crs.rb

@@ -1,204 +0,0 @@
-# encoding: UTF-8
-require 'stringio'
-
-module Proj
-  # Represents a coordinate reference system.
-  class Crs < PjObject
-    # To create a coordinate system, you can use CRS codes, well-known text (WKT) strings
-    # or old-style Proj4 strings (which are deprecated).
-    #
-    # @example
-    #   crs1 = Proj::Crs.new('EPSG:4326')
-    #   crs2 = Proj::Crs.new('urn:ogc:def:crs:EPSG::4326')
-    #   crs3 = Proj::Crs.new('+proj=longlat +datum=WGS84 +no_defs +type=crs')
-    #   crs4 = Proj::Crs.new(<<~EOS)
-    #            GEOGCRS["WGS 84",
-    #            DATUM["World Geodetic System 1984",
-    #                  ELLIPSOID["WGS 84",6378137,298.257223563,
-    #                            LENGTHUNIT["metre",1]]],
-    #            PRIMEM["Greenwich",0,
-    #                   ANGLEUNIT["degree",0.0174532925199433]],
-    #            CS[ellipsoidal,2],
-    #            AXIS["geodetic latitude (Lat)",north,
-    #                 ORDER[1],
-    #                 ANGLEUNIT["degree",0.0174532925199433]],
-    #            AXIS["geodetic longitude (Lon)",east,
-    #                 ORDER[2],
-    #                 ANGLEUNIT["degree",0.0174532925199433]],
-    #            USAGE[
-    #                SCOPE["unknown"],
-    #                    AREA["World"],
-    #                BBOX[-90,-180,90,180]],
-    #            ID["EPSG",4326]]
-    #          EOS
-    #
-    # Notice when using the old-style Proj4 string, the addition of the "+type=crs" value.
-    #
-    # @param value [String]. See above
-    # @param context [Context]. An optional Context that the Crs will use for calculations.
-    def initialize(value, context=nil)
-      pointer = Api.proj_create(context || Context.current, value)
-
-      if pointer.null?
-        Error.check
-      end
-
-      super(pointer, context)
-
-      if Api.method_defined?(:proj_is_crs) && !Api.proj_is_crs(pointer)
-        raise(Error, "Invalid crs definition. Proj created an instance of: #{self.proj_type}.")
-      end
-    end
-
-    # Get the geodeticCRS / geographicCRS from a CRS.
-    #
-    # @return [Crs]
-    def geodetic_crs
-      PjObject.new(Api.proj_crs_get_geodetic_crs(self.context, self))
-    end
-
-    # Get a CRS component from a CompoundCRS.
-    #
-    # @return [Crs]
-    def sub_crs(index)
-      PjObject.new(Api.proj_crs_get_sub_crs(self.context, self, index))
-    end
-
-    # Returns the datum of a SingleCRS.
-    #
-    # @return [Crs]
-    def datum
-      PjObject.new(Api.proj_crs_get_datum(self.context, self))
-    end
-
-    # Get the horizontal datum from a CRS.
-    #
-    # @return [Crs]
-    def horizontal_datum
-      PjObject.new(Api.proj_crs_get_horizontal_datum(self.context, self))
-    end
-
-    # Returns the coordinate system of a SingleCRS.
-    #
-    # @return [Crs]
-    def coordinate_system
-      PjObject.new(Api.proj_crs_get_coordinate_system(self.context, self))
-    end
-
-    # Returns the number of axis of the coordinate system.
-    #
-    # @return [Integer]
-    def axis_count
-      result = Api.proj_cs_get_axis_count(self.context, self.coordinate_system)
-      if result == -1
-        Error.check
-      end
-      result
-    end
-
-    # Returns information on an axis.
-    #
-    # @return [Array<Hash>]
-    def axis_info
-      self.axis_count.times.map do |index|
-        p_name = FFI::MemoryPointer.new(:pointer)
-        p_abbreviation = FFI::MemoryPointer.new(:pointer)
-        p_direction = FFI::MemoryPointer.new(:pointer)
-        p_unit_conv_factor = FFI::MemoryPointer.new(:double)
-        p_unit_name = FFI::MemoryPointer.new(:pointer)
-        p_unit_auth_name = FFI::MemoryPointer.new(:pointer)
-        p_unit_code = FFI::MemoryPointer.new(:pointer)
-
-        result = Api.proj_cs_get_axis_info(self.context, self.coordinate_system, index,
-                                           p_name, p_abbreviation, p_direction, p_unit_conv_factor, p_unit_name, p_unit_auth_name, p_unit_code)
-
-        unless result
-          Error.check
-        end
-
-        {:name => p_name.read_pointer.read_string,
-         :abbreviation => p_abbreviation.read_pointer.read_string_to_null,
-         :direction => p_direction.read_pointer.read_string_to_null,
-         :unit_conv_factor => p_unit_conv_factor.read_double,
-         :unit_name => p_unit_name.read_pointer.read_string_to_null,
-         :unit_auth_name => p_unit_auth_name.read_pointer.read_string_to_null,
-         :unit_code => p_unit_code.read_pointer.read_string_to_null}
-      end
-    end
-
-    # Returns the type of the coordinate system.
-    #
-    # @return [:PJ_COORDINATE_SYSTEM_TYPE]
-    def crs_type
-      result = Api.proj_cs_get_type(self.context, self.coordinate_system)
-      if result == :PJ_CS_TYPE_UNKNOWN
-        Error.check
-      end
-      result
-    end
-
-    # Return the area of use of an object.
-    #
-    # @return [Area]
-    def area
-      @area ||= Area.for_object(self)
-    end
-
-    # Get the ellipsoid from a CRS or a GeodeticReferenceFrame.
-    #
-    # @return [PjObject]
-    def ellipsoid
-      PjObject.new(Api.proj_get_ellipsoid(self.context, self))
-    end
-
-    # Return the Conversion of a DerivedCRS (such as a ProjectedCRS), or the Transformation from
-    # the baseCRS to the hubCRS of a BoundCRS.
-    #
-    # @return [PjObject]
-    def operation
-      pointer = Api.proj_crs_get_coordoperation(self.context, self)
-      if pointer.null?
-        Error.check
-      end
-      PjObject.new(pointer)
-    end
-
-    # Get the prime meridian of a CRS or a GeodeticReferenceFrame.
-    #
-    # @return [PjObject]
-    def prime_meridian
-      PjObject.new(Api.proj_get_prime_meridian(self.context, self))
-    end
-
-    # A nicely printed out description
-    #
-    # @return [String]
-    def inspect
-      result = StringIO.new
-      result.set_encoding('UTF-8')
-      result << <<~EOS
-                  <#{self.class.name}>: #{self.auth(0)}
-                  #{self.description}
-                  Axis Info [#{self.crs_type}]:
-                EOS
-
-      self.axis_info.each do |axis_info|
-        result << "- #{axis_info[:abbreviation]}[#{axis_info[:direction]}]: #{axis_info[:name]} (#{axis_info[:unit_name]})" << "\n"
-      end
-
-      result << <<~EOS
-                  Area of Use:
-                  - name: #{self.area.name}
-                  - bounds: (#{self.area.west_lon_degree}, #{self.area.south_lat_degree}, #{self.area.east_lon_degree}, #{self.area.north_lat_degree})
-                  Coordinate operation:
-                  - name: ?
-                  - method: ?
-                  Datum: #{self.datum.name}
-                  - Ellipsoid: #{self.ellipsoid.name}
-                  - Prime Meridian: #{self.prime_meridian.name}
-                EOS
-
-      result.string
-    end
-  end
-end

data/lib/ellipsoid.rb

@@ -1,42 +0,0 @@
-module Proj
-  class Ellipsoid
-    attr_reader :id, :major, :ell, :name
-
-    def self.list
-      pointer_to_array = FFI::Pointer.new(Api::PJ_ELLPS, Api.proj_list_ellps)
-      result = Array.new
-      0.step do |i|
-        ellipse_info = Api::PJ_ELLPS.new(pointer_to_array[i])
-        break result if ellipse_info[:id].nil?
-        result << self.new(ellipse_info[:id], ellipse_info[:major], ellipse_info[:ell], ellipse_info[:name])
-      end
-    end
-
-    def self.get(id)
-      self.list.find {|ellipsoid| ellipsoid.id == id}
-    end
-
-    def initialize(id, major, ell, name)
-      @id = id
-      @major = major
-      @ell = ell
-      @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}\", major=\"#{major}\", ell=\"#{ell}\", name=\"#{name}\">"
-    end
-  end
-end

data/lib/error.rb

@@ -1,18 +0,0 @@
-module Proj
-  class Error < StandardError
-    def self.check(errno=nil)
-      unless errno
-        errno = Context.current.errno
-      end
-
-      if errno != 0
-        message = if Api.method_defined?(:proj_errno_string)
-                    Api.proj_errno_string(errno)
-                  else
-                    Api.pj_strerrno(errno)
-                  end
-        raise(self, message)
-      end
-    end
-  end
-end

data/lib/pj_object.rb

@@ -1,80 +0,0 @@
-# encoding: UTF-8
-module Proj
-  class PjObject
-    def self.finalize(pointer)
-      proc do
-        Api.proj_destroy(pointer)
-      end
-    end
-
-    def initialize(pointer, context=nil)
-      @pointer = pointer
-      @context = context
-      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
-    end
-
-    def to_ptr
-      @pointer
-    end
-
-    def context
-      @context || Context.current
-    end
-
-    def proj_type
-      Api.proj_get_type(self)
-    end
-
-    def info
-      Api.proj_pj_info(self)
-    end
-
-    def id
-      self.info[:id]
-    end
-
-    def name
-      Api.proj_get_name(self).force_encoding('UTF-8')
-    end
-
-    def auth_name(index=0)
-      Api.proj_get_id_auth_name(self, index).force_encoding('UTF-8')
-    end
-
-    def auth_code(index=0)
-      Api.proj_get_id_code(self, index)
-    end
-
-    def auth(index=0)
-      "#{self.auth_name(index)}:#{self.auth_code(index)}"
-    end
-
-    def description
-      self.info[:description] ? self.info[:description].force_encoding('UTF-8') : nil
-    end
-
-    def definition
-      self.info[:definition] ? self.info[:definition].force_encoding('UTF-8') : nil
-    end
-
-    def has_inverse?
-      self.info[:has_inverse] == 1 ? true : false
-    end
-
-    def accuracy
-      self.info[:accuracy]
-    end
-
-    def to_proj_string(string_type=:PJ_PROJ_4)
-      Api.proj_as_proj_string(self.context, self, string_type, nil).force_encoding('UTF-8')
-    end
-
-    def to_json
-      Api.proj_as_projjson(self.context, self, nil).force_encoding('UTF-8')
-    end
-
-    def to_wkt(wkt_type=:PJ_WKT2_2018)
-      Api.proj_as_wkt(self.context, self, wkt_type, nil).force_encoding('UTF-8')
-    end
-  end
-end

data/lib/point.rb

@@ -1,72 +0,0 @@
-# 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 Coordinate objects.
-  class Point
-    def self.from_pointer(pointer)
-      result = self.allocate
-      result.instance_variable_set(:@struct, pointer)
-      result
-    end
-
-    # Create new Point object from coordinates.
-    def initialize(x, y)
-      @struct = Api::ProjUV.new
-      @struct[:u] = x
-      @struct[:v] = y
-    end
-
-    def to_ptr
-      @struct.to_ptr
-    end
-
-    def to_radians
-      self.class.new(Api.proj_torad(self.x), Api.proj_torad(self.y))
-    end
-
-    def to_degrees
-      self.class.new(Api.proj_todeg(self.x), Api.proj_todeg(self.y))
-    end
-
-    # Get x coordinate.
-    def x
-      @struct[:u]
-    end
-
-    # Set x coordinate.
-    def x=(value)
-      @struct[:u] = value
-    end
-
-    # Get y coordinate.
-    def y
-      @struct[:v]
-    end
-
-    # Set y coordinate.
-    def y=(value)
-      @struct[:v] = value
-    end
-
-    # Get longitude/x coordinate.
-    def lon
-      @struct[:u]
-    end
-
-    # Set longitude/x coordinate.
-    def lon=(value)
-      @struct[:u] = value
-    end
-
-    # Get latitude/y coordinate.
-    def lat
-      @struct[:v]
-    end
-
-    # Set latitude/y coordinate.
-    def lat=(value)
-      @struct[:v] = value
-    end
-  end
-end

data/lib/prime_meridian.rb

@@ -1,40 +0,0 @@
-module Proj
-  class PrimeMeridian
-    attr_reader :id, :defn
-
-    def self.list
-      pointer_to_array = FFI::Pointer.new(Api::PJ_PRIME_MERIDIANS, Api.proj_list_prime_meridians)
-      result = Array.new
-      0.step do |i|
-        prime_meridian_info = Api::PJ_PRIME_MERIDIANS.new(pointer_to_array[i])
-        break result if prime_meridian_info[:id].nil?
-        result << self.new(prime_meridian_info[:id], prime_meridian_info[:defn])
-      end
-    end
-
-    def self.get(id)
-      self.list.find {|ellipsoid| ellipsoid.id == id}
-    end
-
-    def initialize(id, defn)
-      @id = id
-      @defn = defn
-    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}\", defn=\"#{defn}\">"
-    end
-  end
-end