chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,510 @@
|
||||
// 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-2021 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_core_tests.hpp"
|
||||
#include <opencv2/gapi/cpu/core.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
#define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
|
||||
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
// FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
|
||||
INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU),
|
||||
Values(ADD, MUL),
|
||||
testing::Bool(),
|
||||
Values(1.0),
|
||||
Values(false)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU),
|
||||
Values(MUL),
|
||||
testing::Bool(),
|
||||
Values(1.0, 0.5, 2.0),
|
||||
Values(false)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU),
|
||||
Values(SUB),
|
||||
testing::Bool(),
|
||||
Values (1.0),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU),
|
||||
Values(DIV),
|
||||
testing::Bool(),
|
||||
Values (1.0, 0.5, 2.0),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_32FC1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_32FC1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
|
||||
Combine(Values(CV_32F, CV_32FC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
/* angle_in_degrees */ testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
|
||||
Combine(Values(CV_32F, CV_32FC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U),
|
||||
Values(CORE_CPU),
|
||||
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
|
||||
testing::Bool(),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AND, OR, XOR),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
//Values(1e-5),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CountNonZeroTestCPU, CountNonZeroTest,
|
||||
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values( -1, CV_8U, CV_16U, CV_32F ),
|
||||
Values(CORE_CPU),
|
||||
Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsToleranceScalar(1e-5).to_compare_obj()),
|
||||
Values(NORM_INF, NORM_L1, NORM_L2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
|
||||
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
|
||||
cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
|
||||
Values(cv::Scalar(0, 0, 0, 0),
|
||||
cv::Scalar(100, 100, 100, 100),
|
||||
cv::Scalar(255, 255, 255, 255))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
|
||||
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
|
||||
Combine(Values(CV_8UC4),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC3),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC4),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(0,1,-1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CopyTestCPU, CopyTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC3),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U, CV_16U, CV_16S, CV_32F),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(2.5, 1.0, -1.0),
|
||||
Values(250.0, 0.0, -128.0)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
|
||||
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(-50.0, 90.0),
|
||||
Values(0.6),
|
||||
Values(cv::INTER_LINEAR),
|
||||
Values(cv::BORDER_CONSTANT),
|
||||
Values(cv::Scalar())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(-50.0, 90.0),
|
||||
Values(0.6),
|
||||
Values(cv::INTER_LINEAR),
|
||||
Values(cv::BORDER_CONSTANT),
|
||||
Values(cv::Scalar())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(0.0, 15.0),
|
||||
Values(1.0, 120.0, 255.0),
|
||||
Values(NORM_MINMAX, NORM_INF, NORM_L1, NORM_L2),
|
||||
Values(-1, CV_8U, CV_16U, CV_16S, CV_32F)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeansNDNoInitTestCPU, KMeansNDTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(2, 20)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsTolerance(0.01).to_compare_obj()),
|
||||
Values(5),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS, cv::KMEANS_PP_CENTERS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeansNDInitTestCPU, KMeansNDTest,
|
||||
Combine(Values(CV_32FC1, CV_32FC3),
|
||||
Values(cv::Size(1, 20),
|
||||
cv::Size(2, 20),
|
||||
cv::Size(5, 720)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsTolerance(0.01).to_compare_obj()),
|
||||
Values(5, 15),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS | cv::KMEANS_USE_INITIAL_LABELS,
|
||||
cv::KMEANS_PP_CENTERS | cv::KMEANS_USE_INITIAL_LABELS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeansNDInitReverseTestCPU, KMeansNDTest,
|
||||
Combine(Values(CV_32FC3),
|
||||
Values(cv::Size(20, 1)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsTolerance(0.01).to_compare_obj()),
|
||||
Values(5, 15),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS | cv::KMEANS_USE_INITIAL_LABELS,
|
||||
cv::KMEANS_PP_CENTERS | cv::KMEANS_USE_INITIAL_LABELS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeans2DNoInitTestCPU, KMeans2DTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(-1, 20)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(5),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS, cv::KMEANS_PP_CENTERS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeans2DInitTestCPU, KMeans2DTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(-1, 720),
|
||||
cv::Size(-1, 20)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(5, 15),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS | cv::KMEANS_USE_INITIAL_LABELS,
|
||||
cv::KMEANS_PP_CENTERS | cv::KMEANS_USE_INITIAL_LABELS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeans3DNoInitTestCPU, KMeans3DTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(-1, 20)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(5),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS, cv::KMEANS_PP_CENTERS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(KMeans3DInitTestCPU, KMeans3DTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(-1, 720),
|
||||
cv::Size(-1, 20)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(5, 15),
|
||||
Values(cv::KMEANS_RANDOM_CENTERS | cv::KMEANS_USE_INITIAL_LABELS,
|
||||
cv::KMEANS_PP_CENTERS | cv::KMEANS_USE_INITIAL_LABELS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(TransposeTestCPU, TransposeTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1,
|
||||
CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
|
||||
CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
// PLEASE DO NOT PUT NEW ACCURACY TESTS BELOW THIS POINT! //////////////////////
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BackendOutputAllocationTestCPU, BackendOutputAllocationTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
|
||||
Values(cv::Size(50, 50)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BackendOutputAllocationLargeSizeWithCorrectSubmatrixTestCPU,
|
||||
BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
|
||||
Values(cv::Size(50, 50)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ReInitOutTestCPU, ReInitOutTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC4, CV_32FC1),
|
||||
Values(cv::Size(640, 480)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(cv::Size(640, 400),
|
||||
cv::Size(10, 480))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseSSDBLTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(1920, 1080)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(0.3f, 0.5f, 0.7f),
|
||||
Values(-1, 0, 1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseSSDTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(1920, 1080)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(0.3f, 0.5f, 0.7f),
|
||||
testing::Bool(),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ParseTestCPU, ParseYoloTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(1920, 1080)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(0.3f, 0.5f, 0.7f),
|
||||
Values(0.5f, 1.0f),
|
||||
Values(80, 7),
|
||||
Values(std::make_pair(false, 3),
|
||||
std::make_pair(false, 4),
|
||||
std::make_pair(true, 2),
|
||||
std::make_pair(true, 3),
|
||||
std::make_pair(true, 4))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SizeTestCPU, SizeTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(32, 32),
|
||||
cv::Size(640, 320)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SizeRTestCPU, SizeRTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(32, 32),
|
||||
cv::Size(640, 320)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SizeMFTestCPU, SizeMFTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_32FC1),
|
||||
Values(cv::Size(32, 32),
|
||||
cv::Size(640, 320)),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
}
|
||||
@@ -0,0 +1,319 @@
|
||||
// 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-2019 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_core_tests.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
|
||||
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
// FIXME: Windows accuracy problems after recent update!
|
||||
INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1, CV_8U, CV_32F),
|
||||
Values(CORE_FLUID),
|
||||
Values(DIV, MUL),
|
||||
testing::Bool(),
|
||||
Values(1.0),
|
||||
testing::Bool()));
|
||||
|
||||
// FIXME: Accuracy test for SUB math operation fails on FullHD and HD CV_16SC1 input cv::Mat,
|
||||
// double-presicion input cv::Scalar and CV_32FC1 output cv::Mat on Mac.
|
||||
// Accuracy test for ADD math operation fails on HD CV_16SC1 input cv::Mat,
|
||||
// double-presicion input cv::Scalar and CV_32FC1 output cv::Mat on Mac.
|
||||
// As failures are sporadic, disabling all instantiation cases for SUB and ADD.
|
||||
// Github ticket: https://github.com/opencv/opencv/issues/18373.
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_MathOpTestFluid, MathOpTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1, CV_8U, CV_32F),
|
||||
Values(CORE_FLUID),
|
||||
Values(ADD, SUB),
|
||||
testing::Bool(),
|
||||
Values(1.0),
|
||||
testing::Bool()));
|
||||
|
||||
// FIXME: Accuracy test for SUB math operation fails on CV_16SC1 input cv::Mat, double-presicion
|
||||
// input cv::Scalar and CV_32FC1 output cv::Mat on Mac.
|
||||
// As failures are sporadic, disabling all instantiation cases for SUB operation.
|
||||
// Github ticket: https://github.com/opencv/opencv/issues/18373.
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_SubTestFluid, MathOpTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1 , CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1, CV_8U, CV_32F),
|
||||
Values(CORE_FLUID),
|
||||
Values(SUB),
|
||||
testing::Bool(),
|
||||
Values (1.0),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1), // FIXME: extend with more types
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U, CV_32F),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_MeanTestFluid, MeanTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MaskTestFluid, MaskTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_8UC2,
|
||||
CV_16UC2, CV_16SC2, CV_8UC3, CV_16UC3,
|
||||
CV_16SC3, CV_8UC4, CV_16UC4, CV_16SC4),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AND, OR, XOR),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_SumTestFluid, SumTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U),
|
||||
Values(CORE_FLUID),
|
||||
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
|
||||
Values(false),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
// FIXME: solve comparison error to unite with the test above
|
||||
INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U),
|
||||
Values(CORE_FLUID),
|
||||
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
|
||||
Values(true),
|
||||
Values(AbsSimilarPoints(1, 0.01).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1, CV_8U, CV_32F),
|
||||
Values(CORE_FLUID),
|
||||
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_NormTestFluid, NormTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsToleranceScalar(1e-5).to_compare_obj()),
|
||||
Values(NORM_INF, NORM_L1, NORM_L2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_IntegralTestFluid, IntegralTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8U, CV_16U, CV_16S, CV_32F),
|
||||
Values(CORE_FLUID),
|
||||
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
|
||||
Values(2.5, 1.0, -1.0),
|
||||
Values(250.0, 0.0, -128.0)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatHorTestFluid, ConcatHorTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatVertTestFluid, ConcatVertTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test,
|
||||
Combine(Values(CV_8UC4),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC3),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_8UC4),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_RemapTestFluid, RemapTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_FlipTestFluid, FlipTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(0,1,-1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_CropTestFluid, CropTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4,
|
||||
CV_16UC1, CV_16UC3, CV_16SC1, CV_16SC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_32FC1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(CV_32FC1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest,
|
||||
Combine(Values(CV_32F, CV_32FC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
/* angle_in_degrees */ testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SqrtFluid, SqrtTest,
|
||||
Combine(Values(CV_32F, CV_32FC3),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV,
|
||||
cv::THRESH_TRUNC,
|
||||
cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV),
|
||||
Values(cv::Scalar(0, 0, 0, 0),
|
||||
cv::Scalar(100, 100, 100, 100),
|
||||
cv::Scalar(255, 255, 255, 255))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DISABLED_ThresholdTestFluid, ThresholdOTTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
|
||||
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BackendOutputAllocationTestFluid, BackendOutputAllocationTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
|
||||
Values(cv::Size(50, 50)),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BackendOutputAllocationLargeSizeWithCorrectSubmatrixTestFluid,
|
||||
BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC2, CV_32FC1),
|
||||
Values(cv::Size(50, 50)),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ReInitOutTestFluid, ReInitOutTest,
|
||||
Combine(Values(CV_8UC3, CV_16SC4, CV_32FC1),
|
||||
Values(cv::Size(640, 480)),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(cv::Size(640, 400),
|
||||
cv::Size(10, 480))));
|
||||
}
|
||||
@@ -0,0 +1,563 @@
|
||||
// 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-2020 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
|
||||
#include "../common/gapi_imgproc_tests.hpp"
|
||||
#include <opencv2/gapi/cpu/imgproc.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
#define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::cpu::kernels()}); }
|
||||
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
|
||||
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
|
||||
Values(cv::Size(64,64),
|
||||
cv::Size(30,30))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
|
||||
Values(cv::INTER_LINEAR),
|
||||
Values(cv::Size(64,64),
|
||||
cv::Size(30,30))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
|
||||
Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA),
|
||||
Values(0.5, 0.1),
|
||||
Values(0.5, 0.1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(cv::Size(3, 3),
|
||||
cv::Size(4, 4),
|
||||
cv::Size(5, 5),
|
||||
cv::Size(7, 7)),
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsTolerance(0).to_compare_obj()),
|
||||
Values(3,5),
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_16S, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
|
||||
Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsTolerance(0.0).to_compare_obj()),
|
||||
Values(3,5),
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(cv::MorphShapes::MORPH_RECT,
|
||||
cv::MorphShapes::MORPH_CROSS,
|
||||
cv::MorphShapes::MORPH_ELLIPSE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(1,2,4)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(cv::MorphShapes::MORPH_RECT,
|
||||
cv::MorphShapes::MORPH_CROSS,
|
||||
cv::MorphShapes::MORPH_ELLIPSE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(1,2,4)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MorphologyExTestCPU, MorphologyExTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(cv::MorphTypes::MORPH_ERODE,
|
||||
cv::MorphTypes::MORPH_DILATE,
|
||||
cv::MorphTypes::MORPH_OPEN,
|
||||
cv::MorphTypes::MORPH_CLOSE,
|
||||
cv::MorphTypes::MORPH_GRADIENT,
|
||||
cv::MorphTypes::MORPH_TOPHAT,
|
||||
cv::MorphTypes::MORPH_BLACKHAT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MorphologyExHitMissTestCPU, MorphologyExTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(cv::MorphTypes::MORPH_HITMISS)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_16S, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(0, 1),
|
||||
Values(1, 2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(0, 1),
|
||||
Values(1, 2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_16S, CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(1, 2),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
|
||||
Values(0, 1, 255)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32F),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(1, 2),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT),
|
||||
Values(0, 1, 255)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(LaplacianTestCPU, LaplacianTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(1, 3),
|
||||
Values(0.2, 1.0),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BilateralFilterTestCPU, BilateralFilterTest,
|
||||
Combine(Values(CV_32FC1, CV_32FC3, CV_8UC1, CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3, 5),
|
||||
Values(20),
|
||||
Values(10),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
|
||||
Values(3.0, 120.0),
|
||||
Values(125.0, 240.0),
|
||||
Values(3, 5),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GoodFeaturesTestCPU, GoodFeaturesTest,
|
||||
Combine(Values(IMGPROC_CPU),
|
||||
Values(AbsExactVector<cv::Point2f>().to_compare_obj()),
|
||||
Values("cv/shared/fruits.png"),
|
||||
Values(CV_32FC1, CV_8UC1),
|
||||
Values(50, 100),
|
||||
Values(0.01),
|
||||
Values(10.0),
|
||||
Values(3),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GoodFeaturesInternalTestCPU, GoodFeaturesTest,
|
||||
Combine(Values(IMGPROC_CPU),
|
||||
Values(AbsExactVector<cv::Point2f>().to_compare_obj()),
|
||||
Values("cv/cascadeandhog/images/audrybt1.png"),
|
||||
Values(CV_32FC1, CV_8UC1),
|
||||
Values(100),
|
||||
Values(0.0000001),
|
||||
Values(5.0),
|
||||
Values(3),
|
||||
Values(true)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FindContoursNoOffsetTestCPU, FindContoursNoOffsetTest,
|
||||
Combine(Values(IMGPROC_CPU),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(RETR_EXTERNAL),
|
||||
Values(CHAIN_APPROX_NONE),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FindContoursOffsetTestCPU, FindContoursOffsetTest,
|
||||
Values(IMGPROC_CPU));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
|
||||
Combine(Values(IMGPROC_CPU),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
|
||||
Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
|
||||
CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FindContoursHNoOffset32STestCPU, FindContoursHNoOffsetTest,
|
||||
Combine(Values(IMGPROC_CPU),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32SC1),
|
||||
Values(RETR_CCOMP, RETR_FLOODFILL),
|
||||
Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
|
||||
CHAIN_APPROX_TC89_L1, CHAIN_APPROX_TC89_KCOS),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FindContoursHOffsetTestCPU, FindContoursHOffsetTest,
|
||||
Values(IMGPROC_CPU));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoundingRectMatTestCPU, BoundingRectMatTest,
|
||||
Combine(Values( CV_8UC1 ),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(IoUToleranceRect(0).to_compare_obj()),
|
||||
Values(false)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoundingRectMatVectorTestCPU, BoundingRectMatTest,
|
||||
Combine(Values(CV_32S, CV_32F),
|
||||
Values(cv::Size(1280, 1),
|
||||
cv::Size(128, 1)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(IoUToleranceRect(1e-5).to_compare_obj()),
|
||||
Values(true)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoundingRectVector32STestCPU, BoundingRectVector32STest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(1280, 1),
|
||||
cv::Size(128, 1)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(IoUToleranceRect(0).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BoundingRectVector32FTestCPU, BoundingRectVector32FTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(1280, 1),
|
||||
cv::Size(128, 1)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(IoUToleranceRect(1e-5).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine2DMatVectorTestCPU, FitLine2DMatVectorTest,
|
||||
Combine(Values(CV_8U, CV_8S, CV_16U, CV_16S,
|
||||
CV_32S, CV_32F, CV_64F),
|
||||
Values(cv::Size(8, 0), cv::Size(1024, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
|
||||
DIST_WELSCH, DIST_HUBER)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine2DVector32STestCPU, FitLine2DVector32STest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine2DVector32FTestCPU, FitLine2DVector32FTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine2DVector64FTestCPU, FitLine2DVector64FTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 4>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine3DMatVectorTestCPU, FitLine3DMatVectorTest,
|
||||
Combine(Values(CV_8UC1, CV_8SC1, CV_16UC1, CV_16SC1,
|
||||
CV_32SC1, CV_32FC1, CV_64FC1),
|
||||
Values(cv::Size(8, 0), cv::Size(1024, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1, DIST_L2, DIST_L12, DIST_FAIR,
|
||||
DIST_WELSCH, DIST_HUBER)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine3DVector32STestCPU, FitLine3DVector32STest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine3DVector32FTestCPU, FitLine3DVector32FTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(FitLine3DVector64FTestCPU, FitLine3DVector64FTest,
|
||||
Combine(Values(-1),
|
||||
Values(cv::Size(8, 0)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(RelDiffToleranceVec<float, 6>(0.01).to_compare_obj()),
|
||||
Values(DIST_L1)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2RGBTestCPU, BGR2RGBTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2I420TestCPU, BGR2I420Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2I420TestCPU, RGB2I420Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(I4202BGRTestCPU, I4202BGRTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(I4202RGBTestCPU, I4202RGBTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NV12toRGBTestCPU, NV12toRGBTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NV12toBGRTestCPU, NV12toBGRTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NV12toGrayTestCPU, NV12toGrayTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NV12toRGBpTestCPU, NV12toRGBpTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(NV12toBGRpTestCPU, NV12toBGRpTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2HSVTestCPU, RGB2HSVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestCPU, BayerGR2RGBTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2YUV422TestCPU, RGB2YUV422Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC2),
|
||||
Values(IMGPROC_CPU),
|
||||
Values(AbsTolerance(1).to_compare_obj())));
|
||||
} // opencv_test
|
||||
@@ -0,0 +1,221 @@
|
||||
// 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-2019 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_imgproc_tests.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
#define IMGPROC_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::fluid::kernels()}); }
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest,
|
||||
Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
|
||||
Values(cv::Size(1280, 720),
|
||||
cv::Size(30, 30)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_obj()),
|
||||
Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
|
||||
Values(cv::Size(1280, 720),
|
||||
cv::Size(30, 30))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
|
||||
Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
|
||||
Values(cv::Size(1280, 720),
|
||||
cv::Size(30, 30)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_obj()),
|
||||
Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
|
||||
Values(0.5, 1, 2),
|
||||
Values(0.5, 1, 2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
|
||||
|
||||
// FIXME: Not supported by Fluid yet (no kernel implemented)
|
||||
INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(5e-3, 6).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2HSVTestFluid, RGB2HSVTest,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestFluid, BayerGR2RGBTest,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC3),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceColor(1e-3).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(RGB2YUV422TestFluid, RGB2YUV422Test,
|
||||
Combine(Values(CV_8UC3),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_8UC2),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsTolerance(1).to_compare_obj())));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()),
|
||||
Values(3, 5)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3))); // add kernel size=5 when implementation is ready
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(cv::MorphShapes::MORPH_RECT,
|
||||
cv::MorphShapes::MORPH_CROSS,
|
||||
cv::MorphShapes::MORPH_ELLIPSE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(cv::MorphShapes::MORPH_RECT,
|
||||
cv::MorphShapes::MORPH_CROSS,
|
||||
cv::MorphShapes::MORPH_ELLIPSE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_16S, CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(0, 1),
|
||||
Values(1, 2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(0, 1),
|
||||
Values(1, 2)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
|
||||
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_16S, CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values(3),
|
||||
Values(1, 2),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101),
|
||||
Values(0, 1, 255)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(3),
|
||||
Values(1, 2),
|
||||
Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101),
|
||||
Values(0, 1, 255)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(3), // add kernel size=5 when implementation is ready
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
|
||||
Combine(Values(CV_32FC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(3))); // add kernel size=5 when implementation is ready
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
Values(cv::Size(1280, 720),
|
||||
cv::Size(128, 128)),
|
||||
Values(-1, CV_32F),
|
||||
Values(IMGPROC_FLUID),
|
||||
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
|
||||
Values(cv::Size(3, 3)), // add kernel size=4x4,5x5,7x7 when implementation ready
|
||||
Values(cv::BORDER_DEFAULT)));
|
||||
|
||||
} // opencv_test
|
||||
@@ -0,0 +1,50 @@
|
||||
// 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) 2020 Intel Corporation
|
||||
|
||||
#ifndef OPENCV_GAPI_OCV_STATEFUL_KERNEL_TESTS_UTILS_HPP
|
||||
#define OPENCV_GAPI_OCV_STATEFUL_KERNEL_TESTS_UTILS_HPP
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
|
||||
// TODO: Reuse Anatoliy's logic for support of types with commas in macro.
|
||||
// Retrieve the common part from Anatoliy's logic to the separate place.
|
||||
#define DEFINE_INITIALIZER(Name, StateType, ...) \
|
||||
struct Name \
|
||||
{ \
|
||||
static StateType value() \
|
||||
{ \
|
||||
return __VA_ARGS__; \
|
||||
} \
|
||||
} \
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
// types from anonymous namespace doesn't work well with templates
|
||||
inline namespace gapi_ocv_stateful_kernel_test_utils {
|
||||
|
||||
struct UserStruct
|
||||
{
|
||||
UserStruct() = default;
|
||||
UserStruct(short myShortVal, float myFloatVal):
|
||||
_myShortVal(myShortVal),
|
||||
_myFloatVal(myFloatVal) { }
|
||||
|
||||
bool operator==(const UserStruct& rhs) const
|
||||
{
|
||||
return ((_myShortVal == rhs._myShortVal) &&
|
||||
(_myFloatVal == rhs._myFloatVal));
|
||||
}
|
||||
|
||||
private:
|
||||
short _myShortVal;
|
||||
float _myFloatVal;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
} // opencv_test
|
||||
|
||||
#endif // OPENCV_GAPI_OCV_STATEFUL_KERNEL_TESTS_UTILS_HPP
|
||||
@@ -0,0 +1,689 @@
|
||||
// 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) 2020-2022 Intel Corporation
|
||||
|
||||
#include "gapi_ocv_stateful_kernel_test_utils.hpp"
|
||||
#include <opencv2/gapi/cpu/core.hpp>
|
||||
#include <opencv2/gapi/streaming/cap.hpp>
|
||||
|
||||
#include <opencv2/core.hpp>
|
||||
#include <opencv2/core/cvstd.hpp>
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
#include <opencv2/video.hpp>
|
||||
#endif
|
||||
|
||||
#include <memory> // required by std::shared_ptr
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
struct BackSubStateParams
|
||||
{
|
||||
std::string method;
|
||||
};
|
||||
|
||||
struct CountStateSetupsParams
|
||||
{
|
||||
std::shared_ptr<int> pSetupsCount;
|
||||
};
|
||||
} // namespace opencv_test
|
||||
|
||||
namespace cv
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<> struct CompileArgTag<opencv_test::BackSubStateParams>
|
||||
{
|
||||
static const char* tag()
|
||||
{
|
||||
return "org.opencv.test.background_subtractor_state_params";
|
||||
}
|
||||
};
|
||||
|
||||
template<> struct CompileArgTag<opencv_test::CountStateSetupsParams>
|
||||
{
|
||||
static const char* tag()
|
||||
{
|
||||
return "org.opencv.test.count_state_setups_params";
|
||||
}
|
||||
};
|
||||
} // namespace detail
|
||||
} // namespace cv
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
//TODO: test OT, Background Subtractor, Kalman with 3rd version of API
|
||||
//----------------------------------------------- Simple tests ------------------------------------------------
|
||||
namespace
|
||||
{
|
||||
G_TYPED_KERNEL(GCountCalls, <cv::GOpaque<int>(GMat)>, "org.opencv.test.count_calls")
|
||||
{
|
||||
static GOpaqueDesc outMeta(GMatDesc /* in */) { return empty_gopaque_desc(); }
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(GOCVCountCalls, GCountCalls, int)
|
||||
{
|
||||
static void setup(const cv::GMatDesc &/* in */, std::shared_ptr<int> &state)
|
||||
{
|
||||
state.reset(new int{ });
|
||||
}
|
||||
|
||||
static void run(const cv::Mat &/* in */, int &out, int& state)
|
||||
{
|
||||
out = ++state;
|
||||
}
|
||||
};
|
||||
|
||||
G_TYPED_KERNEL(GIsStateUpToDate, <cv::GOpaque<bool>(GMat)>,
|
||||
"org.opencv.test.is_state_up-to-date")
|
||||
{
|
||||
static GOpaqueDesc outMeta(GMatDesc /* in */) { return empty_gopaque_desc(); }
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(GOCVIsStateUpToDate, GIsStateUpToDate, cv::Size)
|
||||
{
|
||||
static void setup(const cv::GMatDesc &in, std::shared_ptr<cv::Size> &state)
|
||||
{
|
||||
state.reset(new cv::Size(in.size));
|
||||
}
|
||||
|
||||
static void run(const cv::Mat &in , bool &out, cv::Size& state)
|
||||
{
|
||||
out = in.size() == state;
|
||||
}
|
||||
};
|
||||
|
||||
G_TYPED_KERNEL(GStInvalidResize, <GMat(GMat,Size,double,double,int)>,
|
||||
"org.opencv.test.st_invalid_resize")
|
||||
{
|
||||
static GMatDesc outMeta(GMatDesc in, Size, double, double, int) { return in; }
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(GOCVStInvalidResize, GStInvalidResize, int)
|
||||
{
|
||||
static void setup(const cv::GMatDesc, cv::Size, double, double, int,
|
||||
std::shared_ptr<int> &state)
|
||||
{
|
||||
state = std::make_shared<int>();
|
||||
}
|
||||
|
||||
static void run(const cv::Mat& in, cv::Size sz, double fx, double fy, int interp,
|
||||
cv::Mat &out, int& /* state */)
|
||||
{
|
||||
cv::resize(in, out, sz, fx, fy, interp);
|
||||
}
|
||||
};
|
||||
|
||||
G_TYPED_KERNEL(GBackSub, <GMat(GMat)>, "org.opencv.test.background_subtractor")
|
||||
{
|
||||
static GMatDesc outMeta(GMatDesc in) { return in.withType(CV_8U, 1); }
|
||||
};
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
GAPI_OCV_KERNEL_ST(GOCVBackSub, GBackSub, cv::BackgroundSubtractor)
|
||||
{
|
||||
static void setup(const cv::GMatDesc &/* desc */,
|
||||
std::shared_ptr<BackgroundSubtractor> &state,
|
||||
const cv::GCompileArgs &compileArgs)
|
||||
{
|
||||
auto sbParams = cv::gapi::getCompileArg<BackSubStateParams>(compileArgs)
|
||||
.value_or(BackSubStateParams { });
|
||||
|
||||
if (sbParams.method == "knn")
|
||||
state = createBackgroundSubtractorKNN();
|
||||
else if (sbParams.method == "mog2")
|
||||
state = createBackgroundSubtractorMOG2();
|
||||
|
||||
GAPI_Assert(state);
|
||||
}
|
||||
|
||||
static void run(const cv::Mat& in, cv::Mat &out, BackgroundSubtractor& state)
|
||||
{
|
||||
state.apply(in, out, -1);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
G_TYPED_KERNEL(GCountStateSetups, <cv::GOpaque<bool>(GMat)>,
|
||||
"org.opencv.test.count_state_setups")
|
||||
{
|
||||
static GOpaqueDesc outMeta(GMatDesc /* in */) { return empty_gopaque_desc(); }
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(GOCVCountStateSetups, GCountStateSetups, int)
|
||||
{
|
||||
static void setup(const cv::GMatDesc &, std::shared_ptr<int> &state,
|
||||
const cv::GCompileArgs &compileArgs)
|
||||
{
|
||||
state = std::make_shared<int>();
|
||||
auto params = cv::gapi::getCompileArg<CountStateSetupsParams>(compileArgs)
|
||||
.value_or(CountStateSetupsParams { });
|
||||
if (params.pSetupsCount != nullptr) {
|
||||
(*params.pSetupsCount)++;
|
||||
}
|
||||
}
|
||||
|
||||
static void run(const cv::Mat & , bool &out, int &)
|
||||
{
|
||||
out = true;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
TEST(StatefulKernel, StateInitOnceInRegularMode)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> out = GCountStateSetups::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
// Input mat:
|
||||
cv::Mat inputData(1080, 1920, CV_8UC1);
|
||||
cv::randu(inputData, cv::Scalar::all(1), cv::Scalar::all(128));
|
||||
|
||||
// variable to update when state is initialized in the kernel
|
||||
CountStateSetupsParams params;
|
||||
params.pSetupsCount.reset(new int(0));
|
||||
|
||||
// Testing for 100 frames
|
||||
bool result { };
|
||||
for (int i = 0; i < 100; ++i) {
|
||||
c.apply(cv::gin(inputData), cv::gout(result),
|
||||
cv::compile_args(cv::gapi::kernels<GOCVCountStateSetups>(), params));
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(1, *params.pSetupsCount);
|
||||
}
|
||||
}
|
||||
|
||||
struct StateInitOnce : public ::testing::TestWithParam<bool>{};
|
||||
TEST_P(StateInitOnce, StreamingCompiledWithMeta)
|
||||
{
|
||||
bool compileWithMeta = GetParam();
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> out = GCountStateSetups::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
// Input mat:
|
||||
cv::Mat inputData(1080, 1920, CV_8UC1);
|
||||
cv::randu(inputData, cv::Scalar::all(1), cv::Scalar::all(128));
|
||||
|
||||
// variable to update when state is initialized in the kernel
|
||||
CountStateSetupsParams params;
|
||||
params.pSetupsCount.reset(new int(0));
|
||||
|
||||
// Compilation & testing
|
||||
auto ccomp = (compileWithMeta)
|
||||
? c.compileStreaming(cv::descr_of(inputData),
|
||||
cv::compile_args(cv::gapi::kernels<GOCVCountStateSetups>(),
|
||||
params))
|
||||
: c.compileStreaming(
|
||||
cv::compile_args(cv::gapi::kernels<GOCVCountStateSetups>(),
|
||||
params));
|
||||
|
||||
ccomp.setSource(cv::gin(inputData));
|
||||
|
||||
ccomp.start();
|
||||
EXPECT_TRUE(ccomp.running());
|
||||
|
||||
int counter { };
|
||||
bool result;
|
||||
// Process mat 100 times
|
||||
while (ccomp.pull(cv::gout(result)) && (counter++ < 100)) {
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(1, *params.pSetupsCount);
|
||||
}
|
||||
|
||||
ccomp.stop();
|
||||
EXPECT_FALSE(ccomp.running());
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(StatefulKernel, StateInitOnce, ::testing::Bool());
|
||||
|
||||
TEST(StatefulKernel, StateIsMutableInRuntime)
|
||||
{
|
||||
constexpr int expectedCallsCount = 10;
|
||||
|
||||
cv::Mat dummyIn { 1, 1, CV_8UC1 };
|
||||
int actualCallsCount = 0;
|
||||
|
||||
// Declaration of G-API expression
|
||||
GMat in;
|
||||
GOpaque<int> out = GCountCalls::on(in);
|
||||
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
const auto pkg = cv::gapi::kernels<GOCVCountCalls>();
|
||||
|
||||
// Compilation of G-API expression
|
||||
auto callsCounter = comp.compile(cv::descr_of(dummyIn), cv::compile_args(pkg));
|
||||
|
||||
// Simulating video stream: call GCompiled multiple times
|
||||
for (int i = 0; i < expectedCallsCount; i++)
|
||||
{
|
||||
callsCounter(cv::gin(dummyIn), cv::gout(actualCallsCount));
|
||||
EXPECT_EQ(i + 1, actualCallsCount);
|
||||
}
|
||||
|
||||
// End of "video stream"
|
||||
EXPECT_EQ(expectedCallsCount, actualCallsCount);
|
||||
|
||||
// User asks G-API to prepare for a new stream
|
||||
callsCounter.prepareForNewStream();
|
||||
callsCounter(cv::gin(dummyIn), cv::gout(actualCallsCount));
|
||||
EXPECT_EQ(1, actualCallsCount);
|
||||
|
||||
}
|
||||
|
||||
TEST(StateIsResetOnNewStream, RegularMode)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> out = GCountStateSetups::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
// Input mat:
|
||||
cv::Mat inputData(1080, 1920, CV_8UC1);
|
||||
cv::randu(inputData, cv::Scalar::all(1), cv::Scalar::all(128));
|
||||
|
||||
// variable to update when state is initialized in the kernel
|
||||
CountStateSetupsParams params;
|
||||
params.pSetupsCount.reset(new int(0));
|
||||
|
||||
auto setupsCounter = c.compile(cv::descr_of(inputData),
|
||||
cv::compile_args(cv::gapi::kernels<GOCVCountStateSetups>(),
|
||||
params));
|
||||
|
||||
bool result { };
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
setupsCounter(cv::gin(inputData), cv::gout(result));
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(1, *params.pSetupsCount);
|
||||
}
|
||||
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(1, *params.pSetupsCount);
|
||||
setupsCounter.prepareForNewStream();
|
||||
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
setupsCounter(cv::gin(inputData), cv::gout(result));
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(2, *params.pSetupsCount);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(StateIsResetOnNewStream, StreamingMode)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> out = GIsStateUpToDate::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
const auto pkg = cv::gapi::kernels<GOCVIsStateUpToDate>();
|
||||
|
||||
// Compilation & testing
|
||||
auto ccomp = c.compileStreaming(cv::compile_args(pkg));
|
||||
|
||||
auto path = findDataFile("cv/video/768x576.avi");
|
||||
try {
|
||||
ccomp.setSource(gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(path));
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
ccomp.start();
|
||||
EXPECT_TRUE(ccomp.running());
|
||||
|
||||
// Process the full video
|
||||
bool isStateUpToDate = false;
|
||||
while (ccomp.pull(cv::gout(isStateUpToDate))) {
|
||||
EXPECT_TRUE(isStateUpToDate);
|
||||
}
|
||||
EXPECT_FALSE(ccomp.running());
|
||||
|
||||
path = findDataFile("cv/video/1920x1080.avi");
|
||||
try {
|
||||
ccomp.setSource(gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(path));
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
ccomp.start();
|
||||
EXPECT_TRUE(ccomp.running());
|
||||
|
||||
while (ccomp.pull(cv::gout(isStateUpToDate))) {
|
||||
EXPECT_TRUE(isStateUpToDate);
|
||||
}
|
||||
EXPECT_FALSE(ccomp.running());
|
||||
}
|
||||
|
||||
TEST(StatefulKernel, InvalidReallocatingKernel)
|
||||
{
|
||||
cv::GMat in, out;
|
||||
cv::Mat in_mat(500, 500, CV_8UC1), out_mat;
|
||||
out = GStInvalidResize::on(in, cv::Size(300, 300), 0.0, 0.0, cv::INTER_LINEAR);
|
||||
|
||||
const auto pkg = cv::gapi::kernels<GOCVStInvalidResize>();
|
||||
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
EXPECT_THROW(comp.apply(in_mat, out_mat, cv::compile_args(pkg)), std::logic_error);
|
||||
}
|
||||
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
namespace
|
||||
{
|
||||
void compareBackSubResults(const cv::Mat &actual, const cv::Mat &expected,
|
||||
const int diffPercent)
|
||||
{
|
||||
GAPI_Assert(actual.size() == expected.size());
|
||||
int allowedNumDiffPixels = actual.size().area() * diffPercent / 100;
|
||||
|
||||
cv::Mat diff;
|
||||
cv::absdiff(actual, expected, diff);
|
||||
|
||||
cv::Mat hist(256, 1, CV_32FC1, cv::Scalar(0));
|
||||
const float range[] { 0, 256 };
|
||||
const float *histRange { range };
|
||||
calcHist(&diff, 1, 0, Mat(), hist, 1, &hist.rows, &histRange, true, false);
|
||||
for (int i = 2; i < hist.rows; ++i)
|
||||
{
|
||||
hist.at<float>(i) += hist.at<float>(i - 1);
|
||||
}
|
||||
|
||||
int numDiffPixels = static_cast<int>(hist.at<float>(255));
|
||||
|
||||
EXPECT_GT(allowedNumDiffPixels, numDiffPixels);
|
||||
}
|
||||
} // anonymous namespace
|
||||
|
||||
TEST(StatefulKernel, StateIsInitViaCompArgs)
|
||||
{
|
||||
cv::Mat frame(1080, 1920, CV_8UC3),
|
||||
gapiForeground,
|
||||
ocvForeground;
|
||||
|
||||
cv::randu(frame, cv::Scalar(0, 0, 0), cv::Scalar(255, 255, 255));
|
||||
|
||||
// G-API code
|
||||
cv::GMat in;
|
||||
cv::GMat out = GBackSub::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
const auto pkg = cv::gapi::kernels<GOCVBackSub>();
|
||||
|
||||
auto gapiBackSub = c.compile(cv::descr_of(frame),
|
||||
cv::compile_args(pkg, BackSubStateParams { "knn" }));
|
||||
|
||||
gapiBackSub(cv::gin(frame), cv::gout(gapiForeground));
|
||||
|
||||
// OpenCV code
|
||||
auto pOcvBackSub = createBackgroundSubtractorKNN();
|
||||
pOcvBackSub->apply(frame, ocvForeground);
|
||||
|
||||
// Comparison
|
||||
// Allowing 1% difference of all pixels between G-API and OpenCV results
|
||||
compareBackSubResults(gapiForeground, ocvForeground, 1);
|
||||
|
||||
// Additionally, test the case where state is reset
|
||||
gapiBackSub.prepareForNewStream();
|
||||
gapiBackSub(cv::gin(frame), cv::gout(gapiForeground));
|
||||
pOcvBackSub->apply(frame, ocvForeground);
|
||||
compareBackSubResults(gapiForeground, ocvForeground, 1);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
namespace
|
||||
{
|
||||
void testBackSubInStreaming(cv::GStreamingCompiled gapiBackSub, const int diffPercent)
|
||||
{
|
||||
cv::Mat frame,
|
||||
gapiForeground,
|
||||
ocvForeground;
|
||||
|
||||
gapiBackSub.start();
|
||||
EXPECT_TRUE(gapiBackSub.running());
|
||||
|
||||
// OpenCV reference subtractor
|
||||
auto pOCVBackSub = createBackgroundSubtractorKNN();
|
||||
|
||||
// Comparison of G-API and OpenCV subtractors
|
||||
std::size_t frames = 0u;
|
||||
while (gapiBackSub.pull(cv::gout(frame, gapiForeground))) {
|
||||
pOCVBackSub->apply(frame, ocvForeground, -1);
|
||||
|
||||
compareBackSubResults(gapiForeground, ocvForeground, diffPercent);
|
||||
|
||||
frames++;
|
||||
}
|
||||
EXPECT_LT(0u, frames);
|
||||
EXPECT_FALSE(gapiBackSub.running());
|
||||
}
|
||||
} // anonymous namespace
|
||||
|
||||
TEST(StatefulKernel, StateIsInitViaCompArgsInStreaming)
|
||||
{
|
||||
// This test is long as it runs BG subtractor (a) twice
|
||||
// (in G-API + for reference) over (b) two files. In fact
|
||||
// it is one more BG Subtractor accuracy test, but not
|
||||
// a stateful initialization test -- the latter must be
|
||||
// done through a light-weight mock object. So for now:
|
||||
applyTestTag(CV_TEST_TAG_VERYLONG);
|
||||
|
||||
// G-API graph declaration
|
||||
cv::GMat in;
|
||||
cv::GMat out = GBackSub::on(in);
|
||||
// Preserving 'in' in output to have possibility to compare with OpenCV reference
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(cv::gapi::copy(in), out));
|
||||
|
||||
// G-API compilation of graph for streaming mode
|
||||
const auto pkg = cv::gapi::kernels<GOCVBackSub>();
|
||||
auto gapiBackSub = c.compileStreaming(
|
||||
cv::compile_args(pkg, BackSubStateParams { "knn" }));
|
||||
|
||||
// Testing G-API Background Substractor in streaming mode
|
||||
auto path = findDataFile("cv/video/768x576.avi");
|
||||
try {
|
||||
gapiBackSub.setSource(gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(path));
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
// Allowing 1% difference of all pixels between G-API and reference OpenCV results
|
||||
testBackSubInStreaming(gapiBackSub, 1);
|
||||
|
||||
path = findDataFile("cv/video/1920x1080.avi");
|
||||
try {
|
||||
// Additionally, test the case when the new stream happens
|
||||
gapiBackSub.setSource(gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(path));
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
// Allowing 5% difference of all pixels between G-API and reference OpenCV results
|
||||
testBackSubInStreaming(gapiBackSub, 5);
|
||||
}
|
||||
|
||||
TEST(StatefulKernel, StateIsChangedViaCompArgsOnReshape)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GComputation comp(in, GBackSub::on(in));
|
||||
|
||||
const auto pkg = cv::gapi::kernels<GOCVBackSub>();
|
||||
|
||||
// OpenCV reference subtractor
|
||||
auto pOCVBackSubKNN = createBackgroundSubtractorKNN();
|
||||
auto pOCVBackSubMOG2 = createBackgroundSubtractorMOG2();
|
||||
|
||||
const auto run = [&](const std::string& videoPath, const std::string& method) {
|
||||
auto path = findDataFile(videoPath);
|
||||
cv::gapi::wip::IStreamSource::Ptr source;
|
||||
try {
|
||||
source = gapi::wip::make_src<cv::gapi::wip::GCaptureSource>(path);
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
cv::Mat inMat, gapiForeground, ocvForeground;
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
cv::gapi::wip::Data inData;
|
||||
source->pull(inData);
|
||||
inMat = cv::util::get<cv::Mat>(inData);
|
||||
comp.apply(inMat, gapiForeground,
|
||||
cv::compile_args(pkg, BackSubStateParams{method}));
|
||||
|
||||
if (method == "knn") {
|
||||
pOCVBackSubKNN->apply(inMat, ocvForeground, -1);
|
||||
// Allowing 1% difference among all pixels
|
||||
compareBackSubResults(gapiForeground, ocvForeground, 1);
|
||||
} else if (method == "mog2") {
|
||||
pOCVBackSubMOG2->apply(inMat, ocvForeground, -1);
|
||||
compareBackSubResults(gapiForeground, ocvForeground, 5);
|
||||
} else {
|
||||
CV_Assert(false && "Unknown BackSub method");
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
run("cv/video/768x576.avi", "knn");
|
||||
run("cv/video/1920x1080.avi", "mog2");
|
||||
}
|
||||
|
||||
TEST(StatefulKernel, StateIsResetOnceOnReshapeInStreaming)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> out = GCountStateSetups::on(in);
|
||||
cv::GComputation c(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
// variable to update when state is initialized in the kernel
|
||||
CountStateSetupsParams params;
|
||||
params.pSetupsCount.reset(new int(0));
|
||||
|
||||
auto ccomp = c.compileStreaming(
|
||||
cv::compile_args(cv::gapi::kernels<GOCVCountStateSetups>(), params));
|
||||
|
||||
auto run = [&ccomp, ¶ms](const std::string& videoPath, int expectedSetupsCount) {
|
||||
auto path = findDataFile(videoPath);
|
||||
try {
|
||||
ccomp.setSource<cv::gapi::wip::GCaptureSource>(path);
|
||||
} catch(...) {
|
||||
throw SkipTestException("Video file can not be opened");
|
||||
}
|
||||
ccomp.start();
|
||||
|
||||
int frames = 0;
|
||||
bool result = false;
|
||||
while (ccomp.pull(cv::gout(result)) && (frames++ < 10)) {
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_TRUE(params.pSetupsCount != nullptr);
|
||||
EXPECT_EQ(expectedSetupsCount, *params.pSetupsCount);
|
||||
}
|
||||
ccomp.stop();
|
||||
};
|
||||
|
||||
run("cv/video/768x576.avi", 1);
|
||||
// FIXME: it should be 2, not 3 for expectedSetupsCount here.
|
||||
// With current implementation both GCPUExecutable reshape() and
|
||||
// handleNewStream() call setupKernelStates()
|
||||
run("cv/video/1920x1080.avi", 3);
|
||||
}
|
||||
#endif
|
||||
|
||||
TEST(StatefulKernel, StateIsAutoResetOnReshape)
|
||||
{
|
||||
cv::GMat in;
|
||||
cv::GOpaque<bool> up_to_date = GIsStateUpToDate::on(in);
|
||||
cv::GOpaque<int> calls_count = GCountCalls::on(in);
|
||||
cv::GComputation comp(cv::GIn(in), cv::GOut(up_to_date, calls_count));
|
||||
|
||||
auto run = [&comp](const cv::Mat& in_mat) {
|
||||
const auto pkg = cv::gapi::kernels<GOCVIsStateUpToDate, GOCVCountCalls>();
|
||||
bool stateIsUpToDate = false;
|
||||
int callsCount = 0;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
comp.apply(cv::gin(in_mat), cv::gout(stateIsUpToDate, callsCount),
|
||||
cv::compile_args(pkg));
|
||||
EXPECT_TRUE(stateIsUpToDate);
|
||||
EXPECT_EQ(i+1, callsCount);
|
||||
}
|
||||
};
|
||||
|
||||
cv::Mat in_mat1(32, 32, CV_8UC1);
|
||||
run(in_mat1);
|
||||
|
||||
cv::Mat in_mat2(16, 16, CV_8UC1);
|
||||
run(in_mat2);
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
//------------------------------------------- Typed tests on setup() ------------------------------------------
|
||||
namespace
|
||||
{
|
||||
template<typename Tuple>
|
||||
struct SetupStateTypedTest : public ::testing::Test
|
||||
{
|
||||
using StateT = typename std::tuple_element<0, Tuple>::type;
|
||||
using SetupT = typename std::tuple_element<1, Tuple>::type;
|
||||
|
||||
G_TYPED_KERNEL(GReturnState, <cv::GOpaque<StateT>(GMat)>, "org.opencv.test.return_state")
|
||||
{
|
||||
static GOpaqueDesc outMeta(GMatDesc /* in */) { return empty_gopaque_desc(); }
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(GOCVReturnState, GReturnState, StateT)
|
||||
{
|
||||
static void setup(const cv::GMatDesc &/* in */, std::shared_ptr<StateT> &state)
|
||||
{
|
||||
// Don't use input cv::GMatDesc intentionally
|
||||
state.reset(new StateT(SetupT::value()));
|
||||
}
|
||||
|
||||
static void run(const cv::Mat &/* in */, StateT &out, StateT& state)
|
||||
{
|
||||
out = state;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
TYPED_TEST_CASE_P(SetupStateTypedTest);
|
||||
} // namespace
|
||||
|
||||
|
||||
TYPED_TEST_P(SetupStateTypedTest, ReturnInitializedState)
|
||||
{
|
||||
using StateType = typename TestFixture::StateT;
|
||||
using SetupType = typename TestFixture::SetupT;
|
||||
|
||||
cv::Mat dummyIn { 1, 1, CV_8UC1 };
|
||||
StateType retState { };
|
||||
|
||||
GMat in;
|
||||
auto out = TestFixture::GReturnState::on(in);
|
||||
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
||||
|
||||
const auto pkg = cv::gapi::kernels<typename TestFixture::GOCVReturnState>();
|
||||
comp.apply(cv::gin(dummyIn), cv::gout(retState), cv::compile_args(pkg));
|
||||
|
||||
EXPECT_EQ(SetupType::value(), retState);
|
||||
}
|
||||
|
||||
REGISTER_TYPED_TEST_CASE_P(SetupStateTypedTest,
|
||||
ReturnInitializedState);
|
||||
|
||||
|
||||
DEFINE_INITIALIZER(CharValue, char, 'z');
|
||||
DEFINE_INITIALIZER(IntValue, int, 7);
|
||||
DEFINE_INITIALIZER(FloatValue, float, 42.f);
|
||||
DEFINE_INITIALIZER(UcharPtrValue, uchar*, nullptr);
|
||||
namespace
|
||||
{
|
||||
using Std3IntArray = std::array<int, 3>;
|
||||
}
|
||||
DEFINE_INITIALIZER(StdArrayValue, Std3IntArray, { 1, 2, 3 });
|
||||
DEFINE_INITIALIZER(UserValue, UserStruct, { 5, 7.f });
|
||||
|
||||
using TypesToVerify = ::testing::Types<std::tuple<char, CharValue>,
|
||||
std::tuple<int, IntValue>,
|
||||
std::tuple<float, FloatValue>,
|
||||
std::tuple<uchar*, UcharPtrValue>,
|
||||
std::tuple<std::array<int, 3>, StdArrayValue>,
|
||||
std::tuple<UserStruct, UserValue>>;
|
||||
|
||||
INSTANTIATE_TYPED_TEST_CASE_P(SetupStateTypedInst, SetupStateTypedTest, TypesToVerify);
|
||||
//-------------------------------------------------------------------------------------------------------------
|
||||
|
||||
} // opencv_test
|
||||
@@ -0,0 +1,64 @@
|
||||
// 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
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_operators_tests.hpp"
|
||||
#include <opencv2/gapi/cpu/core.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
#define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
|
||||
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
// FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now!
|
||||
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( ADD, SUB, DIV,
|
||||
GT, LT, GE, LE, EQ, NE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( ADD, SUB, MUL, DIV,
|
||||
ADDR, SUBR, MULR, DIVR,
|
||||
GT, LT, GE, LE, EQ, NE,
|
||||
GTR, LTR, GER, LER, EQR, NER)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( AND, OR, XOR )));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( AND, OR, XOR,
|
||||
ANDR, ORR, XORR )));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_CPU)));
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
// 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
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_operators_tests.hpp"
|
||||
|
||||
namespace
|
||||
{
|
||||
#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
|
||||
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( ADD, SUB, DIV,
|
||||
GT, LT, GE, LE, EQ, NE)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( ADD, SUB, MUL, DIV,
|
||||
ADDR, SUBR, MULR, DIVR)));
|
||||
|
||||
// FIXME: solve comparison error
|
||||
INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
|
||||
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsSimilarPoints(1, 0.01).to_compare_obj()),
|
||||
Values( GT, LT, GE, LE, EQ, NE,
|
||||
GTR, LTR, GER, LER, EQR, NER)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( AND, OR, XOR )));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID),
|
||||
Values(AbsExact().to_compare_obj()),
|
||||
Values( AND, OR, XOR,
|
||||
ANDR, ORR, XORR )));
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,
|
||||
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
|
||||
ValuesIn(in_sizes),
|
||||
Values(-1),
|
||||
Values(CORE_FLUID)));
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
// 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) 2023 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
|
||||
#include <opencv2/gapi/ot.hpp>
|
||||
#include <opencv2/gapi/cpu/ot.hpp>
|
||||
|
||||
#include "opencv2/gapi/streaming/meta.hpp"
|
||||
#include "opencv2/gapi/streaming/cap.hpp"
|
||||
|
||||
namespace {
|
||||
cv::gapi::ot::TrackingStatus from_string(const std::string& status) {
|
||||
if (status == "NEW") {
|
||||
return cv::gapi::ot::TrackingStatus::NEW;
|
||||
}
|
||||
else if (status == "TRACKED") {
|
||||
return cv::gapi::ot::TrackingStatus::TRACKED;
|
||||
}
|
||||
else if (status == "LOST") {
|
||||
return cv::gapi::ot::TrackingStatus::LOST;
|
||||
}
|
||||
|
||||
throw std::runtime_error("String representation for cv::gapi::ot::TrackingStatus: \""
|
||||
+ status + "\" contains incorrect value!");
|
||||
}
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test {
|
||||
struct FrameDetections {
|
||||
std::size_t frame_no{};
|
||||
std::vector<std::vector<cv::Rect>> boxes;
|
||||
std::vector<std::vector<int32_t>> box_ids;
|
||||
FrameDetections() {}
|
||||
FrameDetections(std::size_t in_frame_no, const std::vector<std::vector<cv::Rect>>& in_boxes,
|
||||
const std::vector<std::vector<int32_t>>& in_box_ids) :
|
||||
frame_no(in_frame_no),
|
||||
boxes(in_boxes),
|
||||
box_ids(in_box_ids) {}
|
||||
};
|
||||
|
||||
struct TrackerReference {
|
||||
std::size_t frame_no{};
|
||||
std::vector<std::vector<cv::Rect>> tracked_boxes;
|
||||
std::vector<std::vector<int32_t>> tracked_box_ids;
|
||||
std::vector<std::vector<uint64_t>> tracking_ids;
|
||||
std::vector<std::vector<cv::gapi::ot::TrackingStatus>> tracking_statuses;
|
||||
TrackerReference() {}
|
||||
TrackerReference(std::size_t in_frame_no,
|
||||
const std::vector<std::vector<cv::Rect>>& in_tracked_boxes,
|
||||
const std::vector<std::vector<int32_t>>& in_tracked_box_ids,
|
||||
const std::vector<std::vector<uint64_t>>& in_tracking_ids,
|
||||
const std::vector<std::vector<cv::gapi::ot::TrackingStatus>>&
|
||||
in_tracking_statuses) :
|
||||
frame_no(in_frame_no),
|
||||
tracked_boxes(in_tracked_boxes),
|
||||
tracked_box_ids(in_tracked_box_ids),
|
||||
tracking_ids(in_tracking_ids),
|
||||
tracking_statuses(in_tracking_statuses) {}
|
||||
};
|
||||
|
||||
struct FrameDetectionsParams {
|
||||
FrameDetections value;
|
||||
};
|
||||
|
||||
struct TrackerReferenceParams {
|
||||
TrackerReference value;
|
||||
};
|
||||
} // namespace opencv_test
|
||||
|
||||
namespace cv {
|
||||
namespace detail {
|
||||
template<> struct CompileArgTag<opencv_test::FrameDetectionsParams> {
|
||||
static const char* tag() {
|
||||
return "org.opencv.test.frame_detections_params";
|
||||
}
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
namespace detail {
|
||||
template<> struct CompileArgTag<opencv_test::TrackerReferenceParams> {
|
||||
static const char* tag() {
|
||||
return "org.opencv.test.tracker_reference_params";
|
||||
}
|
||||
};
|
||||
} // namespace detail
|
||||
} // namespace cv
|
||||
|
||||
namespace opencv_test {
|
||||
G_API_OP(CvVideo768x576_Detect, <std::tuple<cv::GArray<cv::Rect>, cv::GArray<int32_t>>(cv::GMat)>,
|
||||
"test.custom.cv_video_768x576_detect") {
|
||||
static std::tuple<cv::GArrayDesc, cv::GArrayDesc> outMeta(cv::GMatDesc) {
|
||||
return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc());
|
||||
}
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(OCV_CvVideo768x576_Detect, CvVideo768x576_Detect, FrameDetections) {
|
||||
static void setup(cv::GMatDesc,
|
||||
std::shared_ptr<FrameDetections> &state,
|
||||
const cv::GCompileArgs &compileArgs) {
|
||||
auto params = cv::gapi::getCompileArg<opencv_test::FrameDetectionsParams>(compileArgs)
|
||||
.value_or(opencv_test::FrameDetectionsParams{ });
|
||||
state = std::make_shared<FrameDetections>(params.value);
|
||||
}
|
||||
|
||||
static void run(const cv::Mat&,
|
||||
std::vector<cv::Rect> &out_boxes,
|
||||
std::vector<int32_t> &out_box_ids,
|
||||
FrameDetections &state) {
|
||||
if (state.frame_no < state.boxes.size()) {
|
||||
out_boxes = state.boxes[state.frame_no];
|
||||
out_box_ids = state.box_ids[state.frame_no];
|
||||
++state.frame_no;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
G_API_OP(CheckTrackerResults, <cv::GOpaque<bool>(cv::GArray<cv::Rect>, cv::GArray<int32_t>,
|
||||
cv::GArray<uint64_t>, cv::GArray<int>)>,
|
||||
"test.custom.check_tracker_results") {
|
||||
static cv::GOpaqueDesc outMeta(cv::GArrayDesc, cv::GArrayDesc, cv::GArrayDesc, cv::GArrayDesc) {
|
||||
return cv::empty_gopaque_desc();
|
||||
}
|
||||
};
|
||||
|
||||
GAPI_OCV_KERNEL_ST(OCVCheckTrackerResults, CheckTrackerResults, TrackerReference) {
|
||||
static void setup(cv::GArrayDesc, cv::GArrayDesc,
|
||||
cv::GArrayDesc, cv::GArrayDesc,
|
||||
std::shared_ptr<TrackerReference> &state,
|
||||
const cv::GCompileArgs &compileArgs) {
|
||||
auto params = cv::gapi::getCompileArg<opencv_test::TrackerReferenceParams>(compileArgs)
|
||||
.value_or(opencv_test::TrackerReferenceParams{ });
|
||||
state = std::make_shared<TrackerReference>(params.value);
|
||||
}
|
||||
|
||||
static void run(const std::vector<cv::Rect> &in_tr_rcts,
|
||||
const std::vector<int32_t> &in_det_ids,
|
||||
const std::vector<uint64_t> &in_tr_ids,
|
||||
const std::vector<int> &in_tr_statuses,
|
||||
bool& success,
|
||||
TrackerReference& state) {
|
||||
|
||||
if (state.frame_no < state.tracked_boxes.size()) {
|
||||
auto reference_boxes = state.tracked_boxes[state.frame_no];
|
||||
auto reference_box_ids = state.tracked_box_ids[state.frame_no];
|
||||
auto reference_tr_ids = state.tracking_ids[state.frame_no];
|
||||
auto reference_tr_statuses = state.tracking_statuses[state.frame_no];
|
||||
|
||||
success = true;
|
||||
GAPI_Assert(in_tr_rcts.size() == reference_boxes.size());
|
||||
GAPI_Assert(in_det_ids.size() == reference_box_ids.size());
|
||||
GAPI_Assert(in_tr_ids.size() == reference_tr_ids.size());
|
||||
GAPI_Assert(in_tr_statuses.size() == reference_tr_statuses.size());
|
||||
for (uint32_t i = 0; (i < in_tr_rcts.size() && success); ++i) {
|
||||
const cv::Rect& reference_rc = reference_boxes[i];
|
||||
const cv::Rect& in_rc = in_tr_rcts[i];
|
||||
|
||||
success &= (reference_rc == in_rc);
|
||||
success &= (reference_box_ids[i] == in_det_ids[i]);
|
||||
success &= (reference_tr_ids[i] == in_tr_ids[i]);
|
||||
success &= (reference_tr_statuses[i] == in_tr_statuses[i]);
|
||||
}
|
||||
|
||||
++state.frame_no;
|
||||
}
|
||||
else {
|
||||
success = true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
TEST(VASObjectTracker, PipelineTest)
|
||||
{
|
||||
constexpr int32_t frames_to_handle = 30;
|
||||
std::string pathToVideo = opencv_test::findDataFile("cv/video/768x576.avi");
|
||||
|
||||
std::vector<std::vector<cv::Rect>> input_boxes(frames_to_handle);
|
||||
std::vector<std::vector<int32_t>> input_det_ids(frames_to_handle);
|
||||
|
||||
std::string path_to_boxes = opencv_test::findDataFile("cv/video/vas_object_tracking/detections_30_frames.yml");
|
||||
|
||||
cv::FileStorage fs_input_boxes(path_to_boxes, cv::FileStorage::READ);
|
||||
cv::FileNode fn_input_boxes = fs_input_boxes.root();
|
||||
for (auto it = fn_input_boxes.begin(); it != fn_input_boxes.end(); ++it) {
|
||||
cv::FileNode fn_frame = *it;
|
||||
std::string frame_name = fn_frame.name();
|
||||
int frame_no = std::stoi(frame_name.substr(frame_name.find("_") + 1));
|
||||
|
||||
for (auto fit = fn_frame.begin(); fit != fn_frame.end(); ++fit) {
|
||||
cv::FileNode fn_box = *fit;
|
||||
|
||||
cv::Rect box((int)fn_box["x"], (int)fn_box["y"],
|
||||
(int)fn_box["width"], (int)fn_box["height"]);
|
||||
input_boxes[frame_no].push_back(box);
|
||||
input_det_ids[frame_no].push_back(fn_box["id"]);
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<std::vector<cv::Rect>> reference_trackings(frames_to_handle);
|
||||
std::vector<std::vector<int32_t>> reference_trackings_det_ids(frames_to_handle);
|
||||
std::vector<std::vector<uint64_t>> reference_trackings_tr_ids(frames_to_handle);
|
||||
std::vector<std::vector<cv::gapi::ot::TrackingStatus>> reference_trackings_tr_statuses(frames_to_handle);
|
||||
|
||||
std::string path_to_trackings = opencv_test::findDataFile("cv/video/vas_object_tracking/trackings_30_frames.yml");
|
||||
|
||||
cv::FileStorage fs_reference_trackings(path_to_trackings, cv::FileStorage::READ);
|
||||
cv::FileNode fn_reference_trackings = fs_reference_trackings.root();
|
||||
for (auto it = fn_reference_trackings.begin(); it != fn_reference_trackings.end(); ++it) {
|
||||
cv::FileNode fn_frame = *it;
|
||||
std::string frame_name = fn_frame.name();
|
||||
int frame_no = std::stoi(frame_name.substr(frame_name.find("_") + 1));
|
||||
|
||||
for (auto fit = fn_frame.begin(); fit != fn_frame.end(); ++fit) {
|
||||
cv::FileNode fn_tracked_box = *fit;
|
||||
|
||||
cv::Rect tracked_box((int)fn_tracked_box["x"], (int)fn_tracked_box["y"],
|
||||
(int)fn_tracked_box["width"], (int)fn_tracked_box["height"]);
|
||||
reference_trackings[frame_no].push_back(tracked_box);
|
||||
reference_trackings_det_ids[frame_no].push_back(fn_tracked_box["id"]);
|
||||
reference_trackings_tr_ids[frame_no].push_back(int(fn_tracked_box["tracking_id"]));
|
||||
reference_trackings_tr_statuses[frame_no].push_back(
|
||||
from_string(fn_tracked_box["tracking_status"]));
|
||||
}
|
||||
}
|
||||
|
||||
cv::GMat in;
|
||||
|
||||
cv::GArray<cv::Rect> detections;
|
||||
cv::GArray<int> det_ids;
|
||||
std::tie(detections, det_ids) = CvVideo768x576_Detect::on(in);
|
||||
|
||||
constexpr float delta_time = 0.055f;
|
||||
cv::GArray<cv::Rect> tracking_rects;
|
||||
cv::GArray<int32_t> tracking_det_ids;
|
||||
cv::GArray<uint64_t> tracking_ids;
|
||||
cv::GArray<int> tracking_statuses;
|
||||
std::tie(tracking_rects, tracking_det_ids, tracking_ids, tracking_statuses) =
|
||||
cv::gapi::ot::track(in, detections, det_ids, delta_time);
|
||||
|
||||
cv::GOpaque<bool> check_result =
|
||||
CheckTrackerResults::on(tracking_rects, tracking_det_ids, tracking_ids, tracking_statuses);
|
||||
|
||||
cv::GComputation ccomp(cv::GIn(in), cv::GOut(check_result));
|
||||
|
||||
|
||||
opencv_test::FrameDetections fds { 0, input_boxes, input_det_ids };
|
||||
opencv_test::TrackerReference tr { 0, reference_trackings,
|
||||
reference_trackings_det_ids,
|
||||
reference_trackings_tr_ids,
|
||||
reference_trackings_tr_statuses };
|
||||
|
||||
// Graph compilation for streaming mode:
|
||||
auto compiled =
|
||||
ccomp.compileStreaming(cv::compile_args(
|
||||
cv::gapi::combine(cv::gapi::kernels<OCV_CvVideo768x576_Detect,
|
||||
OCVCheckTrackerResults>(),
|
||||
cv::gapi::ot::cpu::kernels()),
|
||||
opencv_test::FrameDetectionsParams{ fds },
|
||||
opencv_test::TrackerReferenceParams{ tr }));
|
||||
|
||||
EXPECT_TRUE(compiled);
|
||||
EXPECT_FALSE(compiled.running());
|
||||
|
||||
compiled.setSource<cv::gapi::wip::GCaptureSource>(pathToVideo);
|
||||
|
||||
// Start of streaming:
|
||||
compiled.start();
|
||||
EXPECT_TRUE(compiled.running());
|
||||
|
||||
// Streaming:
|
||||
bool success;
|
||||
|
||||
std::size_t counter { }, limit { 30 };
|
||||
while(compiled.pull(cv::gout(success)) && (counter < limit)) {
|
||||
++counter;
|
||||
}
|
||||
|
||||
compiled.stop();
|
||||
|
||||
EXPECT_TRUE(success);
|
||||
EXPECT_FALSE(compiled.running());
|
||||
}
|
||||
} // namespace opencv_test
|
||||
@@ -0,0 +1,39 @@
|
||||
// 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) 2021 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
#include "../common/gapi_stereo_tests.hpp"
|
||||
|
||||
#include <opencv2/gapi/stereo.hpp> // For ::gapi::stereo::disparity/depth
|
||||
#include <opencv2/gapi/cpu/stereo.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
#define STEREO_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::calib3d::cpu::kernels()}); }
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CPU_Tests, TestGAPIStereo,
|
||||
Combine(Values(CV_8UC1),
|
||||
Values(cv::Size(1280, 720)),
|
||||
Values(CV_32FC1),
|
||||
Values(STEREO_CPU),
|
||||
Values(cv::gapi::StereoOutputFormat::DEPTH_FLOAT16,
|
||||
cv::gapi::StereoOutputFormat::DEPTH_FLOAT32,
|
||||
cv::gapi::StereoOutputFormat::DISPARITY_FIXED16_12_4,
|
||||
cv::gapi::StereoOutputFormat::DEPTH_16F,
|
||||
cv::gapi::StereoOutputFormat::DEPTH_32F,
|
||||
cv::gapi::StereoOutputFormat::DISPARITY_16Q_11_4),
|
||||
Values(16),
|
||||
Values(43),
|
||||
Values(63.5),
|
||||
Values(3.6),
|
||||
Values(AbsExact().to_compare_obj())));
|
||||
|
||||
} // opencv_test
|
||||
@@ -0,0 +1,138 @@
|
||||
// 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) 2020 Intel Corporation
|
||||
|
||||
|
||||
#include "../test_precomp.hpp"
|
||||
|
||||
#include "../common/gapi_video_tests.hpp"
|
||||
#include <opencv2/gapi/cpu/video.hpp>
|
||||
|
||||
namespace
|
||||
{
|
||||
#define VIDEO_CPU [] () { return cv::compile_args(cv::gapi::video::cpu::kernels()); }
|
||||
|
||||
#ifdef HAVE_OPENCV_VIDEO
|
||||
#define WITH_VIDEO(X) X
|
||||
#else
|
||||
#define WITH_VIDEO(X) DISABLED_##X
|
||||
#endif // HAVE_OPENCV_VIDEO
|
||||
|
||||
#define INSTANTIATE_TEST_CASE_MACRO_P(prefix, test_case_name, generator, ...) \
|
||||
INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, __VA_ARGS__)
|
||||
} // anonymous namespace
|
||||
|
||||
namespace opencv_test
|
||||
{
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(BuildOptFlowPyramidTestCPU), BuildOptFlowPyramidTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_1.bmp",
|
||||
"cv/optflow/frames/1080p_01.png"),
|
||||
Values(7, 11),
|
||||
Values(1000),
|
||||
testing::Bool(),
|
||||
Values(BORDER_DEFAULT, BORDER_TRANSPARENT),
|
||||
Values(BORDER_DEFAULT, BORDER_TRANSPARENT),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(BuildOptFlowPyramidInternalTestCPU),
|
||||
BuildOptFlowPyramidTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_1.bmp"),
|
||||
Values(15),
|
||||
Values(3),
|
||||
Values(true),
|
||||
Values(BORDER_REFLECT_101),
|
||||
Values(BORDER_CONSTANT),
|
||||
Values(true)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(OptFlowLKTestCPU), OptFlowLKTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_%01d.bmp",
|
||||
"cv/optflow/frames/1080p_%02d.png"),
|
||||
Values(1, 3, 4),
|
||||
Values(std::make_tuple(9, 9), std::make_tuple(15, 15)),
|
||||
Values(7, 11),
|
||||
Values(cv::TermCriteria(cv::TermCriteria::COUNT |
|
||||
cv::TermCriteria::EPS,
|
||||
30, 0.01))));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(OptFlowLKTestForPyrCPU), OptFlowLKTestForPyr,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_%01d.bmp",
|
||||
"cv/optflow/frames/1080p_%02d.png"),
|
||||
Values(1, 3, 4),
|
||||
Values(std::make_tuple(9, 9), std::make_tuple(15, 15)),
|
||||
Values(7, 11),
|
||||
Values(cv::TermCriteria(cv::TermCriteria::COUNT |
|
||||
cv::TermCriteria::EPS,
|
||||
30, 0.01)),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(OptFlowLKInternalTestCPU), OptFlowLKTestForPyr,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_%01d.bmp"),
|
||||
Values(1),
|
||||
Values(std::make_tuple(10, 10)),
|
||||
Values(15),
|
||||
Values(cv::TermCriteria(cv::TermCriteria::COUNT |
|
||||
cv::TermCriteria::EPS,
|
||||
21, 0.05)),
|
||||
Values(true)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(BuildPyr_CalcOptFlow_PipelineTestCPU),
|
||||
BuildPyr_CalcOptFlow_PipelineTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/frames/1080p_%02d.png"),
|
||||
Values(7, 11),
|
||||
Values(1000),
|
||||
testing::Bool()));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(BuildPyr_CalcOptFlow_PipelineInternalTestCPU),
|
||||
BuildPyr_CalcOptFlow_PipelineTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values("cv/optflow/rock_%01d.bmp"),
|
||||
Values(15),
|
||||
Values(3),
|
||||
Values(true)));
|
||||
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(WITH_VIDEO(BackgroundSubtractorTestCPU),
|
||||
BackgroundSubtractorTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values(std::make_tuple(cv::gapi::video::TYPE_BS_MOG2, 16),
|
||||
std::make_tuple(cv::gapi::video::TYPE_BS_MOG2, 8),
|
||||
std::make_tuple(cv::gapi::video::TYPE_BS_KNN, 400),
|
||||
std::make_tuple(cv::gapi::video::TYPE_BS_KNN, 200)),
|
||||
Values(500, 50),
|
||||
testing::Bool(),
|
||||
Values(-1, 0, 0.5, 1),
|
||||
Values("cv/video/768x576.avi"),
|
||||
Values(3)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(KalmanFilterTestCPU,
|
||||
KalmanFilterTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values(CV_32FC1, CV_64FC1),
|
||||
Values(2,5),
|
||||
Values(2,5),
|
||||
Values(2),
|
||||
Values(5)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(KalmanFilterTestCPU,
|
||||
KalmanFilterNoControlTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values(CV_32FC1, CV_64FC1),
|
||||
Values(3),
|
||||
Values(4),
|
||||
Values(3)));
|
||||
|
||||
INSTANTIATE_TEST_CASE_MACRO_P(KalmanFilterTestCPU,
|
||||
KalmanFilterCircleSampleTest,
|
||||
Combine(Values(VIDEO_CPU),
|
||||
Values(CV_32FC1, CV_64FC1),
|
||||
Values(5)));
|
||||
|
||||
} // opencv_test
|
||||
Reference in New Issue
Block a user