proj4rb 3.0.0 → 4.0.0

data/test/database_test.rb

@@ -0,0 +1,360 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DatabaseTest < AbstractTest
+  def create_crs
+    Proj::Crs.new(<<~EOS)
+      GEOGCRS["myGDA2020",
+        DATUM["GDA2020",
+            ELLIPSOID["GRS_1980",6378137,298.257222101,
+                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]]]
+    EOS
+  end
+
+  def test_path
+    database = Proj::Database.new(Proj::Context.current)
+    assert_equal("proj.db", File.basename(database.path))
+  end
+
+  def test_set_path_error
+    database = Proj::Database.new(Proj::Context.current)
+
+    error = assert_raises(Proj::Error) do
+      database.path = "test.db"
+    end
+    # This error is sometimes "Unknown error (code 4096)"
+    # assert_equal("Invalid value for an argument", error.to_s)
+  end
+
+  def test_structure
+    database = Proj::Database.new(Proj::Context.current)
+    structure = database.structure
+    assert(structure.length > 70)
+  end
+
+  def test_metadata
+    database = Proj::Database.new(Proj::Context.current)
+    metadata = database.metadata('IGNF.VERSION')
+    assert_equal('3.1.0', metadata)
+  end
+
+  def test_codes
+    types_with_no_codes = [:PJ_TYPE_TEMPORAL_CRS, :PJ_TYPE_BOUND_CRS, :PJ_TYPE_UNKNOWN, :PJ_TYPE_ENGINEERING_CRS,
+                           :PJ_TYPE_TEMPORAL_DATUM, :PJ_TYPE_ENGINEERING_DATUM, :PJ_TYPE_PARAMETRIC_DATUM,
+                           :PJ_TYPE_OTHER_COORDINATE_OPERATION]
+
+    database = Proj::Database.new(Proj::Context.current)
+
+    Proj::Api::PJ_TYPE.symbols.each do |type|
+      codes = database.codes('EPSG', type)
+      if types_with_no_codes.include?(type)
+        assert(codes.empty?)
+      else
+        refute(codes.empty?)
+      end
+    end
+  end
+
+  def test_authorities
+    database = Proj::Database.new(Proj::Context.current)
+    authorities = database.authorities
+    assert_equal(7, authorities.count)
+
+    authority = authorities[0]
+    assert_equal('EPSG', authority)
+
+    authority = authorities[1]
+    assert_equal('ESRI', authority)
+
+    authority = authorities[2]
+    assert_equal('IAU_2015', authority)
+
+    authority = authorities[3]
+    assert_equal('IGNF', authority)
+
+    authority = authorities[4]
+    assert_equal('NKG', authority)
+
+    authority = authorities[5]
+    assert_equal('OGC', authority)
+
+    authority = authorities[6]
+    assert_equal('PROJ', authority)
+  end
+
+  def test_crs_info
+    database = Proj::Database.new(Proj::Context.current)
+    crs_infos = database.crs_info
+
+    expected = case
+               when proj9?
+                 13107
+               else
+                 12609
+               end
+    assert_equal(expected, crs_infos.count)
+
+    crs_info = crs_infos.first
+    assert_equal("EPSG", crs_info.auth_name)
+    assert_equal("2000", crs_info.code)
+    assert_equal("Anguilla 1957 / British West Indies Grid", crs_info.name)
+    assert_equal(:PJ_TYPE_PROJECTED_CRS, crs_info.type)
+    refute(crs_info.deprecated)
+    assert(crs_info.bbox_valid)
+    assert_equal(-63.22, crs_info.west_lon_degree)
+    assert_equal(18.11, crs_info.south_lat_degree)
+    assert_equal(-62.92, crs_info.east_lon_degree)
+    assert_equal(18.33, crs_info.north_lat_degree)
+    assert_equal("Anguilla - onshore.", crs_info.area_name)
+    assert_equal("Transverse Mercator", crs_info.projection_method_name)
+    assert_equal("Earth", crs_info.celestial_body_name)
+  end
+
+  def test_crs_info_epsg
+    database = Proj::Database.new(Proj::Context.current)
+    crs_infos = database.crs_info("EPSG")
+
+    expected = case
+               when proj9?
+                 7251
+               else
+                 7056
+               end
+    assert_equal(expected, crs_infos.count)
+  end
+
+  def test_crs_info_geodetic
+    database = Proj::Database.new(Proj::Context.current)
+    params = Proj::Parameters.new
+    params.types = [:PJ_TYPE_GEODETIC_CRS]
+    crs_infos = database.crs_info("EPSG", params)
+
+    expected = case
+               when proj9?
+                 943
+               else
+                 930
+               end
+
+    assert_equal(expected, crs_infos.count)
+  end
+
+  def test_crs_info_geographic
+    database = Proj::Database.new(Proj::Context.current)
+    params = Proj::Parameters.new
+    params.types = [:PJ_TYPE_GEOGRAPHIC_2D_CRS, :PJ_TYPE_PROJECTED_CRS]
+    crs_infos = database.crs_info("EPSG", params)
+
+    expected = case
+               when proj9?
+                 5689
+               else
+                 5534
+               end
+
+    assert_equal(expected, crs_infos.count)
+  end
+
+  def test_crs_info_bounds_inclusive
+    database = Proj::Database.new(Proj::Context.current)
+    params = Proj::Parameters.new
+    params.types = [:PJ_TYPE_PROJECTED_CRS]
+    params.bbox_valid = 1
+    params.west_lon_degree = 2
+    params.south_lat_degree = 49
+    params.east_lon_degree = 2.1
+    params.north_lat_degree = 49.1
+
+    crs_infos = database.crs_info("EPSG", params)
+    assert_equal(35, crs_infos.count)
+  end
+
+  def test_crs_info_bounds_exclusive
+    database = Proj::Database.new(Proj::Context.current)
+    params = Proj::Parameters.new
+    params.types = [:PJ_TYPE_PROJECTED_CRS]
+    params.bbox_valid = 1
+    params.west_lon_degree = 2
+    params.south_lat_degree = 49
+    params.east_lon_degree = 2.1
+    params.north_lat_degree = 49.1
+    params.crs_area_of_use_contains_bbox = 0
+
+    crs_infos = database.crs_info("EPSG", params)
+    assert_equal(38, crs_infos.count)
+  end
+
+  def test_crs_info_celestial_body
+    database = Proj::Database.new(Proj::Context.current)
+    params = Proj::Parameters.new
+      params.celestial_body_name = "Earth"
+    crs_infos = database.crs_info("EPSG", params)
+
+    expected = case
+               when proj9?
+                 6723
+               else
+                 6532
+               end
+
+    assert_equal(expected, crs_infos.count)
+  end
+
+  def test_unit
+    database = Proj::Database.new(Proj::Context.current)
+    unit = database.unit("EPSG", "9001")
+    assert_equal("EPSG", unit.auth_name)
+    assert_equal("9001", unit.code)
+    assert_equal("metre", unit.name)
+    assert_equal("linear", unit.category)
+    assert_equal(1.0, unit.conv_factor)
+    refute(unit.proj_short_name)
+    refute(unit.deprecated)
+  end
+
+  def test_geoid_models
+    database = Proj::Database.new(Proj::Context.current)
+    models = database.geoid_models("EPSG", "5703")
+
+    assert_equal(8, models.size)
+
+    expected = %w[GEOID03 GEOID06 GEOID09 GEOID12A GEOID12B GEOID18 GEOID99 GGM10]
+    assert_equal(expected, models.strings)
+  end
+
+  def test_celestial_bodies
+    database = Proj::Database.new(Proj::Context.current)
+    bodies = database.celestial_bodies
+
+    expected = case
+               when proj9?
+                 176
+               else
+                 170
+               end
+
+    assert_equal(expected, bodies.size)
+
+    celestial_body = bodies[0]
+    assert_equal('ESRI', celestial_body.auth_name)
+    assert_equal('1_Ceres', celestial_body.name)
+  end
+
+  def test_celestial_bodies_authority
+    database = Proj::Database.new(Proj::Context.current)
+    bodies = database.celestial_bodies('ESRI')
+
+    expected = case
+               when proj9?
+                 78
+               else
+                 72
+               end
+
+    assert_equal(expected, bodies.size)
+
+    celestial_body = bodies[0]
+    assert_equal('ESRI', celestial_body.auth_name)
+    assert_equal('1_Ceres', celestial_body.name)
+  end
+
+  def test_suggest_code_for
+    crs = create_crs
+    database = Proj::Database.new(crs.context)
+
+    code = database.suggest_code_for(crs, "HOBU", false)
+    assert_equal("MYGDA2020", code)
+
+    code = database.suggest_code_for(crs, "HOBU", true)
+    assert_equal("1", code)
+  end
+
+  def test_celestial_body_name_geographic_crs
+    crs = Proj::Crs.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_geographic_projected_crs
+    crs = Proj::Crs.create_from_database("EPSG", "32631", :PJ_CATEGORY_CRS)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_vertical_crs
+    crs = Proj::Crs.create_from_database("EPSG", "3855", :PJ_CATEGORY_CRS)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_compound_crs
+    crs = Proj::Crs.create_from_database("EPSG", "9518", :PJ_CATEGORY_CRS)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_geodetic_datum
+    crs = Proj::Crs.create_from_database("EPSG", "6267", :PJ_CATEGORY_DATUM)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_datum_ensemble
+    crs = Proj::Crs.create_from_database("EPSG", "6326", :PJ_CATEGORY_DATUM_ENSEMBLE)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_vertical_datum
+    crs = Proj::Crs.create_from_database("EPSG", "1027", :PJ_CATEGORY_DATUM)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_ellipsoid
+    crs = Proj::Crs.create_from_database("EPSG", "7030", :PJ_CATEGORY_ELLIPSOID)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Earth", name)
+  end
+
+  def test_celestial_body_name_ellipsoid_not_earth
+    crs = Proj::Crs.create_from_database("ESRI", "107903", :PJ_CATEGORY_ELLIPSOID)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    assert_equal("Moon", name)
+  end
+
+  def test_celestial_body_name_error
+    crs = Proj::Crs.create_from_database("EPSG", "1591", :PJ_CATEGORY_COORDINATE_OPERATION)
+    database = Proj::Database.new(crs.context)
+    name = database.celestial_body_name(crs)
+    refute(name)
+  end
+
+  if proj7?
+    # This test causes a segmentation fault on proj6
+    def test_metadata_invalid
+      database = Proj::Database.new(Proj::Context.current)
+      metadata = database.metadata('foo')
+      refute(metadata)
+    end
+  end
+end

data/test/datum_ensemble_test.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DatumEnsembleTest < AbstractTest
+  def get_datum_ensemble
+    wkt = <<~EOS
+           GEOGCRS["ETRS89",
+             ENSEMBLE["European Terrestrial Reference System 1989 ensemble",
+                 MEMBER["European Terrestrial Reference Frame 1989"],
+                 MEMBER["European Terrestrial Reference Frame 1990"],
+                 MEMBER["European Terrestrial Reference Frame 1991"],
+                 MEMBER["European Terrestrial Reference Frame 1992"],
+                 MEMBER["European Terrestrial Reference Frame 1993"],
+                 MEMBER["European Terrestrial Reference Frame 1994"],
+                 MEMBER["European Terrestrial Reference Frame 1996"],
+                 MEMBER["European Terrestrial Reference Frame 1997"],
+                 MEMBER["European Terrestrial Reference Frame 2000"],
+                 MEMBER["European Terrestrial Reference Frame 2005"],
+                 MEMBER["European Terrestrial Reference Frame 2014"],
+                 ELLIPSOID["GRS 1980",6378137,298.257222101,
+                     LENGTHUNIT["metre",1]],
+                 ENSEMBLEACCURACY[0.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]]]
+    EOS
+
+    crs = Proj::Crs.create(wkt)
+    crs.datum_ensemble
+  end
+
+  def test_count
+    ensemble = get_datum_ensemble
+    assert_equal(11, ensemble.count)
+  end
+
+  def test_member
+    ensemble = get_datum_ensemble
+
+    member = ensemble[0]
+    assert_equal(:PJ_TYPE_GEODETIC_REFERENCE_FRAME, member.proj_type)
+    assert_equal("European Terrestrial Reference Frame 1989", member.name)
+  end
+
+  def test_member_invalid
+    ensemble = get_datum_ensemble
+    member = ensemble[-1]
+    refute(member)
+
+    member = ensemble[100]
+    refute(member)
+  end
+
+  def test_accuracy
+    ensemble = get_datum_ensemble
+    assert_equal(0.1, ensemble.accuracy)
+  end
+end

data/test/datum_test.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class DatumTest < AbstractTest
+  def test_datum
+    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
+    assert_equal(:PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME, datum.proj_type)
+    assert_equal("International Terrestrial Reference Frame 2008", datum.name)
+  end
+
+  def test_frame_reference_epoch
+    datum = Proj::PjObject.create_from_database("EPSG", "1061", :PJ_CATEGORY_DATUM)
+    epoch = datum.frame_reference_epoch
+    assert_equal(2005.0, epoch)
+  end
+
+  def test_ellipsoid
+    wkt = <<~EOS
+        PROJCS["WGS 84 / UTM zone 31N",
+               GEOGCS["WGS 84",
+                      DATUM["WGS_1984",
+                            SPHEROID["WGS 84",6378137,298.257223563,
+                                     AUTHORITY["EPSG","7030"]],
+                            AUTHORITY["EPSG","6326"]],
+                      PRIMEM["Greenwich",0,
+                             AUTHORITY["EPSG","8901"]],
+                      UNIT["degree",0.0174532925199433,
+                           AUTHORITY["EPSG","9122"]],
+                      AUTHORITY["EPSG","4326"]],
+               PROJECTION["Transverse_Mercator"],
+               PARAMETER["latitude_of_origin",0],
+               PARAMETER["central_meridian",3],
+               PARAMETER["scale_factor",0.9996],
+               PARAMETER["false_easting",500000],
+               PARAMETER["false_northing",0],
+               UNIT["metre",1,
+                    AUTHORITY["EPSG","9001"]],
+               AXIS["Easting",EAST],
+               AXIS["Northing",NORTH],
+               AUTHORITY["EPSG","32631"]]
+      EOS
+
+    crs = Proj::Crs.new(wkt)
+    ellipsoid = crs.ellipsoid
+    assert_equal("WGS 84", ellipsoid.name)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
+
+    ellipsoid_from_datum = crs.datum.ellipsoid
+    assert_equal("WGS 84", ellipsoid_from_datum.name)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid_from_datum.proj_type)
+
+    assert(ellipsoid_from_datum.equivalent_to?(ellipsoid, :PJ_COMP_STRICT))
+  end
+end

data/test/ellipsoid_test.rb

@@ -3,32 +3,78 @@
 require_relative './abstract_test'
 
 class EllipsoidTest < AbstractTest
-  def test_get_all
-    ellipsoids = Proj::Ellipsoid.list.map {|ellipsoid| ellipsoid.id }
+  def parameter_crs
+    wkt = <<~EOS
+      PROJCS["WGS 84 / UTM zone 31N",
+             GEOGCS["WGS 84",
+                    DATUM["WGS_1984",
+                          SPHEROID["WGS 84",6378137,298.257223563,
+                                   AUTHORITY["EPSG","7030"]],
+                          AUTHORITY["EPSG","6326"]],
+                    PRIMEM["Greenwich",0,
+                           AUTHORITY["EPSG","8901"]],
+                    UNIT["degree",0.0174532925199433,
+                         AUTHORITY["EPSG","9122"]],
+                    AUTHORITY["EPSG","4326"]],
+             PROJECTION["Transverse_Mercator"],
+             PARAMETER["latitude_of_origin",0],
+             PARAMETER["central_meridian",3],
+             PARAMETER["scale_factor",0.9996],
+             PARAMETER["false_easting",500000],
+             PARAMETER["false_northing",0],
+             UNIT["metre",1,
+                  AUTHORITY["EPSG","9001"]],
+             AXIS["Easting",EAST],
+             AXIS["Northing",NORTH],
+             AUTHORITY["EPSG","32631"]]
+    EOS
+    Proj::Crs.new(wkt)
+  end
+
+  def test_built_in
+    ellipsoids = Proj::Ellipsoid.built_in.map {|ellipsoid| ellipsoid[:id] }
     assert(ellipsoids.include?('WGS84'))
     assert(ellipsoids.include?('bessel'))
     assert(ellipsoids.include?('lerch'))
   end
 
-  def test_one
-    ellipsoid = Proj::Ellipsoid.get('bessel')
-    assert_kind_of Proj::Ellipsoid, ellipsoid
-    assert_equal('bessel', ellipsoid.id)
-    assert_equal('a=6377397.155', ellipsoid.major)
-    assert_equal('rf=299.1528128', ellipsoid.ell)
-    assert_equal('Bessel 1841', ellipsoid.name)
-    assert_equal('bessel', ellipsoid.to_s)
-    assert_equal('#<Proj::Ellipsoid id="bessel", major="a=6377397.155", ell="rf=299.1528128", name="Bessel 1841">', ellipsoid.inspect)
+  def test_from_database
+    ellipsoid = Proj::Ellipsoid.create_from_database("EPSG", "7030", :PJ_CATEGORY_ELLIPSOID)
+    assert_instance_of(Proj::Ellipsoid, ellipsoid)
+    assert_equal(:PJ_TYPE_ELLIPSOID, ellipsoid.proj_type)
+    assert_equal("EPSG", ellipsoid.auth_name)
+    assert_equal("WGS 84", ellipsoid.name)
+    assert_equal("7030", ellipsoid.id_code)
+  end
+
+  def test_parameters
+    ellipsoid = parameter_crs.ellipsoid
+    params = ellipsoid.parameters
+
+    expected = {semi_major_axis: 6378137.0,
+                semi_minor_axis: 6356752.314245179,
+                semi_minor_axis_computed: true,
+                inverse_flattening: 298.257223563}
+    assert_equal(expected, params)
+  end
+
+  def test_semi_major_axis
+    meridian = parameter_crs.ellipsoid
+    assert_equal(6378137.0, meridian.semi_major_axis)
+  end
+
+  def test_semi_minor_axis
+    meridian = parameter_crs.ellipsoid
+    assert_equal(6356752.314245179, meridian.semi_minor_axis)
   end
 
-  def test_equal
-    e1 = Proj::Ellipsoid.get('bessel')
-    e2 = Proj::Ellipsoid.get('bessel')
-    assert e1 == e2
+  def test_semi_minor_axis_computed
+    meridian = parameter_crs.ellipsoid
+    assert(meridian.semi_minor_axis_computed)
   end
 
-  def test_failed_get
-    ellipsoid = Proj::Ellipsoid.get('foo')
-    assert_nil ellipsoid
+  def test_inverse_flattening
+    meridian = parameter_crs.ellipsoid
+    assert_equal(298.257223563, meridian.inverse_flattening)
   end
 end

data/test/file_api_test.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class FileApiTest < AbstractTest
+  def setup
+    super
+    # Make sure FileAPI callbacks are not GCed
+    #GC.stress = true
+  end
+
+  def teardown
+    super
+    GC.stress = false
+  end
+
+
+  def test_read
+    skip "This test causes a segfault due to the way Proj cleans up on shutdown"
+    context = Proj::Context.new
+    # Network needs to be on for grid delete to work
+    context.network_enabled = true
+
+    # Create a grid
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    grid.delete
+
+    grid.download
+    assert(grid.downloaded?)
+    context.network_enabled = false
+
+    # Hook up a custom FileApiImpl
+    context.set_file_api(Proj::FileApiImpl)
+
+    conversion = Proj::Conversion.new(<<~EOS, context)
+          +proj=pipeline
+          +step +proj=unitconvert +xy_in=deg +xy_out=rad
+          +step +proj=vgridshift +grids=dk_sdfe_dvr90.tif +multiplier=1
+          +step +proj=unitconvert +xy_in=rad +xy_out=deg
+        EOS
+
+    coord = Proj::Coordinate.new(lon: 12, lat: 56, z: 0)
+    new_coord = conversion.forward(coord)
+    assert_in_delta(12, new_coord.lon)
+    assert_in_delta(56, new_coord.lat)
+    assert_in_delta(36.5909996032715, new_coord.z, 1e-10)
+
+    context.destroy
+  end
+
+  def test_write
+    skip "This test causes a segfault due to the way Proj cleans up on shutdown"
+
+    context = Proj::Context.new
+    context.network_enabled = true
+
+    # Create a grid
+    grid = Proj::Grid.new("dk_sdfe_dvr90.tif", context)
+    grid.delete
+
+    context.set_file_api(Proj::FileApiImpl)
+    grid.download
+
+    assert(grid.downloaded?)
+  end
+end