add part of opencv

Lib/opencv/sources/modules/imgcodecs/test/test_exr.impl.hpp

@@ -0,0 +1,117 @@
+// 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 {
+
+TEST(Imgcodecs_EXR, readWrite_32FC1)
+{
+    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));
+    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)
+{
+    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()));
+}
+
+
+}} // namespace

Lib/opencv/sources/modules/imgcodecs/test/test_grfmt.cpp

@@ -0,0 +1,394 @@
+/*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)
+    "readwrite/Rome.jp2",
+    "readwrite/Bretagne2.jp2",
+    "readwrite/Bretagne2.jp2",
+    "readwrite/Grey.jp2",
+    "readwrite/Grey.jp2",
+#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 have problems with "jp2"
+struct notForGDAL {
+    bool operator()(const string &name) const {
+        const string &ext = name.substr(name.size() - 3, 3);
+        return ext == "hdr" || ext == "dcm" || ext == "jp2" ||
+                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

Lib/opencv/sources/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

Lib/opencv/sources/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")

Lib/opencv/sources/modules/imgcodecs/test/test_png.cpp

@@ -0,0 +1,98 @@
+// 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));
+}
+
+#endif // HAVE_PNG
+
+}} // namespace

Lib/opencv/sources/modules/imgcodecs/test/test_precomp.hpp

@@ -0,0 +1,11 @@
+// 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"
+
+#endif

Lib/opencv/sources/modules/imgcodecs/test/test_read_write.cpp

@@ -0,0 +1,155 @@
+// 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 {
+
+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;
+
+TEST_P(Imgcodecs_Image, read_write)
+{
+    const string ext = this->GetParam();
+    const string full_name = cv::tempfile(ext.c_str());
+    const string _name = TS::ptr()->get_data_path() + "../cv/shared/baboon.png";
+    const double thresDbell = 32;
+
+    Mat image = imread(_name);
+    image.convertTo(image, CV_8UC3);
+    ASSERT_FALSE(image.empty());
+
+    imwrite(full_name, image);
+    Mat loaded = imread(full_name);
+    ASSERT_FALSE(loaded.empty());
+
+    double psnr = cvtest::PSNR(loaded, image);
+    EXPECT_GT(psnr, thresDbell);
+
+    vector<uchar> from_file;
+    FILE *f = fopen(full_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("." + ext, 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(full_name.c_str()));
+}
+
+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)
+    "jp2",
+#endif
+#if 0 /*defined HAVE_OPENEXR && !defined __APPLE__*/
+    "exr",
+#endif
+    "bmp",
+#ifdef HAVE_IMGCODEC_PXM
+    "ppm",
+#endif
+#ifdef HAVE_IMGCODEC_SUNRASTER
+    "ras",
+#endif
+};
+
+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

Lib/opencv/sources/modules/imgcodecs/test/test_tiff.cpp

@@ -0,0 +1,338 @@
+// 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)
+{
+    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());
+}
+
+#endif
+
+}} // namespace

Lib/opencv/sources/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