Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/modules/core/perf/perf_arithm.cpp
16354 views
1
#include "perf_precomp.hpp"

2


3
namespace opencv_test

4
{

5
using namespace perf;

6


7
typedef Size_MatType BinaryOpTest;

8


9
PERF_TEST_P_(BinaryOpTest, min)

10
{

11
    Size sz = get<0>(GetParam());

12
    int type = get<1>(GetParam());

13
    cv::Mat a = Mat(sz, type);

14
    cv::Mat b = Mat(sz, type);

15
    cv::Mat c = Mat(sz, type);

16


17
    declare.in(a, b, WARMUP_RNG).out(c);

18


19
    TEST_CYCLE() cv::min(a, b, c);

20


21
    SANITY_CHECK_NOTHING();

22
}

23


24
PERF_TEST_P_(BinaryOpTest, minScalarDouble)

25
{

26
    Size sz = get<0>(GetParam());

27
    int type = get<1>(GetParam());

28
    cv::Mat a = Mat(sz, type);

29
    cv::Scalar b;

30
    cv::Mat c = Mat(sz, type);

31


32
    declare.in(a, b, WARMUP_RNG).out(c);

33


34
    TEST_CYCLE() cv::min(a, b, c);

35


36
    SANITY_CHECK_NOTHING();

37
}

38


39
PERF_TEST_P_(BinaryOpTest, minScalarSameType)

40
{

41
    Size sz = get<0>(GetParam());

42
    int type = get<1>(GetParam());

43
    cv::Mat a = Mat(sz, type);

44
    cv::Scalar b;

45
    cv::Mat c = Mat(sz, type);

46


47
    declare.in(a, b, WARMUP_RNG).out(c);

48


49
    if (CV_MAT_DEPTH(type) < CV_32S)

50
    {

51
        b = Scalar(1, 0, 3, 4); // don't pass non-integer values for 8U/8S/16U/16S processing

52
    }

53
    else if (CV_MAT_DEPTH(type) == CV_32S)

54
    {

55
        b = Scalar(1, 0, -3, 4); // don't pass non-integer values for 32S processing

56
    }

57


58
    TEST_CYCLE() cv::min(a, b, c);

59


60
    SANITY_CHECK_NOTHING();

61
}

62


63
PERF_TEST_P_(BinaryOpTest, max)

64
{

65
    Size sz = get<0>(GetParam());

66
    int type = get<1>(GetParam());

67
    cv::Mat a = Mat(sz, type);

68
    cv::Mat b = Mat(sz, type);

69
    cv::Mat c = Mat(sz, type);

70


71
    declare.in(a, b, WARMUP_RNG).out(c);

72


73
    TEST_CYCLE() cv::max(a, b, c);

74


75
    SANITY_CHECK_NOTHING();

76
}

77


78
PERF_TEST_P_(BinaryOpTest, maxScalarDouble)

79
{

80
    Size sz = get<0>(GetParam());

81
    int type = get<1>(GetParam());

82
    cv::Mat a = Mat(sz, type);

83
    cv::Scalar b;

84
    cv::Mat c = Mat(sz, type);

85


86
    declare.in(a, b, WARMUP_RNG).out(c);

87


88
    TEST_CYCLE() cv::max(a, b, c);

89


90
    SANITY_CHECK_NOTHING();

91
}

92


93
PERF_TEST_P_(BinaryOpTest, maxScalarSameType)

94
{

95
    Size sz = get<0>(GetParam());

96
    int type = get<1>(GetParam());

97
    cv::Mat a = Mat(sz, type);

98
    cv::Scalar b;

99
    cv::Mat c = Mat(sz, type);

100


101
    declare.in(a, b, WARMUP_RNG).out(c);

102


103
    if (CV_MAT_DEPTH(type) < CV_32S)

104
    {

105
        b = Scalar(1, 0, 3, 4); // don't pass non-integer values for 8U/8S/16U/16S processing

106
    }

107
    else if (CV_MAT_DEPTH(type) == CV_32S)

108
    {

109
        b = Scalar(1, 0, -3, 4); // don't pass non-integer values for 32S processing

110
    }

111


112
    TEST_CYCLE() cv::max(a, b, c);

113


114
    SANITY_CHECK_NOTHING();

115
}

116


117
PERF_TEST_P_(BinaryOpTest, absdiff)

118
{

119
    Size sz = get<0>(GetParam());

120
    int type = get<1>(GetParam());

121
    cv::Mat a = Mat(sz, type);

122
    cv::Mat b = Mat(sz, type);

123
    cv::Mat c = Mat(sz, type);

124


125
    declare.in(a, b, WARMUP_RNG).out(c);

126


127
    if (CV_MAT_DEPTH(type) == CV_32S)

128
    {

129
        //see ticket 1529: absdiff can be without saturation on 32S

130
        a /= 2;

131
        b /= 2;

132
    }

133


134
    TEST_CYCLE() cv::absdiff(a, b, c);

135


136
    SANITY_CHECK_NOTHING();

137
}

138


139
PERF_TEST_P_(BinaryOpTest, absdiffScalarDouble)

140
{

141
    Size sz = get<0>(GetParam());

142
    int type = get<1>(GetParam());

143
    cv::Mat a = Mat(sz, type);

144
    cv::Scalar b;

145
    cv::Mat c = Mat(sz, type);

146


147
    declare.in(a, b, WARMUP_RNG).out(c);

148


149
    if (CV_MAT_DEPTH(type) == CV_32S)

150
    {

151
        //see ticket 1529: absdiff can be without saturation on 32S

152
        a /= 2;

153
        b /= 2;

154
    }

155


156
    TEST_CYCLE() cv::absdiff(a, b, c);

157


158
    SANITY_CHECK_NOTHING();

159
}

160


161
PERF_TEST_P_(BinaryOpTest, absdiffScalarSameType)

162
{

163
    Size sz = get<0>(GetParam());

164
    int type = get<1>(GetParam());

165
    cv::Mat a = Mat(sz, type);

166
    cv::Scalar b;

167
    cv::Mat c = Mat(sz, type);

168


169
    declare.in(a, b, WARMUP_RNG).out(c);

170


171
    if (CV_MAT_DEPTH(type) < CV_32S)

172
    {

173
        b = Scalar(1, 0, 3, 4); // don't pass non-integer values for 8U/8S/16U/16S processing

174
    }

175
    else if (CV_MAT_DEPTH(type) == CV_32S)

176
    {

177
        //see ticket 1529: absdiff can be without saturation on 32S

178
        a /= 2;

179
        b = Scalar(1, 0, -3, 4); // don't pass non-integer values for 32S processing

180
    }

181


182
    TEST_CYCLE() cv::absdiff(a, b, c);

183


184
    SANITY_CHECK_NOTHING();

185
}

186


187
PERF_TEST_P_(BinaryOpTest, add)

188
{

189
    Size sz = get<0>(GetParam());

190
    int type = get<1>(GetParam());

191
    cv::Mat a = Mat(sz, type);

192
    cv::Mat b = Mat(sz, type);

193
    cv::Mat c = Mat(sz, type);

194


195
    declare.in(a, b, WARMUP_RNG).out(c);

196
    declare.time(50);

197


198
    if (CV_MAT_DEPTH(type) == CV_32S)

199
    {

200
        //see ticket 1529: add can be without saturation on 32S

201
        a /= 2;

202
        b /= 2;

203
    }

204


205
    TEST_CYCLE() cv::add(a, b, c);

206


207
    SANITY_CHECK_NOTHING();

208
}

209


210
PERF_TEST_P_(BinaryOpTest, addScalarDouble)

211
{

212
    Size sz = get<0>(GetParam());

213
    int type = get<1>(GetParam());

214
    cv::Mat a = Mat(sz, type);

215
    cv::Scalar b;

216
    cv::Mat c = Mat(sz, type);

217


218
    declare.in(a, b, WARMUP_RNG).out(c);

219


220
    if (CV_MAT_DEPTH(type) == CV_32S)

221
    {

222
        //see ticket 1529: add can be without saturation on 32S

223
        a /= 2;

224
        b /= 2;

225
    }

226


227
    TEST_CYCLE() cv::add(a, b, c);

228


229
    SANITY_CHECK_NOTHING();

230
}

231


232
PERF_TEST_P_(BinaryOpTest, addScalarSameType)

233
{

234
    Size sz = get<0>(GetParam());

235
    int type = get<1>(GetParam());

236
    cv::Mat a = Mat(sz, type);

237
    cv::Scalar b;

238
    cv::Mat c = Mat(sz, type);

239


240
    declare.in(a, b, WARMUP_RNG).out(c);

241


242
    if (CV_MAT_DEPTH(type) < CV_32S)

243
    {

244
        b = Scalar(1, 0, 3, 4); // don't pass non-integer values for 8U/8S/16U/16S processing

245
    }

246
    else if (CV_MAT_DEPTH(type) == CV_32S)

247
    {

248
        //see ticket 1529: add can be without saturation on 32S

249
        a /= 2;

250
        b = Scalar(1, 0, -3, 4); // don't pass non-integer values for 32S processing

251
    }

252


253
    TEST_CYCLE() cv::add(a, b, c, noArray(), type);

254


255
    SANITY_CHECK_NOTHING();

256
}

257


258
PERF_TEST_P_(BinaryOpTest, subtract)

259
{

260
    Size sz = get<0>(GetParam());

261
    int type = get<1>(GetParam());

262
    cv::Mat a = Mat(sz, type);

263
    cv::Mat b = Mat(sz, type);

264
    cv::Mat c = Mat(sz, type);

265


266
    declare.in(a, b, WARMUP_RNG).out(c);

267


268
    if (CV_MAT_DEPTH(type) == CV_32S)

269
    {

270
        //see ticket 1529: subtract can be without saturation on 32S

271
        a /= 2;

272
        b /= 2;

273
    }

274


275
    TEST_CYCLE() cv::subtract(a, b, c);

276


277
    SANITY_CHECK_NOTHING();

278
}

279


280
PERF_TEST_P_(BinaryOpTest, subtractScalarDouble)

281
{

282
    Size sz = get<0>(GetParam());

283
    int type = get<1>(GetParam());

284
    cv::Mat a = Mat(sz, type);

285
    cv::Scalar b;

286
    cv::Mat c = Mat(sz, type);

287


288
    declare.in(a, b, WARMUP_RNG).out(c);

289


290
    if (CV_MAT_DEPTH(type) == CV_32S)

291
    {

292
        //see ticket 1529: subtract can be without saturation on 32S

293
        a /= 2;

294
        b /= 2;

295
    }

296


297
    TEST_CYCLE() cv::subtract(a, b, c);

298


299
    SANITY_CHECK_NOTHING();

300
}

301


302
PERF_TEST_P_(BinaryOpTest, subtractScalarSameType)

303
{

304
    Size sz = get<0>(GetParam());

305
    int type = get<1>(GetParam());

306
    cv::Mat a = Mat(sz, type);

307
    cv::Scalar b;

308
    cv::Mat c = Mat(sz, type);

309


310
    declare.in(a, b, WARMUP_RNG).out(c);

311


312
    if (CV_MAT_DEPTH(type) < CV_32S)

313
    {

314
        b = Scalar(1, 0, 3, 4); // don't pass non-integer values for 8U/8S/16U/16S processing

315
    }

316
    else if (CV_MAT_DEPTH(type) == CV_32S)

317
    {

318
        //see ticket 1529: subtract can be without saturation on 32S

319
        a /= 2;

320
        b = Scalar(1, 0, -3, 4); // don't pass non-integer values for 32S processing

321
    }

322


323
    TEST_CYCLE() cv::subtract(a, b, c, noArray(), type);

324


325
    SANITY_CHECK_NOTHING();

326
}

327


328
PERF_TEST_P_(BinaryOpTest, multiply)

329
{

330
    Size sz = get<0>(GetParam());

331
    int type = get<1>(GetParam());

332
    cv::Mat a(sz, type), b(sz, type), c(sz, type);

333


334
    declare.in(a, b, WARMUP_RNG).out(c);

335
    if (CV_MAT_DEPTH(type) == CV_32S)

336
    {

337
        //According to docs, saturation is not applied when result is 32bit integer

338
        a /= (2 << 16);

339
        b /= (2 << 16);

340
    }

341


342
    TEST_CYCLE() cv::multiply(a, b, c);

343


344
    SANITY_CHECK_NOTHING();

345
}

346


347
PERF_TEST_P_(BinaryOpTest, multiplyScale)

348
{

349
    Size sz = get<0>(GetParam());

350
    int type = get<1>(GetParam());

351
    cv::Mat a(sz, type), b(sz, type), c(sz, type);

352
    double scale = 0.5;

353


354
    declare.in(a, b, WARMUP_RNG).out(c);

355


356
    if (CV_MAT_DEPTH(type) == CV_32S)

357
    {

358
        //According to docs, saturation is not applied when result is 32bit integer

359
        a /= (2 << 16);

360
        b /= (2 << 16);

361
    }

362


363
    TEST_CYCLE() cv::multiply(a, b, c, scale);

364


365
    SANITY_CHECK_NOTHING();

366
}

367


368
PERF_TEST_P_(BinaryOpTest, divide)

369
{

370
    Size sz = get<0>(GetParam());

371
    int type = get<1>(GetParam());

372
    cv::Mat a(sz, type), b(sz, type), c(sz, type);

373
    double scale = 0.5;

374


375
    declare.in(a, b, WARMUP_RNG).out(c);

376


377
    TEST_CYCLE() cv::divide(a, b, c, scale);

378


379
    SANITY_CHECK_NOTHING();

380
}

381


382
PERF_TEST_P_(BinaryOpTest, reciprocal)

383
{

384
    Size sz = get<0>(GetParam());

385
    int type = get<1>(GetParam());

386
    cv::Mat b(sz, type), c(sz, type);

387
    double scale = 0.5;

388


389
    declare.in(b, WARMUP_RNG).out(c);

390


391
    TEST_CYCLE() cv::divide(scale, b, c);

392


393
    SANITY_CHECK_NOTHING();

394
}

395


396
INSTANTIATE_TEST_CASE_P(/*nothing*/ , BinaryOpTest,

397
    testing::Combine(

398
        testing::Values(szVGA, sz720p, sz1080p),

399
        testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1)

400
    )

401
);

402


403
} // namespace

404


405