Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
16337 views
1
// This file is part of OpenCV project.

2
// It is subject to the license terms in the LICENSE file found in the top-level directory

3
// of this distribution and at http://opencv.org/license.html.

4
//

5
// Copyright (C) 2018 Intel Corporation

6


7


8
#include "test_precomp.hpp"

9
#include "../common/gapi_operators_tests.hpp"

10
#include "opencv2/gapi/cpu/core.hpp"

11


12
#define CORE_FLUID cv::gapi::core::cpu::kernels()

13


14
namespace opencv_test

15
{

16
    INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,

17
                            Combine(Values( opPlusM, opMinusM, opDivM,

18
                                            opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq),

19
                                    Values(CV_8UC1, CV_16SC1, CV_32FC1),

20
                                    Values(cv::Size(1280, 720),

21
                                       cv::Size(640, 480),

22
                                       cv::Size(128, 128)),

23
                                    Values(-1, CV_8U, CV_32F),

24
    /*init output matrices or not*/ testing::Bool(),

25
                                    Values(cv::compile_args(CORE_FLUID))));

26


27
    //FIXME: Some Mat/Scalar Fluid kernels are not there yet!

28
    INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest,

29
                            Combine(Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, opDiv, opDivR,

30
                                            opGT, opLT, opGE, opLE, opEQ, opNE,

31
                                            opGTR, opLTR, opGER, opLER, opEQR, opNER),

32
                                    Values(CV_8UC1, CV_16SC1, CV_32FC1),

33
                                    Values(cv::Size(1280, 720),

34
                                           cv::Size(640, 480),

35
                                           cv::Size(128, 128)),

36
                                    Values(-1, CV_8U, CV_32F),

37
    /*init output matrices or not*/ testing::Bool(),

38
                                    Values(cv::compile_args(CORE_FLUID))));

39


40
    INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,

41
                            Combine(Values( opAnd, opOr, opXor ),

42
                                    Values(CV_8UC1, CV_16UC1, CV_16SC1),

43
                                    Values(cv::Size(1280, 720),

44
                                       cv::Size(640, 480),

45
                                       cv::Size(128, 128)),

46
                                    Values(-1),

47
    /*init output matrices or not*/ testing::Bool(),

48
                                    Values(cv::compile_args(CORE_FLUID))));

49


50
    //FIXME: Some Mat/Scalar Fluid kernels are not there yet!

51
    INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest,

52
                            Combine(Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ),

53
                                    Values(CV_8UC1, CV_16UC1, CV_16SC1),

54
                                    Values(cv::Size(1280, 720),

55
                                           cv::Size(640, 480),

56
                                           cv::Size(128, 128)),

57
                                    Values(-1),

58
    /*init output matrices or not*/ testing::Bool(),

59
                                    Values(cv::compile_args(CORE_FLUID))));

60


61
    INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,

62
                        Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),

63
                                Values(cv::Size(1280, 720),

64
                                       cv::Size(640, 480),

65
                                       cv::Size(128, 128)),

66
    /*init output matrices or not*/ testing::Bool(),

67
                                    Values(cv::compile_args(CORE_FLUID))));

68
}

69


70