Line data    Source code

       1             : ///////////////////////////////////////////////////////////////////////////////
       2             : //
       3             : // Project:  C++ Test Suite for GDAL/OGR
       4             : // Purpose:  Test DTED support. Ported from gdrivers/dted.py.
       5             : // Author:   Mateusz Loskot <mateusz@loskot.net>
       6             : //
       7             : ///////////////////////////////////////////////////////////////////////////////
       8             : // Copyright (c) 2006, Mateusz Loskot <mateusz@loskot.net>
       9             : // Copyright (c) 2010, Even Rouault <even dot rouault at spatialys.com>
      10             : /*
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #include "gdal_unit_test.h"
      15             : 
      16             : #include "cpl_string.h"
      17             : #include "gdal_alg.h"
      18             : #include "gdal_priv.h"
      19             : #include "gdal.h"
      20             : 
      21             : #include <vector>
      22             : 
      23             : #include "gtest_include.h"
      24             : 
      25             : namespace
      26             : {
      27             : 
      28             : // Common fixture with test data
      29             : struct test_gdal_dted : public ::testing::Test
      30             : {
      31             :     struct raster_t
      32             :     {
      33             :         std::string file_;
      34             :         int band_;
      35             :         int checksum_;
      36             : 
      37           7 :         raster_t(std::string const &f, int b, int c)
      38           7 :             : file_(f), band_(b), checksum_(c)
      39             :         {
      40           7 :         }
      41             :     };
      42             : 
      43             :     typedef std::vector<raster_t> rasters_t;
      44             : 
      45             :     GDALDriverH drv_;
      46             :     std::string drv_name_;
      47             :     std::string data_;
      48             :     std::string data_tmp_;
      49             :     rasters_t rasters_;
      50             : 
      51           7 :     test_gdal_dted() : drv_(nullptr), drv_name_("DTED")
      52             :     {
      53           7 :         drv_ = GDALGetDriverByName(drv_name_.c_str());
      54             : 
      55             :         // Compose data path for test group
      56           7 :         data_ = tut::common::data_basedir;
      57           7 :         data_tmp_ = tut::common::tmp_basedir;
      58             : 
      59             :         // Collection of test DEM datasets
      60             : 
      61             :         // TODO: Verify value of this checksum
      62           7 :         rasters_.push_back(raster_t("n43.dt0", 1, 49187));
      63           7 :     }
      64             : 
      65           7 :     void SetUp() override
      66             :     {
      67           7 :         if (drv_ == nullptr)
      68           0 :             GTEST_SKIP() << "DTED driver missing";
      69             :     }
      70             : };
      71             : 
      72             : // Test open dataset
      73           4 : TEST_F(test_gdal_dted, open)
      74             : {
      75           1 :     if (drv_ == nullptr)
      76           0 :         return;
      77           2 :     for (const auto &raster : rasters_)
      78             :     {
      79           1 :         std::string file(data_ + SEP);
      80           1 :         file += raster.file_;
      81           1 :         GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
      82           1 :         ASSERT_TRUE(nullptr != ds);
      83           1 :         GDALClose(ds);
      84             :     }
      85             : }
      86             : 
      87             : // Test dataset checksums
      88           4 : TEST_F(test_gdal_dted, checksums)
      89             : {
      90           1 :     if (drv_ == nullptr)
      91           0 :         return;
      92           2 :     for (const auto &raster : rasters_)
      93             :     {
      94           1 :         std::string file(data_ + SEP);
      95           1 :         file += raster.file_;
      96             : 
      97           1 :         GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
      98           1 :         ASSERT_TRUE(nullptr != ds);
      99             : 
     100           1 :         GDALRasterBandH band = GDALGetRasterBand(ds, raster.band_);
     101           1 :         ASSERT_TRUE(nullptr != band);
     102             : 
     103           1 :         const int xsize = GDALGetRasterXSize(ds);
     104           1 :         const int ysize = GDALGetRasterYSize(ds);
     105           1 :         const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
     106             : 
     107           1 :         EXPECT_EQ(checksum, raster.checksum_);
     108             : 
     109           1 :         GDALClose(ds);
     110             :     }
     111             : }
     112             : 
     113             : // Test affine transformation coefficients
     114           4 : TEST_F(test_gdal_dted, geotransform)
     115             : {
     116             :     // Index of test file being tested
     117           1 :     const std::size_t fileIdx = 0;
     118             : 
     119           1 :     std::string file(data_ + SEP);
     120           1 :     file += rasters_.at(fileIdx).file_;
     121             : 
     122           1 :     GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
     123           1 :     ASSERT_TRUE(nullptr != ds);
     124             : 
     125           1 :     double geoTransform[6] = {0};
     126           1 :     CPLErr err = GDALGetGeoTransform(ds, geoTransform);
     127           1 :     ASSERT_EQ(err, CE_None);
     128             : 
     129             :     // Test affine transformation coefficients
     130           1 :     const double maxError = 0.000001;
     131             :     const double expect[6] = {
     132             :         -80.004166666666663,   0.0083333333333333332, 0, 44.00416666666667, 0,
     133             :         -0.0083333333333333332};
     134           1 :     EXPECT_NEAR(expect[0], geoTransform[0], maxError);
     135           1 :     EXPECT_NEAR(expect[1], geoTransform[1], maxError);
     136           1 :     EXPECT_NEAR(expect[2], geoTransform[2], maxError);
     137           1 :     EXPECT_NEAR(expect[3], geoTransform[3], maxError);
     138           1 :     EXPECT_NEAR(expect[4], geoTransform[4], maxError);
     139           1 :     EXPECT_NEAR(expect[5], geoTransform[5], maxError);
     140             : 
     141           1 :     GDALClose(ds);
     142             : }
     143             : 
     144             : // Test projection definition
     145           4 : TEST_F(test_gdal_dted, projection)
     146             : {
     147             :     // Index of test file being tested
     148           1 :     const std::size_t fileIdx = 0;
     149             : 
     150           1 :     std::string file(data_ + SEP);
     151           1 :     file += rasters_.at(fileIdx).file_;
     152             : 
     153           1 :     GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
     154           1 :     ASSERT_TRUE(nullptr != ds);
     155             : 
     156           1 :     std::string proj(GDALGetProjectionRef(ds));
     157           1 :     ASSERT_TRUE(!proj.empty());
     158             : 
     159             :     std::string expect(
     160             :         "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS "
     161             :         "84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY["
     162             :         "\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\","
     163             :         "\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\","
     164             :         "\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],"
     165           2 :         "AUTHORITY[\"EPSG\",\"4326\"]]");
     166           1 :     EXPECT_EQ(proj, expect);
     167             : 
     168           1 :     GDALClose(ds);
     169             : }
     170             : 
     171             : // Test band data type and NODATA value
     172           4 : TEST_F(test_gdal_dted, nodata)
     173             : {
     174             :     // Index of test file being tested
     175           1 :     const std::size_t fileIdx = 0;
     176             : 
     177           1 :     std::string file(data_ + SEP);
     178           1 :     file += rasters_.at(fileIdx).file_;
     179             : 
     180           1 :     GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
     181           1 :     ASSERT_TRUE(nullptr != ds);
     182             : 
     183           1 :     GDALRasterBandH band = GDALGetRasterBand(ds, rasters_.at(fileIdx).band_);
     184           1 :     ASSERT_TRUE(nullptr != band);
     185             : 
     186           1 :     const double noData = GDALGetRasterNoDataValue(band, nullptr);
     187           1 :     EXPECT_EQ(noData, -32767);
     188             : 
     189           1 :     EXPECT_EQ(GDALGetRasterDataType(band), GDT_Int16);
     190             : 
     191           1 :     GDALClose(ds);
     192             : }
     193             : 
     194             : // Create simple copy and check
     195           4 : TEST_F(test_gdal_dted, copy)
     196             : {
     197             :     // Index of test file being tested
     198           1 :     const std::size_t fileIdx = 0;
     199             : 
     200           1 :     std::string src(data_ + SEP);
     201           1 :     src += rasters_.at(fileIdx).file_;
     202             : 
     203           1 :     GDALDatasetH dsSrc = GDALOpen(src.c_str(), GA_ReadOnly);
     204           1 :     ASSERT_TRUE(nullptr != dsSrc);
     205             : 
     206           1 :     std::string dst(data_tmp_ + SEP);
     207           1 :     dst += rasters_.at(fileIdx).file_;
     208             : 
     209           1 :     GDALDatasetH dsDst = nullptr;
     210           1 :     dsDst = GDALCreateCopy(drv_, dst.c_str(), dsSrc, FALSE, nullptr, nullptr,
     211             :                            nullptr);
     212           1 :     GDALClose(dsSrc);
     213           1 :     ASSERT_TRUE(nullptr != dsDst);
     214             : 
     215           1 :     std::string proj(GDALGetProjectionRef(dsDst));
     216           1 :     ASSERT_TRUE(!proj.empty());
     217             : 
     218             :     std::string expect(
     219             :         "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS "
     220             :         "84\",6378137,298.257223563,AUTHORITY[\"EPSG\",\"7030\"]],AUTHORITY["
     221             :         "\"EPSG\",\"6326\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\","
     222             :         "\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\","
     223             :         "\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],"
     224           1 :         "AUTHORITY[\"EPSG\",\"4326\"]]");
     225           1 :     EXPECT_EQ(proj, expect);
     226             : 
     227           1 :     GDALRasterBandH band = GDALGetRasterBand(dsDst, rasters_.at(fileIdx).band_);
     228           1 :     ASSERT_TRUE(nullptr != band);
     229             : 
     230           1 :     const int xsize = GDALGetRasterXSize(dsDst);
     231           1 :     const int ysize = GDALGetRasterYSize(dsDst);
     232           1 :     const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
     233             : 
     234           1 :     EXPECT_EQ(checksum, rasters_.at(fileIdx).checksum_);
     235             : 
     236           1 :     GDALClose(dsDst);
     237             : }
     238             : 
     239             : // Test subwindow read and the tail recursion problem.
     240           4 : TEST_F(test_gdal_dted, subwindow_read)
     241             : {
     242             :     // Index of test file being tested
     243           1 :     const std::size_t fileIdx = 0;
     244             : 
     245           1 :     std::string file(data_ + SEP);
     246           1 :     file += rasters_.at(fileIdx).file_;
     247             : 
     248           1 :     GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
     249           1 :     ASSERT_TRUE(nullptr != ds);
     250             : 
     251           1 :     GDALRasterBandH band = GDALGetRasterBand(ds, rasters_.at(fileIdx).band_);
     252           1 :     ASSERT_TRUE(nullptr != band);
     253             : 
     254             :     // Sub-windows size
     255             :     const int win[4] = {5, 5, 5, 5};
     256             :     // subwindow checksum
     257           1 :     const int winChecksum = 305;
     258             :     const int checksum =
     259           1 :         GDALChecksumImage(band, win[0], win[1], win[2], win[3]);
     260             : 
     261           1 :     EXPECT_EQ(checksum, winChecksum);
     262             : 
     263           1 :     GDALClose(ds);
     264             : }
     265             : 
     266             : }  // namespace