CoCalc -- perf_optflowpyrlk.cpp

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/video/perf/perf_optflowpyrlk.cpp
¹⁶³⁵⁴ views
1
#include "perf_precomp.hpp"
2

3
namespace opencv_test { namespace {
4
using namespace perf;
5

6
typedef tuple<std::string, int, int, tuple<int,int>, int> Path_Idx_Cn_NPoints_WSize_t;
7
typedef TestBaseWithParam<Path_Idx_Cn_NPoints_WSize_t> Path_Idx_Cn_NPoints_WSize;
8

9
void FormTrackingPointsArray(vector<Point2f>& points, int width, int height, int nPointsX, int nPointsY)
10
{
11
    int stepX = width / nPointsX;
12
    int stepY = height / nPointsY;
13
    if (stepX < 1 || stepY < 1) FAIL() << "Specified points number is too big";
14

15
    points.clear();
16
    points.reserve(nPointsX * nPointsY);
17

18
    for( int x = stepX / 2; x < width; x += stepX )
19
    {
20
        for( int y = stepY / 2; y < height; y += stepY )
21
        {
22
            Point2f pt(static_cast<float>(x), static_cast<float>(y));
23
            points.push_back(pt);
24
        }
25
    }
26
}
27

28
PERF_TEST_P(Path_Idx_Cn_NPoints_WSize, OpticalFlowPyrLK_full, testing::Combine(
29
                testing::Values<std::string>("cv/optflow/frames/VGA_%02d.png", "cv/optflow/frames/720p_%02d.png"),
30
                testing::Range(1, 3),
31
                testing::Values(1, 3, 4),
32
                testing::Values(make_tuple(9, 9), make_tuple(15, 15)),
33
                testing::Values(7, 11)
34
                )
35
            )
36
{
37
    string filename1 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam())));
38
    string filename2 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam()) + 1));
39
    Mat img1 = imread(filename1);
40
    Mat img2 = imread(filename2);
41
    if (img1.empty()) FAIL() << "Unable to load source image " << filename1;
42
    if (img2.empty()) FAIL() << "Unable to load source image " << filename2;
43

44
    int cn = get<2>(GetParam());
45
    int nPointsX = std::min(get<0>(get<3>(GetParam())), img1.cols);
46
    int nPointsY = std::min(get<1>(get<3>(GetParam())), img1.rows);
47
    int winSize = get<4>(GetParam());
48

49
    int maxLevel = 2;
50
    TermCriteria criteria(TermCriteria::COUNT|TermCriteria::EPS, 7, 0.001);
51
    int flags = 0;
52
    double minEigThreshold = 1e-4;
53

54
    Mat frame1, frame2;
55
    switch(cn)
56
    {
57
    case 1:
58
        cvtColor(img1, frame1, COLOR_BGR2GRAY, cn);
59
        cvtColor(img2, frame2, COLOR_BGR2GRAY, cn);
60
        break;
61
    case 3:
62
        frame1 = img1;
63
        frame2 = img2;
64
        break;
65
    case 4:
66
        cvtColor(img1, frame1, COLOR_BGR2BGRA, cn);
67
        cvtColor(img2, frame2, COLOR_BGR2BGRA, cn);
68
        break;
69
    default:
70
        FAIL() << "Unexpected number of channels: " << cn;
71
    }
72

73
    vector<Point2f> inPoints;
74
    vector<Point2f> outPoints;
75
    vector<uchar> status;
76
    vector<float> err;
77

78
    FormTrackingPointsArray(inPoints, frame1.cols, frame1.rows, nPointsX, nPointsY);
79
    outPoints.resize(inPoints.size());
80
    status.resize(inPoints.size());
81
    err.resize(inPoints.size());
82

83
    declare.in(frame1, frame2, inPoints).out(outPoints);
84

85
    TEST_CYCLE_N(30)
86
    {
87
        calcOpticalFlowPyrLK(frame1, frame2, inPoints, outPoints, status, err,
88
                             Size(winSize, winSize), maxLevel, criteria,
89
                             flags, minEigThreshold);
90
    }
91

92
    SANITY_CHECK_NOTHING();
93
}
94

95
typedef tuple<std::string, int, tuple<int, int>, int> Path_Idx_NPoints_WSize_t;
96
typedef TestBaseWithParam<Path_Idx_NPoints_WSize_t> Path_Idx_NPoints_WSize;
97

98
PERF_TEST_P(Path_Idx_NPoints_WSize, OpticalFlowPyrLK_ovx, testing::Combine(
99
                testing::Values<std::string>("cv/optflow/frames/VGA_%02d.png", "cv/optflow/frames/720p_%02d.png"),
100
                testing::Range(1, 3),
101
                testing::Values(make_tuple(9, 9), make_tuple(15, 15)),
102
                testing::Values(7, 11)
103
                )
104
            )
105
{
106
    string filename1 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam())));
107
    string filename2 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam()) + 1));
108
    Mat img1 = imread(filename1);
109
    Mat img2 = imread(filename2);
110
    if (img1.empty()) FAIL() << "Unable to load source image " << filename1;
111
    if (img2.empty()) FAIL() << "Unable to load source image " << filename2;
112

113
    int nPointsX = std::min(get<0>(get<2>(GetParam())), img1.cols);
114
    int nPointsY = std::min(get<1>(get<2>(GetParam())), img1.rows);
115
    int winSize = get<3>(GetParam());
116

117
    int maxLevel = 2;
118
    TermCriteria criteria(TermCriteria::COUNT|TermCriteria::EPS, 7, 0.001);
119
    int flags = 0;
120
    double minEigThreshold = 1e-4;
121

122
    Mat frame1, frame2;
123
    cvtColor(img1, frame1, COLOR_BGR2GRAY, 1);
124
    cvtColor(img2, frame2, COLOR_BGR2GRAY, 1);
125

126
    vector<Point2f> inPoints;
127
    vector<Point2f> outPoints;
128
    vector<uchar> status;
129

130
    FormTrackingPointsArray(inPoints, frame1.cols, frame1.rows, nPointsX, nPointsY);
131
    outPoints.resize(inPoints.size());
132
    status.resize(inPoints.size());
133

134
    declare.in(frame1, frame2, inPoints).out(outPoints);
135

136
    TEST_CYCLE_N(30)
137
    {
138
        calcOpticalFlowPyrLK(frame1, frame2, inPoints, outPoints, status, cv::noArray(),
139
                             Size(winSize, winSize), maxLevel, criteria,
140
                             flags, minEigThreshold);
141
    }
142

143
    SANITY_CHECK_NOTHING();
144
}
145

146
typedef tuple<std::string, int, int, tuple<int,int>, int, bool> Path_Idx_Cn_NPoints_WSize_Deriv_t;
147
typedef TestBaseWithParam<Path_Idx_Cn_NPoints_WSize_Deriv_t> Path_Idx_Cn_NPoints_WSize_Deriv;
148

149
PERF_TEST_P(Path_Idx_Cn_NPoints_WSize_Deriv, OpticalFlowPyrLK_self, testing::Combine(
150
                testing::Values<std::string>("cv/optflow/frames/VGA_%02d.png", "cv/optflow/frames/720p_%02d.png"),
151
                testing::Range(1, 3),
152
                testing::Values(1, 3, 4),
153
                testing::Values(make_tuple(9, 9), make_tuple(15, 15)),
154
                testing::Values(7, 11),
155
                testing::Bool()
156
                )
157
            )
158
{
159
    string filename1 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam())));
160
    string filename2 = getDataPath(cv::format(get<0>(GetParam()).c_str(), get<1>(GetParam()) + 1));
161
    Mat img1 = imread(filename1);
162
    Mat img2 = imread(filename2);
163
    if (img1.empty()) FAIL() << "Unable to load source image " << filename1;
164
    if (img2.empty()) FAIL() << "Unable to load source image " << filename2;
165

166
    int cn = get<2>(GetParam());
167
    int nPointsX = std::min(get<0>(get<3>(GetParam())), img1.cols);
168
    int nPointsY = std::min(get<1>(get<3>(GetParam())), img1.rows);
169
    int winSize = get<4>(GetParam());
170
    bool withDerivatives = get<5>(GetParam());
171

172
    int maxLevel = 2;
173
    TermCriteria criteria(TermCriteria::COUNT|TermCriteria::EPS, 7, 0.001);
174
    int flags = 0;
175
    double minEigThreshold = 1e-4;
176

177
    Mat frame1, frame2;
178
    switch(cn)
179
    {
180
    case 1:
181
        cvtColor(img1, frame1, COLOR_BGR2GRAY, cn);
182
        cvtColor(img2, frame2, COLOR_BGR2GRAY, cn);
183
        break;
184
    case 3:
185
        frame1 = img1;
186
        frame2 = img2;
187
        break;
188
    case 4:
189
        cvtColor(img1, frame1, COLOR_BGR2BGRA, cn);
190
        cvtColor(img2, frame2, COLOR_BGR2BGRA, cn);
191
        break;
192
    default:
193
        FAIL() << "Unexpected number of channels: " << cn;
194
    }
195

196
    vector<Point2f> inPoints;
197
    vector<Point2f> outPoints;
198
    vector<uchar> status;
199
    vector<float> err;
200

201
    FormTrackingPointsArray(inPoints, frame1.cols, frame1.rows, nPointsX, nPointsY);
202
    outPoints.resize(inPoints.size());
203
    status.resize(inPoints.size());
204
    err.resize(inPoints.size());
205

206
    std::vector<Mat> pyramid1, pyramid2;
207

208
    maxLevel = buildOpticalFlowPyramid(frame1, pyramid1, Size(winSize, winSize), maxLevel, withDerivatives);
209
    maxLevel = buildOpticalFlowPyramid(frame2, pyramid2, Size(winSize, winSize), maxLevel, withDerivatives);
210

211
    declare.in(pyramid1, pyramid2, inPoints).out(outPoints);
212
    declare.time(400);
213

214
    int runs = 3;
215
    TEST_CYCLE_MULTIRUN(runs)
216
    {
217
        calcOpticalFlowPyrLK(pyramid1, pyramid2, inPoints, outPoints, status, err,
218
                             Size(winSize, winSize), maxLevel, criteria,
219
                             flags, minEigThreshold);
220
    }
221

222
    SANITY_CHECK_NOTHING();
223
}
224

225
CV_ENUM(PyrBorderMode, BORDER_DEFAULT, BORDER_TRANSPARENT)
226
typedef tuple<std::string, int, bool, PyrBorderMode, bool> Path_Win_Deriv_Border_Reuse_t;
227
typedef TestBaseWithParam<Path_Win_Deriv_Border_Reuse_t> Path_Win_Deriv_Border_Reuse;
228

229
PERF_TEST_P(Path_Win_Deriv_Border_Reuse, OpticalFlowPyrLK_pyr, testing::Combine(
230
                testing::Values<std::string>("cv/optflow/frames/720p_01.png"),
231
                testing::Values(7, 11),
232
                testing::Bool(),
233
                PyrBorderMode::all(),
234
                testing::Bool()
235
                )
236
            )
237
{
238
    string filename = getDataPath(get<0>(GetParam()));
239
    Mat img = imread(filename);
240
    Size winSize(get<1>(GetParam()), get<1>(GetParam()));
241
    bool withDerivatives = get<2>(GetParam());
242
    int derivBorder = get<3>(GetParam());
243
    int pyrBorder = derivBorder;
244
    if(derivBorder != BORDER_TRANSPARENT)
245
    {
246
        derivBorder = BORDER_CONSTANT;
247
        pyrBorder = BORDER_REFLECT_101;
248
    }
249
    bool tryReuseInputImage = get<4>(GetParam());
250
    std::vector<Mat> pyramid;
251

252
    img.adjustROI(winSize.height, winSize.height, winSize.width, winSize.width);
253

254
    int maxLevel = buildOpticalFlowPyramid(img, pyramid, winSize, 1000, withDerivatives, BORDER_CONSTANT, BORDER_CONSTANT, tryReuseInputImage);
255

256
    declare.in(img).out(pyramid);
257

258

259
    TEST_CYCLE()
260
    {
261
        buildOpticalFlowPyramid(img, pyramid, winSize, maxLevel, withDerivatives, pyrBorder, derivBorder, tryReuseInputImage);
262
    }
263

264
    size_t expected_layers = ((size_t)maxLevel + 1) * (withDerivatives ? 2 : 1);
265
    ASSERT_EQ(expected_layers, pyramid.size());
266
    SANITY_CHECK_NOTHING();
267
}
268

269
}} // namespace
270

271
Product

Resources

Company
