mirror of
https://github.com/opencv/opencv.git
synced 2024-12-13 16:09:23 +08:00
314 lines
10 KiB
C++
314 lines
10 KiB
C++
// 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()));
|
|
}
|
|
|
|
// See https://github.com/opencv/opencv/issues/25274
|
|
typedef testing::TestWithParam<int> Imgcodecs_Jpeg_decode_cmyk;
|
|
TEST_P(Imgcodecs_Jpeg_decode_cmyk, regression25274)
|
|
{
|
|
const int imread_flag = GetParam();
|
|
|
|
/*
|
|
* "test_1_c4.jpg" is CMYK-JPEG.
|
|
* $ convert test_1_c3.jpg -colorspace CMYK test_1_c4.jpg
|
|
* $ identify test_1_c4.jpg
|
|
* test_1_c4.jpg JPEG 480x640 480x640+0+0 8-bit CMYK 11240B 0.000u 0:00.000
|
|
*/
|
|
|
|
cvtest::TS& ts = *cvtest::TS::ptr();
|
|
|
|
string rgb_filename = string(ts.get_data_path()) + "readwrite/test_1_c3.jpg";
|
|
cv::Mat rgb_img = cv::imread(rgb_filename, imread_flag);
|
|
ASSERT_FALSE(rgb_img.empty());
|
|
|
|
string cmyk_filename = string(ts.get_data_path()) + "readwrite/test_1_c4.jpg";
|
|
cv::Mat cmyk_img = cv::imread(cmyk_filename, imread_flag);
|
|
ASSERT_FALSE(cmyk_img.empty());
|
|
|
|
EXPECT_EQ(rgb_img.size(), cmyk_img.size());
|
|
EXPECT_EQ(rgb_img.type(), cmyk_img.type());
|
|
|
|
// Jpeg is lossy compression.
|
|
// There may be small differences in decoding results by environments.
|
|
// -> 255 * 1% = 2.55 .
|
|
EXPECT_LE(cvtest::norm(rgb_img, cmyk_img, NORM_INF), 3); // norm() <= 3
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P( /* nothing */,
|
|
Imgcodecs_Jpeg_decode_cmyk,
|
|
testing::Values(cv::IMREAD_COLOR,
|
|
cv::IMREAD_GRAYSCALE,
|
|
cv::IMREAD_ANYCOLOR));
|
|
|
|
//==================================================================================================
|
|
|
|
static const uint32_t default_sampling_factor = static_cast<uint32_t>(0x221111);
|
|
|
|
static uint32_t test_jpeg_subsampling( const Mat src, const vector<int> param )
|
|
{
|
|
vector<uint8_t> jpeg;
|
|
|
|
if ( cv::imencode(".jpg", src, jpeg, param ) == false )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ( src.channels() != 3 )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Find SOF Marker(FFC0)
|
|
int sof_offset = 0; // not found.
|
|
int jpeg_size = static_cast<int>( jpeg.size() );
|
|
for ( int i = 0 ; i < jpeg_size - 1; i++ )
|
|
{
|
|
if ( (jpeg[i] == 0xff ) && ( jpeg[i+1] == 0xC0 ) )
|
|
{
|
|
sof_offset = i;
|
|
break;
|
|
}
|
|
}
|
|
if ( sof_offset == 0 )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// Extract Subsampling Factor from SOF.
|
|
return ( jpeg[sof_offset + 0x0A + 3 * 0 + 1] << 16 ) +
|
|
( jpeg[sof_offset + 0x0A + 3 * 1 + 1] << 8 ) +
|
|
( jpeg[sof_offset + 0x0A + 3 * 2 + 1] ) ;
|
|
}
|
|
|
|
TEST(Imgcodecs_Jpeg, encode_subsamplingfactor_default)
|
|
{
|
|
vector<int> param;
|
|
Mat src( 48, 64, CV_8UC3, cv::Scalar::all(0) );
|
|
EXPECT_EQ( default_sampling_factor, test_jpeg_subsampling(src, param) );
|
|
}
|
|
|
|
TEST(Imgcodecs_Jpeg, encode_subsamplingfactor_usersetting_valid)
|
|
{
|
|
Mat src( 48, 64, CV_8UC3, cv::Scalar::all(0) );
|
|
const uint32_t sampling_factor_list[] = {
|
|
IMWRITE_JPEG_SAMPLING_FACTOR_411,
|
|
IMWRITE_JPEG_SAMPLING_FACTOR_420,
|
|
IMWRITE_JPEG_SAMPLING_FACTOR_422,
|
|
IMWRITE_JPEG_SAMPLING_FACTOR_440,
|
|
IMWRITE_JPEG_SAMPLING_FACTOR_444,
|
|
};
|
|
const int sampling_factor_list_num = 5;
|
|
|
|
for ( int i = 0 ; i < sampling_factor_list_num; i ++ )
|
|
{
|
|
vector<int> param;
|
|
param.push_back( IMWRITE_JPEG_SAMPLING_FACTOR );
|
|
param.push_back( sampling_factor_list[i] );
|
|
EXPECT_EQ( sampling_factor_list[i], test_jpeg_subsampling(src, param) );
|
|
}
|
|
}
|
|
|
|
TEST(Imgcodecs_Jpeg, encode_subsamplingfactor_usersetting_invalid)
|
|
{
|
|
Mat src( 48, 64, CV_8UC3, cv::Scalar::all(0) );
|
|
const uint32_t sampling_factor_list[] = { // Invalid list
|
|
0x111112,
|
|
0x000000,
|
|
0x001111,
|
|
0xFF1111,
|
|
0x141111, // 1x4,1x1,1x1 - unknown
|
|
0x241111, // 2x4,1x1,1x1 - unknown
|
|
0x421111, // 4x2,1x1,1x1 - unknown
|
|
0x441111, // 4x4,1x1,1x1 - 410(libjpeg cannot handle it)
|
|
};
|
|
const int sampling_factor_list_num = 8;
|
|
|
|
for ( int i = 0 ; i < sampling_factor_list_num; i ++ )
|
|
{
|
|
vector<int> param;
|
|
param.push_back( IMWRITE_JPEG_SAMPLING_FACTOR );
|
|
param.push_back( sampling_factor_list[i] );
|
|
EXPECT_EQ( default_sampling_factor, test_jpeg_subsampling(src, param) );
|
|
}
|
|
}
|
|
|
|
#endif // HAVE_JPEG
|
|
|
|
}} // namespace
|