← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/modules/cudaimgproc/test/test_color.cpp

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/modules/cudaimgproc/test/test_color.cpp
 
1
/*M///////////////////////////////////////////////////////////////////////////////////////
 
2
//
 
3
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 
4
//
 
5
//  By downloading, copying, installing or using the software you agree to this license.
 
6
//  If you do not agree to this license, do not download, install,
 
7
//  copy or use the software.
 
8
//
 
9
//
 
10
//                           License Agreement
 
11
//                For Open Source Computer Vision Library
 
12
//
 
13
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
 
14
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
 
15
// Third party copyrights are property of their respective owners.
 
16
//
 
17
// Redistribution and use in source and binary forms, with or without modification,
 
18
// are permitted provided that the following conditions are met:
 
19
//
 
20
//   * Redistribution's of source code must retain the above copyright notice,
 
21
//     this list of conditions and the following disclaimer.
 
22
//
 
23
//   * Redistribution's in binary form must reproduce the above copyright notice,
 
24
//     this list of conditions and the following disclaimer in the documentation
 
25
//     and/or other materials provided with the distribution.
 
26
//
 
27
//   * The name of the copyright holders may not be used to endorse or promote products
 
28
//     derived from this software without specific prior written permission.
 
29
//
 
30
// This software is provided by the copyright holders and contributors "as is" and
 
31
// any express or implied warranties, including, but not limited to, the implied
 
32
// warranties of merchantability and fitness for a particular purpose are disclaimed.
 
33
// In no event shall the Intel Corporation or contributors be liable for any direct,
 
34
// indirect, incidental, special, exemplary, or consequential damages
 
35
// (including, but not limited to, procurement of substitute goods or services;
 
36
// loss of use, data, or profits; or business interruption) however caused
 
37
// and on any theory of liability, whether in contract, strict liability,
 
38
// or tort (including negligence or otherwise) arising in any way out of
 
39
// the use of this software, even if advised of the possibility of such damage.
 
40
//
 
41
//M*/
 
42
 
 
43
#include "test_precomp.hpp"
 
44
 
 
45
#ifdef HAVE_CUDA
 
46
 
 
47
using namespace cvtest;
 
48
 
 
49
///////////////////////////////////////////////////////////////////////////////////////////////////////
 
50
// cvtColor
 
51
 
 
52
PARAM_TEST_CASE(CvtColor, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
53
{
 
54
    cv::cuda::DeviceInfo devInfo;
 
55
    cv::Size size;
 
56
    int depth;
 
57
    bool useRoi;
 
58
 
 
59
    cv::Mat img;
 
60
 
 
61
    virtual void SetUp()
 
62
    {
 
63
        devInfo = GET_PARAM(0);
 
64
        size = GET_PARAM(1);
 
65
        depth = GET_PARAM(2);
 
66
        useRoi = GET_PARAM(3);
 
67
 
 
68
        cv::cuda::setDevice(devInfo.deviceID());
 
69
 
 
70
        img = randomMat(size, CV_MAKE_TYPE(depth, 3), 0.0, depth == CV_32F ? 1.0 : 255.0);
 
71
    }
 
72
};
 
73
 
 
74
CUDA_TEST_P(CvtColor, BGR2RGB)
 
75
{
 
76
    cv::Mat src = img;
 
77
 
 
78
    cv::cuda::GpuMat dst;
 
79
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
 
80
 
 
81
    cv::Mat dst_gold;
 
82
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
 
83
 
 
84
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
85
}
 
86
 
 
87
CUDA_TEST_P(CvtColor, BGR2RGBA)
 
88
{
 
89
    cv::Mat src = img;
 
90
 
 
91
    cv::cuda::GpuMat dst;
 
92
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
 
93
 
 
94
    cv::Mat dst_gold;
 
95
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
 
96
 
 
97
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
98
}
 
99
 
 
100
CUDA_TEST_P(CvtColor, BGR2BGRA)
 
101
{
 
102
    cv::Mat src = img;
 
103
 
 
104
    cv::cuda::GpuMat dst;
 
105
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
 
106
 
 
107
    cv::Mat dst_gold;
 
108
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
 
109
 
 
110
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
111
}
 
112
 
 
113
CUDA_TEST_P(CvtColor, BGRA2RGB)
 
114
{
 
115
    cv::Mat src;
 
116
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
117
 
 
118
    cv::cuda::GpuMat dst;
 
119
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
 
120
 
 
121
    cv::Mat dst_gold;
 
122
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
 
123
 
 
124
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
125
}
 
126
 
 
127
CUDA_TEST_P(CvtColor, BGRA2BGR)
 
128
{
 
129
    cv::Mat src;
 
130
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
131
 
 
132
    cv::cuda::GpuMat dst;
 
133
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
 
134
 
 
135
    cv::Mat dst_gold;
 
136
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
 
137
 
 
138
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
139
}
 
140
 
 
141
CUDA_TEST_P(CvtColor, BGRA2RGBA)
 
142
{
 
143
    cv::Mat src;
 
144
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
145
 
 
146
    cv::cuda::GpuMat dst;
 
147
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
 
148
 
 
149
    cv::Mat dst_gold;
 
150
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
151
 
 
152
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
153
}
 
154
 
 
155
CUDA_TEST_P(CvtColor, BGR2GRAY)
 
156
{
 
157
    cv::Mat src = img;
 
158
 
 
159
    cv::cuda::GpuMat dst;
 
160
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
 
161
 
 
162
    cv::Mat dst_gold;
 
163
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
 
164
 
 
165
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
166
}
 
167
 
 
168
CUDA_TEST_P(CvtColor, RGB2GRAY)
 
169
{
 
170
    cv::Mat src = img;
 
171
 
 
172
    cv::cuda::GpuMat dst;
 
173
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
 
174
 
 
175
    cv::Mat dst_gold;
 
176
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
 
177
 
 
178
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
179
}
 
180
 
 
181
CUDA_TEST_P(CvtColor, GRAY2BGR)
 
182
{
 
183
    cv::Mat src;
 
184
    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
185
 
 
186
    cv::cuda::GpuMat dst;
 
187
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
 
188
 
 
189
    cv::Mat dst_gold;
 
190
    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
 
191
 
 
192
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
193
}
 
194
 
 
195
CUDA_TEST_P(CvtColor, GRAY2BGRA)
 
196
{
 
197
    cv::Mat src;
 
198
    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
199
 
 
200
    cv::cuda::GpuMat dst;
 
201
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
 
202
 
 
203
    cv::Mat dst_gold;
 
204
    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
 
205
 
 
206
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
207
}
 
208
 
 
209
CUDA_TEST_P(CvtColor, BGRA2GRAY)
 
210
{
 
211
    cv::Mat src;
 
212
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
213
 
 
214
    cv::cuda::GpuMat dst;
 
215
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
 
216
 
 
217
    cv::Mat dst_gold;
 
218
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
 
219
 
 
220
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
221
}
 
222
 
 
223
CUDA_TEST_P(CvtColor, RGBA2GRAY)
 
224
{
 
225
    cv::Mat src;
 
226
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
227
 
 
228
    cv::cuda::GpuMat dst;
 
229
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
 
230
 
 
231
    cv::Mat dst_gold;
 
232
    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
 
233
 
 
234
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
235
}
 
236
 
 
237
CUDA_TEST_P(CvtColor, BGR2BGR565)
 
238
{
 
239
    if (depth != CV_8U)
 
240
        return;
 
241
 
 
242
    cv::Mat src = img;
 
243
 
 
244
    cv::cuda::GpuMat dst;
 
245
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
 
246
 
 
247
    cv::Mat dst_gold;
 
248
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
 
249
 
 
250
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
251
}
 
252
 
 
253
CUDA_TEST_P(CvtColor, RGB2BGR565)
 
254
{
 
255
    if (depth != CV_8U)
 
256
        return;
 
257
 
 
258
    cv::Mat src = img;
 
259
 
 
260
    cv::cuda::GpuMat dst;
 
261
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
 
262
 
 
263
    cv::Mat dst_gold;
 
264
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
 
265
 
 
266
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
267
}
 
268
 
 
269
CUDA_TEST_P(CvtColor, BGR5652BGR)
 
270
{
 
271
    if (depth != CV_8U)
 
272
        return;
 
273
 
 
274
    cv::Mat src;
 
275
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
276
 
 
277
    cv::cuda::GpuMat dst;
 
278
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
 
279
 
 
280
    cv::Mat dst_gold;
 
281
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
 
282
 
 
283
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
284
}
 
285
 
 
286
CUDA_TEST_P(CvtColor, BGR5652RGB)
 
287
{
 
288
    if (depth != CV_8U)
 
289
        return;
 
290
 
 
291
    cv::Mat src;
 
292
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
293
 
 
294
    cv::cuda::GpuMat dst;
 
295
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
 
296
 
 
297
    cv::Mat dst_gold;
 
298
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
 
299
 
 
300
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
301
}
 
302
 
 
303
CUDA_TEST_P(CvtColor, BGRA2BGR565)
 
304
{
 
305
    if (depth != CV_8U)
 
306
        return;
 
307
 
 
308
    cv::Mat src;
 
309
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
310
 
 
311
    cv::cuda::GpuMat dst;
 
312
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
 
313
 
 
314
    cv::Mat dst_gold;
 
315
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
 
316
 
 
317
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
318
}
 
319
 
 
320
CUDA_TEST_P(CvtColor, RGBA2BGR565)
 
321
{
 
322
    if (depth != CV_8U)
 
323
        return;
 
324
 
 
325
    cv::Mat src;
 
326
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
327
 
 
328
    cv::cuda::GpuMat dst;
 
329
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
 
330
 
 
331
    cv::Mat dst_gold;
 
332
    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
 
333
 
 
334
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
335
}
 
336
 
 
337
CUDA_TEST_P(CvtColor, BGR5652BGRA)
 
338
{
 
339
    if (depth != CV_8U)
 
340
        return;
 
341
 
 
342
    cv::Mat src;
 
343
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
344
 
 
345
    cv::cuda::GpuMat dst;
 
346
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
 
347
 
 
348
    cv::Mat dst_gold;
 
349
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
 
350
 
 
351
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
352
}
 
353
 
 
354
CUDA_TEST_P(CvtColor, BGR5652RGBA)
 
355
{
 
356
    if (depth != CV_8U)
 
357
        return;
 
358
 
 
359
    cv::Mat src;
 
360
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
361
 
 
362
    cv::cuda::GpuMat dst;
 
363
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
 
364
 
 
365
    cv::Mat dst_gold;
 
366
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
 
367
 
 
368
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
369
}
 
370
 
 
371
CUDA_TEST_P(CvtColor, GRAY2BGR565)
 
372
{
 
373
    if (depth != CV_8U)
 
374
        return;
 
375
 
 
376
    cv::Mat src;
 
377
    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
378
 
 
379
    cv::cuda::GpuMat dst;
 
380
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
 
381
 
 
382
    cv::Mat dst_gold;
 
383
    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
 
384
 
 
385
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
386
}
 
387
 
 
388
CUDA_TEST_P(CvtColor, BGR5652GRAY)
 
389
{
 
390
    if (depth != CV_8U)
 
391
        return;
 
392
 
 
393
    cv::Mat src;
 
394
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
395
 
 
396
    cv::cuda::GpuMat dst;
 
397
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
 
398
 
 
399
    cv::Mat dst_gold;
 
400
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
 
401
 
 
402
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
403
}
 
404
 
 
405
CUDA_TEST_P(CvtColor, BGR2BGR555)
 
406
{
 
407
    if (depth != CV_8U)
 
408
        return;
 
409
 
 
410
    cv::Mat src = img;
 
411
 
 
412
    cv::cuda::GpuMat dst;
 
413
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
 
414
 
 
415
    cv::Mat dst_gold;
 
416
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
 
417
 
 
418
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
419
}
 
420
 
 
421
CUDA_TEST_P(CvtColor, RGB2BGR555)
 
422
{
 
423
    if (depth != CV_8U)
 
424
        return;
 
425
 
 
426
    cv::Mat src = img;
 
427
 
 
428
    cv::cuda::GpuMat dst;
 
429
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
 
430
 
 
431
    cv::Mat dst_gold;
 
432
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
 
433
 
 
434
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
435
}
 
436
 
 
437
CUDA_TEST_P(CvtColor, BGR5552BGR)
 
438
{
 
439
    if (depth != CV_8U)
 
440
        return;
 
441
 
 
442
    cv::Mat src;
 
443
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
444
 
 
445
    cv::cuda::GpuMat dst;
 
446
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
 
447
 
 
448
    cv::Mat dst_gold;
 
449
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
 
450
 
 
451
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
452
}
 
453
 
 
454
CUDA_TEST_P(CvtColor, BGR5552RGB)
 
455
{
 
456
    if (depth != CV_8U)
 
457
        return;
 
458
 
 
459
    cv::Mat src;
 
460
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
461
 
 
462
    cv::cuda::GpuMat dst;
 
463
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
 
464
 
 
465
    cv::Mat dst_gold;
 
466
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
 
467
 
 
468
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
469
}
 
470
 
 
471
CUDA_TEST_P(CvtColor, BGRA2BGR555)
 
472
{
 
473
    if (depth != CV_8U)
 
474
        return;
 
475
 
 
476
    cv::Mat src;
 
477
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
478
 
 
479
    cv::cuda::GpuMat dst;
 
480
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
 
481
 
 
482
    cv::Mat dst_gold;
 
483
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
 
484
 
 
485
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
486
}
 
487
 
 
488
CUDA_TEST_P(CvtColor, RGBA2BGR555)
 
489
{
 
490
    if (depth != CV_8U)
 
491
        return;
 
492
 
 
493
    cv::Mat src;
 
494
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
495
 
 
496
    cv::cuda::GpuMat dst;
 
497
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
 
498
 
 
499
    cv::Mat dst_gold;
 
500
    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
 
501
 
 
502
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
503
}
 
504
 
 
505
CUDA_TEST_P(CvtColor, BGR5552BGRA)
 
506
{
 
507
    if (depth != CV_8U)
 
508
        return;
 
509
 
 
510
    cv::Mat src;
 
511
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
512
 
 
513
    cv::cuda::GpuMat dst;
 
514
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
 
515
 
 
516
    cv::Mat dst_gold;
 
517
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
 
518
 
 
519
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
520
}
 
521
 
 
522
CUDA_TEST_P(CvtColor, BGR5552RGBA)
 
523
{
 
524
    if (depth != CV_8U)
 
525
        return;
 
526
 
 
527
    cv::Mat src;
 
528
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
529
 
 
530
    cv::cuda::GpuMat dst;
 
531
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
 
532
 
 
533
    cv::Mat dst_gold;
 
534
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
 
535
 
 
536
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
537
}
 
538
 
 
539
CUDA_TEST_P(CvtColor, GRAY2BGR555)
 
540
{
 
541
    if (depth != CV_8U)
 
542
        return;
 
543
 
 
544
    cv::Mat src;
 
545
    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
546
 
 
547
    cv::cuda::GpuMat dst;
 
548
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
 
549
 
 
550
    cv::Mat dst_gold;
 
551
    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
 
552
 
 
553
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
554
}
 
555
 
 
556
CUDA_TEST_P(CvtColor, BGR5552GRAY)
 
557
{
 
558
    if (depth != CV_8U)
 
559
        return;
 
560
 
 
561
    cv::Mat src;
 
562
    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
563
 
 
564
    cv::cuda::GpuMat dst;
 
565
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
 
566
 
 
567
    cv::Mat dst_gold;
 
568
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
 
569
 
 
570
    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 
571
}
 
572
 
 
573
CUDA_TEST_P(CvtColor, BGR2XYZ)
 
574
{
 
575
    cv::Mat src = img;
 
576
 
 
577
    cv::cuda::GpuMat dst;
 
578
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
 
579
 
 
580
    cv::Mat dst_gold;
 
581
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
582
 
 
583
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
584
}
 
585
 
 
586
CUDA_TEST_P(CvtColor, RGB2XYZ)
 
587
{
 
588
    cv::Mat src = img;
 
589
 
 
590
    cv::cuda::GpuMat dst;
 
591
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
 
592
 
 
593
    cv::Mat dst_gold;
 
594
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
 
595
 
 
596
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
597
}
 
598
 
 
599
CUDA_TEST_P(CvtColor, BGR2XYZ4)
 
600
{
 
601
    cv::Mat src = img;
 
602
 
 
603
    cv::cuda::GpuMat dst;
 
604
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
605
 
 
606
    ASSERT_EQ(4, dst.channels());
 
607
 
 
608
    cv::Mat dst_gold;
 
609
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
610
 
 
611
    cv::Mat h_dst(dst);
 
612
 
 
613
    cv::Mat channels[4];
 
614
    cv::split(h_dst, channels);
 
615
    cv::merge(channels, 3, h_dst);
 
616
 
 
617
    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 
618
}
 
619
 
 
620
CUDA_TEST_P(CvtColor, BGRA2XYZ4)
 
621
{
 
622
    cv::Mat src;
 
623
    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
624
 
 
625
    cv::cuda::GpuMat dst;
 
626
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
627
 
 
628
    ASSERT_EQ(4, dst.channels());
 
629
 
 
630
    cv::Mat dst_gold;
 
631
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
632
 
 
633
    cv::Mat h_dst(dst);
 
634
 
 
635
    cv::Mat channels[4];
 
636
    cv::split(h_dst, channels);
 
637
    cv::merge(channels, 3, h_dst);
 
638
 
 
639
    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 
640
}
 
641
 
 
642
CUDA_TEST_P(CvtColor, XYZ2BGR)
 
643
{
 
644
    cv::Mat src;
 
645
    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
646
 
 
647
    cv::cuda::GpuMat dst;
 
648
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
649
 
 
650
    cv::Mat dst_gold;
 
651
    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
652
 
 
653
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
654
}
 
655
 
 
656
CUDA_TEST_P(CvtColor, XYZ2RGB)
 
657
{
 
658
    cv::Mat src;
 
659
    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
660
 
 
661
    cv::cuda::GpuMat dst;
 
662
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
 
663
 
 
664
    cv::Mat dst_gold;
 
665
    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
 
666
 
 
667
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
668
}
 
669
 
 
670
CUDA_TEST_P(CvtColor, XYZ42BGR)
 
671
{
 
672
    cv::Mat src;
 
673
    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
674
 
 
675
    cv::Mat dst_gold;
 
676
    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
677
 
 
678
    cv::Mat channels[4];
 
679
    cv::split(src, channels);
 
680
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
681
    cv::merge(channels, 4, src);
 
682
 
 
683
    cv::cuda::GpuMat dst;
 
684
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
685
 
 
686
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
687
}
 
688
 
 
689
CUDA_TEST_P(CvtColor, XYZ42BGRA)
 
690
{
 
691
    cv::Mat src;
 
692
    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
693
 
 
694
    cv::Mat dst_gold;
 
695
    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
 
696
 
 
697
    cv::Mat channels[4];
 
698
    cv::split(src, channels);
 
699
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
700
    cv::merge(channels, 4, src);
 
701
 
 
702
    cv::cuda::GpuMat dst;
 
703
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
 
704
 
 
705
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
706
}
 
707
 
 
708
CUDA_TEST_P(CvtColor, BGR2YCrCb)
 
709
{
 
710
    cv::Mat src = img;
 
711
 
 
712
    cv::cuda::GpuMat dst;
 
713
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
 
714
 
 
715
    cv::Mat dst_gold;
 
716
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
717
 
 
718
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
719
}
 
720
 
 
721
CUDA_TEST_P(CvtColor, RGB2YCrCb)
 
722
{
 
723
    cv::Mat src = img;
 
724
 
 
725
    cv::cuda::GpuMat dst;
 
726
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
 
727
 
 
728
    cv::Mat dst_gold;
 
729
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
 
730
 
 
731
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
732
}
 
733
 
 
734
CUDA_TEST_P(CvtColor, BGR2YCrCb4)
 
735
{
 
736
    cv::Mat src = img;
 
737
 
 
738
    cv::cuda::GpuMat dst;
 
739
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
740
 
 
741
    ASSERT_EQ(4, dst.channels());
 
742
 
 
743
    cv::Mat dst_gold;
 
744
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
745
 
 
746
    cv::Mat h_dst(dst);
 
747
 
 
748
    cv::Mat channels[4];
 
749
    cv::split(h_dst, channels);
 
750
    cv::merge(channels, 3, h_dst);
 
751
 
 
752
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
753
}
 
754
 
 
755
CUDA_TEST_P(CvtColor, RGBA2YCrCb4)
 
756
{
 
757
    cv::Mat src;
 
758
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
759
 
 
760
    cv::cuda::GpuMat dst;
 
761
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
762
 
 
763
    ASSERT_EQ(4, dst.channels());
 
764
 
 
765
    cv::Mat dst_gold;
 
766
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
767
 
 
768
    cv::Mat h_dst(dst);
 
769
 
 
770
    cv::Mat channels[4];
 
771
    cv::split(h_dst, channels);
 
772
    cv::merge(channels, 3, h_dst);
 
773
 
 
774
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
775
}
 
776
 
 
777
CUDA_TEST_P(CvtColor, YCrCb2BGR)
 
778
{
 
779
    cv::Mat src;
 
780
    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
781
 
 
782
    cv::cuda::GpuMat dst;
 
783
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
 
784
 
 
785
    cv::Mat dst_gold;
 
786
    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
 
787
 
 
788
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
789
}
 
790
 
 
791
CUDA_TEST_P(CvtColor, YCrCb2RGB)
 
792
{
 
793
    cv::Mat src;
 
794
    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
795
 
 
796
    cv::cuda::GpuMat dst;
 
797
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
798
 
 
799
    cv::Mat dst_gold;
 
800
    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
801
 
 
802
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
803
}
 
804
 
 
805
CUDA_TEST_P(CvtColor, YCrCb42RGB)
 
806
{
 
807
    cv::Mat src;
 
808
    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
809
 
 
810
    cv::Mat dst_gold;
 
811
    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
812
 
 
813
    cv::Mat channels[4];
 
814
    cv::split(src, channels);
 
815
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
816
    cv::merge(channels, 4, src);
 
817
 
 
818
    cv::cuda::GpuMat dst;
 
819
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
820
 
 
821
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
822
}
 
823
 
 
824
CUDA_TEST_P(CvtColor, YCrCb42RGBA)
 
825
{
 
826
    cv::Mat src;
 
827
    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
828
 
 
829
    cv::Mat dst_gold;
 
830
    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
 
831
 
 
832
    cv::Mat channels[4];
 
833
    cv::split(src, channels);
 
834
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
835
    cv::merge(channels, 4, src);
 
836
 
 
837
    cv::cuda::GpuMat dst;
 
838
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
 
839
 
 
840
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
841
}
 
842
 
 
843
CUDA_TEST_P(CvtColor, BGR2HSV)
 
844
{
 
845
    if (depth == CV_16U)
 
846
        return;
 
847
 
 
848
    cv::Mat src = img;
 
849
 
 
850
    cv::cuda::GpuMat dst;
 
851
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
 
852
 
 
853
    cv::Mat dst_gold;
 
854
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
 
855
 
 
856
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
857
}
 
858
 
 
859
CUDA_TEST_P(CvtColor, RGB2HSV)
 
860
{
 
861
    if (depth == CV_16U)
 
862
        return;
 
863
 
 
864
    cv::Mat src = img;
 
865
 
 
866
    cv::cuda::GpuMat dst;
 
867
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
 
868
 
 
869
    cv::Mat dst_gold;
 
870
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
871
 
 
872
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
873
}
 
874
 
 
875
CUDA_TEST_P(CvtColor, RGB2HSV4)
 
876
{
 
877
    if (depth == CV_16U)
 
878
        return;
 
879
 
 
880
    cv::Mat src = img;
 
881
 
 
882
    cv::cuda::GpuMat dst;
 
883
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
884
 
 
885
    ASSERT_EQ(4, dst.channels());
 
886
 
 
887
    cv::Mat dst_gold;
 
888
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
889
 
 
890
    cv::Mat h_dst(dst);
 
891
 
 
892
    cv::Mat channels[4];
 
893
    cv::split(h_dst, channels);
 
894
    cv::merge(channels, 3, h_dst);
 
895
 
 
896
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
897
}
 
898
 
 
899
CUDA_TEST_P(CvtColor, RGBA2HSV4)
 
900
{
 
901
    if (depth == CV_16U)
 
902
        return;
 
903
 
 
904
    cv::Mat src;
 
905
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
906
 
 
907
    cv::cuda::GpuMat dst;
 
908
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
909
 
 
910
    ASSERT_EQ(4, dst.channels());
 
911
 
 
912
    cv::Mat dst_gold;
 
913
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
914
 
 
915
    cv::Mat h_dst(dst);
 
916
 
 
917
    cv::Mat channels[4];
 
918
    cv::split(h_dst, channels);
 
919
    cv::merge(channels, 3, h_dst);
 
920
 
 
921
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
922
}
 
923
 
 
924
CUDA_TEST_P(CvtColor, BGR2HLS)
 
925
{
 
926
    if (depth == CV_16U)
 
927
        return;
 
928
 
 
929
    cv::Mat src = img;
 
930
 
 
931
    cv::cuda::GpuMat dst;
 
932
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
 
933
 
 
934
    cv::Mat dst_gold;
 
935
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
 
936
 
 
937
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
938
}
 
939
 
 
940
CUDA_TEST_P(CvtColor, RGB2HLS)
 
941
{
 
942
    if (depth == CV_16U)
 
943
        return;
 
944
 
 
945
    cv::Mat src = img;
 
946
 
 
947
    cv::cuda::GpuMat dst;
 
948
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
 
949
 
 
950
    cv::Mat dst_gold;
 
951
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
952
 
 
953
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
954
}
 
955
 
 
956
CUDA_TEST_P(CvtColor, RGB2HLS4)
 
957
{
 
958
    if (depth == CV_16U)
 
959
        return;
 
960
 
 
961
    cv::Mat src = img;
 
962
 
 
963
    cv::cuda::GpuMat dst;
 
964
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
965
 
 
966
    ASSERT_EQ(4, dst.channels());
 
967
 
 
968
    cv::Mat dst_gold;
 
969
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
970
 
 
971
    cv::Mat h_dst(dst);
 
972
 
 
973
    cv::Mat channels[4];
 
974
    cv::split(h_dst, channels);
 
975
    cv::merge(channels, 3, h_dst);
 
976
 
 
977
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
978
}
 
979
 
 
980
CUDA_TEST_P(CvtColor, RGBA2HLS4)
 
981
{
 
982
    if (depth == CV_16U)
 
983
        return;
 
984
 
 
985
    cv::Mat src;
 
986
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
987
 
 
988
    cv::cuda::GpuMat dst;
 
989
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
990
 
 
991
    ASSERT_EQ(4, dst.channels());
 
992
 
 
993
    cv::Mat dst_gold;
 
994
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
995
 
 
996
    cv::Mat h_dst(dst);
 
997
 
 
998
    cv::Mat channels[4];
 
999
    cv::split(h_dst, channels);
 
1000
    cv::merge(channels, 3, h_dst);
 
1001
 
 
1002
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
1003
}
 
1004
 
 
1005
CUDA_TEST_P(CvtColor, HSV2BGR)
 
1006
{
 
1007
    if (depth == CV_16U)
 
1008
        return;
 
1009
 
 
1010
    cv::Mat src;
 
1011
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
1012
 
 
1013
    cv::cuda::GpuMat dst;
 
1014
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
1015
 
 
1016
    cv::Mat dst_gold;
 
1017
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
1018
 
 
1019
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1020
}
 
1021
 
 
1022
CUDA_TEST_P(CvtColor, HSV2RGB)
 
1023
{
 
1024
    if (depth == CV_16U)
 
1025
        return;
 
1026
 
 
1027
    cv::Mat src;
 
1028
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
1029
 
 
1030
    cv::cuda::GpuMat dst;
 
1031
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
 
1032
 
 
1033
    cv::Mat dst_gold;
 
1034
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
 
1035
 
 
1036
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1037
}
 
1038
 
 
1039
CUDA_TEST_P(CvtColor, HSV42BGR)
 
1040
{
 
1041
    if (depth == CV_16U)
 
1042
        return;
 
1043
 
 
1044
    cv::Mat src;
 
1045
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
1046
 
 
1047
    cv::Mat dst_gold;
 
1048
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
1049
 
 
1050
    cv::Mat channels[4];
 
1051
    cv::split(src, channels);
 
1052
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1053
    cv::merge(channels, 4, src);
 
1054
 
 
1055
    cv::cuda::GpuMat dst;
 
1056
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
1057
 
 
1058
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1059
}
 
1060
 
 
1061
CUDA_TEST_P(CvtColor, HSV42BGRA)
 
1062
{
 
1063
    if (depth == CV_16U)
 
1064
        return;
 
1065
 
 
1066
    cv::Mat src;
 
1067
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
1068
 
 
1069
    cv::Mat dst_gold;
 
1070
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
 
1071
 
 
1072
    cv::Mat channels[4];
 
1073
    cv::split(src, channels);
 
1074
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1075
    cv::merge(channels, 4, src);
 
1076
 
 
1077
    cv::cuda::GpuMat dst;
 
1078
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
 
1079
 
 
1080
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1081
}
 
1082
 
 
1083
CUDA_TEST_P(CvtColor, HLS2BGR)
 
1084
{
 
1085
    if (depth == CV_16U)
 
1086
        return;
 
1087
 
 
1088
    cv::Mat src;
 
1089
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
1090
 
 
1091
    cv::cuda::GpuMat dst;
 
1092
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
 
1093
 
 
1094
    cv::Mat dst_gold;
 
1095
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
 
1096
 
 
1097
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1098
}
 
1099
 
 
1100
CUDA_TEST_P(CvtColor, HLS2RGB)
 
1101
{
 
1102
    if (depth == CV_16U)
 
1103
        return;
 
1104
 
 
1105
    cv::Mat src;
 
1106
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
1107
 
 
1108
    cv::cuda::GpuMat dst;
 
1109
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
1110
 
 
1111
    cv::Mat dst_gold;
 
1112
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
1113
 
 
1114
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1115
}
 
1116
 
 
1117
CUDA_TEST_P(CvtColor, HLS42RGB)
 
1118
{
 
1119
    if (depth == CV_16U)
 
1120
        return;
 
1121
 
 
1122
    cv::Mat src;
 
1123
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
1124
 
 
1125
    cv::Mat dst_gold;
 
1126
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
1127
 
 
1128
    cv::Mat channels[4];
 
1129
    cv::split(src, channels);
 
1130
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1131
    cv::merge(channels, 4, src);
 
1132
 
 
1133
    cv::cuda::GpuMat dst;
 
1134
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
1135
 
 
1136
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1137
}
 
1138
 
 
1139
CUDA_TEST_P(CvtColor, HLS42RGBA)
 
1140
{
 
1141
    if (depth == CV_16U)
 
1142
        return;
 
1143
 
 
1144
    cv::Mat src;
 
1145
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
1146
 
 
1147
    cv::Mat dst_gold;
 
1148
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
 
1149
 
 
1150
    cv::Mat channels[4];
 
1151
    cv::split(src, channels);
 
1152
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1153
    cv::merge(channels, 4, src);
 
1154
 
 
1155
 
 
1156
    cv::cuda::GpuMat dst;
 
1157
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
 
1158
 
 
1159
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1160
}
 
1161
 
 
1162
CUDA_TEST_P(CvtColor, BGR2HSV_FULL)
 
1163
{
 
1164
    if (depth == CV_16U)
 
1165
        return;
 
1166
 
 
1167
    cv::Mat src = img;
 
1168
 
 
1169
    cv::cuda::GpuMat dst;
 
1170
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
 
1171
 
 
1172
    cv::Mat dst_gold;
 
1173
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
 
1174
 
 
1175
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1176
}
 
1177
 
 
1178
CUDA_TEST_P(CvtColor, RGB2HSV_FULL)
 
1179
{
 
1180
    if (depth == CV_16U)
 
1181
        return;
 
1182
 
 
1183
    cv::Mat src = img;
 
1184
 
 
1185
    cv::cuda::GpuMat dst;
 
1186
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
 
1187
 
 
1188
    cv::Mat dst_gold;
 
1189
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
1190
 
 
1191
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1192
}
 
1193
 
 
1194
CUDA_TEST_P(CvtColor, RGB2HSV4_FULL)
 
1195
{
 
1196
    if (depth == CV_16U)
 
1197
        return;
 
1198
 
 
1199
    cv::Mat src = img;
 
1200
 
 
1201
    cv::cuda::GpuMat dst;
 
1202
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
1203
 
 
1204
    ASSERT_EQ(4, dst.channels());
 
1205
 
 
1206
    cv::Mat dst_gold;
 
1207
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
1208
 
 
1209
    cv::Mat h_dst(dst);
 
1210
 
 
1211
    cv::Mat channels[4];
 
1212
    cv::split(h_dst, channels);
 
1213
    cv::merge(channels, 3, h_dst);
 
1214
 
 
1215
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
1216
}
 
1217
 
 
1218
CUDA_TEST_P(CvtColor, RGBA2HSV4_FULL)
 
1219
{
 
1220
    if (depth == CV_16U)
 
1221
        return;
 
1222
 
 
1223
    cv::Mat src;
 
1224
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1225
 
 
1226
    cv::cuda::GpuMat dst;
 
1227
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
1228
 
 
1229
    ASSERT_EQ(4, dst.channels());
 
1230
 
 
1231
    cv::Mat dst_gold;
 
1232
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
1233
 
 
1234
    cv::Mat h_dst(dst);
 
1235
 
 
1236
    cv::Mat channels[4];
 
1237
    cv::split(h_dst, channels);
 
1238
    cv::merge(channels, 3, h_dst);
 
1239
 
 
1240
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
1241
}
 
1242
 
 
1243
CUDA_TEST_P(CvtColor, BGR2HLS_FULL)
 
1244
{
 
1245
    if (depth == CV_16U)
 
1246
        return;
 
1247
 
 
1248
    cv::Mat src = img;
 
1249
 
 
1250
    cv::cuda::GpuMat dst;
 
1251
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
 
1252
 
 
1253
    cv::Mat dst_gold;
 
1254
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
 
1255
 
 
1256
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1257
}
 
1258
 
 
1259
CUDA_TEST_P(CvtColor, RGB2HLS_FULL)
 
1260
{
 
1261
    if (depth == CV_16U)
 
1262
        return;
 
1263
 
 
1264
    cv::Mat src = img;
 
1265
 
 
1266
    cv::cuda::GpuMat dst;
 
1267
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
 
1268
 
 
1269
    cv::Mat dst_gold;
 
1270
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
1271
 
 
1272
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1273
}
 
1274
 
 
1275
CUDA_TEST_P(CvtColor, RGB2HLS4_FULL)
 
1276
{
 
1277
    if (depth == CV_16U)
 
1278
        return;
 
1279
 
 
1280
    cv::Mat src = img;
 
1281
 
 
1282
    cv::cuda::GpuMat dst;
 
1283
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
1284
 
 
1285
    ASSERT_EQ(4, dst.channels());
 
1286
 
 
1287
    cv::Mat dst_gold;
 
1288
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
1289
 
 
1290
    cv::Mat h_dst(dst);
 
1291
 
 
1292
    cv::Mat channels[4];
 
1293
    cv::split(h_dst, channels);
 
1294
    cv::merge(channels, 3, h_dst);
 
1295
 
 
1296
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
1297
}
 
1298
 
 
1299
CUDA_TEST_P(CvtColor, RGBA2HLS4_FULL)
 
1300
{
 
1301
    if (depth == CV_16U)
 
1302
        return;
 
1303
 
 
1304
    cv::Mat src;
 
1305
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1306
 
 
1307
    cv::cuda::GpuMat dst;
 
1308
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
1309
 
 
1310
    ASSERT_EQ(4, dst.channels());
 
1311
 
 
1312
    cv::Mat dst_gold;
 
1313
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
1314
 
 
1315
    cv::Mat h_dst(dst);
 
1316
 
 
1317
    cv::Mat channels[4];
 
1318
    cv::split(h_dst, channels);
 
1319
    cv::merge(channels, 3, h_dst);
 
1320
 
 
1321
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 
1322
}
 
1323
 
 
1324
CUDA_TEST_P(CvtColor, HSV2BGR_FULL)
 
1325
{
 
1326
    if (depth == CV_16U)
 
1327
        return;
 
1328
 
 
1329
    cv::Mat src;
 
1330
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
1331
 
 
1332
    cv::cuda::GpuMat dst;
 
1333
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
 
1334
 
 
1335
    cv::Mat dst_gold;
 
1336
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
 
1337
 
 
1338
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1339
}
 
1340
 
 
1341
CUDA_TEST_P(CvtColor, HSV2RGB_FULL)
 
1342
{
 
1343
    if (depth == CV_16U)
 
1344
        return;
 
1345
 
 
1346
    cv::Mat src;
 
1347
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
1348
 
 
1349
    cv::cuda::GpuMat dst;
 
1350
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
1351
 
 
1352
    cv::Mat dst_gold;
 
1353
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
1354
 
 
1355
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1356
}
 
1357
 
 
1358
CUDA_TEST_P(CvtColor, HSV42RGB_FULL)
 
1359
{
 
1360
    if (depth == CV_16U)
 
1361
        return;
 
1362
 
 
1363
    cv::Mat src;
 
1364
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
1365
 
 
1366
    cv::Mat dst_gold;
 
1367
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
1368
 
 
1369
    cv::Mat channels[4];
 
1370
    cv::split(src, channels);
 
1371
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1372
    cv::merge(channels, 4, src);
 
1373
 
 
1374
    cv::cuda::GpuMat dst;
 
1375
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
1376
 
 
1377
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1378
}
 
1379
 
 
1380
CUDA_TEST_P(CvtColor, HSV42RGBA_FULL)
 
1381
{
 
1382
    if (depth == CV_16U)
 
1383
        return;
 
1384
 
 
1385
    cv::Mat src;
 
1386
    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
1387
 
 
1388
    cv::Mat dst_gold;
 
1389
    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
 
1390
 
 
1391
    cv::Mat channels[4];
 
1392
    cv::split(src, channels);
 
1393
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1394
    cv::merge(channels, 4, src);
 
1395
 
 
1396
    cv::cuda::GpuMat dst;
 
1397
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
 
1398
 
 
1399
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1400
}
 
1401
 
 
1402
CUDA_TEST_P(CvtColor, HLS2BGR_FULL)
 
1403
{
 
1404
    if (depth == CV_16U)
 
1405
        return;
 
1406
 
 
1407
    cv::Mat src;
 
1408
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
1409
 
 
1410
    cv::cuda::GpuMat dst;
 
1411
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
 
1412
 
 
1413
    cv::Mat dst_gold;
 
1414
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
 
1415
 
 
1416
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1417
}
 
1418
 
 
1419
CUDA_TEST_P(CvtColor, HLS2RGB_FULL)
 
1420
{
 
1421
    if (depth == CV_16U)
 
1422
        return;
 
1423
 
 
1424
    cv::Mat src;
 
1425
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
1426
 
 
1427
    cv::cuda::GpuMat dst;
 
1428
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
1429
 
 
1430
    cv::Mat dst_gold;
 
1431
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
1432
 
 
1433
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1434
}
 
1435
 
 
1436
CUDA_TEST_P(CvtColor, HLS42RGB_FULL)
 
1437
{
 
1438
    if (depth == CV_16U)
 
1439
        return;
 
1440
 
 
1441
    cv::Mat src;
 
1442
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
1443
 
 
1444
    cv::Mat dst_gold;
 
1445
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
1446
 
 
1447
    cv::Mat channels[4];
 
1448
    cv::split(src, channels);
 
1449
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1450
    cv::merge(channels, 4, src);
 
1451
 
 
1452
    cv::cuda::GpuMat dst;
 
1453
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
1454
 
 
1455
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1456
}
 
1457
 
 
1458
CUDA_TEST_P(CvtColor, HLS42RGBA_FULL)
 
1459
{
 
1460
    if (depth == CV_16U)
 
1461
        return;
 
1462
 
 
1463
    cv::Mat src;
 
1464
    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
1465
 
 
1466
    cv::Mat dst_gold;
 
1467
    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
 
1468
 
 
1469
    cv::Mat channels[4];
 
1470
    cv::split(src, channels);
 
1471
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1472
    cv::merge(channels, 4, src);
 
1473
 
 
1474
    cv::cuda::GpuMat dst;
 
1475
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
 
1476
 
 
1477
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 
1478
}
 
1479
 
 
1480
CUDA_TEST_P(CvtColor, BGR2YUV)
 
1481
{
 
1482
    cv::Mat src = img;
 
1483
 
 
1484
    cv::cuda::GpuMat dst;
 
1485
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
 
1486
 
 
1487
    cv::Mat dst_gold;
 
1488
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
1489
 
 
1490
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1491
}
 
1492
 
 
1493
CUDA_TEST_P(CvtColor, RGB2YUV)
 
1494
{
 
1495
    cv::Mat src = img;
 
1496
 
 
1497
    cv::cuda::GpuMat dst;
 
1498
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
 
1499
 
 
1500
    cv::Mat dst_gold;
 
1501
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
1502
 
 
1503
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1504
}
 
1505
 
 
1506
CUDA_TEST_P(CvtColor, YUV2BGR)
 
1507
{
 
1508
    cv::Mat src;
 
1509
    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
1510
 
 
1511
    cv::cuda::GpuMat dst;
 
1512
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
1513
 
 
1514
    cv::Mat dst_gold;
 
1515
    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
1516
 
 
1517
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1518
}
 
1519
 
 
1520
CUDA_TEST_P(CvtColor, YUV42BGR)
 
1521
{
 
1522
    cv::Mat src;
 
1523
    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
1524
 
 
1525
    cv::Mat dst_gold;
 
1526
    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
1527
 
 
1528
    cv::Mat channels[4];
 
1529
    cv::split(src, channels);
 
1530
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1531
    cv::merge(channels, 4, src);
 
1532
 
 
1533
    cv::cuda::GpuMat dst;
 
1534
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
1535
 
 
1536
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1537
}
 
1538
 
 
1539
CUDA_TEST_P(CvtColor, YUV42BGRA)
 
1540
{
 
1541
    cv::Mat src;
 
1542
    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
1543
 
 
1544
    cv::Mat dst_gold;
 
1545
    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
 
1546
 
 
1547
    cv::Mat channels[4];
 
1548
    cv::split(src, channels);
 
1549
    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
 
1550
    cv::merge(channels, 4, src);
 
1551
 
 
1552
    cv::cuda::GpuMat dst;
 
1553
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
 
1554
 
 
1555
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1556
}
 
1557
 
 
1558
CUDA_TEST_P(CvtColor, YUV2RGB)
 
1559
{
 
1560
    cv::Mat src;
 
1561
    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
 
1562
 
 
1563
    cv::cuda::GpuMat dst;
 
1564
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
 
1565
 
 
1566
    cv::Mat dst_gold;
 
1567
    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
 
1568
 
 
1569
    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 
1570
}
 
1571
 
 
1572
CUDA_TEST_P(CvtColor, BGR2YUV4)
 
1573
{
 
1574
    cv::Mat src = img;
 
1575
 
 
1576
    cv::cuda::GpuMat dst;
 
1577
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
 
1578
 
 
1579
    ASSERT_EQ(4, dst.channels());
 
1580
 
 
1581
    cv::Mat dst_gold;
 
1582
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
1583
 
 
1584
    cv::Mat h_dst(dst);
 
1585
 
 
1586
    cv::Mat channels[4];
 
1587
    cv::split(h_dst, channels);
 
1588
    cv::merge(channels, 3, h_dst);
 
1589
 
 
1590
    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 
1591
}
 
1592
 
 
1593
CUDA_TEST_P(CvtColor, RGBA2YUV4)
 
1594
{
 
1595
    cv::Mat src;
 
1596
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1597
 
 
1598
    cv::cuda::GpuMat dst;
 
1599
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
 
1600
 
 
1601
    ASSERT_EQ(4, dst.channels());
 
1602
 
 
1603
    cv::Mat dst_gold;
 
1604
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
1605
 
 
1606
    cv::Mat h_dst(dst);
 
1607
 
 
1608
    cv::Mat channels[4];
 
1609
    cv::split(h_dst, channels);
 
1610
    cv::merge(channels, 3, h_dst);
 
1611
 
 
1612
    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 
1613
}
 
1614
 
 
1615
CUDA_TEST_P(CvtColor, BGR2Lab)
 
1616
{
 
1617
    if (depth == CV_16U)
 
1618
        return;
 
1619
 
 
1620
    cv::Mat src = img;
 
1621
 
 
1622
    cv::cuda::GpuMat dst;
 
1623
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2Lab);
 
1624
 
 
1625
    cv::Mat dst_gold;
 
1626
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2Lab);
 
1627
 
 
1628
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1629
}
 
1630
 
 
1631
CUDA_TEST_P(CvtColor, RGB2Lab)
 
1632
{
 
1633
    if (depth == CV_16U)
 
1634
        return;
 
1635
 
 
1636
    cv::Mat src = img;
 
1637
 
 
1638
    cv::cuda::GpuMat dst;
 
1639
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2Lab);
 
1640
 
 
1641
    cv::Mat dst_gold;
 
1642
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2Lab);
 
1643
 
 
1644
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1645
}
 
1646
 
 
1647
CUDA_TEST_P(CvtColor, BGRA2Lab4)
 
1648
{
 
1649
    if (depth == CV_16U)
 
1650
        return;
 
1651
 
 
1652
    cv::Mat src;
 
1653
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1654
 
 
1655
    cv::cuda::GpuMat dst;
 
1656
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2Lab, 4);
 
1657
 
 
1658
    ASSERT_EQ(4, dst.channels());
 
1659
 
 
1660
    cv::Mat dst_gold;
 
1661
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2Lab);
 
1662
 
 
1663
    cv::Mat h_dst(dst);
 
1664
 
 
1665
    cv::Mat channels[4];
 
1666
    cv::split(h_dst, channels);
 
1667
    cv::merge(channels, 3, h_dst);
 
1668
 
 
1669
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_8U ? 1 : 1e-3);
 
1670
}
 
1671
 
 
1672
CUDA_TEST_P(CvtColor, LBGR2Lab)
 
1673
{
 
1674
    if (depth == CV_16U)
 
1675
        return;
 
1676
 
 
1677
    cv::Mat src = img;
 
1678
 
 
1679
    cv::cuda::GpuMat dst;
 
1680
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LBGR2Lab);
 
1681
 
 
1682
    cv::Mat dst_gold;
 
1683
    cv::cvtColor(src, dst_gold, cv::COLOR_LBGR2Lab);
 
1684
 
 
1685
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1686
}
 
1687
 
 
1688
CUDA_TEST_P(CvtColor, LRGB2Lab)
 
1689
{
 
1690
    if (depth == CV_16U)
 
1691
        return;
 
1692
 
 
1693
    cv::Mat src = img;
 
1694
 
 
1695
    cv::cuda::GpuMat dst;
 
1696
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LRGB2Lab);
 
1697
 
 
1698
    cv::Mat dst_gold;
 
1699
    cv::cvtColor(src, dst_gold, cv::COLOR_LRGB2Lab);
 
1700
 
 
1701
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1702
}
 
1703
 
 
1704
CUDA_TEST_P(CvtColor, LBGRA2Lab4)
 
1705
{
 
1706
    if (depth == CV_16U)
 
1707
        return;
 
1708
 
 
1709
    cv::Mat src;
 
1710
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1711
 
 
1712
    cv::cuda::GpuMat dst;
 
1713
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LBGR2Lab, 4);
 
1714
 
 
1715
    ASSERT_EQ(4, dst.channels());
 
1716
 
 
1717
    cv::Mat dst_gold;
 
1718
    cv::cvtColor(src, dst_gold, cv::COLOR_LBGR2Lab);
 
1719
 
 
1720
    cv::Mat h_dst(dst);
 
1721
 
 
1722
    cv::Mat channels[4];
 
1723
    cv::split(h_dst, channels);
 
1724
    cv::merge(channels, 3, h_dst);
 
1725
 
 
1726
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_8U ? 1 : 1e-3);
 
1727
}
 
1728
 
 
1729
CUDA_TEST_P(CvtColor, Lab2BGR)
 
1730
{
 
1731
    if (depth == CV_16U)
 
1732
        return;
 
1733
 
 
1734
    cv::Mat src;
 
1735
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1736
 
 
1737
    cv::cuda::GpuMat dst;
 
1738
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2BGR);
 
1739
 
 
1740
    cv::Mat dst_gold;
 
1741
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2BGR);
 
1742
 
 
1743
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1744
}
 
1745
 
 
1746
CUDA_TEST_P(CvtColor, Lab2RGB)
 
1747
{
 
1748
    if (depth == CV_16U)
 
1749
        return;
 
1750
 
 
1751
    cv::Mat src;
 
1752
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1753
 
 
1754
    cv::cuda::GpuMat dst;
 
1755
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2RGB);
 
1756
 
 
1757
    cv::Mat dst_gold;
 
1758
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2RGB);
 
1759
 
 
1760
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1761
}
 
1762
 
 
1763
CUDA_TEST_P(CvtColor, Lab2BGRA)
 
1764
{
 
1765
    if (depth == CV_16U)
 
1766
        return;
 
1767
 
 
1768
    cv::Mat src;
 
1769
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1770
 
 
1771
    cv::cuda::GpuMat dst;
 
1772
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2BGR, 4);
 
1773
 
 
1774
    ASSERT_EQ(4, dst.channels());
 
1775
 
 
1776
    cv::Mat dst_gold;
 
1777
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2BGR, 4);
 
1778
 
 
1779
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1780
}
 
1781
 
 
1782
CUDA_TEST_P(CvtColor, Lab2LBGR)
 
1783
{
 
1784
    if (depth == CV_16U)
 
1785
        return;
 
1786
 
 
1787
    cv::Mat src;
 
1788
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1789
 
 
1790
    cv::cuda::GpuMat dst;
 
1791
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2LBGR);
 
1792
 
 
1793
    cv::Mat dst_gold;
 
1794
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2LBGR);
 
1795
 
 
1796
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1797
}
 
1798
 
 
1799
CUDA_TEST_P(CvtColor, Lab2LRGB)
 
1800
{
 
1801
    if (depth == CV_16U)
 
1802
        return;
 
1803
 
 
1804
    cv::Mat src;
 
1805
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1806
 
 
1807
    cv::cuda::GpuMat dst;
 
1808
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2LRGB);
 
1809
 
 
1810
    cv::Mat dst_gold;
 
1811
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2LRGB);
 
1812
 
 
1813
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1814
}
 
1815
 
 
1816
CUDA_TEST_P(CvtColor, Lab2LRGBA)
 
1817
{
 
1818
    if (depth == CV_16U)
 
1819
        return;
 
1820
 
 
1821
    cv::Mat src;
 
1822
    cv::cvtColor(img, src, cv::COLOR_BGR2Lab);
 
1823
 
 
1824
    cv::cuda::GpuMat dst;
 
1825
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Lab2LRGB, 4);
 
1826
 
 
1827
    cv::Mat dst_gold;
 
1828
    cv::cvtColor(src, dst_gold, cv::COLOR_Lab2LRGB, 4);
 
1829
 
 
1830
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-5);
 
1831
}
 
1832
 
 
1833
CUDA_TEST_P(CvtColor, BGR2Luv)
 
1834
{
 
1835
    if (depth == CV_16U)
 
1836
        return;
 
1837
 
 
1838
    cv::Mat src = img;
 
1839
 
 
1840
    cv::cuda::GpuMat dst;
 
1841
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2Luv);
 
1842
 
 
1843
    cv::Mat dst_gold;
 
1844
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2Luv);
 
1845
 
 
1846
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1847
}
 
1848
 
 
1849
CUDA_TEST_P(CvtColor, RGB2Luv)
 
1850
{
 
1851
    if (depth == CV_16U)
 
1852
        return;
 
1853
 
 
1854
    cv::Mat src = img;
 
1855
 
 
1856
    cv::cuda::GpuMat dst;
 
1857
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2Luv);
 
1858
 
 
1859
    cv::Mat dst_gold;
 
1860
    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2Luv);
 
1861
 
 
1862
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1863
}
 
1864
 
 
1865
CUDA_TEST_P(CvtColor, BGRA2Luv4)
 
1866
{
 
1867
    if (depth == CV_16U)
 
1868
        return;
 
1869
 
 
1870
    cv::Mat src;
 
1871
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1872
 
 
1873
    cv::cuda::GpuMat dst;
 
1874
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2Luv, 4);
 
1875
 
 
1876
    ASSERT_EQ(4, dst.channels());
 
1877
 
 
1878
    cv::Mat dst_gold;
 
1879
    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2Luv);
 
1880
 
 
1881
    cv::Mat h_dst(dst);
 
1882
 
 
1883
    cv::Mat channels[4];
 
1884
    cv::split(h_dst, channels);
 
1885
    cv::merge(channels, 3, h_dst);
 
1886
 
 
1887
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_8U ? 1 : 1e-3);
 
1888
}
 
1889
 
 
1890
CUDA_TEST_P(CvtColor, LBGR2Luv)
 
1891
{
 
1892
    if (depth == CV_16U)
 
1893
        return;
 
1894
 
 
1895
    cv::Mat src = img;
 
1896
 
 
1897
    cv::cuda::GpuMat dst;
 
1898
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LBGR2Luv);
 
1899
 
 
1900
    cv::Mat dst_gold;
 
1901
    cv::cvtColor(src, dst_gold, cv::COLOR_LBGR2Luv);
 
1902
 
 
1903
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1904
}
 
1905
 
 
1906
CUDA_TEST_P(CvtColor, LRGB2Luv)
 
1907
{
 
1908
    if (depth == CV_16U)
 
1909
        return;
 
1910
 
 
1911
    cv::Mat src = img;
 
1912
 
 
1913
    cv::cuda::GpuMat dst;
 
1914
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LRGB2Luv);
 
1915
 
 
1916
    cv::Mat dst_gold;
 
1917
    cv::cvtColor(src, dst_gold, cv::COLOR_LRGB2Luv);
 
1918
 
 
1919
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-3);
 
1920
}
 
1921
 
 
1922
CUDA_TEST_P(CvtColor, LBGRA2Luv4)
 
1923
{
 
1924
    if (depth == CV_16U)
 
1925
        return;
 
1926
 
 
1927
    cv::Mat src;
 
1928
    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
1929
 
 
1930
    cv::cuda::GpuMat dst;
 
1931
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_LBGR2Luv, 4);
 
1932
 
 
1933
    ASSERT_EQ(4, dst.channels());
 
1934
 
 
1935
    cv::Mat dst_gold;
 
1936
    cv::cvtColor(src, dst_gold, cv::COLOR_LBGR2Luv);
 
1937
 
 
1938
    cv::Mat h_dst(dst);
 
1939
 
 
1940
    cv::Mat channels[4];
 
1941
    cv::split(h_dst, channels);
 
1942
    cv::merge(channels, 3, h_dst);
 
1943
 
 
1944
    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_8U ? 1 : 1e-3);
 
1945
}
 
1946
 
 
1947
CUDA_TEST_P(CvtColor, Luv2BGR)
 
1948
{
 
1949
    if (depth == CV_16U)
 
1950
        return;
 
1951
 
 
1952
    cv::Mat src;
 
1953
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
1954
 
 
1955
    cv::cuda::GpuMat dst;
 
1956
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2BGR);
 
1957
 
 
1958
    cv::Mat dst_gold;
 
1959
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2BGR);
 
1960
 
 
1961
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
1962
}
 
1963
 
 
1964
CUDA_TEST_P(CvtColor, Luv2RGB)
 
1965
{
 
1966
    if (depth == CV_16U)
 
1967
        return;
 
1968
 
 
1969
    cv::Mat src;
 
1970
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
1971
 
 
1972
    cv::cuda::GpuMat dst;
 
1973
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2RGB);
 
1974
 
 
1975
    cv::Mat dst_gold;
 
1976
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2RGB);
 
1977
 
 
1978
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
1979
}
 
1980
 
 
1981
CUDA_TEST_P(CvtColor, Luv2BGRA)
 
1982
{
 
1983
    if (depth == CV_16U)
 
1984
        return;
 
1985
 
 
1986
    cv::Mat src;
 
1987
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
1988
 
 
1989
    cv::cuda::GpuMat dst;
 
1990
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2BGR, 4);
 
1991
 
 
1992
    ASSERT_EQ(4, dst.channels());
 
1993
 
 
1994
    cv::Mat dst_gold;
 
1995
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2BGR, 4);
 
1996
 
 
1997
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
1998
}
 
1999
 
 
2000
CUDA_TEST_P(CvtColor, Luv2LBGR)
 
2001
{
 
2002
    if (depth == CV_16U)
 
2003
        return;
 
2004
 
 
2005
    cv::Mat src;
 
2006
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
2007
 
 
2008
    cv::cuda::GpuMat dst;
 
2009
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2LBGR);
 
2010
 
 
2011
    cv::Mat dst_gold;
 
2012
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2LBGR);
 
2013
 
 
2014
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
2015
}
 
2016
 
 
2017
CUDA_TEST_P(CvtColor, Luv2LRGB)
 
2018
{
 
2019
    if (depth == CV_16U)
 
2020
        return;
 
2021
 
 
2022
    cv::Mat src;
 
2023
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
2024
 
 
2025
    cv::cuda::GpuMat dst;
 
2026
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2LRGB);
 
2027
 
 
2028
    cv::Mat dst_gold;
 
2029
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2LRGB);
 
2030
 
 
2031
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
2032
}
 
2033
 
 
2034
CUDA_TEST_P(CvtColor, Luv2LRGBA)
 
2035
{
 
2036
    if (depth == CV_16U)
 
2037
        return;
 
2038
 
 
2039
    cv::Mat src;
 
2040
    cv::cvtColor(img, src, cv::COLOR_BGR2Luv);
 
2041
 
 
2042
    cv::cuda::GpuMat dst;
 
2043
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_Luv2LRGB, 4);
 
2044
 
 
2045
    cv::Mat dst_gold;
 
2046
    cv::cvtColor(src, dst_gold, cv::COLOR_Luv2LRGB, 4);
 
2047
 
 
2048
    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_8U ? 1 : 1e-4);
 
2049
}
 
2050
 
 
2051
#if defined (CUDA_VERSION) && (CUDA_VERSION >= 5000)
 
2052
 
 
2053
CUDA_TEST_P(CvtColor, RGBA2mRGBA)
 
2054
{
 
2055
    if (depth != CV_8U)
 
2056
        return;
 
2057
 
 
2058
    cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
 
2059
 
 
2060
    cv::cuda::GpuMat dst = createMat(src.size(), src.type(), useRoi);
 
2061
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
 
2062
 
 
2063
    cv::Mat dst_gold;
 
2064
    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
 
2065
 
 
2066
    EXPECT_MAT_NEAR(dst_gold, dst, 1);
 
2067
}
 
2068
 
 
2069
#endif // defined (CUDA_VERSION) && (CUDA_VERSION >= 5000)
 
2070
 
 
2071
CUDA_TEST_P(CvtColor, BayerBG2BGR)
 
2072
{
 
2073
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2074
        return;
 
2075
 
 
2076
    cv::Mat src = randomMat(size, depth);
 
2077
 
 
2078
    cv::cuda::GpuMat dst;
 
2079
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
 
2080
 
 
2081
    cv::Mat dst_gold;
 
2082
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
2083
 
 
2084
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2085
}
 
2086
 
 
2087
CUDA_TEST_P(CvtColor, BayerBG2BGR4)
 
2088
{
 
2089
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2090
        return;
 
2091
 
 
2092
    cv::Mat src = randomMat(size, depth);
 
2093
 
 
2094
    cv::cuda::GpuMat dst;
 
2095
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
 
2096
 
 
2097
    ASSERT_EQ(4, dst.channels());
 
2098
 
 
2099
    cv::Mat dst_gold;
 
2100
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
2101
 
 
2102
    cv::Mat dst4(dst);
 
2103
    cv::Mat dst3;
 
2104
    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
2105
 
 
2106
 
 
2107
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2108
}
 
2109
 
 
2110
CUDA_TEST_P(CvtColor, BayerGB2BGR)
 
2111
{
 
2112
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2113
        return;
 
2114
 
 
2115
    cv::Mat src = randomMat(size, depth);
 
2116
 
 
2117
    cv::cuda::GpuMat dst;
 
2118
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
 
2119
 
 
2120
    cv::Mat dst_gold;
 
2121
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
2122
 
 
2123
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2124
}
 
2125
 
 
2126
CUDA_TEST_P(CvtColor, BayerGB2BGR4)
 
2127
{
 
2128
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2129
        return;
 
2130
 
 
2131
    cv::Mat src = randomMat(size, depth);
 
2132
 
 
2133
    cv::cuda::GpuMat dst;
 
2134
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
 
2135
 
 
2136
    ASSERT_EQ(4, dst.channels());
 
2137
 
 
2138
    cv::Mat dst_gold;
 
2139
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
2140
 
 
2141
    cv::Mat dst4(dst);
 
2142
    cv::Mat dst3;
 
2143
    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
2144
 
 
2145
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2146
}
 
2147
 
 
2148
CUDA_TEST_P(CvtColor, BayerRG2BGR)
 
2149
{
 
2150
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2151
        return;
 
2152
 
 
2153
    cv::Mat src = randomMat(size, depth);
 
2154
 
 
2155
    cv::cuda::GpuMat dst;
 
2156
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
 
2157
 
 
2158
    cv::Mat dst_gold;
 
2159
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
2160
 
 
2161
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2162
}
 
2163
 
 
2164
CUDA_TEST_P(CvtColor, BayerRG2BGR4)
 
2165
{
 
2166
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2167
        return;
 
2168
 
 
2169
    cv::Mat src = randomMat(size, depth);
 
2170
 
 
2171
    cv::cuda::GpuMat dst;
 
2172
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
 
2173
 
 
2174
    ASSERT_EQ(4, dst.channels());
 
2175
 
 
2176
    cv::Mat dst_gold;
 
2177
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
2178
 
 
2179
    cv::Mat dst4(dst);
 
2180
    cv::Mat dst3;
 
2181
    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
2182
 
 
2183
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2184
}
 
2185
 
 
2186
CUDA_TEST_P(CvtColor, BayerGR2BGR)
 
2187
{
 
2188
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2189
        return;
 
2190
 
 
2191
    cv::Mat src = randomMat(size, depth);
 
2192
 
 
2193
    cv::cuda::GpuMat dst;
 
2194
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
 
2195
 
 
2196
    cv::Mat dst_gold;
 
2197
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
2198
 
 
2199
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2200
}
 
2201
 
 
2202
CUDA_TEST_P(CvtColor, BayerGR2BGR4)
 
2203
{
 
2204
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2205
        return;
 
2206
 
 
2207
    cv::Mat src = randomMat(size, depth);
 
2208
 
 
2209
    cv::cuda::GpuMat dst;
 
2210
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
 
2211
 
 
2212
    ASSERT_EQ(4, dst.channels());
 
2213
 
 
2214
    cv::Mat dst_gold;
 
2215
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
2216
 
 
2217
    cv::Mat dst4(dst);
 
2218
    cv::Mat dst3;
 
2219
    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
2220
 
 
2221
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 
2222
}
 
2223
 
 
2224
CUDA_TEST_P(CvtColor, BayerBG2Gray)
 
2225
{
 
2226
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2227
        return;
 
2228
 
 
2229
    cv::Mat src = randomMat(size, depth);
 
2230
 
 
2231
    cv::cuda::GpuMat dst;
 
2232
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2GRAY);
 
2233
 
 
2234
    cv::Mat dst_gold;
 
2235
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2GRAY);
 
2236
 
 
2237
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 2);
 
2238
}
 
2239
 
 
2240
CUDA_TEST_P(CvtColor, BayerGB2Gray)
 
2241
{
 
2242
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2243
        return;
 
2244
 
 
2245
    cv::Mat src = randomMat(size, depth);
 
2246
 
 
2247
    cv::cuda::GpuMat dst;
 
2248
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2GRAY);
 
2249
 
 
2250
    cv::Mat dst_gold;
 
2251
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2GRAY);
 
2252
 
 
2253
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 2);
 
2254
}
 
2255
 
 
2256
CUDA_TEST_P(CvtColor, BayerRG2Gray)
 
2257
{
 
2258
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2259
        return;
 
2260
 
 
2261
    cv::Mat src = randomMat(size, depth);
 
2262
 
 
2263
    cv::cuda::GpuMat dst;
 
2264
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2GRAY);
 
2265
 
 
2266
    cv::Mat dst_gold;
 
2267
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2GRAY);
 
2268
 
 
2269
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 2);
 
2270
}
 
2271
 
 
2272
CUDA_TEST_P(CvtColor, BayerGR2Gray)
 
2273
{
 
2274
    if ((depth != CV_8U && depth != CV_16U) || useRoi)
 
2275
        return;
 
2276
 
 
2277
    cv::Mat src = randomMat(size, depth);
 
2278
 
 
2279
    cv::cuda::GpuMat dst;
 
2280
    cv::cuda::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2GRAY);
 
2281
 
 
2282
    cv::Mat dst_gold;
 
2283
    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2GRAY);
 
2284
 
 
2285
    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 2);
 
2286
}
 
2287
 
 
2288
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, CvtColor, testing::Combine(
 
2289
    ALL_DEVICES,
 
2290
    DIFFERENT_SIZES,
 
2291
    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
 
2292
    WHOLE_SUBMAT));
 
2293
 
 
2294
///////////////////////////////////////////////////////////////////////////////////////////////////////
 
2295
// Demosaicing
 
2296
 
 
2297
struct Demosaicing : testing::TestWithParam<cv::cuda::DeviceInfo>
 
2298
{
 
2299
    cv::cuda::DeviceInfo devInfo;
 
2300
 
 
2301
    virtual void SetUp()
 
2302
    {
 
2303
        devInfo = GetParam();
 
2304
 
 
2305
        cv::cuda::setDevice(devInfo.deviceID());
 
2306
    }
 
2307
 
 
2308
    static void mosaic(const cv::Mat_<cv::Vec3b>& src, cv::Mat_<uchar>& dst, cv::Point firstRed)
 
2309
    {
 
2310
        dst.create(src.size());
 
2311
 
 
2312
        for (int y = 0; y < src.rows; ++y)
 
2313
        {
 
2314
            for (int x = 0; x < src.cols; ++x)
 
2315
            {
 
2316
                cv::Vec3b pix = src(y, x);
 
2317
 
 
2318
                cv::Point alternate;
 
2319
                alternate.x = (x + firstRed.x) % 2;
 
2320
                alternate.y = (y + firstRed.y) % 2;
 
2321
 
 
2322
                if (alternate.y == 0)
 
2323
                {
 
2324
                    if (alternate.x == 0)
 
2325
                    {
 
2326
                        // RG
 
2327
                        // GB
 
2328
                        dst(y, x) = pix[2];
 
2329
                    }
 
2330
                    else
 
2331
                    {
 
2332
                        // GR
 
2333
                        // BG
 
2334
                        dst(y, x) = pix[1];
 
2335
                    }
 
2336
                }
 
2337
                else
 
2338
                {
 
2339
                    if (alternate.x == 0)
 
2340
                    {
 
2341
                        // GB
 
2342
                        // RG
 
2343
                        dst(y, x) = pix[1];
 
2344
                    }
 
2345
                    else
 
2346
                    {
 
2347
                        // BG
 
2348
                        // GR
 
2349
                        dst(y, x) = pix[0];
 
2350
                    }
 
2351
                }
 
2352
            }
 
2353
        }
 
2354
    }
 
2355
};
 
2356
 
 
2357
CUDA_TEST_P(Demosaicing, BayerBG2BGR)
 
2358
{
 
2359
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2360
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2361
 
 
2362
    cv::Mat_<uchar> src;
 
2363
    mosaic(img, src, cv::Point(1, 1));
 
2364
 
 
2365
    cv::cuda::GpuMat dst;
 
2366
    cv::cuda::demosaicing(loadMat(src), dst, cv::COLOR_BayerBG2BGR);
 
2367
 
 
2368
    EXPECT_MAT_SIMILAR(img, dst, 2e-2);
 
2369
}
 
2370
 
 
2371
CUDA_TEST_P(Demosaicing, BayerGB2BGR)
 
2372
{
 
2373
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2374
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2375
 
 
2376
    cv::Mat_<uchar> src;
 
2377
    mosaic(img, src, cv::Point(0, 1));
 
2378
 
 
2379
    cv::cuda::GpuMat dst;
 
2380
    cv::cuda::demosaicing(loadMat(src), dst, cv::COLOR_BayerGB2BGR);
 
2381
 
 
2382
    EXPECT_MAT_SIMILAR(img, dst, 2e-2);
 
2383
}
 
2384
 
 
2385
CUDA_TEST_P(Demosaicing, BayerRG2BGR)
 
2386
{
 
2387
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2388
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2389
 
 
2390
    cv::Mat_<uchar> src;
 
2391
    mosaic(img, src, cv::Point(0, 0));
 
2392
 
 
2393
    cv::cuda::GpuMat dst;
 
2394
    cv::cuda::demosaicing(loadMat(src), dst, cv::COLOR_BayerRG2BGR);
 
2395
 
 
2396
    EXPECT_MAT_SIMILAR(img, dst, 2e-2);
 
2397
}
 
2398
 
 
2399
CUDA_TEST_P(Demosaicing, BayerGR2BGR)
 
2400
{
 
2401
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2402
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2403
 
 
2404
    cv::Mat_<uchar> src;
 
2405
    mosaic(img, src, cv::Point(1, 0));
 
2406
 
 
2407
    cv::cuda::GpuMat dst;
 
2408
    cv::cuda::demosaicing(loadMat(src), dst, cv::COLOR_BayerGR2BGR);
 
2409
 
 
2410
    EXPECT_MAT_SIMILAR(img, dst, 2e-2);
 
2411
}
 
2412
 
 
2413
CUDA_TEST_P(Demosaicing, BayerBG2BGR_MHT)
 
2414
{
 
2415
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2416
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2417
 
 
2418
    cv::Mat_<uchar> src;
 
2419
    mosaic(img, src, cv::Point(1, 1));
 
2420
 
 
2421
    cv::cuda::GpuMat dst;
 
2422
    cv::cuda::demosaicing(loadMat(src), dst, cv::cuda::COLOR_BayerBG2BGR_MHT);
 
2423
 
 
2424
    EXPECT_MAT_SIMILAR(img, dst, 5e-3);
 
2425
}
 
2426
 
 
2427
CUDA_TEST_P(Demosaicing, BayerGB2BGR_MHT)
 
2428
{
 
2429
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2430
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2431
 
 
2432
    cv::Mat_<uchar> src;
 
2433
    mosaic(img, src, cv::Point(0, 1));
 
2434
 
 
2435
    cv::cuda::GpuMat dst;
 
2436
    cv::cuda::demosaicing(loadMat(src), dst, cv::cuda::COLOR_BayerGB2BGR_MHT);
 
2437
 
 
2438
    EXPECT_MAT_SIMILAR(img, dst, 5e-3);
 
2439
}
 
2440
 
 
2441
CUDA_TEST_P(Demosaicing, BayerRG2BGR_MHT)
 
2442
{
 
2443
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2444
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2445
 
 
2446
    cv::Mat_<uchar> src;
 
2447
    mosaic(img, src, cv::Point(0, 0));
 
2448
 
 
2449
    cv::cuda::GpuMat dst;
 
2450
    cv::cuda::demosaicing(loadMat(src), dst, cv::cuda::COLOR_BayerRG2BGR_MHT);
 
2451
 
 
2452
    EXPECT_MAT_SIMILAR(img, dst, 5e-3);
 
2453
}
 
2454
 
 
2455
CUDA_TEST_P(Demosaicing, BayerGR2BGR_MHT)
 
2456
{
 
2457
    cv::Mat img = readImage("stereobm/aloe-L.png");
 
2458
    ASSERT_FALSE(img.empty()) << "Can't load input image";
 
2459
 
 
2460
    cv::Mat_<uchar> src;
 
2461
    mosaic(img, src, cv::Point(1, 0));
 
2462
 
 
2463
    cv::cuda::GpuMat dst;
 
2464
    cv::cuda::demosaicing(loadMat(src), dst, cv::cuda::COLOR_BayerGR2BGR_MHT);
 
2465
 
 
2466
    EXPECT_MAT_SIMILAR(img, dst, 5e-3);
 
2467
}
 
2468
 
 
2469
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, Demosaicing, ALL_DEVICES);
 
2470
 
 
2471
///////////////////////////////////////////////////////////////////////////////////////////////////////
 
2472
// swapChannels
 
2473
 
 
2474
PARAM_TEST_CASE(SwapChannels, cv::cuda::DeviceInfo, cv::Size, UseRoi)
 
2475
{
 
2476
    cv::cuda::DeviceInfo devInfo;
 
2477
    cv::Size size;
 
2478
    bool useRoi;
 
2479
 
 
2480
    virtual void SetUp()
 
2481
    {
 
2482
        devInfo = GET_PARAM(0);
 
2483
        size = GET_PARAM(1);
 
2484
        useRoi = GET_PARAM(2);
 
2485
 
 
2486
        cv::cuda::setDevice(devInfo.deviceID());
 
2487
    }
 
2488
};
 
2489
 
 
2490
CUDA_TEST_P(SwapChannels, Accuracy)
 
2491
{
 
2492
    cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
 
2493
    ASSERT_FALSE(src.empty());
 
2494
 
 
2495
    cv::cuda::GpuMat d_src = loadMat(src, useRoi);
 
2496
 
 
2497
    const int dstOrder[] = {2, 1, 0, 3};
 
2498
    cv::cuda::swapChannels(d_src, dstOrder);
 
2499
 
 
2500
    cv::Mat dst_gold;
 
2501
    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
2502
 
 
2503
    EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
 
2504
}
 
2505
 
 
2506
INSTANTIATE_TEST_CASE_P(CUDA_ImgProc, SwapChannels, testing::Combine(
 
2507
    ALL_DEVICES,
 
2508
    DIFFERENT_SIZES,
 
2509
    WHOLE_SUBMAT));
 
2510
 
 
2511
#endif // HAVE_CUDA