added new perf tests to core

modules/core/perf/opencl/perf_arithm.cpp

@@ -460,7 +460,7 @@ OCL_PERF_TEST_P(BitwiseAndFixture, Bitwise_and,
 
     checkDeviceMaxMemoryAllocSize(srcSize, type);
 
-    Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
     declare.in(src1, src2, WARMUP_RNG).out(dst);
 
     OCL_TEST_CYCLE() cv::bitwise_and(src1, src2, dst);
@@ -481,7 +481,7 @@ OCL_PERF_TEST_P(BitwiseXorFixture, Bitwise_xor,
 
     checkDeviceMaxMemoryAllocSize(srcSize, type);
 
-    Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
     declare.in(src1, src2, WARMUP_RNG).out(dst);
 
     OCL_TEST_CYCLE() cv::bitwise_xor(src1, src2, dst);
@@ -617,11 +617,11 @@ OCL_PERF_TEST_P(SqrtFixture, Sqrt, ::testing::Combine(
 
     checkDeviceMaxMemoryAllocSize(srcSize, type);
 
-    Mat src(srcSize, type), dst(srcSize, type);
+    UMat src(srcSize, type), dst(srcSize, type);
     randu(src, 0, 1000);
     declare.in(src).out(dst);
 
-    TEST_CYCLE() cv::sqrt(src, dst);
+    OCL_TEST_CYCLE() cv::sqrt(src, dst);
 
     SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
 }
@@ -706,6 +706,114 @@ OCL_PERF_TEST_P(NormFixture, DISABLED_Norm,
     SANITY_CHECK(res, 1e-6, ERROR_RELATIVE);
 }
 
+///////////// Repeat ////////////////////////
+
+typedef Size_MatType RepeatFixture;
+
+OCL_PERF_TEST_P(RepeatFixture, Repeat,
+            ::testing::Combine(OCL_PERF_ENUM(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3), OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params), nx = 2, ny = 2;
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(Size(srcSize.width * nx, srcSize.height * ny), type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::repeat(src, nx, ny, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Min ////////////////////////
+
+typedef Size_MatType MinFixture;
+
+OCL_PERF_TEST_P(MinFixture, Min,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::min(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Max ////////////////////////
+
+typedef Size_MatType MaxFixture;
+
+OCL_PERF_TEST_P(MaxFixture, Max,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::max(src1, src2, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// InRange ////////////////////////
+
+typedef Size_MatType InRangeFixture;
+
+OCL_PERF_TEST_P(InRangeFixture, InRange,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES))
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), lb(srcSize, type), ub(srcSize, type), dst(srcSize, CV_8UC1);
+    declare.in(src, lb, ub, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::inRange(src, lb, ub, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Normalize ////////////////////////
+
+CV_ENUM(NormalizeModes, CV_MINMAX, CV_L2, CV_L1, CV_C)
+
+typedef tuple<Size, MatType, NormalizeModes> NormalizeParams;
+typedef TestBaseWithParam<NormalizeParams> NormalizeFixture;
+
+OCL_PERF_TEST_P(NormalizeFixture, Normalize,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES, NormalizeModes::all()))
+{
+    const NormalizeParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params), mode = get<2>(params);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type), dst(srcSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::normalize(src, dst, 10, 110, mode);
+
+    SANITY_CHECK(dst, 5e-2);
+}
+
 } } // namespace cvtest::ocl
 
 #endif // HAVE_OPENCL

modules/core/perf/opencl/perf_channels.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//    Jin Ma,       jin@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace cvtest {
+namespace ocl {
+
+///////////// Merge////////////////////////
+
+typedef tuple<Size, MatDepth, int> MergeParams;
+typedef TestBaseWithParam<MergeParams> MergeFixture;
+
+OCL_PERF_TEST_P(MergeFixture, Merge,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_PERF_ENUM(CV_8U, CV_32F), Values(2, 3)))
+{
+    const MergeParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int depth = get<1>(params), cn = get<2>(params), dtype = CV_MAKE_TYPE(depth, cn);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, dtype);
+
+    UMat dst(srcSize, dtype);
+    vector<UMat> src(cn);
+    for (vector<UMat>::iterator i = src.begin(), end = src.end(); i != end; ++i)
+    {
+        i->create(srcSize, CV_MAKE_TYPE(depth, 1));
+        declare.in(*i, WARMUP_RNG);
+    }
+    declare.out(dst);
+
+    OCL_TEST_CYCLE() cv::merge(src, dst);
+
+    SANITY_CHECK(dst);
+}
+
+///////////// Split ////////////////////////
+
+typedef MergeParams SplitParams;
+typedef TestBaseWithParam<SplitParams> SplitFixture;
+
+OCL_PERF_TEST_P(SplitFixture, Split,
+                ::testing::Combine(OCL_TEST_SIZES, OCL_PERF_ENUM(CV_8U, CV_32F), Values(2, 3)))
+{
+    const SplitParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int depth = get<1>(params), cn = get<2>(params), type = CV_MAKE_TYPE(depth, cn);
+
+    ASSERT_TRUE(cn == 3 || cn == 2);
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat src(srcSize, type);
+    std::vector<UMat> dst(cn, UMat(srcSize, CV_MAKE_TYPE(depth, 1)));
+
+    declare.in(src, WARMUP_RNG);
+    for (int i = 0; i < cn; ++i)
+        declare.in(dst[i]);
+
+    OCL_TEST_CYCLE() cv::split(src, dst);
+
+    ASSERT_EQ(cn, (int)dst.size());
+
+    if (cn == 2)
+    {
+        UMat & dst0 = dst[0], & dst1 = dst[1];
+        SANITY_CHECK(dst0);
+        SANITY_CHECK(dst1);
+    }
+    else
+    {
+        UMat & dst0 = dst[0], & dst1 = dst[1], & dst2 = dst[2];
+        SANITY_CHECK(dst0);
+        SANITY_CHECK(dst1);
+        SANITY_CHECK(dst2);
+    }
+}
+
+///////////// MixChannels ////////////////////////
+
+typedef tuple<Size, MatDepth> MixChannelsParams;
+typedef TestBaseWithParam<MixChannelsParams> MixChannelsFixture;
+
+OCL_PERF_TEST_P(MixChannelsFixture, MixChannels,
+                ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3),
+                                   OCL_PERF_ENUM(CV_8U, CV_32F)))
+{
+    const MixChannelsParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int depth = get<1>(params), type = CV_MAKE_TYPE(depth, 2), n = 2;
+
+    checkDeviceMaxMemoryAllocSize(srcSize, type);
+
+    UMat templ(srcSize, type);
+    std::vector<UMat> src(n, templ), dst(n, templ);
+    for (int i = 0; i < n; ++i)
+        declare.in(src[i], WARMUP_RNG).out(dst[i]);
+
+    int fromTo[] = { 1,2, 2,0, 0,3, 3,1 };
+
+    OCL_TEST_CYCLE() cv::mixChannels(src, dst, fromTo, 4);
+
+    UMat & dst0 = dst[0], & dst1 = dst[1];
+    SANITY_CHECK(dst0);
+    SANITY_CHECK(dst1);
+}
+
+} } // namespace cvtest::ocl
+
+#endif // HAVE_OPENCL

modules/core/perf/opencl/perf_dxt.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//    Jin Ma,       jin@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace cvtest {
+namespace ocl {
+
+///////////// dft ////////////////////////
+
+typedef tuple<Size, int> DftParams;
+typedef TestBaseWithParam<DftParams> DftFixture;
+
+OCL_PERF_TEST_P(DftFixture, Dft, ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3),
+                                                Values((int)DFT_ROWS, (int)DFT_SCALE, (int)DFT_INVERSE,
+                                                       (int)DFT_INVERSE | DFT_SCALE, (int)DFT_ROWS | DFT_INVERSE)))
+{
+    const DftParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int flags = get<1>(params);
+
+    UMat src(srcSize, CV_32FC2), dst(srcSize, CV_32FC2);
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::dft(src, dst, flags | DFT_COMPLEX_OUTPUT);
+
+    SANITY_CHECK(dst, 1e-3);
+}
+
+///////////// MulSpectrums ////////////////////////
+
+typedef tuple<Size, bool> MulSpectrumsParams;
+typedef TestBaseWithParam<MulSpectrumsParams> MulSpectrumsFixture;
+
+OCL_PERF_TEST_P(MulSpectrumsFixture, MulSpectrums,
+                ::testing::Combine(Values(OCL_SIZE_1, OCL_SIZE_2, OCL_SIZE_3),
+                                   Bool()))
+{
+    const MulSpectrumsParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const bool conj = get<1>(params);
+
+    UMat src1(srcSize, CV_32FC2), src2(srcSize, CV_32FC2), dst(srcSize, CV_32FC2);
+    declare.in(src1, src2, WARMUP_RNG).out(dst);
+
+    OCL_TEST_CYCLE() cv::mulSpectrums(src1, src2, dst, 0, conj);
+
+    SANITY_CHECK(dst, 1e-3);
+}
+
+} } // namespace cvtest::ocl
+
+#endif // HAVE_OPENCL

modules/core/perf/opencl/perf_gemm.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Fangfang Bai, fangfang@multicorewareinc.com
+//    Jin Ma,       jin@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace cvtest {
+namespace ocl {
+
+///////////// gemm ////////////////////////
+
+typedef tuple<Size, int> GemmParams;
+typedef TestBaseWithParam<GemmParams> GemmFixture;
+
+OCL_PERF_TEST_P(GemmFixture, Gemm, ::testing::Combine(
+                    ::testing::Values(Size(1000, 1000), Size(1500, 1500)),
+            Values((int)cv::GEMM_3_T, (int)cv::GEMM_3_T | (int)cv::GEMM_2_T)))
+{
+    GemmParams params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int flags = get<1>(params);
+
+    UMat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
+            src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
+    declare.in(src1, src2, src3).out(dst);
+    randu(src1, -10.0f, 10.0f);
+    randu(src2, -10.0f, 10.0f);
+    randu(src3, -10.0f, 10.0f);
+
+    OCL_TEST_CYCLE() cv::gemm(src1, src2, 0.6, src3, 1.5, dst, flags);
+
+    SANITY_CHECK(dst, 0.01);
+}
+
+} } // namespace cvtest::ocl
+
+#endif // HAVE_OPENCL

modules/core/src/arithm.cpp

@@ -1409,7 +1409,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
     int wtype, dims1 = psrc1->dims(), dims2 = psrc2->dims();
     Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
     Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
-    bool use_opencl = _dst.kind() == _OutputArray::UMAT && ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2;
+    bool use_opencl = _dst.isUMat() && ocl::useOpenCL() && dims1 <= 2 && dims2 <= 2;
     bool src1Scalar = checkScalar(*psrc1, type2, kind1, kind2);
     bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1);
 

modules/core/src/convert.cpp

@@ -619,9 +619,11 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
     if(npairs == 0)
         return;
     bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
-                      src.kind() != _InputArray::STD_VECTOR_VECTOR;
+            src.kind() != _InputArray::STD_VECTOR_VECTOR &&
+            src.kind() != _InputArray::STD_VECTOR_UMAT;
     bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT &&
-                      dst.kind() != _InputArray::STD_VECTOR_VECTOR;
+            dst.kind() != _InputArray::STD_VECTOR_VECTOR &&
+            dst.kind() != _InputArray::STD_VECTOR_UMAT;
     int i;
     int nsrc = src_is_mat ? 1 : (int)src.total();
     int ndst = dst_is_mat ? 1 : (int)dst.total();
@@ -642,9 +644,11 @@ void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
     if(fromTo.empty())
         return;
     bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
-                      src.kind() != _InputArray::STD_VECTOR_VECTOR;
+            src.kind() != _InputArray::STD_VECTOR_VECTOR &&
+            src.kind() != _InputArray::STD_VECTOR_UMAT;
     bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT &&
-                      dst.kind() != _InputArray::STD_VECTOR_VECTOR;
+            dst.kind() != _InputArray::STD_VECTOR_VECTOR &&
+            dst.kind() != _InputArray::STD_VECTOR_UMAT;
     int i;
     int nsrc = src_is_mat ? 1 : (int)src.total();
     int ndst = dst_is_mat ? 1 : (int)dst.total();

modules/core/test/ocl/test_arithm.cpp

@@ -1234,7 +1234,7 @@ OCL_TEST_P(Normalize, Mat)
         for (int i = 0, size = sizeof(modes) / sizeof(modes[0]); i < size; ++i)
         {
             OCL_OFF(cv::normalize(src1_roi, dst1_roi, 10, 110, modes[i], src1_roi.type(), mask_roi));
-            OCL_ON(cv::normalize(usrc1_roi, udst1_roi,  10, 110, modes[i], src1_roi.type(), umask_roi));
+            OCL_ON(cv::normalize(usrc1_roi, udst1_roi, 10, 110, modes[i], src1_roi.type(), umask_roi));
 
             Near(1);
         }

modules/core/test/test_misc.cpp

@@ -25,7 +25,7 @@ TEST(Core_Drawing, _914)
 }
 
 
-TEST(Core_OutputArraySreate, _1997)
+TEST(Core_OutputArrayCreate, _1997)
 {
     struct local {
         static void create(OutputArray arr, Size submatSize, int type)