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 #if defined(HAVE_CUDA) && defined(HAVE_OPENGL) 46 47 #include "opencv2/core/cuda.hpp" 48 #include "opencv2/core/opengl.hpp" 49 #include "opencv2/ts/cuda_test.hpp" 50 51 using namespace cvtest; 52 53 ///////////////////////////////////////////// 54 // Buffer 55 56 PARAM_TEST_CASE(Buffer, cv::Size, MatType) 57 { 58 static void SetUpTestCase() 59 { 60 cv::namedWindow("test", cv::WINDOW_OPENGL); 61 } 62 63 static void TearDownTestCase() 64 { 65 cv::destroyAllWindows(); 66 } 67 68 cv::Size size; 69 int type; 70 71 virtual void SetUp() 72 { 73 size = GET_PARAM(0); 74 type = GET_PARAM(1); 75 } 76 }; 77 78 CUDA_TEST_P(Buffer, Constructor1) 79 { 80 cv::ogl::Buffer buf(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true); 81 82 EXPECT_EQ(size.height, buf.rows()); 83 EXPECT_EQ(size.width, buf.cols()); 84 EXPECT_EQ(type, buf.type()); 85 } 86 87 CUDA_TEST_P(Buffer, Constructor2) 88 { 89 cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); 90 91 EXPECT_EQ(size.height, buf.rows()); 92 EXPECT_EQ(size.width, buf.cols()); 93 EXPECT_EQ(type, buf.type()); 94 } 95 96 CUDA_TEST_P(Buffer, ConstructorFromMat) 97 { 98 cv::Mat gold = randomMat(size, type); 99 100 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 101 102 cv::Mat bufData; 103 buf.copyTo(bufData); 104 105 EXPECT_MAT_NEAR(gold, bufData, 0); 106 } 107 108 CUDA_TEST_P(Buffer, ConstructorFromGpuMat) 109 { 110 cv::Mat gold = randomMat(size, type); 111 cv::cuda::GpuMat d_gold(gold); 112 113 cv::ogl::Buffer buf(d_gold, cv::ogl::Buffer::ARRAY_BUFFER); 114 115 cv::Mat bufData; 116 buf.copyTo(bufData); 117 118 EXPECT_MAT_NEAR(gold, bufData, 0); 119 } 120 121 CUDA_TEST_P(Buffer, ConstructorFromBuffer) 122 { 123 cv::ogl::Buffer buf_gold(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); 124 125 cv::ogl::Buffer buf(buf_gold); 126 127 EXPECT_EQ(buf_gold.bufId(), buf.bufId()); 128 EXPECT_EQ(buf_gold.rows(), buf.rows()); 129 EXPECT_EQ(buf_gold.cols(), buf.cols()); 130 EXPECT_EQ(buf_gold.type(), buf.type()); 131 } 132 133 CUDA_TEST_P(Buffer, Create) 134 { 135 cv::ogl::Buffer buf; 136 buf.create(size.height, size.width, type, cv::ogl::Buffer::ARRAY_BUFFER, true); 137 138 EXPECT_EQ(size.height, buf.rows()); 139 EXPECT_EQ(size.width, buf.cols()); 140 EXPECT_EQ(type, buf.type()); 141 } 142 143 CUDA_TEST_P(Buffer, CopyFromMat) 144 { 145 cv::Mat gold = randomMat(size, type); 146 147 cv::ogl::Buffer buf; 148 buf.copyFrom(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 149 150 cv::Mat bufData; 151 buf.copyTo(bufData); 152 153 EXPECT_MAT_NEAR(gold, bufData, 0); 154 } 155 156 CUDA_TEST_P(Buffer, CopyFromGpuMat) 157 { 158 cv::Mat gold = randomMat(size, type); 159 cv::cuda::GpuMat d_gold(gold); 160 161 cv::ogl::Buffer buf; 162 buf.copyFrom(d_gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 163 164 cv::Mat bufData; 165 buf.copyTo(bufData); 166 167 EXPECT_MAT_NEAR(gold, bufData, 0); 168 } 169 170 CUDA_TEST_P(Buffer, CopyFromBuffer) 171 { 172 cv::Mat gold = randomMat(size, type); 173 cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 174 175 cv::ogl::Buffer buf; 176 buf.copyFrom(buf_gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 177 178 EXPECT_NE(buf_gold.bufId(), buf.bufId()); 179 180 cv::Mat bufData; 181 buf.copyTo(bufData); 182 183 EXPECT_MAT_NEAR(gold, bufData, 0); 184 } 185 186 CUDA_TEST_P(Buffer, CopyToGpuMat) 187 { 188 cv::Mat gold = randomMat(size, type); 189 190 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 191 192 cv::cuda::GpuMat dst; 193 buf.copyTo(dst); 194 195 EXPECT_MAT_NEAR(gold, dst, 0); 196 } 197 198 CUDA_TEST_P(Buffer, CopyToBuffer) 199 { 200 cv::Mat gold = randomMat(size, type); 201 202 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 203 204 cv::ogl::Buffer dst; 205 buf.copyTo(dst); 206 dst.setAutoRelease(true); 207 208 EXPECT_NE(buf.bufId(), dst.bufId()); 209 210 cv::Mat bufData; 211 dst.copyTo(bufData); 212 213 EXPECT_MAT_NEAR(gold, bufData, 0); 214 } 215 216 CUDA_TEST_P(Buffer, Clone) 217 { 218 cv::Mat gold = randomMat(size, type); 219 220 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 221 222 cv::ogl::Buffer dst = buf.clone(cv::ogl::Buffer::ARRAY_BUFFER, true); 223 224 EXPECT_NE(buf.bufId(), dst.bufId()); 225 226 cv::Mat bufData; 227 dst.copyTo(bufData); 228 229 EXPECT_MAT_NEAR(gold, bufData, 0); 230 } 231 232 CUDA_TEST_P(Buffer, MapHostRead) 233 { 234 cv::Mat gold = randomMat(size, type); 235 236 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 237 238 cv::Mat dst = buf.mapHost(cv::ogl::Buffer::READ_ONLY); 239 240 EXPECT_MAT_NEAR(gold, dst, 0); 241 242 buf.unmapHost(); 243 } 244 245 CUDA_TEST_P(Buffer, MapHostWrite) 246 { 247 cv::Mat gold = randomMat(size, type); 248 249 cv::ogl::Buffer buf(size, type, cv::ogl::Buffer::ARRAY_BUFFER, true); 250 251 cv::Mat dst = buf.mapHost(cv::ogl::Buffer::WRITE_ONLY); 252 gold.copyTo(dst); 253 buf.unmapHost(); 254 dst.release(); 255 256 cv::Mat bufData; 257 buf.copyTo(bufData); 258 259 EXPECT_MAT_NEAR(gold, bufData, 0); 260 } 261 262 CUDA_TEST_P(Buffer, MapDevice) 263 { 264 cv::Mat gold = randomMat(size, type); 265 266 cv::ogl::Buffer buf(gold, cv::ogl::Buffer::ARRAY_BUFFER, true); 267 268 cv::cuda::GpuMat dst = buf.mapDevice(); 269 270 EXPECT_MAT_NEAR(gold, dst, 0); 271 272 buf.unmapDevice(); 273 } 274 275 INSTANTIATE_TEST_CASE_P(OpenGL, Buffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); 276 277 ///////////////////////////////////////////// 278 // Texture2D 279 280 PARAM_TEST_CASE(Texture2D, cv::Size, MatType) 281 { 282 static void SetUpTestCase() 283 { 284 cv::namedWindow("test", cv::WINDOW_OPENGL); 285 } 286 287 static void TearDownTestCase() 288 { 289 cv::destroyAllWindows(); 290 } 291 292 cv::Size size; 293 int type; 294 int depth; 295 int cn; 296 cv::ogl::Texture2D::Format format; 297 298 virtual void SetUp() 299 { 300 size = GET_PARAM(0); 301 type = GET_PARAM(1); 302 303 depth = CV_MAT_DEPTH(type); 304 cn = CV_MAT_CN(type); 305 format = cn == 1 ? cv::ogl::Texture2D::DEPTH_COMPONENT : cn == 3 ? cv::ogl::Texture2D::RGB : cn == 4 ? cv::ogl::Texture2D::RGBA : cv::ogl::Texture2D::NONE; 306 } 307 }; 308 309 CUDA_TEST_P(Texture2D, Constructor1) 310 { 311 cv::ogl::Texture2D tex(size.height, size.width, format, true); 312 313 EXPECT_EQ(size.height, tex.rows()); 314 EXPECT_EQ(size.width, tex.cols()); 315 EXPECT_EQ(format, tex.format()); 316 } 317 318 CUDA_TEST_P(Texture2D, Constructor2) 319 { 320 cv::ogl::Texture2D tex(size, format, true); 321 322 EXPECT_EQ(size.height, tex.rows()); 323 EXPECT_EQ(size.width, tex.cols()); 324 EXPECT_EQ(format, tex.format()); 325 } 326 327 CUDA_TEST_P(Texture2D, ConstructorFromMat) 328 { 329 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 330 331 cv::ogl::Texture2D tex(gold, true); 332 333 cv::Mat texData; 334 tex.copyTo(texData, depth); 335 336 EXPECT_MAT_NEAR(gold, texData, 1e-2); 337 } 338 339 CUDA_TEST_P(Texture2D, ConstructorFromGpuMat) 340 { 341 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 342 cv::cuda::GpuMat d_gold(gold); 343 344 cv::ogl::Texture2D tex(d_gold, true); 345 346 cv::Mat texData; 347 tex.copyTo(texData, depth); 348 349 EXPECT_MAT_NEAR(gold, texData, 1e-2); 350 } 351 352 CUDA_TEST_P(Texture2D, ConstructorFromBuffer) 353 { 354 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 355 cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true); 356 357 cv::ogl::Texture2D tex(buf_gold, true); 358 359 cv::Mat texData; 360 tex.copyTo(texData, depth); 361 362 EXPECT_MAT_NEAR(gold, texData, 1e-2); 363 } 364 365 CUDA_TEST_P(Texture2D, ConstructorFromTexture2D) 366 { 367 cv::ogl::Texture2D tex_gold(size, format, true); 368 cv::ogl::Texture2D tex(tex_gold); 369 370 EXPECT_EQ(tex_gold.texId(), tex.texId()); 371 EXPECT_EQ(tex_gold.rows(), tex.rows()); 372 EXPECT_EQ(tex_gold.cols(), tex.cols()); 373 EXPECT_EQ(tex_gold.format(), tex.format()); 374 } 375 376 CUDA_TEST_P(Texture2D, Create) 377 { 378 cv::ogl::Texture2D tex; 379 tex.create(size.height, size.width, format, true); 380 381 EXPECT_EQ(size.height, tex.rows()); 382 EXPECT_EQ(size.width, tex.cols()); 383 EXPECT_EQ(format, tex.format()); 384 } 385 386 CUDA_TEST_P(Texture2D, CopyFromMat) 387 { 388 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 389 390 cv::ogl::Texture2D tex; 391 tex.copyFrom(gold, true); 392 393 cv::Mat texData; 394 tex.copyTo(texData, depth); 395 396 EXPECT_MAT_NEAR(gold, texData, 1e-2); 397 } 398 399 CUDA_TEST_P(Texture2D, CopyFromGpuMat) 400 { 401 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 402 cv::cuda::GpuMat d_gold(gold); 403 404 cv::ogl::Texture2D tex; 405 tex.copyFrom(d_gold, true); 406 407 cv::Mat texData; 408 tex.copyTo(texData, depth); 409 410 EXPECT_MAT_NEAR(gold, texData, 1e-2); 411 } 412 413 CUDA_TEST_P(Texture2D, CopyFromBuffer) 414 { 415 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 416 cv::ogl::Buffer buf_gold(gold, cv::ogl::Buffer::PIXEL_UNPACK_BUFFER, true); 417 418 cv::ogl::Texture2D tex; 419 tex.copyFrom(buf_gold, true); 420 421 cv::Mat texData; 422 tex.copyTo(texData, depth); 423 424 EXPECT_MAT_NEAR(gold, texData, 1e-2); 425 } 426 427 CUDA_TEST_P(Texture2D, CopyToGpuMat) 428 { 429 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 430 431 cv::ogl::Texture2D tex(gold, true); 432 433 cv::cuda::GpuMat dst; 434 tex.copyTo(dst, depth); 435 436 EXPECT_MAT_NEAR(gold, dst, 1e-2); 437 } 438 439 CUDA_TEST_P(Texture2D, CopyToBuffer) 440 { 441 cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); 442 443 cv::ogl::Texture2D tex(gold, true); 444 445 cv::ogl::Buffer dst; 446 tex.copyTo(dst, depth, true); 447 448 cv::Mat bufData; 449 dst.copyTo(bufData); 450 451 EXPECT_MAT_NEAR(gold, bufData, 1e-2); 452 } 453 454 INSTANTIATE_TEST_CASE_P(OpenGL, Texture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4))); 455 456 #endif 457
