Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Open Source Computer Vision Library https://opencv.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
25241 Commits
6 Branches
126 Tags
3.0 GiB
 
 
 
 
 
 
Tag: Branch: Tree: 853f5111c2
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '853f5111c2'
${ noResults }
opencv/modules/gapi/test/common/gapi_imgproc_tests_inl.hpp

751 lines
27 KiB
Raw Blame History

// 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.
//
// Copyright (C) 2018 Intel Corporation
#ifndef OPENCV_GAPI_IMGPROC_TESTS_INL_HPP
#define OPENCV_GAPI_IMGPROC_TESTS_INL_HPP
#include "opencv2/gapi/imgproc.hpp"
#include "gapi_imgproc_tests.hpp"
namespace opencv_test
{
TEST_P(Filter2DTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0, borderType = 0, dtype = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, borderType, dtype, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, dtype, initOut);
cv::Point anchor = {-1, -1};
double delta = 0;
cv::Mat kernel = cv::Mat(kernSize, kernSize, CV_32FC1 );
cv::Scalar kernMean = cv::Scalar(1.0);
cv::Scalar kernStddev = cv::Scalar(2.0/3);
randn(kernel, kernMean, kernStddev);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::filter2D(in, dtype, kernel, anchor, delta, borderType);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::filter2D(in_mat1, out_mat_ocv, dtype, kernel, anchor, delta, borderType);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: Control this choice with test's especial parameter
#if 1
// Allow some rounding error
if (CV_MAT_DEPTH(out_mat_gapi.type()) == CV_32F)
{
// 6 decimal digits is nearly best accuracy we can expect of FP32 arithmetic here
EXPECT_EQ(0, cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) > 1e-6*cv::abs(out_mat_ocv)));
}
else
{
// allow wrong rounding if result fractional part is nearly 0.5,
// assume there would be not more than 0.01% of such cases
EXPECT_LE(cv::countNonZero(out_mat_gapi != out_mat_ocv), 1e-4*out_mat_ocv.total());
}
#else
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(BoxFilterTest, AccuracyTest)
{
MatType type = 0;
int filterSize = 0, borderType = 0, dtype = 0;
cv::Size sz;
double tolerance = 0.0;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, filterSize, sz, borderType, dtype, tolerance, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, dtype, initOut);
cv::Point anchor = {-1, -1};
bool normalize = true;
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::boxFilter(in, dtype, cv::Size(filterSize, filterSize), anchor, normalize, borderType);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::boxFilter(in_mat1, out_mat_ocv, dtype, cv::Size(filterSize, filterSize), anchor, normalize, borderType);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: Control this choice with test's especial parameter
#if 1
// Allow some rounding error
if (CV_MAT_DEPTH(out_mat_gapi.type()) == CV_32F)
{
// 6 decimal digits is nearly best accuracy we can expect of FP32 arithmetic here
EXPECT_EQ(0, cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) > 1e-6*cv::abs(out_mat_ocv)));
}
else
{
// allow wrong rounding if result fractional part is nearly 0.5,
// assume there would be not more than 0.01% of such cases
EXPECT_LE(cv::countNonZero(out_mat_gapi != out_mat_ocv), 1e-4*out_mat_ocv.total());
}
#else
cv::Mat absDiff;
cv::absdiff(out_mat_gapi, out_mat_ocv, absDiff);
EXPECT_EQ(0, cv::countNonZero(absDiff > tolerance));
#endif
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(SepFilterTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0, dtype = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, dtype, initOut, compile_args) = GetParam();
cv::Mat kernelX(kernSize, 1, CV_32F);
cv::Mat kernelY(kernSize, 1, CV_32F);
randu(kernelX, -1, 1);
randu(kernelY, -1, 1);
initMatsRandN(type, sz, dtype, initOut);
cv::Point anchor = cv::Point(-1, -1);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::sepFilter(in, dtype, kernelX, kernelY, anchor, cv::Scalar() );
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::sepFilter2D(in_mat1, out_mat_ocv, dtype, kernelX, kernelY );
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: Control this choice with test's especial parameter
#if 1
// Expect some rounding error
EXPECT_LE(cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) > 1e-5 * cv::abs(out_mat_ocv)),
0.01 * out_mat_ocv.total());
#else
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(BlurTest, AccuracyTest)
{
MatType type = 0;
int filterSize = 0, borderType = 0;
cv::Size sz;
double tolerance = 0.0;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, filterSize, sz, borderType, tolerance, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Point anchor = {-1, -1};
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::blur(in, cv::Size(filterSize, filterSize), anchor, borderType);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::blur(in_mat1, out_mat_ocv, cv::Size(filterSize, filterSize), anchor, borderType);
}
// Comparison //////////////////////////////////////////////////////////////
{
cv::Mat absDiff;
cv::absdiff(out_mat_gapi, out_mat_ocv, absDiff);
EXPECT_EQ(0, cv::countNonZero(absDiff > tolerance));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(GaussianBlurTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Size kSize = cv::Size(kernSize, kernSize);
double sigmaX = rand();
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::gaussianBlur(in, kSize, sigmaX);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::GaussianBlur(in_mat1, out_mat_ocv, kSize, sigmaX);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: Control this choice with test's especial parameter
#if 1
// Expect some rounding error
if (CV_MAT_DEPTH(out_mat_gapi.type()) == CV_32F ||
CV_MAT_DEPTH(out_mat_gapi.type()) == CV_64F)
{
// Note that 1e-6 is nearly best accuracy we can expect of FP32 arithetic
EXPECT_EQ(0, cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) >
1e-6*cv::abs(out_mat_ocv)));
}
else if (CV_MAT_DEPTH(out_mat_gapi.type()) == CV_8U)
{
// OpenCV uses 16-bits fixed-point for 8U data, so may produce wrong results
EXPECT_LE(cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) > 1),
0.05*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(cv::abs(out_mat_gapi - out_mat_ocv) > 2), 0);
}
else
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
}
#else
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(MedianBlurTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::medianBlur(in, kernSize);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::medianBlur(in_mat1, out_mat_ocv, kernSize);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(ErodeTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0, kernType = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, kernType, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::erode(in, kernel);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::erode(in_mat1, out_mat_ocv, kernel);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(Erode3x3Test, AccuracyTest)
{
MatType type = 0;
int numIters = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, sz, initOut, numIters, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3,3));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::erode3x3(in, numIters);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::erode(in_mat1, out_mat_ocv, kernel, cv::Point(-1, -1), numIters);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(DilateTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0, kernType = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, kernType, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Mat kernel = cv::getStructuringElement(kernType, cv::Size(kernSize, kernSize));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::dilate(in, kernel);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::dilate(in_mat1, out_mat_ocv, kernel);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(Dilate3x3Test, AccuracyTest)
{
MatType type = 0;
int numIters = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, sz, initOut, numIters, compile_args) = GetParam();
initMatsRandN(type, sz, type, initOut);
cv::Mat kernel = cv::getStructuringElement(cv::MorphShapes::MORPH_RECT, cv::Size(3,3));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::dilate3x3(in, numIters);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::dilate(in_mat1, out_mat_ocv, kernel, cv::Point(-1,-1), numIters);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(SobelTest, AccuracyTest)
{
MatType type = 0;
int kernSize = 0, dtype = 0, dx = 0, dy = 0;
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, kernSize, sz, dtype, dx, dy, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, dtype, initOut);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::Sobel(in, dtype, dx, dy, kernSize );
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::Sobel(in_mat1, out_mat_ocv, dtype, dx, dy, kernSize);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(EqHistTest, AccuracyTest)
{
cv::Size sz;
bool initOut = false;
cv::GCompileArgs compile_args;
std::tie(sz, initOut, compile_args) = GetParam();
initMatsRandN(CV_8UC1, sz, CV_8UC1, initOut);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::equalizeHist(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::equalizeHist(in_mat1, out_mat_ocv);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(GetParam()));
}
}
TEST_P(CannyTest, AccuracyTest)
{
MatType type;
int apSize = 0;
double thrLow = 0.0, thrUp = 0.0;
cv::Size sz;
bool l2gr = false, initOut = false;
cv::GCompileArgs compile_args;
std::tie(type, sz, thrLow, thrUp, apSize, l2gr, initOut, compile_args) = GetParam();
initMatsRandN(type, sz, CV_8UC1, initOut);
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::Canny(in, thrLow, thrUp, apSize, l2gr);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::Canny(in_mat1, out_mat_ocv, thrLow, thrUp, apSize, l2gr);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
}
}
TEST_P(RGB2GrayTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC1, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::RGB2Gray(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_RGB2GRAY);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding if result's fractional part is nearly 0.5
// - assume not more than 0.1% of pixels may deviate this way
// - deviation must not exceed 1 unit anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.001*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0);
#else
// insist of bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(BGR2GrayTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC1, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::BGR2Gray(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_BGR2GRAY);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding if result's fractional part is nearly 0.5
// - assume not more than 0.1% of pixels may deviate this way
// - deviation must not exceed 1 unit anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.001*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0);
#else
// insist of bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(RGB2YUVTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::RGB2YUV(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_RGB2YUV);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding if result's fractional part is nearly 0.5
// - assume not more than 15% of pixels may deviate this way
// - deviation must not exceed 1 unit anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.15*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0);
#else
// insist of bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(YUV2RGBTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::YUV2RGB(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_YUV2RGB);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding if result's fractional part is nearly 0.5
// - assume not more than 1% of pixels may deviate this way
// - deviation must not exceed 1 unit anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.01*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0);
#else
// insist of bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(RGB2LabTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::RGB2Lab(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_RGB2Lab);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding, if result's fractional part is nearly 0.5
// - assume not more than 25% of pixels may deviate this way
// - not more than 1% of pixels may deviate by 1 unit
// - deviation must not exceed 2 units anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.25*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0.01*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 2), 1e-5*3*out_mat_ocv.total());
#else
// insist on bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(BGR2LUVTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::BGR2LUV(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_BGR2Luv);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding, if result's fractional part is nearly 0.5
// - assume not more than 25% of pixels may deviate this way
// - not more than 1% of pixels may deviate by 2+ units
// - not more than 0.01% pixels may deviate by 5+ units
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.25 * 3 * out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0.01 * 3 * out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 5), 0.0001 * 3 * out_mat_ocv.total());
#else
// insist on bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(LUV2BGRTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::LUV2BGR(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_Luv2BGR);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(BGR2YUVTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::BGR2YUV(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_BGR2YUV);
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
TEST_P(YUV2BGRTest, AccuracyTest)
{
auto param = GetParam();
auto compile_args = std::get<2>(param);
initMatsRandN(CV_8UC3, std::get<0>(param), CV_8UC3, std::get<1>(param));
// G-API code //////////////////////////////////////////////////////////////
cv::GMat in;
auto out = cv::gapi::YUV2BGR(in);
cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args));
// OpenCV code /////////////////////////////////////////////////////////////
{
cv::cvtColor(in_mat1, out_mat_ocv, cv::COLOR_YUV2BGR);
}
// Comparison //////////////////////////////////////////////////////////////
{
// TODO: control this choice with especial parameter of this test
#if 1
// allow faithful rounding, if result's fractional part is nearly 0.5
// - assume not more than 25% of pixels may deviate this way
// - not more than 1% of pixels may deviate by 1 unit
// - deviation must not exceed 2 units anyway
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 0), 0.25*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 1), 0.01*3*out_mat_ocv.total());
EXPECT_LE(cv::countNonZero(out_mat_gapi - out_mat_ocv > 2), 1e-5*3*out_mat_ocv.total());
#else
// insist on bit-exact results
EXPECT_EQ(0, cv::countNonZero(out_mat_gapi != out_mat_ocv));
#endif
EXPECT_EQ(out_mat_gapi.size(), std::get<0>(param));
}
}
} // opencv_test
#endif //OPENCV_GAPI_IMGPROC_TESTS_INL_HPP