Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/modules/imgproc/perf/perf_accumulate.cpp
16339 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
#include "perf_precomp.hpp"

5


6
namespace opencv_test {

7


8
typedef Size_MatType Accumulate;

9


10
#define MAT_TYPES_ACCUMLATE CV_8UC1, CV_16UC1, CV_32FC1

11
#define MAT_TYPES_ACCUMLATE_C MAT_TYPES_ACCUMLATE, CV_8UC3, CV_16UC3, CV_32FC3

12
#define MAT_TYPES_ACCUMLATE_D MAT_TYPES_ACCUMLATE, CV_64FC1

13
#define MAT_TYPES_ACCUMLATE_D_C MAT_TYPES_ACCUMLATE_C, CV_64FC1, CV_64FC1

14


15
#define PERF_ACCUMULATE_INIT(_FLTC)                    \

16
    const Size srcSize = get<0>(GetParam());           \

17
    const int srcType = get<1>(GetParam());            \

18
    const int dstType = _FLTC(CV_MAT_CN(srcType));     \

19
    Mat src1(srcSize, srcType), dst(srcSize, dstType); \

20
    declare.in(src1, dst, WARMUP_RNG).out(dst);

21


22
#define PERF_ACCUMULATE_MASK_INIT(_FLTC) \

23
    PERF_ACCUMULATE_INIT(_FLTC)          \

24
    Mat mask(srcSize, CV_8UC1);          \

25
    declare.in(mask, WARMUP_RNG);

26


27
#define PERF_TEST_P_ACCUMULATE(_NAME, _TYPES, _INIT, _FUN)           \

28
    PERF_TEST_P(Accumulate, _NAME,                                   \

29
        testing::Combine(                                            \

30
            testing::Values(sz1080p, sz720p, szVGA, szQVGA, szODD),  \

31
            testing::Values(_TYPES)                                  \

32
        )                                                            \

33
    )                                                                \

34
    {                                                                \

35
        _INIT                                                        \

36
        TEST_CYCLE() _FUN;                                           \

37
        SANITY_CHECK_NOTHING();                                      \

38
    }

39


40
/////////////////////////////////// Accumulate ///////////////////////////////////

41


42
PERF_TEST_P_ACCUMULATE(Accumulate, MAT_TYPES_ACCUMLATE,

43
        PERF_ACCUMULATE_INIT(CV_32FC), accumulate(src1, dst))

44


45
PERF_TEST_P_ACCUMULATE(AccumulateMask, MAT_TYPES_ACCUMLATE_C,

46
    PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulate(src1, dst, mask))

47


48
PERF_TEST_P_ACCUMULATE(AccumulateDouble, MAT_TYPES_ACCUMLATE_D,

49
    PERF_ACCUMULATE_INIT(CV_64FC), accumulate(src1, dst))

50


51
PERF_TEST_P_ACCUMULATE(AccumulateDoubleMask, MAT_TYPES_ACCUMLATE_D_C,

52
    PERF_ACCUMULATE_MASK_INIT(CV_64FC), accumulate(src1, dst, mask))

53


54
///////////////////////////// AccumulateSquare ///////////////////////////////////

55


56
PERF_TEST_P_ACCUMULATE(Square, MAT_TYPES_ACCUMLATE,

57
    PERF_ACCUMULATE_INIT(CV_32FC), accumulateSquare(src1, dst))

58


59
PERF_TEST_P_ACCUMULATE(SquareMask, MAT_TYPES_ACCUMLATE_C,

60
    PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulateSquare(src1, dst, mask))

61


62
PERF_TEST_P_ACCUMULATE(SquareDouble, MAT_TYPES_ACCUMLATE_D,

63
    PERF_ACCUMULATE_INIT(CV_64FC), accumulateSquare(src1, dst))

64


65
PERF_TEST_P_ACCUMULATE(SquareDoubleMask, MAT_TYPES_ACCUMLATE_D_C,

66
    PERF_ACCUMULATE_MASK_INIT(CV_64FC), accumulateSquare(src1, dst, mask))

67


68
///////////////////////////// AccumulateProduct ///////////////////////////////////

69


70
#define PERF_ACCUMULATE_INIT_2(_FLTC) \

71
    PERF_ACCUMULATE_INIT(_FLTC)       \

72
    Mat src2(srcSize, srcType);       \

73
    declare.in(src2);

74


75
#define PERF_ACCUMULATE_MASK_INIT_2(_FLTC) \

76
    PERF_ACCUMULATE_MASK_INIT(_FLTC)       \

77
    Mat src2(srcSize, srcType);            \

78
    declare.in(src2);

79


80
PERF_TEST_P_ACCUMULATE(Product, MAT_TYPES_ACCUMLATE,

81
    PERF_ACCUMULATE_INIT_2(CV_32FC), accumulateProduct(src1, src2, dst))

82


83
PERF_TEST_P_ACCUMULATE(ProductMask, MAT_TYPES_ACCUMLATE_C,

84
    PERF_ACCUMULATE_MASK_INIT_2(CV_32FC), accumulateProduct(src1, src2, dst, mask))

85


86
PERF_TEST_P_ACCUMULATE(ProductDouble, MAT_TYPES_ACCUMLATE_D,

87
    PERF_ACCUMULATE_INIT_2(CV_64FC), accumulateProduct(src1, src2, dst))

88


89
PERF_TEST_P_ACCUMULATE(ProductDoubleMask, MAT_TYPES_ACCUMLATE_D_C,

90
    PERF_ACCUMULATE_MASK_INIT_2(CV_64FC), accumulateProduct(src1, src2, dst, mask))

91


92
///////////////////////////// AccumulateWeighted ///////////////////////////////////

93


94
PERF_TEST_P_ACCUMULATE(Weighted, MAT_TYPES_ACCUMLATE,

95
    PERF_ACCUMULATE_INIT(CV_32FC), accumulateWeighted(src1, dst, 0.123))

96


97
PERF_TEST_P_ACCUMULATE(WeightedMask, MAT_TYPES_ACCUMLATE_C,

98
    PERF_ACCUMULATE_MASK_INIT(CV_32FC), accumulateWeighted(src1, dst, 0.123, mask))

99


100
PERF_TEST_P_ACCUMULATE(WeightedDouble, MAT_TYPES_ACCUMLATE_D,

101
    PERF_ACCUMULATE_INIT(CV_64FC), accumulateWeighted(src1, dst, 0.123456))

102


103
PERF_TEST_P_ACCUMULATE(WeightedDoubleMask, MAT_TYPES_ACCUMLATE_D_C,

104
    PERF_ACCUMULATE_MASK_INIT(CV_64FC), accumulateWeighted(src1, dst, 0.123456, mask))

105


106
} // namespace

107


108