Line data    Source code

       1             : ///////////////////////////////////////////////////////////////////////////////
       2             : //
       3             : // Project:  C++ Test Suite for GDAL/OGR
       4             : // Purpose:  Test read/write functionality for GeoTIFF format.
       5             : //           Ported from gcore/tiff_read.py, gcore/tiff_write.py.
       6             : // Author:   Mateusz Loskot <mateusz@loskot.net>
       7             : //
       8             : ///////////////////////////////////////////////////////////////////////////////
       9             : // Copyright (c) 2006, Mateusz Loskot <mateusz@loskot.net>
      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_gtiff : public ::testing::Test
      30             : {
      31             :     struct raster_t
      32             :     {
      33             :         std::string file_;
      34             :         int band_;
      35             :         int checksum_;
      36             : 
      37          84 :         raster_t(std::string const &f, int b, int c)
      38          84 :             : file_(f), band_(b), checksum_(c)
      39             :         {
      40          84 :         }
      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_gtiff() : drv_(nullptr), drv_name_("GTiff")
      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 GeoTIFF rasters
      60           7 :         rasters_.push_back(raster_t("byte.tif", 1, 4672));
      61           7 :         rasters_.push_back(raster_t("int16.tif", 1, 4672));
      62           7 :         rasters_.push_back(raster_t("uint16.tif", 1, 4672));
      63           7 :         rasters_.push_back(raster_t("int32.tif", 1, 4672));
      64           7 :         rasters_.push_back(raster_t("uint32.tif", 1, 4672));
      65           7 :         rasters_.push_back(raster_t("float32.tif", 1, 4672));
      66           7 :         rasters_.push_back(raster_t("float64.tif", 1, 4672));
      67           7 :         rasters_.push_back(raster_t("cint16.tif", 1, 5028));
      68           7 :         rasters_.push_back(raster_t("cint32.tif", 1, 5028));
      69           7 :         rasters_.push_back(raster_t("cfloat32.tif", 1, 5028));
      70           7 :         rasters_.push_back(raster_t("cfloat64.tif", 1, 5028));
      71           7 :         rasters_.push_back(raster_t("utmsmall.tif", 1, 50054));
      72           7 :     }
      73             : 
      74           7 :     void SetUp() override
      75             :     {
      76           7 :         if (drv_ == nullptr)
      77           0 :             GTEST_SKIP() << "GTiff driver missing";
      78             :     }
      79             : };
      80             : 
      81             : // Test open dataset
      82           4 : TEST_F(test_gdal_gtiff, open)
      83             : {
      84          13 :     for (const auto &raster : rasters_)
      85             :     {
      86          12 :         std::string file(data_ + SEP);
      87          12 :         file += raster.file_;
      88          12 :         GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
      89          12 :         ASSERT_TRUE(nullptr != ds);
      90          12 :         GDALClose(ds);
      91             :     }
      92             : }
      93             : 
      94             : // Test dataset checksums
      95           4 : TEST_F(test_gdal_gtiff, checksum)
      96             : {
      97          13 :     for (const auto &raster : rasters_)
      98             :     {
      99          12 :         std::string file(data_ + SEP);
     100          12 :         file += raster.file_;
     101             : 
     102          12 :         GDALDatasetH ds = GDALOpen(file.c_str(), GA_ReadOnly);
     103          12 :         ASSERT_TRUE(nullptr != ds);
     104             : 
     105          12 :         GDALRasterBandH band = GDALGetRasterBand(ds, raster.band_);
     106          12 :         ASSERT_TRUE(nullptr != band);
     107             : 
     108          12 :         const int xsize = GDALGetRasterXSize(ds);
     109          12 :         const int ysize = GDALGetRasterYSize(ds);
     110          12 :         const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
     111             : 
     112          12 :         EXPECT_EQ(raster.checksum_, checksum);
     113             : 
     114          12 :         GDALClose(ds);
     115             :     }
     116             : }
     117             : 
     118             : // Test GeoTIFF driver metadata
     119           4 : TEST_F(test_gdal_gtiff, driver_metadata)
     120             : {
     121           1 :     const char *mdItem = GDALGetMetadataItem(drv_, "DMD_MIMETYPE", nullptr);
     122           1 :     ASSERT_TRUE(nullptr != mdItem);
     123             : 
     124           1 :     EXPECT_STREQ(mdItem, "image/tiff");
     125             : }
     126             : 
     127             : // Create a simple file by copying from an existing one
     128           4 : TEST_F(test_gdal_gtiff, copy)
     129             : {
     130             :     // Index of test file being copied
     131           1 :     const std::size_t fileIdx = 10;
     132             : 
     133           1 :     std::string src(data_ + SEP);
     134           1 :     src += rasters_.at(fileIdx).file_;
     135           1 :     GDALDatasetH dsSrc = GDALOpen(src.c_str(), GA_ReadOnly);
     136           1 :     ASSERT_TRUE(nullptr != dsSrc);
     137             : 
     138           1 :     std::string dst(data_tmp_ + "\\test_2.tif");
     139           1 :     GDALDatasetH dsDst = nullptr;
     140           1 :     dsDst = GDALCreateCopy(drv_, dst.c_str(), dsSrc, FALSE, nullptr, nullptr,
     141             :                            nullptr);
     142           1 :     ASSERT_TRUE(nullptr != dsDst);
     143             : 
     144           1 :     GDALClose(dsDst);
     145           1 :     GDALClose(dsSrc);
     146             : 
     147             :     // Re-open copied dataset and test it
     148           1 :     dsDst = GDALOpen(dst.c_str(), GA_ReadOnly);
     149           1 :     GDALRasterBandH band = GDALGetRasterBand(dsDst, rasters_.at(fileIdx).band_);
     150           1 :     ASSERT_TRUE(nullptr != band);
     151             : 
     152           1 :     const int xsize = GDALGetRasterXSize(dsDst);
     153           1 :     const int ysize = GDALGetRasterYSize(dsDst);
     154           1 :     const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
     155             : 
     156           1 :     EXPECT_EQ(rasters_.at(fileIdx).checksum_, checksum);
     157             : 
     158           1 :     GDALClose(dsDst);
     159           1 :     GDALDeleteDataset(drv_, dst.c_str());
     160             : }
     161             : 
     162             : // Create a simple file by copying from an existing one using creation options
     163           4 : TEST_F(test_gdal_gtiff, copy_creation_options)
     164             : {
     165             :     // Index of test file being copied
     166           1 :     const std::size_t fileIdx = 11;
     167           1 :     std::string src(data_ + SEP);
     168           1 :     src += rasters_.at(fileIdx).file_;
     169           1 :     GDALDatasetH dsSrc = GDALOpen(src.c_str(), GA_ReadOnly);
     170           1 :     ASSERT_TRUE(nullptr != dsSrc);
     171             : 
     172           1 :     std::string dst(data_tmp_ + "\\test_3.tif");
     173             : 
     174           1 :     char **options = nullptr;
     175           1 :     options = CSLSetNameValue(options, "TILED", "YES");
     176           1 :     options = CSLSetNameValue(options, "BLOCKXSIZE", "32");
     177           1 :     options = CSLSetNameValue(options, "BLOCKYSIZE", "32");
     178             : 
     179           1 :     GDALDatasetH dsDst = nullptr;
     180           1 :     dsDst = GDALCreateCopy(drv_, dst.c_str(), dsSrc, FALSE, options, nullptr,
     181             :                            nullptr);
     182           1 :     ASSERT_TRUE(nullptr != dsDst);
     183             : 
     184           1 :     GDALClose(dsDst);
     185           1 :     CSLDestroy(options);
     186           1 :     GDALClose(dsSrc);
     187             : 
     188             :     // Re-open copied dataset and test it
     189           1 :     dsDst = GDALOpen(dst.c_str(), GA_ReadOnly);
     190           1 :     GDALRasterBandH band = GDALGetRasterBand(dsDst, rasters_.at(fileIdx).band_);
     191           1 :     ASSERT_TRUE(nullptr != band);
     192             : 
     193           1 :     const int xsize = GDALGetRasterXSize(dsDst);
     194           1 :     const int ysize = GDALGetRasterYSize(dsDst);
     195           1 :     const int checksum = GDALChecksumImage(band, 0, 0, xsize, ysize);
     196             : 
     197           1 :     EXPECT_EQ(rasters_.at(fileIdx).checksum_, checksum);
     198             : 
     199           1 :     GDALClose(dsDst);
     200           1 :     GDALDeleteDataset(drv_, dst.c_str());
     201             : }
     202             : 
     203             : // Test raster min/max calculation
     204           4 : TEST_F(test_gdal_gtiff, raster_min_max)
     205             : {
     206             :     // Index of test file being copied
     207           1 :     const std::size_t fileIdx = 10;
     208             : 
     209           1 :     std::string src(data_ + SEP);
     210           1 :     src += rasters_.at(fileIdx).file_;
     211           1 :     GDALDatasetH ds = GDALOpen(src.c_str(), GA_ReadOnly);
     212           1 :     ASSERT_TRUE(nullptr != ds);
     213             : 
     214           1 :     GDALRasterBandH band = GDALGetRasterBand(ds, rasters_.at(fileIdx).band_);
     215           1 :     ASSERT_TRUE(nullptr != band);
     216             : 
     217           1 :     double expect[2] = {74.0, 255.0};
     218           1 :     double minmax[2] = {0};
     219           1 :     GDALComputeRasterMinMax(band, TRUE, minmax);
     220             : 
     221           1 :     EXPECT_EQ(expect[0], minmax[0]);
     222           1 :     EXPECT_EQ(expect[1], minmax[1]);
     223             : 
     224           1 :     GDALClose(ds);
     225             : }
     226             : 
     227             : // Test setting a nodata value with SetNoDataValue(double) on a int64 dataset
     228           4 : TEST_F(test_gdal_gtiff, set_nodata_value_on_int64)
     229             : {
     230           2 :     std::string osTmpFile = "/vsimem/temp.tif";
     231             :     auto poDS =
     232             :         std::unique_ptr<GDALDataset>(GDALDriver::FromHandle(drv_)->Create(
     233           2 :             osTmpFile.c_str(), 1, 1, 1, GDT_Int64, nullptr));
     234           1 :     EXPECT_EQ(poDS->GetRasterBand(1)->SetNoDataValue(1), CE_None);
     235             :     {
     236           1 :         int bGotNoData = false;
     237           1 :         EXPECT_EQ(poDS->GetRasterBand(1)->GetNoDataValue(&bGotNoData), 1.0);
     238           1 :         EXPECT_TRUE(bGotNoData);
     239             :     }
     240             :     {
     241           1 :         int bGotNoData = false;
     242           1 :         EXPECT_EQ(poDS->GetRasterBand(1)->GetNoDataValueAsInt64(&bGotNoData),
     243             :                   1.0);
     244           1 :         EXPECT_TRUE(bGotNoData);
     245             :     }
     246           1 :     int64_t nVal = 0;
     247           1 :     EXPECT_EQ(poDS->GetRasterBand(1)->RasterIO(GF_Read, 0, 0, 1, 1, &nVal, 1, 1,
     248             :                                                GDT_Int64, 0, 0, nullptr),
     249             :               CE_None);
     250           1 :     EXPECT_EQ(nVal, 1);
     251           1 :     poDS.reset();
     252           1 :     VSIUnlink(osTmpFile.c_str());
     253           1 : }
     254             : 
     255             : }  // namespace