Merge branch 4.x

modules/imgcodecs/test/test_animation.cpp

@@ -636,6 +636,52 @@ TEST(Imgcodecs_APNG, imencode_animation)
     }
 }
 
+TEST(Imgcodecs_APNG, animation_has_hidden_frame)
+{
+    // Set the path to the test image directory and filename for loading.
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/033.png";
+    Animation animation1, animation2, animation3;
+
+    imreadanimation(filename, animation1);
+
+    EXPECT_FALSE(animation1.still_image.empty());
+    EXPECT_EQ((size_t)2, animation1.frames.size());
+
+    std::vector<unsigned char> buf;
+    EXPECT_TRUE(imencodeanimation(".png", animation1, buf));
+    EXPECT_TRUE(imdecodeanimation(buf, animation2));
+
+    EXPECT_FALSE(animation2.still_image.empty());
+    EXPECT_EQ(animation1.frames.size(), animation2.frames.size());
+
+    animation1.frames.erase(animation1.frames.begin());
+    animation1.durations.erase(animation1.durations.begin());
+    EXPECT_TRUE(imencodeanimation(".png", animation1, buf));
+    EXPECT_TRUE(imdecodeanimation(buf, animation3));
+
+    EXPECT_FALSE(animation1.still_image.empty());
+    EXPECT_TRUE(animation3.still_image.empty());
+    EXPECT_EQ((size_t)1, animation3.frames.size());
+}
+
+TEST(Imgcodecs_APNG, animation_imread_preview)
+{
+    // Set the path to the test image directory and filename for loading.
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/034.png";
+    cv::Mat imread_result;
+    cv::imread(filename, imread_result, cv::IMREAD_UNCHANGED);
+    EXPECT_FALSE(imread_result.empty());
+
+    Animation animation;
+    ASSERT_TRUE(imreadanimation(filename, animation));
+    EXPECT_FALSE(animation.still_image.empty());
+    EXPECT_EQ((size_t)2, animation.frames.size());
+
+    EXPECT_EQ(0, cv::norm(animation.still_image, imread_result, cv::NORM_INF));
+}
+
 #endif // HAVE_PNG
 
 #if defined(HAVE_PNG) || defined(HAVE_SPNG)
@@ -676,7 +722,7 @@ TEST(Imgcodecs_APNG, imread_animation_16u)
     img = imread(filename, IMREAD_ANYDEPTH);
     ASSERT_FALSE(img.empty());
     EXPECT_TRUE(img.type() == CV_16UC1);
-    EXPECT_EQ(19519, img.at<ushort>(0, 0));
+    EXPECT_EQ(19517, img.at<ushort>(0, 0));
 
     img = imread(filename, IMREAD_COLOR | IMREAD_ANYDEPTH);
     ASSERT_FALSE(img.empty());

modules/imgcodecs/test/test_exif.cpp

@@ -148,7 +148,246 @@ const std::vector<std::string> exif_files
 };
 
 INSTANTIATE_TEST_CASE_P(Imgcodecs, Exif,
-    testing::ValuesIn(exif_files));
+                        testing::ValuesIn(exif_files));
 
+static Mat makeCirclesImage(Size size, int type, int nbits)
+{
+    Mat img(size, type);
+    img.setTo(Scalar::all(0));
+    RNG& rng = theRNG();
+    int maxval = (int)(1 << nbits);
+    for (int i = 0; i < 100; i++) {
+        int x = rng.uniform(0, img.cols);
+        int y = rng.uniform(0, img.rows);
+        int radius = rng.uniform(5, std::min(img.cols, img.rows)/5);
+        int b = rng.uniform(0, maxval);
+        int g = rng.uniform(0, maxval);
+        int r = rng.uniform(0, maxval);
+        circle(img, Point(x, y), radius, Scalar(b, g, r), -1, LINE_AA);
+    }
+    return img;
 }
+
+#ifdef HAVE_AVIF
+TEST(Imgcodecs_Avif, ReadWriteWithExif)
+{
+    static const uchar exif_data[] = {
+        'M', 'M', 0, '*', 0, 0, 0, 8, 0, 10, 1, 0, 0, 4, 0, 0, 0, 1, 0, 0, 5,
+        0, 1, 1, 0, 4, 0, 0, 0, 1, 0, 0, 2, 208, 1, 2, 0, 3, 0, 0, 0, 1,
+        0, 10, 0, 0, 1, 18, 0, 3, 0, 0, 0, 1, 0, 1, 0, 0, 1, 14, 0, 2, 0, 0,
+        0, '"', 0, 0, 0, 176, 1, '1', 0, 2, 0, 0, 0, 7, 0, 0, 0, 210, 1, 26,
+        0, 5, 0, 0, 0, 1, 0, 0, 0, 218, 1, 27, 0, 5, 0, 0, 0, 1, 0, 0, 0,
+        226, 1, '(', 0, 3, 0, 0, 0, 1, 0, 2, 0, 0, 135, 'i', 0, 4, 0, 0, 0,
+        1, 0, 0, 0, 134, 0, 0, 0, 0, 0, 3, 144, 0, 0, 7, 0, 0, 0, 4, '0', '2',
+        '2', '1', 160, 2, 0, 4, 0, 0, 0, 1, 0, 0, 5, 0, 160, 3, 0, 4, 0, 0,
+        0, 1, 0, 0, 2, 208, 0, 0, 0, 0, 'S', 'a', 'm', 'p', 'l', 'e', ' ', '1', '0',
+        '-', 'b', 'i', 't', ' ', 'i', 'm', 'a', 'g', 'e', ' ', 'w', 'i', 't', 'h', ' ',
+        'm', 'e', 't', 'a', 'd', 'a', 't', 'a', 0, 'O', 'p', 'e', 'n', 'C', 'V', 0, 0,
+        0, 0, 0, 'H', 0, 0, 0, 1, 0, 0, 0, 'H', 0, 0, 0, 1
+    };
+
+    int avif_nbits = 10;
+    int avif_speed = 10;
+    int avif_quality = 85;
+    int imgdepth = avif_nbits > 8 ? CV_16U : CV_8U;
+    int imgtype = CV_MAKETYPE(imgdepth, 3);
+    const string outputname = cv::tempfile(".avif");
+    Mat img = makeCirclesImage(Size(1280, 720), imgtype, avif_nbits);
+
+    std::vector<int> metadata_types = {IMAGE_METADATA_EXIF};
+    std::vector<std::vector<uchar> > metadata(1);
+    metadata[0].assign(exif_data, exif_data + sizeof(exif_data));
+
+    std::vector<int> write_params = {
+        IMWRITE_AVIF_DEPTH, avif_nbits,
+        IMWRITE_AVIF_SPEED, avif_speed,
+        IMWRITE_AVIF_QUALITY, avif_quality
+    };
+
+    imwriteWithMetadata(outputname, img, metadata_types, metadata, write_params);
+    std::vector<uchar> compressed;
+    imencodeWithMetadata(outputname, img, metadata_types, metadata, compressed, write_params);
+
+    std::vector<int> read_metadata_types, read_metadata_types2;
+    std::vector<std::vector<uchar> > read_metadata, read_metadata2;
+    Mat img2 = imreadWithMetadata(outputname, read_metadata_types, read_metadata, IMREAD_UNCHANGED);
+    Mat img3 = imdecodeWithMetadata(compressed, read_metadata_types2, read_metadata2, IMREAD_UNCHANGED);
+    EXPECT_EQ(img2.cols, img.cols);
+    EXPECT_EQ(img2.rows, img.rows);
+    EXPECT_EQ(img2.type(), imgtype);
+    EXPECT_EQ(read_metadata_types, read_metadata_types2);
+    EXPECT_GE(read_metadata_types.size(), 1u);
+    EXPECT_EQ(read_metadata, read_metadata2);
+    EXPECT_EQ(read_metadata_types[0], IMAGE_METADATA_EXIF);
+    EXPECT_EQ(read_metadata_types.size(), read_metadata.size());
+    EXPECT_EQ(read_metadata[0], metadata[0]);
+    EXPECT_EQ(cv::norm(img2, img3, NORM_INF), 0.);
+    double mse = cv::norm(img, img2, NORM_L2SQR)/(img.rows*img.cols);
+    EXPECT_LT(mse, 1500);
+    remove(outputname.c_str());
 }
+#endif // HAVE_AVIF
+
+TEST(Imgcodecs_Jpeg, ReadWriteWithExif)
+{
+    static const uchar exif_data[] = {
+        'M', 'M', 0, '*', 0, 0, 0, 8, 0, 10, 1, 0, 0, 4, 0, 0, 0, 1, 0, 0, 5,
+        0, 1, 1, 0, 4, 0, 0, 0, 1, 0, 0, 2, 208, 1, 2, 0, 3, 0, 0, 0, 1,
+        0, 8, 0, 0, 1, 18, 0, 3, 0, 0, 0, 1, 0, 1, 0, 0, 1, 14, 0, 2, 0, 0,
+        0, '!', 0, 0, 0, 176, 1, '1', 0, 2, 0, 0, 0, 7, 0, 0, 0, 210, 1, 26,
+        0, 5, 0, 0, 0, 1, 0, 0, 0, 218, 1, 27, 0, 5, 0, 0, 0, 1, 0, 0, 0,
+        226, 1, '(', 0, 3, 0, 0, 0, 1, 0, 2, 0, 0, 135, 'i', 0, 4, 0, 0, 0,
+        1, 0, 0, 0, 134, 0, 0, 0, 0, 0, 3, 144, 0, 0, 7, 0, 0, 0, 4, '0', '2',
+        '2', '1', 160, 2, 0, 4, 0, 0, 0, 1, 0, 0, 5, 0, 160, 3, 0, 4, 0, 0,
+        0, 1, 0, 0, 2, 208, 0, 0, 0, 0, 'S', 'a', 'm', 'p', 'l', 'e', ' ', '8', '-',
+        'b', 'i', 't', ' ', 'i', 'm', 'a', 'g', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'm',
+        'e', 't', 'a', 'd', 'a', 't', 'a', 0, 0, 'O', 'p', 'e', 'n', 'C', 'V', 0, 0,
+        0, 0, 0, 'H', 0, 0, 0, 1, 0, 0, 0, 'H', 0, 0, 0, 1
+    };
+
+    int jpeg_quality = 95;
+    int imgtype = CV_MAKETYPE(CV_8U, 3);
+    const string outputname = cv::tempfile(".jpeg");
+    Mat img = makeCirclesImage(Size(1280, 720), imgtype, 8);
+
+    std::vector<int> metadata_types = {IMAGE_METADATA_EXIF};
+    std::vector<std::vector<uchar> > metadata(1);
+    metadata[0].assign(exif_data, exif_data + sizeof(exif_data));
+
+    std::vector<int> write_params = {
+        IMWRITE_JPEG_QUALITY, jpeg_quality
+    };
+
+    imwriteWithMetadata(outputname, img, metadata_types, metadata, write_params);
+    std::vector<uchar> compressed;
+    imencodeWithMetadata(outputname, img, metadata_types, metadata, compressed, write_params);
+
+    std::vector<int> read_metadata_types, read_metadata_types2;
+    std::vector<std::vector<uchar> > read_metadata, read_metadata2;
+    Mat img2 = imreadWithMetadata(outputname, read_metadata_types, read_metadata, IMREAD_UNCHANGED);
+    Mat img3 = imdecodeWithMetadata(compressed, read_metadata_types2, read_metadata2, IMREAD_UNCHANGED);
+    EXPECT_EQ(img2.cols, img.cols);
+    EXPECT_EQ(img2.rows, img.rows);
+    EXPECT_EQ(img2.type(), imgtype);
+    EXPECT_EQ(read_metadata_types, read_metadata_types2);
+    EXPECT_GE(read_metadata_types.size(), 1u);
+    EXPECT_EQ(read_metadata, read_metadata2);
+    EXPECT_EQ(read_metadata_types[0], IMAGE_METADATA_EXIF);
+    EXPECT_EQ(read_metadata_types.size(), read_metadata.size());
+    EXPECT_EQ(read_metadata[0], metadata[0]);
+    EXPECT_EQ(cv::norm(img2, img3, NORM_INF), 0.);
+    double mse = cv::norm(img, img2, NORM_L2SQR)/(img.rows*img.cols);
+    EXPECT_LT(mse, 80);
+    remove(outputname.c_str());
+}
+
+TEST(Imgcodecs_Png, ReadWriteWithExif)
+{
+    static const uchar exif_data[] = {
+        'M', 'M', 0, '*', 0, 0, 0, 8, 0, 10, 1, 0, 0, 4, 0, 0, 0, 1, 0, 0, 5,
+        0, 1, 1, 0, 4, 0, 0, 0, 1, 0, 0, 2, 208, 1, 2, 0, 3, 0, 0, 0, 1,
+        0, 8, 0, 0, 1, 18, 0, 3, 0, 0, 0, 1, 0, 1, 0, 0, 1, 14, 0, 2, 0, 0,
+        0, '!', 0, 0, 0, 176, 1, '1', 0, 2, 0, 0, 0, 7, 0, 0, 0, 210, 1, 26,
+        0, 5, 0, 0, 0, 1, 0, 0, 0, 218, 1, 27, 0, 5, 0, 0, 0, 1, 0, 0, 0,
+        226, 1, '(', 0, 3, 0, 0, 0, 1, 0, 2, 0, 0, 135, 'i', 0, 4, 0, 0, 0,
+        1, 0, 0, 0, 134, 0, 0, 0, 0, 0, 3, 144, 0, 0, 7, 0, 0, 0, 4, '0', '2',
+        '2', '1', 160, 2, 0, 4, 0, 0, 0, 1, 0, 0, 5, 0, 160, 3, 0, 4, 0, 0,
+        0, 1, 0, 0, 2, 208, 0, 0, 0, 0, 'S', 'a', 'm', 'p', 'l', 'e', ' ', '8', '-',
+        'b', 'i', 't', ' ', 'i', 'm', 'a', 'g', 'e', ' ', 'w', 'i', 't', 'h', ' ', 'm',
+        'e', 't', 'a', 'd', 'a', 't', 'a', 0, 0, 'O', 'p', 'e', 'n', 'C', 'V', 0, 0,
+        0, 0, 0, 'H', 0, 0, 0, 1, 0, 0, 0, 'H', 0, 0, 0, 1
+    };
+
+    int png_compression = 3;
+    int imgtype = CV_MAKETYPE(CV_8U, 3);
+    const string outputname = cv::tempfile(".png");
+    Mat img = makeCirclesImage(Size(1280, 720), imgtype, 8);
+
+    std::vector<int> metadata_types = {IMAGE_METADATA_EXIF};
+    std::vector<std::vector<uchar> > metadata(1);
+    metadata[0].assign(exif_data, exif_data + sizeof(exif_data));
+
+    std::vector<int> write_params = {
+        IMWRITE_PNG_COMPRESSION, png_compression
+    };
+
+    imwriteWithMetadata(outputname, img, metadata_types, metadata, write_params);
+    std::vector<uchar> compressed;
+    imencodeWithMetadata(outputname, img, metadata_types, metadata, compressed, write_params);
+
+    std::vector<int> read_metadata_types, read_metadata_types2;
+    std::vector<std::vector<uchar> > read_metadata, read_metadata2;
+    Mat img2 = imreadWithMetadata(outputname, read_metadata_types, read_metadata, IMREAD_UNCHANGED);
+    Mat img3 = imdecodeWithMetadata(compressed, read_metadata_types2, read_metadata2, IMREAD_UNCHANGED);
+    EXPECT_EQ(img2.cols, img.cols);
+    EXPECT_EQ(img2.rows, img.rows);
+    EXPECT_EQ(img2.type(), imgtype);
+    EXPECT_EQ(read_metadata_types, read_metadata_types2);
+    EXPECT_GE(read_metadata_types.size(), 1u);
+    EXPECT_EQ(read_metadata, read_metadata2);
+    EXPECT_EQ(read_metadata_types[0], IMAGE_METADATA_EXIF);
+    EXPECT_EQ(read_metadata_types.size(), read_metadata.size());
+    EXPECT_EQ(read_metadata[0], metadata[0]);
+    EXPECT_EQ(cv::norm(img2, img3, NORM_INF), 0.);
+    double mse = cv::norm(img, img2, NORM_L2SQR)/(img.rows*img.cols);
+    EXPECT_EQ(mse, 0); // png is lossless
+    remove(outputname.c_str());
+}
+
+static size_t locateString(const uchar* exif, size_t exif_size, const std::string& pattern)
+{
+    size_t plen = pattern.size();
+    for (size_t i = 0; i + plen <= exif_size; i++) {
+        if (exif[i] == pattern[0] && memcmp(&exif[i], pattern.c_str(), plen) == 0)
+            return i;
+    }
+    return 0xFFFFFFFFu;
+}
+
+typedef std::tuple<std::string, size_t, std::string, size_t> ReadExif_Sanity_Params;
+typedef testing::TestWithParam<ReadExif_Sanity_Params> ReadExif_Sanity;
+
+TEST_P(ReadExif_Sanity, Check)
+{
+    std::string filename = get<0>(GetParam());
+    size_t exif_size = get<1>(GetParam());
+    std::string pattern = get<2>(GetParam());
+    size_t ploc = get<3>(GetParam());
+
+    const string root = cvtest::TS::ptr()->get_data_path();
+    filename = root + filename;
+
+    std::vector<int> metadata_types;
+    std::vector<Mat> metadata;
+    Mat img = imreadWithMetadata(filename, metadata_types, metadata, 1);
+
+    EXPECT_EQ(img.type(), CV_8UC3);
+    ASSERT_GE(metadata_types.size(), 1u);
+    EXPECT_EQ(metadata_types.size(), metadata.size());
+    const Mat& exif = metadata[IMAGE_METADATA_EXIF];
+    EXPECT_EQ(exif.type(), CV_8U);
+    EXPECT_EQ(exif.total(), exif_size);
+    ASSERT_GE(exif_size, 26u); // minimal exif should take at least 26 bytes
+                                 // (the header + IDF0 with at least 1 entry).
+    EXPECT_TRUE(exif.data[0] == 'I' || exif.data[0] == 'M');
+    EXPECT_EQ(exif.data[0], exif.data[1]);
+    EXPECT_EQ(locateString(exif.data, exif_size, pattern), ploc);
+}
+
+static const std::vector<ReadExif_Sanity_Params> exif_sanity_params
+{
+#ifdef HAVE_JPEG
+    {"readwrite/testExifOrientation_3.jpg", 916, "Photoshop", 120},
+#endif
+#ifdef OPENCV_IMGCODECS_PNG_WITH_EXIF
+    {"readwrite/testExifOrientation_5.png", 112, "ExifTool", 102},
+#endif
+#ifdef HAVE_AVIF
+    {"readwrite/testExifOrientation_7.avif", 913, "Photoshop", 120},
+#endif
+};
+
+INSTANTIATE_TEST_CASE_P(Imgcodecs, ReadExif_Sanity,
+                        testing::ValuesIn(exif_sanity_params));
+
+}}

modules/imgcodecs/test/test_exr.cpp

@@ -71,6 +71,36 @@ TEST(Imgcodecs_EXR, readWrite_32FC3)
     EXPECT_EQ(0, remove(filenameOutput.c_str()));
 }
 
+TEST(Imgcodecs_EXR, readWrite_32FC7)
+{ // 0-6 channels (multispectral)
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC7.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(3, 5);
+    Mat img(sz, CV_32FC7);
+    img.at<cv::Vec<float, 7>>(0, 0)[0] = 101.125;
+    img.at<cv::Vec<float, 7>>(2, 1)[3] = 203.500;
+    img.at<cv::Vec<float, 7>>(4, 2)[6] = 305.875;
+    ASSERT_TRUE(cv::imwrite(filenameInput, img));
+#endif
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_MAKETYPE(CV_32F, 7), img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    EXPECT_EQ(img2.type(), img.type());
+    EXPECT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+    const Mat img3 = cv::imread(filenameInput, IMREAD_GRAYSCALE);
+    ASSERT_TRUE(img3.empty());
+    const Mat img4 = cv::imread(filenameInput, IMREAD_COLOR);
+    ASSERT_TRUE(img4.empty());
+}
+
 
 TEST(Imgcodecs_EXR, readWrite_32FC1_half)
 {

modules/imgcodecs/test/test_gdal.cpp

@@ -0,0 +1,41 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html
+#include "test_precomp.hpp"
+#include "test_common.hpp"
+
+namespace opencv_test { namespace {
+
+#ifdef HAVE_GDAL
+
+static void test_gdal_read(const string filename, bool required = true) {
+    const string path = cvtest::findDataFile(filename);
+    Mat img;
+    ASSERT_NO_THROW(img = imread(path, cv::IMREAD_LOAD_GDAL | cv::IMREAD_ANYDEPTH | cv::IMREAD_ANYCOLOR));
+    if(!required && img.empty())
+    {
+        throw SkipTestException("GDAL is built wihout required back-end support");
+    }
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(3, img.cols);
+    EXPECT_EQ(5, img.rows);
+    EXPECT_EQ(CV_MAKETYPE(CV_32F, 7), img.type());
+    EXPECT_EQ(101.125, (img.at<Vec<float, 7>>(0, 0)[0]));
+    EXPECT_EQ(203.500, (img.at<Vec<float, 7>>(2, 1)[3]));
+    EXPECT_EQ(305.875, (img.at<Vec<float, 7>>(4, 2)[6]));
+}
+
+TEST(Imgcodecs_gdal, read_envi)
+{
+    test_gdal_read("../cv/gdal/envi_test.raw");
+}
+
+TEST(Imgcodecs_gdal, read_fits)
+{
+    // .fit test is optional because GDAL may be built wihtout CFITSIO library support
+    test_gdal_read("../cv/gdal/fits_test.fit", false);
+}
+
+#endif // HAVE_GDAL
+
+}} // namespace

modules/imgcodecs/test/test_png.cpp

@@ -150,19 +150,107 @@ TEST(Imgcodecs_Png, decode_regression27295)
 
 typedef testing::TestWithParam<string> Imgcodecs_Png_PngSuite;
 
+// Parameterized test for decoding PNG files from the PNGSuite test set
 TEST_P(Imgcodecs_Png_PngSuite, decode)
 {
+    // Construct full paths for the PNG image and corresponding ground truth XML file
     const string root = cvtest::TS::ptr()->get_data_path();
     const string filename = root + "pngsuite/" + GetParam() + ".png";
     const string xml_filename = root + "pngsuite/" + GetParam() + ".xml";
-    FileStorage fs(xml_filename, FileStorage::READ);
-    EXPECT_TRUE(fs.isOpened());
 
+    // Load the XML file containing the ground truth data
+    FileStorage fs(xml_filename, FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened()); // Ensure the file was opened successfully
+
+    // Load the image using IMREAD_UNCHANGED to preserve original format
     Mat src = imread(filename, IMREAD_UNCHANGED);
+    ASSERT_FALSE(src.empty()); // Ensure the image was loaded successfully
+
+    // Load the ground truth matrix from XML
     Mat gt;
     fs.getFirstTopLevelNode() >> gt;
 
+    // Compare the image loaded with IMREAD_UNCHANGED to the ground truth
     EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), src, gt);
+
+    // Declare matrices for ground truth in different imread flag combinations
+    Mat gt_0, gt_1, gt_2, gt_3, gt_256, gt_258;
+
+    // Handle grayscale 8-bit and 16-bit images
+    if (gt.channels() == 1)
+    {
+        gt.copyTo(gt_2); // For IMREAD_ANYDEPTH
+        if (gt.depth() == CV_16U)
+            gt_2.convertTo(gt_0, CV_8U, 1. / 256);
+        else
+            gt_0 = gt_2; // For IMREAD_GRAYSCALE
+
+        cvtColor(gt_2, gt_3, COLOR_GRAY2BGR);  // For IMREAD_COLOR | IMREAD_ANYDEPTH
+
+        if (gt.depth() == CV_16U)
+            gt_3.convertTo(gt_1, CV_8U, 1. / 256);
+        else
+            gt_1 = gt_3; // For IMREAD_COLOR
+
+        gt_256 = gt_1; // For IMREAD_COLOR_RGB
+        gt_258 = gt_3; // For IMREAD_COLOR_RGB | IMREAD_ANYDEPTH
+    }
+
+    // Handle color images (3 or 4 channels) with 8-bit and 16-bit depth
+    if (gt.channels() > 1)
+    {
+        // Convert to grayscale
+        cvtColor(gt, gt_2, COLOR_BGRA2GRAY);
+        if (gt.depth() == CV_16U)
+            gt_2.convertTo(gt_0, CV_8U, 1. / 256);
+        else
+            gt_0 = gt_2;
+
+        // Convert to 3-channel BGR
+        if (gt.channels() == 3)
+            gt.copyTo(gt_3);
+        else
+            cvtColor(gt, gt_3, COLOR_BGRA2BGR);
+
+        if (gt.depth() == CV_16U)
+            gt_3.convertTo(gt_1, CV_8U, 1. / 256);
+        else
+            gt_1 = gt_3;
+
+        // Convert to RGB for IMREAD_COLOR_RGB variants
+        cvtColor(gt_1, gt_256, COLOR_BGR2RGB);
+        cvtColor(gt_3, gt_258, COLOR_BGR2RGB);
+    }
+
+    // Perform comparisons with different imread flags
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(1, 0), imread(filename, IMREAD_GRAYSCALE), gt_0);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(1, 0), imread(filename, IMREAD_COLOR), gt_1);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(4, 0), imread(filename, IMREAD_ANYDEPTH), gt_2);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR | IMREAD_ANYDEPTH), gt_3);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(1, 0), imread(filename, IMREAD_COLOR_RGB), gt_256);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR_RGB | IMREAD_ANYDEPTH), gt_258);
+
+// Uncomment this block to write out the decoded images for visual/manual inspection
+// or for regenerating expected ground truth PNGs (for example, after changing decoder logic).
+#if 0
+    imwrite(filename + "_0.png", imread(filename, IMREAD_GRAYSCALE));
+    imwrite(filename + "_1.png", imread(filename, IMREAD_COLOR));
+    imwrite(filename + "_2.png", imread(filename, IMREAD_ANYDEPTH));
+    imwrite(filename + "_3.png", imread(filename, IMREAD_COLOR | IMREAD_ANYDEPTH));
+    imwrite(filename + "_256.png", imread(filename, IMREAD_COLOR_RGB));
+    imwrite(filename + "_258.png", imread(filename, IMREAD_COLOR_RGB | IMREAD_ANYDEPTH));
+#endif
+
+// Uncomment this block to verify that saved images (from above) load identically
+// when read back with IMREAD_UNCHANGED. Helps ensure write-read symmetry.
+#if 0
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_GRAYSCALE), imread(filename + "_0.png", IMREAD_UNCHANGED));
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR), imread(filename + "_1.png", IMREAD_UNCHANGED));
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_ANYDEPTH), imread(filename + "_2.png", IMREAD_UNCHANGED));
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR | IMREAD_ANYDEPTH), imread(filename + "_3.png", IMREAD_UNCHANGED));
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR_RGB), imread(filename + "_256.png", IMREAD_UNCHANGED));
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), imread(filename, IMREAD_COLOR_RGB | IMREAD_ANYDEPTH), imread(filename + "_258.png", IMREAD_UNCHANGED));
+#endif
 }
 
 const string pngsuite_files[] =
@@ -243,23 +331,13 @@ const string pngsuite_files[] =
     "f04n2c08",
     "f99n0g04",
     "g03n0g16",
-    "g03n2c08",
-    "g03n3p04",
     "g04n0g16",
-    "g04n2c08",
-    "g04n3p04",
     "g05n0g16",
-    "g05n2c08",
-    "g05n3p04",
     "g07n0g16",
-    "g07n2c08",
-    "g07n3p04",
     "g10n0g16",
     "g10n2c08",
     "g10n3p04",
     "g25n0g16",
-    "g25n2c08",
-    "g25n3p04",
     "oi1n0g16",
     "oi1n2c16",
     "oi2n0g16",
@@ -333,6 +411,49 @@ const string pngsuite_files[] =
 INSTANTIATE_TEST_CASE_P(/*nothing*/, Imgcodecs_Png_PngSuite,
                         testing::ValuesIn(pngsuite_files));
 
+typedef testing::TestWithParam<string> Imgcodecs_Png_PngSuite_Gamma;
+
+// Parameterized test for decoding PNG files from the PNGSuite test set
+TEST_P(Imgcodecs_Png_PngSuite_Gamma, decode)
+{
+    // Construct full paths for the PNG image and corresponding ground truth XML file
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "pngsuite/" + GetParam() + ".png";
+    const string xml_filename = root + "pngsuite/" + GetParam() + ".xml";
+
+    // Load the XML file containing the ground truth data
+    FileStorage fs(xml_filename, FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened()); // Ensure the file was opened successfully
+
+    // Load the image using IMREAD_UNCHANGED to preserve original format
+    Mat src = imread(filename, IMREAD_UNCHANGED);
+    ASSERT_FALSE(src.empty()); // Ensure the image was loaded successfully
+
+    // Load the ground truth matrix from XML
+    Mat gt;
+    fs.getFirstTopLevelNode() >> gt;
+
+    // Compare the image loaded with IMREAD_UNCHANGED to the ground truth
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), src, gt);
+}
+
+const string pngsuite_files_gamma[] =
+{
+    "g03n2c08",
+    "g03n3p04",
+    "g04n2c08",
+    "g04n3p04",
+    "g05n2c08",
+    "g05n3p04",
+    "g07n2c08",
+    "g07n3p04",
+    "g25n2c08",
+    "g25n3p04"
+};
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Imgcodecs_Png_PngSuite_Gamma,
+                        testing::ValuesIn(pngsuite_files_gamma));
+
 typedef testing::TestWithParam<string> Imgcodecs_Png_PngSuite_Corrupted;
 
 TEST_P(Imgcodecs_Png_PngSuite_Corrupted, decode)