feat: 切换后端至PaddleOCR-NCNN，切换工程为CMake

1.项目后端整体迁移至PaddleOCR-NCNN算法，已通过基本的兼容性测试
2.工程改为使用CMake组织，后续为了更好地兼容第三方库，不再提供QMake工程
3.重整权利声明文件，重整代码工程，确保最小化侵权风险

Log: 切换后端至PaddleOCR-NCNN，切换工程为CMake
Change-Id: I4d5d2c5d37505a4a24b389b1a4c5d12f17bfa38c

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_common.cpp

@@ -0,0 +1,51 @@
+// 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 {
+
+static
+Mat generateTestImageBGR_()
+{
+    Size sz(640, 480);
+    Mat result(sz, CV_8UC3, Scalar::all(0));
+
+    const string fname = cvtest::findDataFile("../cv/shared/baboon.png");
+    Mat image = imread(fname, IMREAD_COLOR);
+    CV_Assert(!image.empty());
+    CV_CheckEQ(image.size(), Size(512, 512), "");
+    Rect roi((640-512) / 2, 0, 512, 480);
+    image(Rect(0, 0, 512, 480)).copyTo(result(roi));
+    result(Rect(0,  0, 5, 5)).setTo(Scalar(0, 0, 255));  // R
+    result(Rect(5,  0, 5, 5)).setTo(Scalar(0, 255, 0));  // G
+    result(Rect(10, 0, 5, 5)).setTo(Scalar(255, 0, 0));  // B
+    result(Rect(0,  5, 5, 5)).setTo(Scalar(128, 128, 128));  // gray
+    //imshow("test_image", result); waitKey();
+    return result;
+}
+Mat generateTestImageBGR()
+{
+    static Mat image = generateTestImageBGR_();  // initialize once
+    CV_Assert(!image.empty());
+    return image;
+}
+
+static
+Mat generateTestImageGrayscale_()
+{
+    Mat imageBGR = generateTestImageBGR();
+    CV_Assert(!imageBGR.empty());
+
+    Mat result;
+    cvtColor(imageBGR, result, COLOR_BGR2GRAY);
+    return result;
+}
+Mat generateTestImageGrayscale()
+{
+    static Mat image = generateTestImageGrayscale_();  // initialize once
+    return image;
+}
+
+}  // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_common.hpp

@@ -0,0 +1,15 @@
+// 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
+
+#ifndef OPENCV_TEST_IMGCODECS_COMMON_HPP
+#define OPENCV_TEST_IMGCODECS_COMMON_HPP
+
+namespace opencv_test {
+
+Mat generateTestImageBGR();
+Mat generateTestImageGrayscale();
+
+}  // namespace
+
+#endif  // OPENCV_TEST_IMGCODECS_COMMON_HPP

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_exr.impl.hpp

@@ -0,0 +1,308 @@
+// 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
+
+//#define GENERATE_DATA
+
+namespace opencv_test { namespace {
+
+size_t getFileSize(const string& filename)
+{
+    std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
+    if (ifs.is_open())
+    {
+        ifs.seekg(0, std::ios::end);
+        return (size_t)ifs.tellg();
+    }
+    return 0;
+}
+
+TEST(Imgcodecs_EXR, readWrite_32FC1)
+{ // Y channels
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC1.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(64, 32);
+    Mat img(sz, CV_32FC1, Scalar(0.5, 0.1, 1));
+    img(Rect(10, 5, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 0, 0));
+    ASSERT_TRUE(cv::imwrite(filenameInput, img));
+#endif
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1,img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    // Check generated file size to ensure that it's compressed with proper options
+    ASSERT_EQ(396u, getFileSize(filenameOutput));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, readWrite_32FC3)
+{ // RGB channels
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC3.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(64, 32);
+    Mat img(sz, CV_32FC3, Scalar(0.5, 0.1, 1));
+    img(Rect(10, 5, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 0, 0));
+    ASSERT_TRUE(cv::imwrite(filenameInput, img));
+#endif
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+
+TEST(Imgcodecs_EXR, readWrite_32FC1_half)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC1_half.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_EXR_TYPE);
+    params.push_back(IMWRITE_EXR_TYPE_HALF);
+
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(64, 32);
+    Mat img(sz, CV_32FC1, Scalar(0.5, 0.1, 1));
+    img(Rect(10, 5, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 0, 0));
+    ASSERT_TRUE(cv::imwrite(filenameInput, img, params));
+#endif
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1,img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img, params));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, readWrite_32FC3_half)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC3_half.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_EXR_TYPE);
+    params.push_back(IMWRITE_EXR_TYPE_HALF);
+
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(64, 32);
+    Mat img(sz, CV_32FC3, Scalar(0.5, 0.1, 1));
+    img(Rect(10, 5, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 0, 0));
+    ASSERT_TRUE(cv::imwrite(filenameInput, img, params));
+#endif
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img, params));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, readWrite_32FC1_PIZ)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC1.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1, img.type());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_EXR_COMPRESSION);
+    params.push_back(IMWRITE_EXR_COMPRESSION_PIZ);
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img, params));
+    // Check generated file size to ensure that it's compressed with proper options
+    ASSERT_EQ(849u, getFileSize(filenameOutput));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+// Note: YC to GRAYSCALE (IMREAD_GRAYSCALE | IMREAD_ANYDEPTH)
+// outputs a black image,
+// as does Y to RGB (IMREAD_COLOR | IMREAD_ANYDEPTH).
+// This behavoir predates adding EXR alpha support issue
+// 16115.
+
+TEST(Imgcodecs_EXR, read_YA_ignore_alpha)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YA.exr";
+
+    const Mat img = cv::imread(filenameInput, IMREAD_GRAYSCALE | IMREAD_ANYDEPTH);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1, img.type());
+
+    // Writing Y covered by test 32FC1
+}
+
+TEST(Imgcodecs_EXR, read_YA_unchanged)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YA.exr";
+
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC2, img.type());
+
+    // Cannot test writing, 2 channel writing not suppported by loadsave
+}
+
+TEST(Imgcodecs_EXR, read_YC_changeDepth)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YRYBY.exr";
+
+    const Mat img = cv::imread(filenameInput, IMREAD_COLOR);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_8UC3, img.type());
+
+    // Cannot test writing, EXR encoder doesn't support 8U depth
+}
+
+TEST(Imgcodecs_EXR, readwrite_YCA_ignore_alpha)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YRYBYA.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+    const Mat img = cv::imread(filenameInput, IMREAD_COLOR | IMREAD_ANYDEPTH);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, read_YC_unchanged)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YRYBY.exr";
+
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    // Writing YC covered by test readwrite_YCA_ignore_alpha
+}
+
+TEST(Imgcodecs_EXR, readwrite_YCA_unchanged)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_YRYBYA.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC4, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, readwrite_RGBA_togreyscale)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_GeneratedRGBA.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+    const Mat img = cv::imread(filenameInput, IMREAD_GRAYSCALE | IMREAD_ANYDEPTH);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_EXR, read_RGBA_ignore_alpha)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_GeneratedRGBA.exr";
+
+    const Mat img = cv::imread(filenameInput, IMREAD_COLOR | IMREAD_ANYDEPTH);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    // Writing RGB covered by test 32FC3
+}
+
+TEST(Imgcodecs_EXR, read_RGBA_unchanged)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test_GeneratedRGBA.exr";
+    const string filenameOutput = cv::tempfile(".exr");
+
+#ifndef GENERATE_DATA
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+#else
+    const Size sz(64, 32);
+    Mat img(sz, CV_32FC4, Scalar(0.5, 0.1, 1, 1));
+    img(Rect(10, 5, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 0, 0, 1));
+    img(Rect(10, 20, sz.width - 30, sz.height - 20)).setTo(Scalar(1, 1, 0, 0));
+    ASSERT_TRUE(cv::imwrite(filenameInput, img));
+#endif
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC4, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+}} // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_grfmt.cpp

@@ -0,0 +1,397 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef tuple<string, int> File_Mode;
+typedef testing::TestWithParam<File_Mode> Imgcodecs_FileMode;
+
+TEST_P(Imgcodecs_FileMode, regression)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + get<0>(GetParam());
+    const int mode = get<1>(GetParam());
+
+    const Mat single = imread(filename, mode);
+    ASSERT_FALSE(single.empty());
+
+    vector<Mat> pages;
+    ASSERT_TRUE(imreadmulti(filename, pages, mode));
+    ASSERT_FALSE(pages.empty());
+    const Mat page = pages[0];
+    ASSERT_FALSE(page.empty());
+
+    EXPECT_EQ(page.channels(), single.channels());
+    EXPECT_EQ(page.depth(), single.depth());
+    EXPECT_EQ(page.size().height, single.size().height);
+    EXPECT_EQ(page.size().width, single.size().width);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), page, single);
+}
+
+const string all_images[] =
+{
+#if (defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)) \
+    || defined(HAVE_OPENJPEG)
+    "readwrite/Rome.jp2",
+    "readwrite/Bretagne2.jp2",
+    "readwrite/Bretagne2.jp2",
+    "readwrite/Grey.jp2",
+    "readwrite/Grey.jp2",
+    "readwrite/balloon.j2c",
+#endif
+
+#ifdef HAVE_GDCM
+    "readwrite/int16-mono1.dcm",
+    "readwrite/uint8-mono2.dcm",
+    "readwrite/uint16-mono2.dcm",
+    "readwrite/uint8-rgb.dcm",
+#endif
+    "readwrite/color_palette_alpha.png",
+    "readwrite/multipage.tif",
+    "readwrite/ordinary.bmp",
+    "readwrite/rle8.bmp",
+    "readwrite/test_1_c1.jpg",
+#ifdef HAVE_IMGCODEC_HDR
+    "readwrite/rle.hdr"
+#endif
+};
+
+const int basic_modes[] =
+{
+    IMREAD_UNCHANGED,
+    IMREAD_GRAYSCALE,
+    IMREAD_COLOR,
+    IMREAD_ANYDEPTH,
+    IMREAD_ANYCOLOR
+};
+
+INSTANTIATE_TEST_CASE_P(All, Imgcodecs_FileMode,
+                        testing::Combine(
+                            testing::ValuesIn(all_images),
+                            testing::ValuesIn(basic_modes)));
+
+// GDAL does not support "hdr", "dcm" and has problems with JPEG2000 files (jp2, j2c)
+struct notForGDAL {
+    bool operator()(const string &name) const {
+        const string &ext = name.substr(name.size() - 3, 3);
+        return ext == "hdr" || ext == "dcm" || ext == "jp2" || ext == "j2c" ||
+                name.find("rle8.bmp") != std::string::npos;
+    }
+};
+
+inline vector<string> gdal_images()
+{
+    vector<string> res;
+    std::back_insert_iterator< vector<string> > it(res);
+    std::remove_copy_if(all_images, all_images + sizeof(all_images)/sizeof(all_images[0]), it, notForGDAL());
+    return res;
+}
+
+INSTANTIATE_TEST_CASE_P(GDAL, Imgcodecs_FileMode,
+                        testing::Combine(
+                            testing::ValuesIn(gdal_images()),
+                            testing::Values(IMREAD_LOAD_GDAL)));
+
+//==================================================================================================
+
+typedef tuple<string, Size> Ext_Size;
+typedef testing::TestWithParam<Ext_Size> Imgcodecs_ExtSize;
+
+TEST_P(Imgcodecs_ExtSize, write_imageseq)
+{
+    const string ext = get<0>(GetParam());
+    const Size size = get<1>(GetParam());
+    const Point2i center = Point2i(size.width / 2, size.height / 2);
+    const int radius = std::min(size.height, size.width / 4);
+
+    for (int cn = 1; cn <= 4; cn++)
+    {
+        SCOPED_TRACE(format("channels %d", cn));
+        std::vector<int> parameters;
+        if (cn == 2)
+            continue;
+        if (cn == 4 && ext != ".tiff")
+            continue;
+        if (cn > 1 && (ext == ".pbm" || ext == ".pgm"))
+            continue;
+        if (cn != 3 && ext == ".ppm")
+            continue;
+        string filename = cv::tempfile(format("%d%s", cn, ext.c_str()).c_str());
+
+        Mat img_gt(size, CV_MAKETYPE(CV_8U, cn), Scalar::all(0));
+        circle(img_gt, center, radius, Scalar::all(255));
+
+#if 1
+        if (ext == ".pbm" || ext == ".pgm" || ext == ".ppm")
+        {
+            parameters.push_back(IMWRITE_PXM_BINARY);
+            parameters.push_back(0);
+        }
+#endif
+        ASSERT_TRUE(imwrite(filename, img_gt, parameters));
+        Mat img = imread(filename, IMREAD_UNCHANGED);
+        ASSERT_FALSE(img.empty());
+        EXPECT_EQ(img.size(), img.size());
+        EXPECT_EQ(img.type(), img.type());
+        EXPECT_EQ(cn, img.channels());
+
+
+        if (ext == ".jpg")
+        {
+            // JPEG format does not provide 100% accuracy
+            // using fuzzy image comparison
+            double n = cvtest::norm(img, img_gt, NORM_L1);
+            double expected = 0.07 * img.size().area();
+            EXPECT_LT(n, expected);
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(10, 0), img, img_gt);
+        }
+        else if (ext == ".pfm")
+        {
+            img_gt.convertTo(img_gt, CV_MAKETYPE(CV_32F, img.channels()));
+            double n = cvtest::norm(img, img_gt, NORM_L2);
+            EXPECT_LT(n, 1.);
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), img, img_gt);
+        }
+        else
+        {
+            double n = cvtest::norm(img, img_gt, NORM_L2);
+            EXPECT_LT(n, 1.);
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), img, img_gt);
+        }
+
+#if 0
+        imshow("loaded", img);
+        waitKey(0);
+#else
+        EXPECT_EQ(0, remove(filename.c_str()));
+#endif
+    }
+}
+
+const string all_exts[] =
+{
+#ifdef HAVE_PNG
+    ".png",
+#endif
+#ifdef HAVE_TIFF
+    ".tiff",
+#endif
+#ifdef HAVE_JPEG
+    ".jpg",
+#endif
+    ".bmp",
+#ifdef HAVE_IMGCODEC_PXM
+    ".pam",
+    ".ppm",
+    ".pgm",
+    ".pbm",
+    ".pnm",
+#endif
+#ifdef HAVE_IMGCODEC_PFM
+    ".pfm",
+#endif
+};
+
+vector<Size> all_sizes()
+{
+    vector<Size> res;
+    for (int k = 1; k <= 5; ++k)
+        res.push_back(Size(640 * k, 480 * k));
+    return res;
+}
+
+INSTANTIATE_TEST_CASE_P(All, Imgcodecs_ExtSize,
+                        testing::Combine(
+                            testing::ValuesIn(all_exts),
+                            testing::ValuesIn(all_sizes())));
+
+#ifdef HAVE_IMGCODEC_PXM
+typedef testing::TestWithParam<bool> Imgcodecs_pbm;
+TEST_P(Imgcodecs_pbm, write_read)
+{
+    bool binary = GetParam();
+    const String ext = "pbm";
+    const string full_name = cv::tempfile(ext.c_str());
+
+    Size size(640, 480);
+    const Point2i center = Point2i(size.width / 2, size.height / 2);
+    const int radius = std::min(size.height, size.width / 4);
+    Mat image(size, CV_8UC1, Scalar::all(0));
+    circle(image, center, radius, Scalar::all(255));
+
+    vector<int> pbm_params;
+    pbm_params.push_back(IMWRITE_PXM_BINARY);
+    pbm_params.push_back(binary);
+
+    imwrite( full_name, image, pbm_params );
+    Mat loaded = imread(full_name, IMREAD_UNCHANGED);
+    ASSERT_FALSE(loaded.empty());
+
+    EXPECT_EQ(0, cvtest::norm(loaded, image, NORM_INF));
+
+    FILE *f = fopen(full_name.c_str(), "rb");
+    ASSERT_TRUE(f != NULL);
+    ASSERT_EQ('P', getc(f));
+    ASSERT_EQ('1' + (binary ? 3 : 0), getc(f));
+    fclose(f);
+    EXPECT_EQ(0, remove(full_name.c_str()));
+}
+
+INSTANTIATE_TEST_CASE_P(All, Imgcodecs_pbm, testing::Bool());
+#endif
+
+
+//==================================================================================================
+
+TEST(Imgcodecs_Bmp, read_rle8)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    Mat rle = imread(root + "readwrite/rle8.bmp");
+    ASSERT_FALSE(rle.empty());
+    Mat ord = imread(root + "readwrite/ordinary.bmp");
+    ASSERT_FALSE(ord.empty());
+    EXPECT_LE(cvtest::norm(rle, ord, NORM_L2), 1.e-10);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), rle, ord);
+}
+
+#ifdef HAVE_IMGCODEC_HDR
+TEST(Imgcodecs_Hdr, regression)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "/readwrite/";
+    string name_rle = folder + "rle.hdr";
+    string name_no_rle = folder + "no_rle.hdr";
+    Mat img_rle = imread(name_rle, -1);
+    ASSERT_FALSE(img_rle.empty()) << "Could not open " << name_rle;
+    Mat img_no_rle = imread(name_no_rle, -1);
+    ASSERT_FALSE(img_no_rle.empty()) << "Could not open " << name_no_rle;
+
+    double min = 0.0, max = 1.0;
+    minMaxLoc(abs(img_rle - img_no_rle), &min, &max);
+    ASSERT_FALSE(max > DBL_EPSILON);
+    string tmp_file_name = tempfile(".hdr");
+    vector<int>param(1);
+    for(int i = 0; i < 2; i++) {
+        param[0] = i;
+        imwrite(tmp_file_name, img_rle, param);
+        Mat written_img = imread(tmp_file_name, -1);
+        ASSERT_FALSE(written_img.empty()) << "Could not open " << tmp_file_name;
+        minMaxLoc(abs(img_rle - written_img), &min, &max);
+        ASSERT_FALSE(max > DBL_EPSILON);
+    }
+    remove(tmp_file_name.c_str());
+}
+#endif
+
+#ifdef HAVE_IMGCODEC_PXM
+TEST(Imgcodecs_Pam, read_write)
+{
+    string folder = string(cvtest::TS::ptr()->get_data_path()) + "readwrite/";
+    string filepath = folder + "lena.pam";
+
+    cv::Mat img = cv::imread(filepath);
+    ASSERT_FALSE(img.empty());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_PAM_TUPLETYPE);
+    params.push_back(IMWRITE_PAM_FORMAT_RGB);
+
+    string writefile = cv::tempfile(".pam");
+    EXPECT_NO_THROW(cv::imwrite(writefile, img, params));
+    cv::Mat reread = cv::imread(writefile);
+
+    string writefile_no_param = cv::tempfile(".pam");
+    EXPECT_NO_THROW(cv::imwrite(writefile_no_param, img));
+    cv::Mat reread_no_param = cv::imread(writefile_no_param);
+
+    EXPECT_EQ(0, cvtest::norm(reread, reread_no_param, NORM_INF));
+    EXPECT_EQ(0, cvtest::norm(img, reread, NORM_INF));
+
+    remove(writefile.c_str());
+    remove(writefile_no_param.c_str());
+}
+#endif
+
+#ifdef HAVE_IMGCODEC_PFM
+TEST(Imgcodecs_Pfm, read_write)
+{
+  Mat img = imread(findDataFile("readwrite/lena.pam"));
+  ASSERT_FALSE(img.empty());
+  img.convertTo(img, CV_32F, 1/255.0f);
+
+  std::vector<int> params;
+  string writefile = cv::tempfile(".pfm");
+  EXPECT_NO_THROW(cv::imwrite(writefile, img, params));
+  cv::Mat reread = cv::imread(writefile, IMREAD_UNCHANGED);
+
+  string writefile_no_param = cv::tempfile(".pfm");
+  EXPECT_NO_THROW(cv::imwrite(writefile_no_param, img));
+  cv::Mat reread_no_param = cv::imread(writefile_no_param, IMREAD_UNCHANGED);
+
+  EXPECT_EQ(0, cvtest::norm(reread, reread_no_param, NORM_INF));
+  EXPECT_EQ(0, cvtest::norm(img, reread, NORM_INF));
+
+  EXPECT_EQ(0, remove(writefile.c_str()));
+  EXPECT_EQ(0, remove(writefile_no_param.c_str()));
+}
+#endif
+
+TEST(Imgcodecs, write_parameter_type)
+{
+    cv::Mat m(10, 10, CV_8UC1, cv::Scalar::all(0));
+    cv::Mat1b m_type = cv::Mat1b::zeros(10, 10);
+    string tmp_file = cv::tempfile(".bmp");
+    EXPECT_NO_THROW(cv::imwrite(tmp_file, cv::Mat(m * 2))) << "* Failed with cv::Mat";
+    EXPECT_NO_THROW(cv::imwrite(tmp_file, m * 2)) << "* Failed with cv::MatExpr";
+    EXPECT_NO_THROW(cv::imwrite(tmp_file, m_type)) << "* Failed with cv::Mat_";
+    EXPECT_NO_THROW(cv::imwrite(tmp_file, m_type * 2)) << "* Failed with cv::MatExpr(Mat_)";
+    cv::Matx<uchar, 10, 10> matx;
+    EXPECT_NO_THROW(cv::imwrite(tmp_file, matx)) << "* Failed with cv::Matx";
+    EXPECT_EQ(0, remove(tmp_file.c_str()));
+}
+
+}} // namespace
+
+#ifdef HAVE_OPENEXR
+#include "test_exr.impl.hpp"
+#endif

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_jpeg.cpp

@@ -0,0 +1,183 @@
+// 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"
+
+namespace opencv_test { namespace {
+
+#ifdef HAVE_JPEG
+
+/**
+ * Test for check whether reading exif orientation tag was processed successfully or not
+ * The test info is the set of 8 images named testExifRotate_{1 to 8}.jpg
+ * The test image is the square 10x10 points divided by four sub-squares:
+ * (R corresponds to Red, G to Green, B to Blue, W to white)
+ * ---------             ---------
+ * | R | G |             | G | R |
+ * |-------| - (tag 1)   |-------| - (tag 2)
+ * | B | W |             | W | B |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | W | B |             | B | W |
+ * |-------| - (tag 3)   |-------| - (tag 4)
+ * | G | R |             | R | G |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | R | B |             | G | W |
+ * |-------| - (tag 5)   |-------| - (tag 6)
+ * | G | W |             | R | B |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | W | G |             | B | R |
+ * |-------| - (tag 7)   |-------| - (tag 8)
+ * | B | R |             | W | G |
+ * ---------             ---------
+ *
+ *
+ * Every image contains exif field with orientation tag (0x112)
+ * After reading each image the corresponding matrix must be read as
+ * ---------
+ * | R | G |
+ * |-------|
+ * | B | W |
+ * ---------
+ *
+ */
+
+typedef testing::TestWithParam<string> Imgcodecs_Jpeg_Exif;
+
+TEST_P(Imgcodecs_Jpeg_Exif, exif_orientation)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + GetParam();
+    const int colorThresholdHigh = 250;
+    const int colorThresholdLow = 5;
+
+    Mat m_img = imread(filename);
+    ASSERT_FALSE(m_img.empty());
+    Vec3b vec;
+
+    //Checking the first quadrant (with supposed red)
+    vec = m_img.at<Vec3b>(2, 2); //some point inside the square
+    EXPECT_LE(vec.val[0], colorThresholdLow);
+    EXPECT_LE(vec.val[1], colorThresholdLow);
+    EXPECT_GE(vec.val[2], colorThresholdHigh);
+
+    //Checking the second quadrant (with supposed green)
+    vec = m_img.at<Vec3b>(2, 7);  //some point inside the square
+    EXPECT_LE(vec.val[0], colorThresholdLow);
+    EXPECT_GE(vec.val[1], colorThresholdHigh);
+    EXPECT_LE(vec.val[2], colorThresholdLow);
+
+    //Checking the third quadrant (with supposed blue)
+    vec = m_img.at<Vec3b>(7, 2);  //some point inside the square
+    EXPECT_GE(vec.val[0], colorThresholdHigh);
+    EXPECT_LE(vec.val[1], colorThresholdLow);
+    EXPECT_LE(vec.val[2], colorThresholdLow);
+}
+
+const string exif_files[] =
+{
+    "readwrite/testExifOrientation_1.jpg",
+    "readwrite/testExifOrientation_2.jpg",
+    "readwrite/testExifOrientation_3.jpg",
+    "readwrite/testExifOrientation_4.jpg",
+    "readwrite/testExifOrientation_5.jpg",
+    "readwrite/testExifOrientation_6.jpg",
+    "readwrite/testExifOrientation_7.jpg",
+    "readwrite/testExifOrientation_8.jpg"
+};
+
+INSTANTIATE_TEST_CASE_P(ExifFiles, Imgcodecs_Jpeg_Exif,
+                        testing::ValuesIn(exif_files));
+
+//==================================================================================================
+
+TEST(Imgcodecs_Jpeg, encode_empty)
+{
+    cv::Mat img;
+    std::vector<uchar> jpegImg;
+    ASSERT_THROW(cv::imencode(".jpg", img, jpegImg), cv::Exception);
+}
+
+TEST(Imgcodecs_Jpeg, encode_decode_progressive_jpeg)
+{
+    cvtest::TS& ts = *cvtest::TS::ptr();
+    string input = string(ts.get_data_path()) + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(input);
+    ASSERT_FALSE(img.empty());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_JPEG_PROGRESSIVE);
+    params.push_back(1);
+
+    string output_progressive = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_progressive, img, params));
+    cv::Mat img_jpg_progressive = cv::imread(output_progressive);
+
+    string output_normal = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_normal, img));
+    cv::Mat img_jpg_normal = cv::imread(output_normal);
+
+    EXPECT_EQ(0, cvtest::norm(img_jpg_progressive, img_jpg_normal, NORM_INF));
+
+    EXPECT_EQ(0, remove(output_progressive.c_str()));
+    EXPECT_EQ(0, remove(output_normal.c_str()));
+}
+
+TEST(Imgcodecs_Jpeg, encode_decode_optimize_jpeg)
+{
+    cvtest::TS& ts = *cvtest::TS::ptr();
+    string input = string(ts.get_data_path()) + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(input);
+    ASSERT_FALSE(img.empty());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_JPEG_OPTIMIZE);
+    params.push_back(1);
+
+    string output_optimized = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_optimized, img, params));
+    cv::Mat img_jpg_optimized = cv::imread(output_optimized);
+
+    string output_normal = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_normal, img));
+    cv::Mat img_jpg_normal = cv::imread(output_normal);
+
+    EXPECT_EQ(0, cvtest::norm(img_jpg_optimized, img_jpg_normal, NORM_INF));
+
+    EXPECT_EQ(0, remove(output_optimized.c_str()));
+    EXPECT_EQ(0, remove(output_normal.c_str()));
+}
+
+TEST(Imgcodecs_Jpeg, encode_decode_rst_jpeg)
+{
+    cvtest::TS& ts = *cvtest::TS::ptr();
+    string input = string(ts.get_data_path()) + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(input);
+    ASSERT_FALSE(img.empty());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_JPEG_RST_INTERVAL);
+    params.push_back(1);
+
+    string output_rst = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_rst, img, params));
+    cv::Mat img_jpg_rst = cv::imread(output_rst);
+
+    string output_normal = cv::tempfile(".jpg");
+    EXPECT_NO_THROW(cv::imwrite(output_normal, img));
+    cv::Mat img_jpg_normal = cv::imread(output_normal);
+
+    EXPECT_EQ(0, cvtest::norm(img_jpg_rst, img_jpg_normal, NORM_INF));
+
+    EXPECT_EQ(0, remove(output_rst.c_str()));
+    EXPECT_EQ(0, remove(output_normal.c_str()));
+}
+
+#endif // HAVE_JPEG
+
+}} // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_main.cpp

@@ -0,0 +1,10 @@
+// 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"
+
+#if defined(HAVE_HPX)
+    #include <hpx/hpx_main.hpp>
+#endif
+
+CV_TEST_MAIN("highgui")

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_png.cpp

@@ -0,0 +1,191 @@
+// 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"
+
+namespace opencv_test { namespace {
+
+#ifdef HAVE_PNG
+
+TEST(Imgcodecs_Png, write_big)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/read.png";
+    const string dst_file = cv::tempfile(".png");
+    Mat img;
+    ASSERT_NO_THROW(img = imread(filename));
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(13043, img.cols);
+    EXPECT_EQ(13917, img.rows);
+    ASSERT_NO_THROW(imwrite(dst_file, img));
+    EXPECT_EQ(0, remove(dst_file.c_str()));
+}
+
+TEST(Imgcodecs_Png, encode)
+{
+    vector<uchar> buff;
+    Mat img_gt = Mat::zeros(1000, 1000, CV_8U);
+    vector<int> param;
+    param.push_back(IMWRITE_PNG_COMPRESSION);
+    param.push_back(3); //default(3) 0-9.
+    EXPECT_NO_THROW(imencode(".png", img_gt, buff, param));
+    Mat img;
+    EXPECT_NO_THROW(img = imdecode(buff, IMREAD_ANYDEPTH)); // hang
+    EXPECT_FALSE(img.empty());
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), img, img_gt);
+}
+
+TEST(Imgcodecs_Png, regression_ImreadVSCvtColor)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string imgName = root + "../cv/shared/lena.png";
+    Mat original_image = imread(imgName);
+    Mat gray_by_codec = imread(imgName, IMREAD_GRAYSCALE);
+    Mat gray_by_cvt;
+    cvtColor(original_image, gray_by_cvt, COLOR_BGR2GRAY);
+
+    Mat diff;
+    absdiff(gray_by_codec, gray_by_cvt, diff);
+    EXPECT_LT(cvtest::mean(diff)[0], 1.);
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(10, 0), gray_by_codec, gray_by_cvt);
+}
+
+// Test OpenCV issue 3075 is solved
+TEST(Imgcodecs_Png, read_color_palette_with_alpha)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    Mat img;
+
+    // First Test : Read PNG with alpha, imread flag -1
+    img = imread(root + "readwrite/color_palette_alpha.png", IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(img.channels() == 4);
+
+    // pixel is red in BGRA
+    EXPECT_EQ(img.at<Vec4b>(0, 0), Vec4b(0, 0, 255, 255));
+    EXPECT_EQ(img.at<Vec4b>(0, 1), Vec4b(0, 0, 255, 255));
+
+    // Second Test : Read PNG without alpha, imread flag -1
+    img = imread(root + "readwrite/color_palette_no_alpha.png", IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(img.channels() == 3);
+
+    // pixel is red in BGR
+    EXPECT_EQ(img.at<Vec3b>(0, 0), Vec3b(0, 0, 255));
+    EXPECT_EQ(img.at<Vec3b>(0, 1), Vec3b(0, 0, 255));
+
+    // Third Test : Read PNG with alpha, imread flag 1
+    img = imread(root + "readwrite/color_palette_alpha.png", IMREAD_COLOR);
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(img.channels() == 3);
+
+    // pixel is red in BGR
+    EXPECT_EQ(img.at<Vec3b>(0, 0), Vec3b(0, 0, 255));
+    EXPECT_EQ(img.at<Vec3b>(0, 1), Vec3b(0, 0, 255));
+
+    // Fourth Test : Read PNG without alpha, imread flag 1
+    img = imread(root + "readwrite/color_palette_no_alpha.png", IMREAD_COLOR);
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(img.channels() == 3);
+
+    // pixel is red in BGR
+    EXPECT_EQ(img.at<Vec3b>(0, 0), Vec3b(0, 0, 255));
+    EXPECT_EQ(img.at<Vec3b>(0, 1), Vec3b(0, 0, 255));
+}
+
+/**
+ * Test for check whether reading exif orientation tag was processed successfully or not
+ * The test info is the set of 8 images named testExifRotate_{1 to 8}.png
+ * The test image is the square 10x10 points divided by four sub-squares:
+ * (R corresponds to Red, G to Green, B to Blue, W to white)
+ * ---------             ---------
+ * | R | G |             | G | R |
+ * |-------| - (tag 1)   |-------| - (tag 2)
+ * | B | W |             | W | B |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | W | B |             | B | W |
+ * |-------| - (tag 3)   |-------| - (tag 4)
+ * | G | R |             | R | G |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | R | B |             | G | W |
+ * |-------| - (tag 5)   |-------| - (tag 6)
+ * | G | W |             | R | B |
+ * ---------             ---------
+ *
+ * ---------             ---------
+ * | W | G |             | B | R |
+ * |-------| - (tag 7)   |-------| - (tag 8)
+ * | B | R |             | W | G |
+ * ---------             ---------
+ *
+ *
+ * Every image contains exif field with orientation tag (0x112)
+ * After reading each image and applying the orientation tag,
+ * the resulting image should be:
+ * ---------
+ * | R | G |
+ * |-------|
+ * | B | W |
+ * ---------
+ *
+ */
+
+typedef testing::TestWithParam<string> Imgcodecs_PNG_Exif;
+
+// Solution to issue 16579: PNG read doesn't support Exif orientation data
+#ifdef OPENCV_IMGCODECS_PNG_WITH_EXIF
+TEST_P(Imgcodecs_PNG_Exif, exif_orientation)
+#else
+TEST_P(Imgcodecs_PNG_Exif, DISABLED_exif_orientation)
+#endif
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + GetParam();
+    const int colorThresholdHigh = 250;
+    const int colorThresholdLow = 5;
+
+    Mat m_img = imread(filename);
+    ASSERT_FALSE(m_img.empty());
+    Vec3b vec;
+
+    //Checking the first quadrant (with supposed red)
+    vec = m_img.at<Vec3b>(2, 2); //some point inside the square
+    EXPECT_LE(vec.val[0], colorThresholdLow);
+    EXPECT_LE(vec.val[1], colorThresholdLow);
+    EXPECT_GE(vec.val[2], colorThresholdHigh);
+
+    //Checking the second quadrant (with supposed green)
+    vec = m_img.at<Vec3b>(2, 7);  //some point inside the square
+    EXPECT_LE(vec.val[0], colorThresholdLow);
+    EXPECT_GE(vec.val[1], colorThresholdHigh);
+    EXPECT_LE(vec.val[2], colorThresholdLow);
+
+    //Checking the third quadrant (with supposed blue)
+    vec = m_img.at<Vec3b>(7, 2);  //some point inside the square
+    EXPECT_GE(vec.val[0], colorThresholdHigh);
+    EXPECT_LE(vec.val[1], colorThresholdLow);
+    EXPECT_LE(vec.val[2], colorThresholdLow);
+}
+
+const string exif_files[] =
+{
+    "readwrite/testExifOrientation_1.png",
+    "readwrite/testExifOrientation_2.png",
+    "readwrite/testExifOrientation_3.png",
+    "readwrite/testExifOrientation_4.png",
+    "readwrite/testExifOrientation_5.png",
+    "readwrite/testExifOrientation_6.png",
+    "readwrite/testExifOrientation_7.png",
+    "readwrite/testExifOrientation_8.png"
+};
+
+INSTANTIATE_TEST_CASE_P(ExifFiles, Imgcodecs_PNG_Exif,
+    testing::ValuesIn(exif_files));
+
+#endif // HAVE_PNG
+
+}} // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_precomp.hpp

@@ -0,0 +1,75 @@
+// 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
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+
+namespace cv {
+
+static inline
+void PrintTo(const ImreadModes& val, std::ostream* os)
+{
+    int v = val;
+    if (v == IMREAD_UNCHANGED && (v & IMREAD_IGNORE_ORIENTATION) != 0)
+    {
+        CV_Assert(IMREAD_UNCHANGED == -1);
+        *os << "IMREAD_UNCHANGED";
+        return;
+    }
+    if ((v & IMREAD_COLOR) != 0)
+    {
+        CV_Assert(IMREAD_COLOR == 1);
+        v &= ~IMREAD_COLOR;
+        *os << "IMREAD_COLOR" << (v == 0 ? "" : " | ");
+    }
+    else
+    {
+        CV_Assert(IMREAD_GRAYSCALE == 0);
+        *os << "IMREAD_GRAYSCALE" << (v == 0 ? "" : " | ");
+    }
+    if ((v & IMREAD_ANYDEPTH) != 0)
+    {
+        v &= ~IMREAD_ANYDEPTH;
+        *os << "IMREAD_ANYDEPTH" << (v == 0 ? "" : " | ");
+    }
+    if ((v & IMREAD_ANYCOLOR) != 0)
+    {
+        v &= ~IMREAD_ANYCOLOR;
+        *os << "IMREAD_ANYCOLOR" << (v == 0 ? "" : " | ");
+    }
+    if ((v & IMREAD_LOAD_GDAL) != 0)
+    {
+        v &= ~IMREAD_LOAD_GDAL;
+        *os << "IMREAD_LOAD_GDAL" << (v == 0 ? "" : " | ");
+    }
+    if ((v & IMREAD_IGNORE_ORIENTATION) != 0)
+    {
+        v &= ~IMREAD_IGNORE_ORIENTATION;
+        *os << "IMREAD_IGNORE_ORIENTATION" << (v == 0 ? "" : " | ");
+    }
+    switch (v)
+    {
+        case IMREAD_UNCHANGED: return;
+        case IMREAD_GRAYSCALE: return;
+        case IMREAD_COLOR: return;
+        case IMREAD_ANYDEPTH: return;
+        case IMREAD_ANYCOLOR: return;
+        case IMREAD_LOAD_GDAL: return;
+        case IMREAD_REDUCED_GRAYSCALE_2: // fallthru
+        case IMREAD_REDUCED_COLOR_2: *os << "REDUCED_2"; return;
+        case IMREAD_REDUCED_GRAYSCALE_4: // fallthru
+        case IMREAD_REDUCED_COLOR_4: *os << "REDUCED_4"; return;
+        case IMREAD_REDUCED_GRAYSCALE_8: // fallthru
+        case IMREAD_REDUCED_COLOR_8: *os << "REDUCED_8"; return;
+        case IMREAD_IGNORE_ORIENTATION: return;
+    } // don't use "default:" to emit compiler warnings
+    *os << "IMREAD_UNKNOWN(" << (int)v << ")";
+}
+
+} // namespace
+
+#endif

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_read_write.cpp

@@ -0,0 +1,306 @@
+// 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 {
+
+/* < <file_name, image_size>, <imread mode, scale> > */
+typedef tuple< tuple<string, Size>, tuple<ImreadModes, int> > Imgcodecs_Resize_t;
+
+typedef testing::TestWithParam< Imgcodecs_Resize_t > Imgcodecs_Resize;
+
+/* resize_flag_and_dims = <imread_flag, scale>*/
+const tuple <ImreadModes, int> resize_flag_and_dims[] =
+{
+    make_tuple(IMREAD_UNCHANGED, 1),
+    make_tuple(IMREAD_REDUCED_GRAYSCALE_2, 2),
+    make_tuple(IMREAD_REDUCED_GRAYSCALE_4, 4),
+    make_tuple(IMREAD_REDUCED_GRAYSCALE_8, 8),
+    make_tuple(IMREAD_REDUCED_COLOR_2, 2),
+    make_tuple(IMREAD_REDUCED_COLOR_4, 4),
+    make_tuple(IMREAD_REDUCED_COLOR_8, 8)
+};
+
+const tuple<string, Size> images[] =
+{
+#ifdef HAVE_JPEG
+    make_tuple<string, Size>("../cv/imgproc/stuff.jpg", Size(640, 480)),
+#endif
+#ifdef HAVE_PNG
+    make_tuple<string, Size>("../cv/shared/pic1.png", Size(400, 300)),
+#endif
+    make_tuple<string, Size>("../highgui/readwrite/ordinary.bmp", Size(480, 272)),
+};
+
+TEST_P(Imgcodecs_Resize, imread_reduce_flags)
+{
+    const string file_name = findDataFile(get<0>(get<0>(GetParam())));
+    const Size imageSize = get<1>(get<0>(GetParam()));
+
+    const int imread_flag = get<0>(get<1>(GetParam()));
+    const int scale = get<1>(get<1>(GetParam()));
+
+    const int cols = imageSize.width / scale;
+    const int rows = imageSize.height / scale;
+    {
+        Mat img = imread(file_name, imread_flag);
+        ASSERT_FALSE(img.empty());
+        EXPECT_EQ(cols, img.cols);
+        EXPECT_EQ(rows, img.rows);
+    }
+}
+
+//==================================================================================================
+
+TEST_P(Imgcodecs_Resize, imdecode_reduce_flags)
+{
+    const string file_name = findDataFile(get<0>(get<0>(GetParam())));
+    const Size imageSize = get<1>(get<0>(GetParam()));
+
+    const int imread_flag = get<0>(get<1>(GetParam()));
+    const int scale = get<1>(get<1>(GetParam()));
+
+    const int cols = imageSize.width / scale;
+    const int rows = imageSize.height / scale;
+
+    const std::ios::openmode mode = std::ios::in | std::ios::binary;
+    std::ifstream ifs(file_name.c_str(), mode);
+    ASSERT_TRUE(ifs.is_open());
+
+    ifs.seekg(0, std::ios::end);
+    const size_t sz = static_cast<size_t>(ifs.tellg());
+    ifs.seekg(0, std::ios::beg);
+
+    std::vector<char> content(sz);
+    ifs.read((char*)content.data(), sz);
+    ASSERT_FALSE(ifs.fail());
+
+    {
+        Mat img = imdecode(Mat(content), imread_flag);
+        ASSERT_FALSE(img.empty());
+        EXPECT_EQ(cols, img.cols);
+        EXPECT_EQ(rows, img.rows);
+    }
+}
+
+//==================================================================================================
+
+INSTANTIATE_TEST_CASE_P(/*nothing*/, Imgcodecs_Resize,
+        testing::Combine(
+            testing::ValuesIn(images),
+            testing::ValuesIn(resize_flag_and_dims)
+            )
+        );
+
+//==================================================================================================
+
+TEST(Imgcodecs_Image, read_write_bmp)
+{
+    const size_t IMAGE_COUNT = 10;
+    const double thresDbell = 32;
+
+    for (size_t i = 0; i < IMAGE_COUNT; ++i)
+    {
+        stringstream s; s << i;
+        const string digit = s.str();
+        const string src_name = TS::ptr()->get_data_path() + "../python/images/QCIF_0" + digit + ".bmp";
+        const string dst_name = cv::tempfile((digit + ".bmp").c_str());
+        Mat image = imread(src_name);
+        ASSERT_FALSE(image.empty());
+
+        resize(image, image, Size(968, 757), 0.0, 0.0, INTER_CUBIC);
+        imwrite(dst_name, image);
+        Mat loaded = imread(dst_name);
+        ASSERT_FALSE(loaded.empty());
+
+        double psnr = cvtest::PSNR(loaded, image);
+        EXPECT_GT(psnr, thresDbell);
+
+        vector<uchar> from_file;
+
+        FILE *f = fopen(dst_name.c_str(), "rb");
+        fseek(f, 0, SEEK_END);
+        long len = ftell(f);
+        from_file.resize((size_t)len);
+        fseek(f, 0, SEEK_SET);
+        from_file.resize(fread(&from_file[0], 1, from_file.size(), f));
+        fclose(f);
+
+        vector<uchar> buf;
+        imencode(".bmp", image, buf);
+        ASSERT_EQ(buf, from_file);
+
+        Mat buf_loaded = imdecode(Mat(buf), 1);
+        ASSERT_FALSE(buf_loaded.empty());
+
+        psnr = cvtest::PSNR(buf_loaded, image);
+        EXPECT_GT(psnr, thresDbell);
+
+        EXPECT_EQ(0, remove(dst_name.c_str()));
+    }
+}
+
+//==================================================================================================
+
+typedef string Ext;
+typedef testing::TestWithParam<Ext> Imgcodecs_Image;
+
+const string exts[] = {
+#ifdef HAVE_PNG
+    "png",
+#endif
+#ifdef HAVE_TIFF
+    "tiff",
+#endif
+#ifdef HAVE_JPEG
+    "jpg",
+#endif
+#if (defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)) \
+    || defined(HAVE_OPENJPEG)
+    "jp2",
+#endif
+#if 0 /*defined HAVE_OPENEXR && !defined __APPLE__*/
+    "exr",
+#endif
+    "bmp",
+#ifdef HAVE_IMGCODEC_PXM
+    "ppm",
+#endif
+#ifdef HAVE_IMGCODEC_SUNRASTER
+    "ras",
+#endif
+};
+
+static
+void test_image_io(const Mat& image, const std::string& fname, const std::string& ext, int imreadFlag, double psnrThreshold)
+{
+    vector<uchar> buf;
+    ASSERT_NO_THROW(imencode("." + ext, image, buf));
+
+    ASSERT_NO_THROW(imwrite(fname, image));
+
+    FILE *f = fopen(fname.c_str(), "rb");
+    fseek(f, 0, SEEK_END);
+    long len = ftell(f);
+    cout << "File size: " << len << " bytes" << endl;
+    EXPECT_GT(len, 1024) << "File is small. Test or implementation is broken";
+    fseek(f, 0, SEEK_SET);
+    vector<uchar> file_buf((size_t)len);
+    EXPECT_EQ(len, (long)fread(&file_buf[0], 1, (size_t)len, f));
+    fclose(f); f = NULL;
+
+    EXPECT_EQ(buf, file_buf) << "imwrite() / imencode() calls must provide the same output (bit-exact)";
+
+    Mat buf_loaded = imdecode(Mat(buf), imreadFlag);
+    EXPECT_FALSE(buf_loaded.empty());
+
+    Mat loaded = imread(fname, imreadFlag);
+    EXPECT_FALSE(loaded.empty());
+
+    EXPECT_EQ(0, cv::norm(loaded, buf_loaded, NORM_INF)) << "imread() and imdecode() calls must provide the same result (bit-exact)";
+
+    double psnr = cvtest::PSNR(loaded, image);
+    EXPECT_GT(psnr, psnrThreshold);
+
+    // not necessary due bitexact check above
+    //double buf_psnr = cvtest::PSNR(buf_loaded, image);
+    //EXPECT_GT(buf_psnr, psnrThreshold);
+
+#if 0  // debug
+    if (psnr <= psnrThreshold /*|| buf_psnr <= thresDbell*/)
+    {
+        cout << "File: " << fname << endl;
+        imshow("origin", image);
+        imshow("imread", loaded);
+        imshow("imdecode", buf_loaded);
+        waitKey();
+    }
+#endif
+}
+
+TEST_P(Imgcodecs_Image, read_write_BGR)
+{
+    const string ext = this->GetParam();
+    const string fname = cv::tempfile(ext.c_str());
+
+    double psnrThreshold = 100;
+    if (ext == "jpg")
+        psnrThreshold = 32;
+#if defined(HAVE_JASPER)
+    if (ext == "jp2")
+        psnrThreshold = 95;
+#elif defined(HAVE_OPENJPEG)
+    if (ext == "jp2")
+        psnrThreshold = 35;
+#endif
+
+    Mat image = generateTestImageBGR();
+    EXPECT_NO_THROW(test_image_io(image, fname, ext, IMREAD_COLOR, psnrThreshold));
+
+    EXPECT_EQ(0, remove(fname.c_str()));
+}
+
+TEST_P(Imgcodecs_Image, read_write_GRAYSCALE)
+{
+    const string ext = this->GetParam();
+
+    if (false
+        || ext == "ppm"  // grayscale is not implemented
+        || ext == "ras"  // broken (black result)
+    )
+        throw SkipTestException("GRAYSCALE mode is not supported");
+
+    const string fname = cv::tempfile(ext.c_str());
+
+    double psnrThreshold = 100;
+    if (ext == "jpg")
+        psnrThreshold = 40;
+#if defined(HAVE_JASPER)
+    if (ext == "jp2")
+        psnrThreshold = 70;
+#elif defined(HAVE_OPENJPEG)
+    if (ext == "jp2")
+        psnrThreshold = 35;
+#endif
+
+    Mat image = generateTestImageGrayscale();
+    EXPECT_NO_THROW(test_image_io(image, fname, ext, IMREAD_GRAYSCALE, psnrThreshold));
+
+    EXPECT_EQ(0, remove(fname.c_str()));
+}
+
+INSTANTIATE_TEST_CASE_P(imgcodecs, Imgcodecs_Image, testing::ValuesIn(exts));
+
+TEST(Imgcodecs_Image, regression_9376)
+{
+    String path = findDataFile("readwrite/regression_9376.bmp");
+    Mat m = imread(path);
+    ASSERT_FALSE(m.empty());
+    EXPECT_EQ(32, m.cols);
+    EXPECT_EQ(32, m.rows);
+}
+
+//==================================================================================================
+
+TEST(Imgcodecs_Image, write_umat)
+{
+    const string src_name = TS::ptr()->get_data_path() + "../python/images/baboon.bmp";
+    const string dst_name = cv::tempfile(".bmp");
+
+    Mat image1 = imread(src_name);
+    ASSERT_FALSE(image1.empty());
+
+    UMat image1_umat = image1.getUMat(ACCESS_RW);
+
+    imwrite(dst_name, image1_umat);
+
+    Mat image2 = imread(dst_name);
+    ASSERT_FALSE(image2.empty());
+
+    EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), image1, image2);
+    EXPECT_EQ(0, remove(dst_name.c_str()));
+}
+
+}} // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_tiff.cpp

@@ -0,0 +1,451 @@
+// 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"
+
+namespace opencv_test { namespace {
+
+#ifdef HAVE_TIFF
+
+// these defines are used to resolve conflict between tiff.h and opencv2/core/types_c.h
+#define uint64 uint64_hack_
+#define int64 int64_hack_
+#include "tiff.h"
+
+#ifdef __ANDROID__
+// Test disabled as it uses a lot of memory.
+// It is killed with SIGKILL by out of memory killer.
+TEST(Imgcodecs_Tiff, DISABLED_decode_tile16384x16384)
+#else
+TEST(Imgcodecs_Tiff, decode_tile16384x16384)
+#endif
+{
+    // see issue #2161
+    cv::Mat big(16384, 16384, CV_8UC1, cv::Scalar::all(0));
+    string file3 = cv::tempfile(".tiff");
+    string file4 = cv::tempfile(".tiff");
+
+    std::vector<int> params;
+    params.push_back(TIFFTAG_ROWSPERSTRIP);
+    params.push_back(big.rows);
+    EXPECT_NO_THROW(cv::imwrite(file4, big, params));
+    EXPECT_NO_THROW(cv::imwrite(file3, big.colRange(0, big.cols - 1), params));
+    big.release();
+
+    try
+    {
+        cv::imread(file3, IMREAD_UNCHANGED);
+        EXPECT_NO_THROW(cv::imread(file4, IMREAD_UNCHANGED));
+    }
+    catch(const std::bad_alloc&)
+    {
+        // not enough memory
+    }
+
+    EXPECT_EQ(0, remove(file3.c_str()));
+    EXPECT_EQ(0, remove(file4.c_str()));
+}
+
+TEST(Imgcodecs_Tiff, write_read_16bit_big_little_endian)
+{
+    // see issue #2601 "16-bit Grayscale TIFF Load Failures Due to Buffer Underflow and Endianness"
+
+    // Setup data for two minimal 16-bit grayscale TIFF files in both endian formats
+    uchar tiff_sample_data[2][86] = { {
+        // Little endian
+        0x49, 0x49, 0x2a, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xad, 0xde, 0xef, 0xbe, 0x06, 0x00, 0x00, 0x01,
+        0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x00, 0x01, 0x00,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00,
+        0x00, 0x00, 0x06, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x01,
+        0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x17, 0x01, 0x04, 0x00, 0x01, 0x00,
+        0x00, 0x00, 0x04, 0x00, 0x00, 0x00 }, {
+        // Big endian
+        0x4d, 0x4d, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x0c, 0xde, 0xad, 0xbe, 0xef, 0x00, 0x06, 0x01, 0x00,
+        0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x01, 0x01, 0x00, 0x03, 0x00, 0x00,
+        0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10,
+        0x00, 0x00, 0x01, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x11,
+        0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x01, 0x17, 0x00, 0x04, 0x00, 0x00,
+        0x00, 0x01, 0x00, 0x00, 0x00, 0x04 }
+        };
+
+    // Test imread() for both a little endian TIFF and big endian TIFF
+    for (int i = 0; i < 2; i++)
+    {
+        string filename = cv::tempfile(".tiff");
+
+        // Write sample TIFF file
+        FILE* fp = fopen(filename.c_str(), "wb");
+        ASSERT_TRUE(fp != NULL);
+        ASSERT_EQ((size_t)1, fwrite(tiff_sample_data[i], 86, 1, fp));
+        fclose(fp);
+
+        Mat img = imread(filename, IMREAD_UNCHANGED);
+
+        EXPECT_EQ(1, img.rows);
+        EXPECT_EQ(2, img.cols);
+        EXPECT_EQ(CV_16U, img.type());
+        EXPECT_EQ(sizeof(ushort), img.elemSize());
+        EXPECT_EQ(1, img.channels());
+        EXPECT_EQ(0xDEAD, img.at<ushort>(0,0));
+        EXPECT_EQ(0xBEEF, img.at<ushort>(0,1));
+
+        EXPECT_EQ(0, remove(filename.c_str()));
+    }
+}
+
+TEST(Imgcodecs_Tiff, decode_tile_remainder)
+{
+    /* see issue #3472 - dealing with tiled images where the tile size is
+     * not a multiple of image size.
+     * The tiled images were created with 'convert' from ImageMagick,
+     * using the command 'convert <input> -define tiff:tile-geometry=128x128 -depth [8|16] <output>
+     * Note that the conversion to 16 bits expands the range from 0-255 to 0-255*255,
+     * so the test converts back but rounding errors cause small differences.
+     */
+    const string root = cvtest::TS::ptr()->get_data_path();
+    cv::Mat img = imread(root + "readwrite/non_tiled.tif",-1);
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(img.channels() == 3);
+    cv::Mat tiled8 = imread(root + "readwrite/tiled_8.tif", -1);
+    ASSERT_FALSE(tiled8.empty());
+    ASSERT_PRED_FORMAT2(cvtest::MatComparator(0, 0), img, tiled8);
+    cv::Mat tiled16 = imread(root + "readwrite/tiled_16.tif", -1);
+    ASSERT_FALSE(tiled16.empty());
+    ASSERT_TRUE(tiled16.elemSize() == 6);
+    tiled16.convertTo(tiled8, CV_8UC3, 1./256.);
+    ASSERT_PRED_FORMAT2(cvtest::MatComparator(2, 0), img, tiled8);
+    // What about 32, 64 bit?
+}
+
+TEST(Imgcodecs_Tiff, decode_infinite_rowsperstrip)
+{
+    const uchar sample_data[142] = {
+        0x49, 0x49, 0x2a, 0x00, 0x10, 0x00, 0x00, 0x00, 0x56, 0x54,
+        0x56, 0x5a, 0x59, 0x55, 0x5a, 0x00, 0x0a, 0x00, 0x00, 0x01,
+        0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x01, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00,
+        0x00, 0x00, 0x02, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0x08, 0x00, 0x00, 0x00, 0x03, 0x01, 0x03, 0x00, 0x01, 0x00,
+        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x03, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x01,
+        0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+        0x15, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+        0x00, 0x00, 0x16, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00,
+        0xff, 0xff, 0xff, 0xff, 0x17, 0x01, 0x04, 0x00, 0x01, 0x00,
+        0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1c, 0x01, 0x03, 0x00,
+        0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00
+    };
+
+    const string filename = cv::tempfile(".tiff");
+    std::ofstream outfile(filename.c_str(), std::ofstream::binary);
+    outfile.write(reinterpret_cast<const char *>(sample_data), sizeof sample_data);
+    outfile.close();
+
+    EXPECT_NO_THROW(cv::imread(filename, IMREAD_UNCHANGED));
+
+    EXPECT_EQ(0, remove(filename.c_str()));
+}
+
+TEST(Imgcodecs_Tiff, readWrite_32FC1)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC1.tiff";
+    const string filenameOutput = cv::tempfile(".tiff");
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC1,img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_Tiff, readWrite_64FC1)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test64FC1.tiff";
+    const string filenameOutput = cv::tempfile(".tiff");
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_64FC1, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_Tiff, readWrite_32FC3_SGILOG)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC3_sgilog.tiff";
+    const string filenameOutput = cv::tempfile(".tiff");
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 0.01);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+TEST(Imgcodecs_Tiff, readWrite_32FC3_RAW)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filenameInput = root + "readwrite/test32FC3_raw.tiff";
+    const string filenameOutput = cv::tempfile(".tiff");
+    const Mat img = cv::imread(filenameInput, IMREAD_UNCHANGED);
+    ASSERT_FALSE(img.empty());
+    ASSERT_EQ(CV_32FC3, img.type());
+
+    std::vector<int> params;
+    params.push_back(IMWRITE_TIFF_COMPRESSION);
+    params.push_back(1/*COMPRESSION_NONE*/);
+
+    ASSERT_TRUE(cv::imwrite(filenameOutput, img, params));
+    const Mat img2 = cv::imread(filenameOutput, IMREAD_UNCHANGED);
+    ASSERT_EQ(img2.type(), img.type());
+    ASSERT_EQ(img2.size(), img.size());
+    EXPECT_LE(cvtest::norm(img, img2, NORM_INF | NORM_RELATIVE), 1e-3);
+    EXPECT_EQ(0, remove(filenameOutput.c_str()));
+}
+
+
+//==================================================================================================
+
+typedef testing::TestWithParam<int> Imgcodecs_Tiff_Modes;
+
+TEST_P(Imgcodecs_Tiff_Modes, decode_multipage)
+{
+    const int mode = GetParam();
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/multipage.tif";
+    const string page_files[] = {
+        "readwrite/multipage_p1.tif",
+        "readwrite/multipage_p2.tif",
+        "readwrite/multipage_p3.tif",
+        "readwrite/multipage_p4.tif",
+        "readwrite/multipage_p5.tif",
+        "readwrite/multipage_p6.tif"
+    };
+    const size_t page_count = sizeof(page_files)/sizeof(page_files[0]);
+    vector<Mat> pages;
+    bool res = imreadmulti(filename, pages, mode);
+    ASSERT_TRUE(res == true);
+    ASSERT_EQ(page_count, pages.size());
+    for (size_t i = 0; i < page_count; i++)
+    {
+        const Mat page = imread(root + page_files[i], mode);
+        EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), page, pages[i]);
+    }
+}
+
+const int all_modes[] =
+{
+    IMREAD_UNCHANGED,
+    IMREAD_GRAYSCALE,
+    IMREAD_COLOR,
+    IMREAD_ANYDEPTH,
+    IMREAD_ANYCOLOR
+};
+
+INSTANTIATE_TEST_CASE_P(AllModes, Imgcodecs_Tiff_Modes, testing::ValuesIn(all_modes));
+
+//==================================================================================================
+
+TEST(Imgcodecs_Tiff_Modes, write_multipage)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/multipage.tif";
+    const string page_files[] = {
+        "readwrite/multipage_p1.tif",
+        "readwrite/multipage_p2.tif",
+        "readwrite/multipage_p3.tif",
+        "readwrite/multipage_p4.tif",
+        "readwrite/multipage_p5.tif",
+        "readwrite/multipage_p6.tif"
+    };
+    const size_t page_count = sizeof(page_files) / sizeof(page_files[0]);
+    vector<Mat> pages;
+    for (size_t i = 0; i < page_count; i++)
+    {
+        const Mat page = imread(root + page_files[i]);
+        pages.push_back(page);
+    }
+
+    string tmp_filename = cv::tempfile(".tiff");
+    bool res = imwrite(tmp_filename, pages);
+    ASSERT_TRUE(res);
+
+    vector<Mat> read_pages;
+    imreadmulti(tmp_filename, read_pages);
+    for (size_t i = 0; i < page_count; i++)
+    {
+        EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), read_pages[i], pages[i]);
+    }
+}
+
+//==================================================================================================
+
+TEST(Imgcodecs_Tiff, imdecode_no_exception_temporary_file_removed)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(filename);
+    ASSERT_FALSE(img.empty());
+    std::vector<uchar> buf;
+    EXPECT_NO_THROW(cv::imencode(".tiff", img, buf));
+    EXPECT_NO_THROW(cv::imdecode(buf, IMREAD_UNCHANGED));
+}
+
+
+TEST(Imgcodecs_Tiff, decode_black_and_write_image_pr12989_grayscale)
+{
+    const string filename = cvtest::findDataFile("readwrite/bitsperpixel1.tiff");
+    cv::Mat img;
+    ASSERT_NO_THROW(img = cv::imread(filename, IMREAD_GRAYSCALE));
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(64, img.cols);
+    EXPECT_EQ(64, img.rows);
+    EXPECT_EQ(CV_8UC1, img.type()) << cv::typeToString(img.type());
+    // Check for 0/255 values only: 267 + 3829 = 64*64
+    EXPECT_EQ(267, countNonZero(img == 0));
+    EXPECT_EQ(3829, countNonZero(img == 255));
+}
+
+TEST(Imgcodecs_Tiff, decode_black_and_write_image_pr12989_default)
+{
+    const string filename = cvtest::findDataFile("readwrite/bitsperpixel1.tiff");
+    cv::Mat img;
+    ASSERT_NO_THROW(img = cv::imread(filename));  // by default image type is CV_8UC3
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(64, img.cols);
+    EXPECT_EQ(64, img.rows);
+    EXPECT_EQ(CV_8UC3, img.type()) << cv::typeToString(img.type());
+}
+
+TEST(Imgcodecs_Tiff, decode_black_and_write_image_pr17275_grayscale)
+{
+    const string filename = cvtest::findDataFile("readwrite/bitsperpixel1_min.tiff");
+    cv::Mat img;
+    ASSERT_NO_THROW(img = cv::imread(filename, IMREAD_GRAYSCALE));
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(64, img.cols);
+    EXPECT_EQ(64, img.rows);
+    EXPECT_EQ(CV_8UC1, img.type()) << cv::typeToString(img.type());
+    // Check for 0/255 values only: 267 + 3829 = 64*64
+    EXPECT_EQ(267, countNonZero(img == 0));
+    EXPECT_EQ(3829, countNonZero(img == 255));
+}
+
+TEST(Imgcodecs_Tiff, decode_black_and_write_image_pr17275_default)
+{
+    const string filename = cvtest::findDataFile("readwrite/bitsperpixel1_min.tiff");
+    cv::Mat img;
+    ASSERT_NO_THROW(img = cv::imread(filename));  // by default image type is CV_8UC3
+    ASSERT_FALSE(img.empty());
+    EXPECT_EQ(64, img.cols);
+    EXPECT_EQ(64, img.rows);
+    EXPECT_EQ(CV_8UC3, img.type()) << cv::typeToString(img.type());
+}
+
+TEST(Imgcodecs_Tiff, count_multipage)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    {
+        const string filename = root + "readwrite/multipage.tif";
+        ASSERT_EQ((size_t)6, imcount(filename));
+    }
+    {
+        const string filename = root + "readwrite/test32FC3_raw.tiff";
+        ASSERT_EQ((size_t)1, imcount(filename));
+    }
+}
+
+TEST(Imgcodecs_Tiff, read_multipage_indexed)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    const string filename = root + "readwrite/multipage.tif";
+    const string page_files[] = {
+        "readwrite/multipage_p1.tif",
+        "readwrite/multipage_p2.tif",
+        "readwrite/multipage_p3.tif",
+        "readwrite/multipage_p4.tif",
+        "readwrite/multipage_p5.tif",
+        "readwrite/multipage_p6.tif"
+    };
+    const int page_count = sizeof(page_files) / sizeof(page_files[0]);
+    vector<Mat> single_pages;
+    for (int i = 0; i < page_count; i++)
+    {
+        // imread and imreadmulti have different default values for the flag
+        const Mat page = imread(root + page_files[i], IMREAD_ANYCOLOR);
+        single_pages.push_back(page);
+    }
+    ASSERT_EQ((size_t)page_count, single_pages.size());
+
+    {
+        SCOPED_TRACE("Edge Cases");
+        vector<Mat> multi_pages;
+        bool res = imreadmulti(filename, multi_pages, 0, 0);
+        // If we asked for 0 images and we successfully read 0 images should this be false ?
+        ASSERT_TRUE(res == false);
+        ASSERT_EQ((size_t)0, multi_pages.size());
+        res = imreadmulti(filename, multi_pages, 0, 123123);
+        ASSERT_TRUE(res == true);
+        ASSERT_EQ((size_t)6, multi_pages.size());
+    }
+
+    {
+        SCOPED_TRACE("Read all with indices");
+        vector<Mat> multi_pages;
+        bool res = imreadmulti(filename, multi_pages, 0, 6);
+        ASSERT_TRUE(res == true);
+        ASSERT_EQ((size_t)page_count, multi_pages.size());
+        for (int i = 0; i < page_count; i++)
+        {
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), multi_pages[i], single_pages[i]);
+        }
+    }
+
+    {
+        SCOPED_TRACE("Read one by one");
+        vector<Mat> multi_pages;
+        for (int i = 0; i < page_count; i++)
+        {
+            bool res = imreadmulti(filename, multi_pages, i, 1);
+            ASSERT_TRUE(res == true);
+            ASSERT_EQ((size_t)1, multi_pages.size());
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), multi_pages[0], single_pages[i]);
+            multi_pages.clear();
+        }
+    }
+
+    {
+        SCOPED_TRACE("Read multiple at a time");
+        vector<Mat> multi_pages;
+        for (int i = 0; i < page_count/2; i++)
+        {
+            bool res = imreadmulti(filename, multi_pages, i*2, 2);
+            ASSERT_TRUE(res == true);
+            ASSERT_EQ((size_t)2, multi_pages.size());
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), multi_pages[0], single_pages[i * 2]) << i;
+            EXPECT_PRED_FORMAT2(cvtest::MatComparator(0, 0), multi_pages[1], single_pages[i * 2 + 1]);
+            multi_pages.clear();
+        }
+    }
+}
+
+
+#endif
+
+}} // namespace

3rdparty/opencv-4.5.4/modules/imgcodecs/test/test_webp.cpp

@@ -0,0 +1,114 @@
+// 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"
+
+namespace opencv_test { namespace {
+
+#ifdef HAVE_WEBP
+
+TEST(Imgcodecs_WebP, encode_decode_lossless_webp)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    string filename = root + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(filename);
+    ASSERT_FALSE(img.empty());
+
+    string output = cv::tempfile(".webp");
+    EXPECT_NO_THROW(cv::imwrite(output, img)); // lossless
+
+    cv::Mat img_webp = cv::imread(output);
+
+    std::vector<unsigned char> buf;
+
+    FILE * wfile = NULL;
+
+    wfile = fopen(output.c_str(), "rb");
+    if (wfile != NULL)
+    {
+        fseek(wfile, 0, SEEK_END);
+        size_t wfile_size = ftell(wfile);
+        fseek(wfile, 0, SEEK_SET);
+
+        buf.resize(wfile_size);
+
+        size_t data_size = fread(&buf[0], 1, wfile_size, wfile);
+
+        if(wfile)
+        {
+            fclose(wfile);
+        }
+
+        if (data_size != wfile_size)
+        {
+            EXPECT_TRUE(false);
+        }
+    }
+
+    EXPECT_EQ(0, remove(output.c_str()));
+
+    cv::Mat decode = cv::imdecode(buf, IMREAD_COLOR);
+    ASSERT_FALSE(decode.empty());
+    EXPECT_TRUE(cvtest::norm(decode, img_webp, NORM_INF) == 0);
+
+    ASSERT_FALSE(img_webp.empty());
+
+    EXPECT_TRUE(cvtest::norm(img, img_webp, NORM_INF) == 0);
+}
+
+TEST(Imgcodecs_WebP, encode_decode_lossy_webp)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    std::string input = root + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(input);
+    ASSERT_FALSE(img.empty());
+
+    for(int q = 100; q>=0; q-=20)
+    {
+        std::vector<int> params;
+        params.push_back(IMWRITE_WEBP_QUALITY);
+        params.push_back(q);
+        string output = cv::tempfile(".webp");
+
+        EXPECT_NO_THROW(cv::imwrite(output, img, params));
+        cv::Mat img_webp = cv::imread(output);
+        EXPECT_EQ(0, remove(output.c_str()));
+        EXPECT_FALSE(img_webp.empty());
+        EXPECT_EQ(3,   img_webp.channels());
+        EXPECT_EQ(512, img_webp.cols);
+        EXPECT_EQ(512, img_webp.rows);
+    }
+}
+
+TEST(Imgcodecs_WebP, encode_decode_with_alpha_webp)
+{
+    const string root = cvtest::TS::ptr()->get_data_path();
+    std::string input = root + "../cv/shared/lena.png";
+    cv::Mat img = cv::imread(input);
+    ASSERT_FALSE(img.empty());
+
+    std::vector<cv::Mat> imgs;
+    cv::split(img, imgs);
+    imgs.push_back(cv::Mat(imgs[0]));
+    imgs[imgs.size() - 1] = cv::Scalar::all(128);
+    cv::merge(imgs, img);
+
+    string output = cv::tempfile(".webp");
+
+    EXPECT_NO_THROW(cv::imwrite(output, img));
+    cv::Mat img_webp = cv::imread(output, IMREAD_UNCHANGED);
+    cv::Mat img_webp_bgr = cv::imread(output); // IMREAD_COLOR by default
+    EXPECT_EQ(0, remove(output.c_str()));
+    EXPECT_FALSE(img_webp.empty());
+    EXPECT_EQ(4,   img_webp.channels());
+    EXPECT_EQ(512, img_webp.cols);
+    EXPECT_EQ(512, img_webp.rows);
+    EXPECT_FALSE(img_webp_bgr.empty());
+    EXPECT_EQ(3,   img_webp_bgr.channels());
+    EXPECT_EQ(512, img_webp_bgr.cols);
+    EXPECT_EQ(512, img_webp_bgr.rows);
+}
+
+#endif // HAVE_WEBP
+
+}} // namespace