proj4rb 4.1.1 → 5.0.0

data/lib/proj/coordinate.rb

@@ -1,281 +1,304 @@
-# 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(:lon => 9, :lat => 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,
-                   lat: nil, lon: 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 lon && lat && z && t
-               [:lon, :lat, :z, :t]
-             elsif lon && lat && z
-               [:lon, :lat, :z]
-             elsif lon && lat
-               [:lon, :lat]
-             elsif s && a1 && a2
-               [:s, :a1, :a2]
-             elsif e && n && u
-               [:e, :n, :u]
-             elsif o && p && k
-               [:o, :p, :k]
-             else
-               []
-             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
-
-    def pj_coord
-      @coord
-    end
-
-    def eql?(other)
-      @coord == other.instance_variable_get(:@coord)
-    end
-
-    def ==(other)
-      @coord.eql?(other.instance_variable_get(:@coord))
-    end
-
-    def enu
-      @coord[:enu]
-    end
-
-    def geod
-      @coord[:geod]
-    end
-
-    def lp
-      @coord[:lp]
-    end
-
-    def lpz
-      @coord[:lpz]
-    end
-
-    def lpzt
-      @coord[:lpzt]
-    end
-
-    def opk
-      @coord[:opk]
-    end
-
-    def uv
-      @coord[:uv]
-    end
-
-    def uvw
-      @coord[:uvw]
-    end
-
-    def uvwt
-      @coord[:uvwt]
-    end
-
-    def xy
-      @coord[:xy]
-    end
-
-    def xyz
-      @coord[:xyz]
-    end
-
-    def xyzt
-      @coord[:xyzt]
-    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 longitude coordinate
-    #
-    # @return [Float]
-    def lon
-      @coord[:v][0]
-    end
-
-    # Returns latitude coordinate
-    #
-    # @return [Float]
-    def lat
-      @coord[:v][1]
-    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
+# 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
+
+    # Calculate the 2-dimensional euclidean distance between two projected coordinates.
+    #
+    # @see https://proj.org/development/reference/functions.html#c.proj_xy_dist
+    #
+    # @param coord1 [Coordinate] Coordinate of first point
+    # @param coord2 [Coordinate] Coordinate of second point
+    #
+    # @return [Float] Distance between the coordinates
+    def self.xy_distance(coord1, coord2)
+      Api.proj_xy_dist(coord1, coord2)
+    end
+
+    # Calculate the 3-dimensional euclidean distance between two projected coordinates.
+    #
+    # @see https://proj.org/development/reference/functions.html#c.proj_xyz_dist
+    #
+    # @param coord1 [Coordinate] Coordinate of first point
+    # @param coord2 [Coordinate] Coordinate of second point
+    #
+    # @return [Float] Distance between the coordinates
+    def self.xyz_distance(coord1, coord2)
+      Api.proj_xyz_dist(coord1, coord2)
+    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(:lon => 9, :lat => 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,
+                   lat: nil, lon: 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::PjCoord.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 lon && lat && z && t
+               [:lon, :lat, :z, :t]
+             elsif lon && lat && z
+               [:lon, :lat, :z]
+             elsif lon && lat
+               [:lon, :lat]
+             elsif s && a1 && a2
+               [:s, :a1, :a2]
+             elsif e && n && u
+               [:e, :n, :u]
+             elsif o && p && k
+               [:o, :p, :k]
+             else
+               []
+             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
+
+    def pj_coord
+      @coord
+    end
+
+    def eql?(other)
+      other.is_a?(Coordinate) &&
+        self.x == other.x && self.y == other.y && self.z == other.z && self.t == other.t
+    end
+
+    alias == eql?
+
+    def enu
+      @coord[:enu]
+    end
+
+    def geod
+      @coord[:geod]
+    end
+
+    def lp
+      @coord[:lp]
+    end
+
+    def lpz
+      @coord[:lpz]
+    end
+
+    def lpzt
+      @coord[:lpzt]
+    end
+
+    def opk
+      @coord[:opk]
+    end
+
+    def uv
+      @coord[:uv]
+    end
+
+    def uvw
+      @coord[:uvw]
+    end
+
+    def uvwt
+      @coord[:uvwt]
+    end
+
+    def xy
+      @coord[:xy]
+    end
+
+    def xyz
+      @coord[:xyz]
+    end
+
+    def xyzt
+      @coord[:xyzt]
+    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 longitude coordinate
+    #
+    # @return [Float]
+    def lon
+      @coord[:v][0]
+    end
+
+    # Returns latitude coordinate
+    #
+    # @return [Float]
+    def lat
+      @coord[:v][1]
+    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][2]
+    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/proj/coordinate_metadata.rb

@@ -1,38 +1,38 @@
-# encoding: UTF-8
-
-module Proj
-  # Coordinate metadata is the information required to make coordinates unambiguous. For a
-  # coordinate set referenced to a static CRS it is the CRS definition. For a
-  # coordinate set referenced to a dynamic CRS it is the CRS definition together
-  # with the coordinate epoch of the coordinates in the coordinate set.
-  #
-  # In a dynamic CRS, coordinates of a point on the surface of the Earth may change with time.
-  # To be unambiguous the coordinates must always be qualified with the epoch at which they
-  # are valid. The coordinate epoch is not necessarily the epoch at which the observation
-  # was collected.
-  class CoordinateMetadata < PjObject
-    # Create a CoordinateMetadata object
-    #
-    # @param crs [Crs] The associated Crs
-    # @param context [Context]. An optional Context
-    # @param epoch [Double]. Epoch at wich the CRS is valid
-    #
-    # @return [CoordinateMetadata]
-    def initialize(crs, context=nil, epoch=nil)
-      ptr = Api.proj_coordinate_metadata_create(context || Context.current, crs, epoch)
-
-      if ptr.null?
-        Error.check_object(self)
-      end
-
-      super(ptr, context)
-    end
-
-    # Returns the coordinate epoch
-    #
-    # @return [Double]
-    def epoch
-      Api.proj_coordinate_metadata_get_epoch(self.context, self)
-    end
-  end
-end
+# encoding: UTF-8
+
+module Proj
+  # Coordinate metadata is the information required to make coordinates unambiguous. For a
+  # coordinate set referenced to a static CRS it is the CRS definition. For a
+  # coordinate set referenced to a dynamic CRS it is the CRS definition together
+  # with the coordinate epoch of the coordinates in the coordinate set.
+  #
+  # In a dynamic CRS, coordinates of a point on the surface of the Earth may change with time.
+  # To be unambiguous the coordinates must always be qualified with the epoch at which they
+  # are valid. The coordinate epoch is not necessarily the epoch at which the observation
+  # was collected.
+  class CoordinateMetadata < PjObject
+    # Create a CoordinateMetadata object
+    #
+    # @param crs [Crs] The associated Crs
+    # @param context [Context]. An optional Context
+    # @param epoch [Double]. Epoch at wich the CRS is valid
+    #
+    # @return [CoordinateMetadata]
+    def initialize(crs, context=nil, epoch=0)
+      ptr = Api.proj_coordinate_metadata_create(context || Context.current, crs, epoch)
+
+      if ptr.null?
+        Error.check_object(self)
+      end
+
+      super(ptr, context)
+    end
+
+    # Returns the coordinate epoch
+    #
+    # @return [Double]
+    def epoch
+      Api.proj_coordinate_metadata_get_epoch(self.context, self)
+    end
+  end
+end