proj4rb 1.0.0 → 2.0.0

data/lib/area.rb

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

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

@@ -0,0 +1,103 @@
+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/coordinate.rb

@@ -0,0 +1,197 @@
+# encoding: UTF-8
+
+module Proj
+  # A four dimensional coordinate of double values.
+  #
+  # For most geographic Crses, the units will be in degrees.
+  class Coordinate
+    def self.from_coord(pj_coord)
+      result = self.allocate
+      result.instance_variable_set(:@coord, pj_coord)
+      result
+    end
+
+    # Creates a new coordinate.
+    #
+    # @example
+    #
+    #    coord = Proj::Coordinate.new(:x => 1, :y => 2, :z => 3, :t => 4)
+    #    coord = Proj::Coordinate.new(:u => 5, :v => 6, :w => 7, :t => 8)
+    #    coord = Proj::Coordinate.new(:lam => 9, :phi => 10, :z => 11, :t => 12)
+    #    coord = Proj::Coordinate.new(:s => 13, :a1 => 14, :a2 => 15)
+    #    coord = Proj::Coordinate.new(:o => 16, :p => 17, :k => 18)
+    #    coord = Proj::Coordinate.new(:e => 19, :n => 20, :u => 21)
+
+    def initialize(x: nil, y: nil, z: nil, t: nil,
+                   u: nil, v: nil, w: nil, # t: nil
+                   lam: nil, phi: nil, # z: nil, t: nil,
+                   s: nil, a1: nil, a2: nil,
+                   o: nil, p: nil, k: nil,
+                   e: nil, n: nil) #u: nil
+
+      @coord = Api::PJ_COORD.new
+
+      keys = if x && y && z && t
+               [:x, :y, :z, :t]
+             elsif x && y && z
+               [:x, :y, :z]
+             elsif x && y
+               [:x, :y]
+             elsif u && v && w && t
+               [:u, :v, :w, :t]
+             elsif u && v && w
+               [:u, :v, :w]
+             elsif u && v
+               [:u, :v]
+             elsif lam && phi && z && t
+               [:lam, :phi, :z, :t]
+             elsif lam && phi && z
+               [:lam, :phi, :z]
+             elsif lam && phi
+               [:lam, :phi]
+             elsif s && a1 && a2
+               [:s, :a1, :a2]
+             elsif e && n && u
+               [:e, :n, :u]
+             elsif o && p && k
+               [:o, :p, :k]
+             end
+
+      coord_struct = @coord[:v]
+      keys.each_with_index do |key, index|
+        coord_struct[index] = binding.local_variable_get(key)
+      end
+    end
+
+    def to_ptr
+      @coord.to_ptr
+    end
+
+    # Returns x coordinate
+    #
+    # @return [Float]
+    def x
+      @coord[:v][0]
+    end
+
+    # Returns y coordinate
+    #
+    # @return [Float]
+    def y
+      @coord[:v][1]
+    end
+
+    # Returns z coordinate
+    #
+    # @return [Float]
+    def z
+      @coord[:v][2]
+    end
+
+    # Returns t coordinate
+    #
+    # @return [Float]
+    def t
+      @coord[:v][3]
+    end
+
+    # Returns u coordinate
+    #
+    # @return [Float]
+    # TODO - This could be u in uvw or enu. Going to ignore that
+    def u
+      @coord[:v][0]
+    end
+
+    # Returns v coordinate
+    #
+    # @return [Float]
+    def v
+      @coord[:v][1]
+    end
+
+    # Returns w coordinate
+    #
+    # @return [Float]
+    def w
+      @coord[:v][2]
+    end
+
+    # Returns lam coordinate
+    #
+    # @return [Float]
+    def lam
+      @coord[:v][0]
+    end
+
+    # Returns phi coordinate
+    #
+    # @return [Float]
+    def phi
+      @coord[:v][1]
+    end
+
+    # Returns o coordinate
+    #
+    # @return [Float]
+    def o
+      @coord[:v][0]
+    end
+
+    # Returns p coordinate
+    #
+    # @return [Float]
+    def p
+      @coord[:v][1]
+    end
+
+    # Returns k coordinate
+    #
+    # @return [Float]
+    def k
+      @coord[:v][3]
+    end
+
+    # Returns e coordinate
+    #
+    # @return [Float]
+    def e
+      @coord[:v][0]
+    end
+
+    # Returns n coordinate
+    #
+    # @return [Float]
+    def n
+      @coord[:v][1]
+    end
+
+    # Returns s coordinate
+    #
+    # @return [Float]
+    def s
+      @coord[:v][0]
+    end
+
+    # Returns a1 coordinate
+    #
+    # @return [Float]
+    def a1
+      @coord[:v][1]
+    end
+
+    # Returns a2 coordinate
+    #
+    # @return [Float]
+    def a2
+      @coord[:v][2]
+    end
+
+    # Returns nice printout of coordinate contents
+    #
+    # @return [String]
+    def to_s
+      "v0: #{self.x}, v1: #{self.y}, v2: #{self.z}, v3: #{self.t}"
+    end
+  end
+end

data/lib/crs.rb

@@ -0,0 +1,206 @@
+# 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
+      foo = Api.proj_crs_get_coordinate_system(self.context, self)
+      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
+      foo = Api.proj_crs_get_coordinate_system(self.context, self)
+      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