proj4r 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20be86854d023b958dc46d3858b78656bfd5e0b0e81a094ca6bc452511190b30
+  data.tar.gz: 0bcf9158aca9445914c84bbf16c0b93b08def84d5151306126e7437dac3b6a7b
+SHA512:
+  metadata.gz: fc451a9dbcebdcb5febb9e32c79736eabd0ff6b7d452d48fceaf4f18ed1d56e393256c8ae67a9f800e7fdcee91f9e5d9a0352c295c8d191f2e12e21a6cee48b8
+  data.tar.gz: 2682e765ea2b320234cbc39a67518df6c0dd93470064eca109d08b86e177b7d3e58c2f6d1fca5a807601557c62d119f764529ec8052792a32cf0988d05a9f4a6

data/API.md

@@ -0,0 +1,111 @@
+PROJ4R
+=======
+
+Notes for forward or inverse transformation
+
+    Proj
+      forward : (lon, lat) -> (x, y)
+      inverse : (x, y) -> (lon, lat)
+    
+    Proj.transform 
+      forward : (src, dst, x, y, z) -> (x', y', z')
+      inverse : (dst, src, x, y, z) -> (x', y', z')
+    
+        If src = latlong, dst = projection, they work like Proj#forward, Proj#inverse.
+        In the cases, use lon as x, lat as y.
+    
+    Geod
+      forward : (lat1, lon1, az12, dist) -> (lat2, lon2, az21)
+      inverse : (lat1, lon1, lat2, lon2) -> (dist, az12, az21)
+
+Notes for (lon,lat) or (lat,lon)
+
+    PROJ4::Proj     -> (lon, lat) 
+    PROJ4.transform -> (lon, lat) 
+    PROJ4::Geod     -> (lat, lon) 
+
+These differences originate from Proj.4 C API.
+
+Proj
+----
+
+### Constructor
+
+    pj = PROJ4::Proj.new("+proj=latlon +ellps=WGS84 units=km")
+
+### Attributes
+
+    pj.definition
+    pj.latlong?
+    pj.geocent?
+
+### Replication
+
+    pj.to_latlong
+
+### forward
+
+    x, y = pj.forward(lon, lat)
+    
+### inverse
+
+    lon, lat = *pj.inverse(x, y)
+
+p pj.to_latlong.definition
+
+Transformation
+--------------
+
+
+Geod
+----
+
+### Constructor
+
+    geod = PROJ4::Geod.new()                           ### [+ellps=WGS84, units=m]
+    geod = PROJ4::Geod.new(6378137.0, 1/298.257223563) ### [+ellps=WGS84, units=m]
+    geod = PROJ4::Geod.new("+ellps=WGS84 units=m")
+
+### forward
+
+    lat2, lon2, az21 = *geod.forward(lat1, lon1, az12, dist)
+    
+    input: 
+      lat1: latitude of original point in degree
+      lon1: longitudde of original point in degree
+      az12: azimuth point to target point at origninal point in degree
+      dist: distance from original point to target point in units defined in constructor
+    
+    output: 
+      lat2: latitude of target point in degree
+      lon1: longitude of target point in degree
+      az21: azimuth point to original point at target point in degree
+
+### inverse
+
+    dist, az12, az21 = *geod.inverse(lat1, lon1, lat2, lon2)
+     
+    input:
+      lat1: latitude of original point in degree
+      lon1: longitude of original point in degree
+      lat2: latitude of target point in degree
+      lon2: longitude of target point in degree
+     
+    output: 
+      dist: distance between original and target points in units defined in constructor 
+      az12: azimuth point to target point at origninal point in degree
+      az21: azimuth point to original point at target point in degree
+
+### distance
+ 
+    dist = *geod.distance(lat1, lon1, lat2, lon2)
+    
+    input:
+      lat1: latitude of original point in degree
+      lon1: longitude of original point in degree
+      lat2: latitude of target point in degree
+      lon2: longitude of target point in degree
+    
+    output: 
+      dist: distance between original and target points in units defined in constructor 
+  

data/README.md

@@ -0,0 +1,23 @@
+proj4r
+======
+
+    module PROJ4
+      RAD_TO_DEG
+      DEG_TO_RAD
+      def self.dmstor
+      def self.rtodms
+      def self.dmstod
+      def self.dtodms
+      def self.transform
+      def self.transform_ca
+      class Proj
+        def inverse 
+        def forward
+      end
+      class Geod
+        def inverse
+        def forward
+        def distance
+        def geodline
+      end
+    end

data/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+require 'carray/mkmf'
+
+dir_config("proj", possible_includes, possible_libs)
+dir_config("geod", possible_includes, possible_libs)
+
+if have_header("proj_api.h") and have_library("proj")
+  have_carray()
+  create_makefile("proj4r")
+end
+
+

data/lib/proj4r.rb

@@ -0,0 +1,184 @@
+require 'carray'
+require 'proj4r.so'
+
+module PROJ4
+
+  def self.transform (src, dst, x, y, z = nil)
+    if x.is_a?(CArray) and y.is_a?(CArray)
+      if z.is_a?(CArray)
+        x2 = x.to_ca
+        y2 = y.to_ca
+        z2 = z.to_ca
+        _transform_ca(src, dst, x2, y2, z2)
+        return [x2, y2, z2]
+      elsif z.nil?
+        x2 = x.to_ca
+        y2 = y.to_ca
+        z2 = x.template { 0 }
+        _transform_ca(src, dst, x2, y2, z2)
+        return [x2, y2]
+      end
+    end
+    return _transform(src, dst, x, y, z)
+  end
+
+  class Proj
+
+    def forward (*argv)
+      if argv.size == 2
+        lon1, lat1 = *argv
+        if lon1.is_a?(CArray) and lat1.is_a?(CArray)
+          x2 = lon1.template
+          y2 = lat1.template
+          _forward_ca(lon1, lat1, x2, y2)
+          return [x2, y2]
+        else
+          return _forward(lon1, lat1)
+        end
+      else
+        return _forward_ca(*argv)
+      end
+    end
+
+    def inverse (*argv)
+      if argv.size == 2
+        x1, y1 = *argv
+        if x1.is_a?(CArray) and y1.is_a?(CArray)
+          lon2 = x1.template
+          lat2 = y1.template
+          _inverse_ca(x1, y1, lon2, lat2)
+          return [lon2, lat2]
+        else
+          return _inverse(x1, y1)
+        end
+      else
+        return _inverse_ca(*argv)
+      end
+    end
+
+  end
+
+  class Geod
+    
+    def initialize (*argv)
+      if argv.size == 1 and (arg = argv.first).is_a?(String)
+        pj = Proj.new("+proj=latlon " + arg)
+        a = pj.a
+        f = pj.f
+        @fr_meter = pj.fr_meter
+        @to_meter = 1.0/@fr_meter
+        _initialize(a,f)
+      else
+        @fr_meter = 1.0
+        @to_meter = 1.0
+        _initialize(*argv)
+      end
+    end
+
+    def forward (*argv)
+      case argv.size
+      when 4
+        lat1, lon1, az12, dist = *argv
+        if lat1.is_a?(CArray) and lon1.is_a?(CArray) and
+            az12.is_a?(CArray) and dist.is_a?(CArray)
+          lon2 = lon1.template
+          lat2 = lat1.template
+          az21 = az12.template
+          _forward_ca(lat1, lon1, az12, dist*@to_meter, lat2, lon2, az21)
+          return [lon2, lat2, az21]
+        else
+          return _forward(lat1, lon1, az12, dist*@to_meter)
+        end
+      when 7
+        argv[2] *= @to_meter
+        return _forward_ca(*argv)
+      else
+        raise "invalid # of argument 4 or 7 required"
+      end
+    end
+
+    def inverse (*argv)
+      case argv.size
+      when 4
+        lat1, lon1, lat2, lon2 = *argv
+        if lat1.is_a?(CArray) and lon1.is_a?(CArray) and
+            lat2.is_a?(CArray) and lon2.is_a?(CArray)
+          dist = lat1.template
+          az12 = lat1.template
+          az21 = lat1.template
+          _inverse_ca(lat1, lon1, lat2, lon2, dist, az12, az21)
+          az21 += 180
+          az21[:gt,180] -= 360
+          return dist*@fr_meter, az12, az21
+        else
+          dist, az12, az21 = *_inverse(lat1, lon1, lat2, lon2)
+          az21 += 180
+          if az21 > 180
+            az21 -= 360
+          end
+          return dist*@fr_meter, az12, az21
+        end
+      when 7
+        _inverse_ca(*argv)
+        argv[4] *= @fr_meter
+        argv[6] += 180
+        argv[6][:gt,180] -= 360
+        return self
+      else
+        raise "invalid # of argument 4 or 7 required"        
+      end
+    end
+
+    def distance (*argv)
+      case argv.size
+      when 4
+        lat1, lon1, lat2, lon2 = *argv
+        if lat1.is_a?(CArray) and lon1.is_a?(CArray) and
+            lat2.is_a?(CArray) and lon2.is_a?(CArray)
+          dist = lon1.template
+          _distance_ca(lat1, lon1, lat2, lon2, dist)
+          return dist*@fr_meter
+        else
+          return _distance(lat1, lon1, lat2, lon2)*@fr_meter
+        end
+      when 5
+        _distance_ca(*argv)
+        argv[4] *= @fr_meter
+        return self
+      else
+        raise "invalid # of argument 4 or 5 required"        
+      end
+    end
+
+    def geodline (lat0, lon0, lat1, lon1, count: nil, interval: nil)
+
+      total_geod_S, az12, az21 = self.inverse(lat0, lon0, lat1, lon1)
+      total_geod_S *= @fr_meter
+
+      if not count.nil? and interval.nil?
+        del_S = total_geod_S / ( count - 1 )
+      elsif count.nil? and not interval.nil?
+        del_S = interval
+      else
+        del_S = total_geod_S / ( 100 - 1 )
+      end
+
+      list = []
+      list.push [lon0, lat0, 0]
+      
+      geod_S = del_S
+      loop do 
+        lat, lon, az21 = self.forward(lat0, lon0, az12, geod_S*@to_meter)
+        list.push [lat, lon, geod_S]
+        geod_S += del_S
+        if geod_S >= total_geod_S
+          break
+        end
+      end
+
+      list.push [lat1, lon1, total_geod_S]
+      
+      return list
+    end
+  end
+end

data/proj4r.gemspec

@@ -0,0 +1,22 @@
+
+Gem::Specification::new do |s|
+  version = "1.0.0"
+
+  files = Dir.glob("**/*") - [ 
+                               Dir.glob("proj4r*.gem"), 
+                             ].flatten
+
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "proj4r"
+  s.summary     = "Extension library for PROJ.4"
+  s.description = <<-HERE
+    Extension library for PROJ.4
+  HERE
+  s.version     = version
+  s.author      = "Hiroki Motoyoshi"
+  s.email       = ""
+  s.homepage    = 'https://github.com/himotoyoshi/proj4r'
+  s.files       = files
+  s.extensions  = [ "extconf.rb" ]
+  s.required_ruby_version = ">= 1.8.1"
+end