proj4rb 2.2.2 → 4.0.0

data/test/pj_object_test.rb

@@ -0,0 +1,179 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+class PjObjectTest < AbstractTest
+  def test_clone
+    object = Proj::PjObject.create("+proj=longlat")
+    clone = object.clone
+    assert(object.equivalent_to?(clone, :PJ_COMP_STRICT))
+    assert(object.context.equal?(clone.context))
+  end
+
+  def test_dup
+    object = Proj::PjObject.create("+proj=longlat")
+    clone = object.dup
+    assert(object.equivalent_to?(clone, :PJ_COMP_STRICT))
+    assert(object.context.equal?(clone.context))
+  end
+  
+  def test_equivalent
+    from_epsg = Proj::PjObject.create_from_database("EPSG", "7844", :PJ_CATEGORY_CRS)
+    from_wkt = Proj::PjObject.create_from_wkt(<<~EOS)
+                    GEOGCRS["GDA2020",
+                      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
+
+    assert(from_epsg.equivalent_to?(from_wkt, :PJ_COMP_EQUIVALENT))
+  end
+
+  def test_accuracy_crs
+    object = Proj::PjObject.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+    assert_equal(-1, object.accuracy)
+  end
+
+  def test_accuracy_coordinate_operation
+    object = Proj::PjObject.create_from_database("EPSG", "1170", :PJ_CATEGORY_COORDINATE_OPERATION)
+    assert_equal(16.0, object.accuracy)
+  end
+
+  def test_accuracy_projection
+    object = Proj::Conversion.new("+proj=helmert")
+    assert_equal(-1.0, object.accuracy)
+  end
+
+  def test_id_code
+    crs = Proj::Crs.new('EPSG:4326')
+    assert_equal("4326", crs.id_code)
+    refute(crs.id_code(1))
+  end
+
+  def test_remarks_transformation
+    transformation = Proj::PjObject.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Scale difference in ppb where 1/billion = 1E-9. See CT codes 8444-46 for NTv2 method giving equivalent results for Christmas Island, Cocos Islands and Australia respectively. See CT code 8447 for alternative including distortion model for Australia only."
+    assert_equal(expected, transformation.remarks)
+  end
+
+  def test_remarks_conversion
+    operation = Proj::PjObject.create_from_database("EPSG", "3811", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Replaces Lambert 2005."
+    assert_equal(expected, operation.remarks)
+  end
+
+  def test_scope_transformation
+    transformation = Proj::PjObject.create_from_database("EPSG", "8048", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Transformation of GDA94 coordinates that have been derived through GNSS CORS."
+    assert_equal(expected, transformation.scope)
+  end
+
+  def test_scope_conversion
+    operation = Proj::PjObject.create_from_database("EPSG", "3811", :PJ_CATEGORY_COORDINATE_OPERATION)
+
+    expected = "Engineering survey, topographic mapping."
+    assert_equal(expected, operation.scope)
+  end
+
+  def test_scope_invalid
+    operation = Proj::Conversion.new("+proj=noop")
+    refute(operation.scope)
+  end
+
+  def test_factors
+    conversion = Proj::Conversion.new("+proj=merc +ellps=WGS84")
+    coord = Proj::Coordinate.new(lon: Proj.degrees_to_radians(12), lat: Proj.degrees_to_radians(55))
+    factors = conversion.factors(coord)
+
+    assert_in_delta(1.739526610076288, factors[:meridional_scale], 1e-7)
+    assert_in_delta(1.739526609938368, factors[:parallel_scale], 1e-7)
+    assert_in_delta(3.0259528269235867, factors[:areal_scale], 1e-7)
+
+    assert_in_delta(0.0, factors[:angular_distortion], 1e-7)
+    assert_in_delta(1.5707963267948966, factors[:meridian_parallel_angle], 1e-7)
+    assert_in_delta(0.0, factors[:meridian_convergence], 1e-7)
+
+    assert_in_delta(1.7395266100073281, factors[:tissot_semimajor], 1e-7)
+    assert_in_delta(1.7395266100073281, factors[:tissot_semiminor], 1e-7)
+
+    assert_in_delta(0.9999999999996122, factors[:dx_dlam], 1e-7)
+    assert_in_delta(0.0, factors[:dx_dphi], 1e-7)
+    assert_in_delta(0.0, factors[:dy_dlam], 1e-7)
+    assert_in_delta(1.7395897312200146, factors[:dy_dphi], 1e-7)
+  end
+
+  def test_create_from_name
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context)
+    assert_equal(5, objects.size)
+  end
+
+  def test_create_from_name_with_auth_name
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, auth_name: "xx")
+    assert_equal(0, objects.size)
+  end
+
+  def test_create_from_name_with_types
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+    assert_equal(3, objects.size)
+  end
+
+  def test_create_from_name_with_types_and_approximate_match
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, approximate_match: true,
+                                              types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+
+    expected = proj9? ? 442 : 440
+    assert_equal(expected, objects.size)
+  end
+
+  def test_create_from_name_with_types_and_approximate_match_and_limit
+    context = Proj::Context.new
+    objects = Proj::PjObject.create_from_name("WGS 84", context, approximate_match: true, limit: 25,
+                                              types: [:PJ_TYPE_GEODETIC_CRS, :PJ_TYPE_PROJECTED_CRS])
+    assert_equal(25, objects.size)
+  end
+
+  def test_deprecated_true
+    wkt = <<~EOS
+          GEOGCRS["SAD69 (deprecated)",
+              DATUM["South_American_Datum_1969",
+                  ELLIPSOID["GRS 1967",6378160,298.247167427,
+                      LENGTHUNIT["metre",1,
+                          ID["EPSG",9001]]]],
+              PRIMEM["Greenwich",0,
+                  ANGLEUNIT["degree",0.0174532925199433,
+                      ID["EPSG",9122]]],
+              CS[ellipsoidal,2],
+                  AXIS["latitude",north,
+                      ORDER[1],
+                      ANGLEUNIT["degree",0.0174532925199433,
+                          ID["EPSG",9122]]],
+                  AXIS["longitude",east,
+                      ORDER[2],
+                      ANGLEUNIT["degree",0.0174532925199433,
+                          ID["EPSG",9122]]]]
+    EOS
+
+    crs = Proj::Crs.create(wkt)
+    assert(crs.deprecated?)
+  end
+
+  def test_deprecated_false
+    crs = Proj::Crs.create_from_database("EPSG", "4326", :PJ_CATEGORY_CRS)
+    refute(crs.deprecated?)
+  end
+end

data/test/prime_meridian_test.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class PrimeMeridianTest < AbstractTest
+  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
+    prime_meridians = Proj::PrimeMeridian.built_in.map {|prime_merdian| prime_merdian[:id] }
+    assert(prime_meridians.include?('greenwich'))
+    assert(prime_meridians.include?('athens'))
+    assert(prime_meridians.include?('lisbon'))
+    assert(prime_meridians.include?('rome'))
+  end
+
+  def test_from_database
+    meridian = Proj::PrimeMeridian.create_from_database("EPSG", "8903", :PJ_CATEGORY_PRIME_MERIDIAN)
+    assert_instance_of(Proj::PrimeMeridian, meridian)
+    assert_equal(:PJ_TYPE_PRIME_MERIDIAN, meridian.proj_type)
+    assert_equal("EPSG", meridian.auth_name)
+    assert_equal("Paris", meridian.name)
+    assert_equal("8903", meridian.id_code)
+  end
+
+  def test_parameters
+    meridian = parameter_crs.prime_meridian
+    params = meridian.parameters
+
+    expected = {longitude: 0.0,
+                unit_conv_factor: 0.017453292519943295,
+                unit_name: "degree"}
+
+    assert_equal(expected, params)
+  end
+
+  def test_longitude
+    meridian = parameter_crs.prime_meridian
+    assert_equal(0.0, meridian.longitude)
+  end
+
+  def test_unit_conv_factor
+    meridian = parameter_crs.prime_meridian
+    assert_equal(0.017453292519943295, meridian.unit_conv_factor)
+  end
+
+  def test_unit_name
+    meridian = parameter_crs.prime_meridian
+    assert_equal("degree", meridian.unit_name)
+  end
+end

data/test/proj_test.rb

@@ -1,17 +1,59 @@
-# encoding: UTF-8
-
-require_relative './abstract_test'
-
-class ProjTest < AbstractTest
-  def test_info
-    info = Proj.info
-    assert_equal(6, info[:major])
-    assert_equal(2, info[:minor])
-    assert_equal(1, info[:patch])
-    assert_equal('Rel. 6.2.1, November 1st, 2019', info[:release])
-    assert_equal('6.2.1', info[:version])
-    refute_nil(info[:searchpath])
-    refute(info[:paths].null?)
-    assert_equal(1, info[:path_count])
-  end
+# encoding: UTF-8
+
+require_relative './abstract_test'
+
+class ProjTest < AbstractTest
+  def test_info
+    info = Proj.info
+    assert([4,6,7,8,9].include?(info[:major]))
+    assert([0,1,2,3].include?(info[:minor]))
+    assert([0,1,2,3].include?(info[:patch]))
+    refute_nil(info[:release])
+    refute_nil(info[:searchpath])
+    assert(info[:paths].null?)
+    assert(0, info[:path_count])
+  end
+
+  def test_search_paths
+    search_paths = Proj.search_paths
+    assert_instance_of(Array, search_paths)
+    refute(search_paths.empty?)
+  end
+
+  def test_init_file_info
+    info = Proj.init_file_info("EPSG")
+    assert_equal("EPSG", info[:name].to_ptr.read_string)
+    assert(info[:filename].to_ptr.read_string.empty?)
+    # Info returns gibberish hex values, need to look at Proj source code
+    # and see what is going on
+    #assert_equal("epsg", info[:version].to_ptr.read_string)
+    #assert_equal("", info[:origin].to_ptr.read_string)
+    #assert_equal("", info[:lastupdate].to_ptr.read_string)
+  end
+
+  def test_version
+    assert_instance_of(Gem::Version, Proj::Api::PROJ_VERSION)
+    assert(Proj::Api::PROJ_VERSION.canonical_segments.first >= 5)
+  end
+
+  def test_degrees_to_radians
+    radians = Proj.degrees_to_radians(180)
+    assert_equal(Math::PI, radians)
+  end
+
+  def test_radians_to_degrees
+    degrees = Proj.radians_to_degrees(-Math::PI)
+    assert_equal(-180, degrees)
+  end
+
+  def test_degrees_minutes_seconds_to_radians
+    value = "19°46'27\"E"
+    radians = Proj.degrees_minutes_seconds_to_radians(value)
+    assert_in_delta(0.34512432, radians, 1e-7)
+  end
+
+  def test_radians_to_degrees_minutes_seconds
+    result = Proj.radians_to_degrees_minutes_seconds(Math::PI)
+    assert_equal("180dN", result)
+  end
 end