Files
opencv-MIRROR/modules/core/perf/perf_mat.cpp

225 lines
6.2 KiB
C++

#include "perf_precomp.hpp"
namespace opencv_test
{
using namespace perf;
PERF_TEST_P(Size_MatType, Mat_Eye,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES))
)
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
Mat diagonalMatrix(size.height, size.width, type);
declare.out(diagonalMatrix);
int runs = (size.width <= 640) ? 15 : 5;
TEST_CYCLE_MULTIRUN(runs)
{
diagonalMatrix = Mat::eye(size, type);
}
SANITY_CHECK(diagonalMatrix, 1);
}
PERF_TEST_P(Size_MatType, Mat_Zeros,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES, CV_32FC3))
)
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
Mat zeroMatrix(size.height, size.width, type);
declare.out(zeroMatrix);
int runs = (size.width <= 640) ? 15 : 5;
TEST_CYCLE_MULTIRUN(runs)
{
zeroMatrix = Mat::zeros(size, type);
}
SANITY_CHECK(zeroMatrix, 1);
}
PERF_TEST_P(Size_MatType, Mat_Clone,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES))
)
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
Mat source(size.height, size.width, type);
Mat destination(size.height, size.width, type);
declare.in(source, WARMUP_RNG).out(destination);
TEST_CYCLE()
{
Mat tmp = source.clone();
CV_UNUSED(tmp);
}
destination = source.clone();
SANITY_CHECK(destination, 1);
}
PERF_TEST_P(Size_MatType, Mat_Clone_Roi,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(TYPICAL_MAT_TYPES))
)
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
unsigned int width = size.width;
unsigned int height = size.height;
Mat source(height, width, type);
Mat destination(size.height/2, size.width/2, type);
declare.in(source, WARMUP_RNG).out(destination);
Mat roi(source, Rect(width/4, height/4, 3*width/4, 3*height/4));
TEST_CYCLE()
{
Mat tmp = roi.clone();
CV_UNUSED(tmp);
}
destination = roi.clone();
SANITY_CHECK(destination, 1);
}
PERF_TEST_P(Size_MatType, Mat_CopyToWithMask,
testing::Combine(testing::Values(::perf::sz1080p, ::perf::szODD),
testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_16UC1, CV_16UC3, CV_32SC1, CV_32SC2, CV_32FC3, CV_32FC4))
)
{
const Size_MatType_t params = GetParam();
const Size size = get<0>(params);
const int type = get<1>(params);
Mat src(size, type), dst(size, type), mask(size, CV_8UC1);
declare.in(src, mask, WARMUP_RNG).out(dst);
TEST_CYCLE()
{
src.copyTo(dst, mask);
}
SANITY_CHECK(dst);
}
PERF_TEST_P(Size_MatType, Mat_SetToWithMask,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4, CV_16UC3, CV_16UC4, CV_32FC3, CV_32FC4))
)
{
const Size_MatType_t params = GetParam();
const Size size = get<0>(params);
const int type = get<1>(params);
const Scalar sc = Scalar::all(27);
Mat src(size, type), mask(size, CV_8UC1);
declare.in(src, mask, WARMUP_RNG).out(src);
TEST_CYCLE()
{
src.setTo(sc, mask);
}
SANITY_CHECK(src);
}
enum { MASK_RANDOM, MASK_BLOCKS, MASK_ZERO };
CV_ENUM(MaskPattern, MASK_RANDOM, MASK_BLOCKS, MASK_ZERO)
typedef tuple<MatType, MaskPattern> MatType_MaskPattern_t;
typedef TestBaseWithParam<MatType_MaskPattern_t> MatType_MaskPattern;
static Mat makeMaskPattern(Size size, int pattern)
{
Mat mask(size, CV_8UC1, Scalar(0));
RNG& rng = theRNG();
if (pattern == MASK_RANDOM)
rng.fill(mask, RNG::UNIFORM, 0, 2);
else if (pattern == MASK_BLOCKS)
for (int y = 0; y < size.height; y += 64)
for (int x = 0; x < size.width; x += 64)
if (rng.uniform(0, 2))
mask(Rect(x, y, std::min(64, size.width - x), std::min(64, size.height - y))).setTo(255);
return mask;
}
PERF_TEST_P(MatType_MaskPattern, Mat_CopyToWithMaskPattern,
testing::Combine(testing::Values(CV_64FC1, CV_32FC2, CV_16UC4),
MaskPattern::all()))
{
const int type = get<0>(GetParam());
const int pattern = get<1>(GetParam());
const Size size = sz1080p;
Mat src(size, type), dst(size, type, Scalar::all(0));
randu(src, 0, 100);
Mat mask = makeMaskPattern(size, pattern);
declare.in(src, mask).out(dst);
TEST_CYCLE() src.copyTo(dst, mask);
SANITY_CHECK_NOTHING();
}
PERF_TEST_P(MatType_MaskPattern, Mat_SetToWithMaskPattern,
testing::Combine(testing::Values(CV_64FC1, CV_32FC2, CV_16UC4),
MaskPattern::all()))
{
const int type = get<0>(GetParam());
const int pattern = get<1>(GetParam());
const Size size = sz1080p;
Mat dst(size, type, Scalar::all(0));
Mat mask = makeMaskPattern(size, pattern);
declare.in(mask).out(dst);
TEST_CYCLE() dst.setTo(Scalar::all(27), mask);
SANITY_CHECK_NOTHING();
}
///////////// Transform ////////////////////////
PERF_TEST_P(Size_MatType, Mat_Transform,
testing::Combine(testing::Values(TYPICAL_MAT_SIZES),
testing::Values(CV_8UC3, CV_8SC3, CV_16UC3, CV_16SC3, CV_32SC3, CV_32FC3, CV_64FC3))
)
{
const Size_MatType_t params = GetParam();
const Size srcSize0 = get<0>(params);
const Size srcSize = Size(1, srcSize0.width*srcSize0.height);
const int type = get<1>(params);
const float transform[] = { 0.5f, 0.f, 0.86602540378f, 128,
0.f, 1.f, 0.f, -64,
0.86602540378f, 0.f, 0.5f, 32,};
Mat mtx(Size(4, 3), CV_32FC1, (void*)transform);
Mat src(srcSize, type), dst(srcSize, type);
randu(src, 0, 30);
declare.in(src).out(dst);
TEST_CYCLE()
{
cv::transform(src, dst, mtx);
}
SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
}
} // namespace