From 65d64af2a8c05746d4e2346d1e224929c09887ad Mon Sep 17 00:00:00 2001 From: krodyush Date: Wed, 19 Mar 2014 19:31:14 +0400 Subject: [PATCH 01/52] ocl_calcOpticalFlowPyrLK optimizations 1. decrease branch number in CL code by replacing them into weights 2. decrease local mem pressure in reduce operation by using private variables 3. decrease image sampler pressure by caching data into local memory 4. remove unnecessary sync point on the HOST side. --- modules/video/src/lkpyramid.cpp | 2 +- modules/video/src/opencl/pyrlk.cl | 210 ++++++++++++++++-------------- 2 files changed, 116 insertions(+), 96 deletions(-) diff --git a/modules/video/src/lkpyramid.cpp b/modules/video/src/lkpyramid.cpp index cd57585658..c95835d9c2 100644 --- a/modules/video/src/lkpyramid.cpp +++ b/modules/video/src/lkpyramid.cpp @@ -989,7 +989,7 @@ namespace cv idxArg = kernel.set(idxArg, (int)winSize.height); // int c_winSize_y idxArg = kernel.set(idxArg, (int)iters); // int c_iters idxArg = kernel.set(idxArg, (char)calcErr); //char calcErr - return kernel.run(2, globalThreads, localThreads, true); + return kernel.run(2, globalThreads, localThreads, false); } private: inline static bool isDeviceCPU() diff --git a/modules/video/src/opencl/pyrlk.cl b/modules/video/src/opencl/pyrlk.cl index c018554902..45571c7b66 100644 --- a/modules/video/src/opencl/pyrlk.cl +++ b/modules/video/src/opencl/pyrlk.cl @@ -45,11 +45,15 @@ // //M*/ -#define BUFFER 64 -#define BUFFER2 BUFFER>>1 +#define GRIDSIZE 3 +#define LSx 8 +#define LSy 8 +#define BUFFER (LSx*LSy) +#define BUFFER2 BUFFER>>1 #ifndef WAVE_SIZE #define WAVE_SIZE 1 #endif + #ifdef CPU inline void reduce3(float val1, float val2, float val3, __local float* smem1, __local float* smem2, __local float* smem3, int tid) @@ -128,24 +132,21 @@ inline void reduce3(float val1, float val2, float val3, #if WAVE_SIZE <16 } barrier(CLK_LOCAL_MEM_FENCE); - if (tid < 8) + if (tid<1) { #endif - smem1[tid] += smem1[tid + 8]; - smem2[tid] += smem2[tid + 8]; - smem3[tid] += smem3[tid + 8]; - - smem1[tid] += smem1[tid + 4]; - smem2[tid] += smem2[tid + 4]; - smem3[tid] += smem3[tid + 4]; - - smem1[tid] += smem1[tid + 2]; - smem2[tid] += smem2[tid + 2]; - smem3[tid] += smem3[tid + 2]; - - smem1[tid] += smem1[tid + 1]; - smem2[tid] += smem2[tid + 1]; - smem3[tid] += smem3[tid + 1]; + local float8* m1 = (local float8*)smem1; + local float8* m2 = (local float8*)smem2; + local float8* m3 = (local float8*)smem3; + float8 t1 = m1[0]+m1[1]; + float8 t2 = m2[0]+m2[1]; + float8 t3 = m3[0]+m3[1]; + float4 t14 = t1.lo + t1.hi; + float4 t24 = t2.lo + t2.hi; + float4 t34 = t3.lo + t3.hi; + smem1[0] = t14.x+t14.y+t14.z+t14.w; + smem2[0] = t24.x+t24.y+t24.z+t24.w; + smem3[0] = t34.x+t34.y+t34.z+t34.w; } barrier(CLK_LOCAL_MEM_FENCE); } @@ -171,20 +172,17 @@ inline void reduce2(float val1, float val2, __local volatile float* smem1, __loc #if WAVE_SIZE <16 } barrier(CLK_LOCAL_MEM_FENCE); - if (tid < 8) + if (tid<1) { #endif - smem1[tid] += smem1[tid + 8]; - smem2[tid] += smem2[tid + 8]; - - smem1[tid] += smem1[tid + 4]; - smem2[tid] += smem2[tid + 4]; - - smem1[tid] += smem1[tid + 2]; - smem2[tid] += smem2[tid + 2]; - - smem1[tid] += smem1[tid + 1]; - smem2[tid] += smem2[tid + 1]; + local float8* m1 = (local float8*)smem1; + local float8* m2 = (local float8*)smem2; + float8 t1 = m1[0]+m1[1]; + float8 t2 = m2[0]+m2[1]; + float4 t14 = t1.lo + t1.hi; + float4 t24 = t2.lo + t2.hi; + smem1[0] = t14.x+t14.y+t14.z+t14.w; + smem2[0] = t24.x+t24.y+t24.z+t24.w; } barrier(CLK_LOCAL_MEM_FENCE); } @@ -207,13 +205,13 @@ inline void reduce1(float val1, __local volatile float* smem1, int tid) #if WAVE_SIZE <16 } barrier(CLK_LOCAL_MEM_FENCE); - if (tid < 8) + if (tid<1) { #endif - smem1[tid] += smem1[tid + 8]; - smem1[tid] += smem1[tid + 4]; - smem1[tid] += smem1[tid + 2]; - smem1[tid] += smem1[tid + 1]; + local float8* m1 = (local float8*)smem1; + float8 t1 = m1[0]+m1[1]; + float4 t14 = t1.lo + t1.hi; + smem1[0] = t14.x+t14.y+t14.z+t14.w; } barrier(CLK_LOCAL_MEM_FENCE); } @@ -225,18 +223,21 @@ inline void reduce1(float val1, __local volatile float* smem1, int tid) // Image read mode __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_LINEAR; -inline void SetPatch(image2d_t I, float x, float y, +// macro to get pixel value from local memory +#define VAL(_y,_x,_yy,_xx) (IPatchLocal[yid+((_y)*LSy)+1+(_yy)][xid+((_x)*LSx)+1+(_xx)]) +inline void SetPatch(local float IPatchLocal[LSy*GRIDSIZE+2][LSx*GRIDSIZE+2], int TileY, int TileX, float* Pch, float* Dx, float* Dy, - float* A11, float* A12, float* A22) + float* A11, float* A12, float* A22, float w) { - *Pch = read_imagef(I, sampler, (float2)(x, y)).x; + unsigned int xid=get_local_id(0); + unsigned int yid=get_local_id(1); + *Pch = VAL(TileY,TileX,0,0); - float dIdx = 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x + 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x - - (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x - 1, y)).x + 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x); - - float dIdy = 3.0f * read_imagef(I, sampler, (float2)(x - 1, y + 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y + 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y + 1)).x - - (3.0f * read_imagef(I, sampler, (float2)(x - 1, y - 1)).x + 10.0f * read_imagef(I, sampler, (float2)(x, y - 1)).x + 3.0f * read_imagef(I, sampler, (float2)(x + 1, y - 1)).x); + float dIdx = (3.0f*VAL(TileY,TileX,-1,1)+10.0f*VAL(TileY,TileX,0,1)+3.0f*VAL(TileY,TileX,+1,1))-(3.0f*VAL(TileY,TileX,-1,-1)+10.0f*VAL(TileY,TileX,0,-1)+3.0f*VAL(TileY,TileX,+1,-1)); + float dIdy = (3.0f*VAL(TileY,TileX,1,-1)+10.0f*VAL(TileY,TileX,1,0)+3.0f*VAL(TileY,TileX,1,+1))-(3.0f*VAL(TileY,TileX,-1,-1)+10.0f*VAL(TileY,TileX,-1,0)+3.0f*VAL(TileY,TileX,-1,+1)); + dIdx *= w; + dIdy *= w; *Dx = dIdx; *Dy = dIdy; @@ -245,6 +246,7 @@ inline void SetPatch(image2d_t I, float x, float y, *A12 += dIdx * dIdy; *A22 += dIdy * dIdy; } +#undef VAL inline void GetPatch(image2d_t J, float x, float y, float* Pch, float* Dx, float* Dy, @@ -303,7 +305,38 @@ inline void GetError4(image2d_t J, const float x, const float y, const float4* P *errval += fabs(diff.x) + fabs(diff.y) + fabs(diff.z); } -#define GRIDSIZE 3 + +//macro to read pixel value into local memory. +#define READI(_y,_x) IPatchLocal[yid+((_y)*LSy)][xid+((_x)*LSx)] = read_imagef(I, sampler, (float2)(Point.x + xid+(_x)*LSx + 0.5f-1, Point.y + yid+(_y)*LSy+ 0.5f-1)).x; +void ReadPatchIToLocalMem(image2d_t I, float2 Point, local float IPatchLocal[LSy*GRIDSIZE+2][LSx*GRIDSIZE+2]) +{ + unsigned int xid=get_local_id(0); + unsigned int yid=get_local_id(1); + //read (3*LSx)*(3*LSy) window. each macro call read LSx*LSy pixels block + READI(0,0);READI(0,1);READI(0,2); + READI(1,0);READI(1,1);READI(1,2); + READI(2,0);READI(2,1);READI(2,2); + if(xid<2) + {// read last 2 columns border. each macro call reads 2*LSy pixels block + READI(0,3); + READI(1,3); + READI(2,3); + } + + if(yid<2) + {// read last 2 row. each macro call reads LSx*2 pixels block + READI(3,0);READI(3,1);READI(3,2); + } + + if(yid<2 && xid<2) + {// read right bottom 2x2 corner. one macro call reads 2*2 pixels block + READI(3,3); + } + barrier(CLK_LOCAL_MEM_FENCE); +} +#undef READI + +__attribute__((reqd_work_group_size(LSx, LSy, 1))) __kernel void lkSparse(image2d_t I, image2d_t J, __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err, const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr) @@ -318,6 +351,8 @@ __kernel void lkSparse(image2d_t I, image2d_t J, unsigned int xsize=get_local_size(0); unsigned int ysize=get_local_size(1); int xBase, yBase, k; + float wx = ((xid+2*xsize)>1, (c_winSize_y - 1)>>1); @@ -346,65 +381,54 @@ __kernel void lkSparse(image2d_t I, image2d_t J, float dIdx_patch[GRIDSIZE][GRIDSIZE]; float dIdy_patch[GRIDSIZE][GRIDSIZE]; - yBase=yid; + // local memory to read image with border to calc sobels + local float IPatchLocal[LSy*GRIDSIZE+2][LSx*GRIDSIZE+2]; + ReadPatchIToLocalMem(I,prevPt,IPatchLocal); + { - xBase=xid; - SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f, + SetPatch(IPatchLocal, 0, 0, &I_patch[0][0], &dIdx_patch[0][0], &dIdy_patch[0][0], - &A11, &A12, &A22); + &A11, &A12, &A22,1); - xBase+=xsize; - SetPatch(I, prevPt.x + xBase + 0.5f, prevPt.y + yBase + 0.5f, + SetPatch(IPatchLocal, 0, 1, &I_patch[0][1], &dIdx_patch[0][1], &dIdy_patch[0][1], - &A11, &A12, &A22); + &A11, &A12, &A22,1); - xBase+=xsize; - if(xBase Date: Thu, 27 Mar 2014 17:08:05 +0400 Subject: [PATCH 02/52] both tests by picture and rand mat --- modules/imgproc/test/ocl/test_histogram.cpp | 40 ++++++++++++++++++++- modules/ts/include/opencv2/ts/ocl_test.hpp | 11 ++++++ 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/modules/imgproc/test/ocl/test_histogram.cpp b/modules/imgproc/test/ocl/test_histogram.cpp index 0a27907b63..7d52fc1de3 100644 --- a/modules/imgproc/test/ocl/test_histogram.cpp +++ b/modules/imgproc/test/ocl/test_histogram.cpp @@ -13,6 +13,7 @@ // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. +// Copyright (C) 2013-2014, Itseez, Inc, all rights reserved. // Third party copyrights are property of their respective owners. // // @Authors @@ -144,6 +145,36 @@ PARAM_TEST_CASE(CalcBackProject, MatDepth, int, bool) scale = randomDouble(0.1, 1); } + + virtual void test_by_pict() + { + Mat frame1 = readImage("optflow/RubberWhale1.png", IMREAD_GRAYSCALE); + + UMat usrc; + frame1.copyTo(usrc); + int histSize = randomInt(3, 29); + float hue_range[] = { 0, 180 }; + const float* ranges = { hue_range }; + + //compute histogram + calcHist(&frame1, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false); + normalize(hist, hist, 0, 255, NORM_MINMAX, -1, Mat()); + + Mat dst; + UMat udst, src, uhist; + hist.copyTo(uhist); + std::vector uims; + uims.push_back(usrc); + std::vector urngs; + urngs.push_back(0); + urngs.push_back(180); + std::vector chs; + chs.push_back(0); + + OCL_OFF(calcBackProject(&frame1, 1, 0, hist, dst, &ranges, 1, true)); + OCL_ON(calcBackProject(uims, chs, uhist, udst, urngs, 1.0)); + EXPECT_MAT_NEAR(dst, udst, 0.0); + } }; //////////////////////////////// CalcBackProject ////////////////////////////////////////////// @@ -157,7 +188,14 @@ OCL_TEST_P(CalcBackProject, Mat) OCL_OFF(cv::calcBackProject(images_roi, channels, hist_roi, dst_roi, ranges, scale)); OCL_ON(cv::calcBackProject(uimages_roi, channels, uhist_roi, udst_roi, ranges, scale)); - OCL_EXPECT_MATS_NEAR(dst, 0.0); + Size dstSize = dst_roi.size(); + int nDiffs = (int)(0.03f*dstSize.height*dstSize.width); + + //check if the dst mats are the same except 3% difference + EXPECT_MAT_N_DIFF(dst_roi, udst_roi, nDiffs); + + //check in addition on given image + test_by_pict(); } } diff --git a/modules/ts/include/opencv2/ts/ocl_test.hpp b/modules/ts/include/opencv2/ts/ocl_test.hpp index 0f0d9657fe..28ff674911 100644 --- a/modules/ts/include/opencv2/ts/ocl_test.hpp +++ b/modules/ts/include/opencv2/ts/ocl_test.hpp @@ -85,6 +85,17 @@ do \ << "Size: " << mat1.size() << std::endl; \ } while ((void)0, 0) +#define EXPECT_MAT_N_DIFF(mat1, mat2, num) \ +do \ +{ \ + ASSERT_EQ(mat1.type(), mat2.type()); \ + ASSERT_EQ(mat1.size(), mat2.size()); \ + Mat diff; \ + absdiff(mat1, mat2, diff); \ + EXPECT_LE(countNonZero(diff.reshape(1)), num) \ + << "Size: " << mat1.size() << std::endl; \ +} while ((void)0, 0) + #define OCL_EXPECT_MATS_NEAR(name, eps) \ do \ { \ From 91511c1521470d10b6a824b2c053bf47a02d948c Mon Sep 17 00:00:00 2001 From: JinoBetti Date: Thu, 27 Mar 2014 16:28:40 +0100 Subject: [PATCH 03/52] Update out.cpp Fixed a bug with the cv::format(cv::Mat, ...) method for matrices with only one row see http://answers.opencv.org/question/21201/cvformat-does-not-format-the-way-it-should/?answer=23945#post-id-23945 for details --- modules/core/src/out.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/modules/core/src/out.cpp b/modules/core/src/out.cpp index 65190c50e3..a2894b7006 100644 --- a/modules/core/src/out.cpp +++ b/modules/core/src/out.cpp @@ -148,7 +148,7 @@ public: void write(std::ostream& out, const Mat& m, const int*, int) const { out << "["; - writeMat(out, m, ';', ' ', m.cols == 1); + writeMat(out, m, ';', ' ', m.rows == 1); out << "]"; } @@ -165,7 +165,7 @@ public: void write(std::ostream& out, const Mat& m, const int*, int) const { out << "["; - writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.cols*m.channels() == 1); + writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.rows*m.channels() == 1); out << "]"; } @@ -187,7 +187,7 @@ public: "uint8", "int8", "uint16", "int16", "int32", "float32", "float64", "uint64" }; out << "array(["; - writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.cols*m.channels() == 1); + writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.rows*m.channels() == 1); out << "], type='" << numpyTypes[m.depth()] << "')"; } @@ -204,7 +204,7 @@ public: virtual ~CSVFormatter() {} void write(std::ostream& out, const Mat& m, const int*, int) const { - writeMat(out, m, ' ', ' ', m.cols*m.channels() == 1); + writeMat(out, m, ' ', ' ', m.rows*m.channels() == 1); if(m.rows > 1) out << "\n"; } @@ -223,7 +223,7 @@ public: void write(std::ostream& out, const Mat& m, const int*, int) const { out << "{"; - writeMat(out, m, ',', ' ', m.cols==1); + writeMat(out, m, ',', ' ', m.rows==1); out << "}"; } From 6d368dc1e7d0da08316c35e453917d8b7a83a583 Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Sun, 30 Mar 2014 18:02:03 -0700 Subject: [PATCH 04/52] increase epsilon for MOG2::getBackgroundImage test: it uses float arithmetics --- modules/gpu/test/test_bgfg.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/gpu/test/test_bgfg.cpp b/modules/gpu/test/test_bgfg.cpp index 6ef93c51b4..e08bfb399b 100644 --- a/modules/gpu/test/test_bgfg.cpp +++ b/modules/gpu/test/test_bgfg.cpp @@ -336,7 +336,7 @@ GPU_TEST_P(MOG2, getBackgroundImage) cv::Mat background_gold; mog2_gold.getBackgroundImage(background_gold); - ASSERT_MAT_NEAR(background_gold, background, 0); + ASSERT_MAT_NEAR(background_gold, background, 1); } INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine( From 4c5de04efb88a28a750399adc4db2010b01cc8bf Mon Sep 17 00:00:00 2001 From: mlyashko Date: Mon, 31 Mar 2014 10:58:15 +0400 Subject: [PATCH 05/52] bug fix --- modules/imgproc/test/ocl/test_histogram.cpp | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/modules/imgproc/test/ocl/test_histogram.cpp b/modules/imgproc/test/ocl/test_histogram.cpp index 7d52fc1de3..5b863bdd22 100644 --- a/modules/imgproc/test/ocl/test_histogram.cpp +++ b/modules/imgproc/test/ocl/test_histogram.cpp @@ -154,15 +154,16 @@ PARAM_TEST_CASE(CalcBackProject, MatDepth, int, bool) frame1.copyTo(usrc); int histSize = randomInt(3, 29); float hue_range[] = { 0, 180 }; - const float* ranges = { hue_range }; + const float* ranges1 = { hue_range }; + Mat hist1; //compute histogram - calcHist(&frame1, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false); - normalize(hist, hist, 0, 255, NORM_MINMAX, -1, Mat()); + calcHist(&frame1, 1, 0, Mat(), hist1, 1, &histSize, &ranges1, true, false); + normalize(hist1, hist1, 0, 255, NORM_MINMAX, -1, Mat()); - Mat dst; - UMat udst, src, uhist; - hist.copyTo(uhist); + Mat dst1; + UMat udst1, src, uhist1; + hist1.copyTo(uhist1); std::vector uims; uims.push_back(usrc); std::vector urngs; @@ -171,9 +172,9 @@ PARAM_TEST_CASE(CalcBackProject, MatDepth, int, bool) std::vector chs; chs.push_back(0); - OCL_OFF(calcBackProject(&frame1, 1, 0, hist, dst, &ranges, 1, true)); - OCL_ON(calcBackProject(uims, chs, uhist, udst, urngs, 1.0)); - EXPECT_MAT_NEAR(dst, udst, 0.0); + OCL_OFF(calcBackProject(&frame1, 1, 0, hist1, dst1, &ranges1, 1, true)); + OCL_ON(calcBackProject(uims, chs, uhist1, udst1, urngs, 1.0)); + EXPECT_MAT_NEAR(dst1, udst1, 0.0); } }; From 5acd17879039027d3c5064bf14bc68955b30d427 Mon Sep 17 00:00:00 2001 From: mlyashko Date: Mon, 31 Mar 2014 14:57:03 +0400 Subject: [PATCH 06/52] copyright fix --- modules/imgproc/test/ocl/test_histogram.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/imgproc/test/ocl/test_histogram.cpp b/modules/imgproc/test/ocl/test_histogram.cpp index 5b863bdd22..c13556b301 100644 --- a/modules/imgproc/test/ocl/test_histogram.cpp +++ b/modules/imgproc/test/ocl/test_histogram.cpp @@ -13,7 +13,7 @@ // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. -// Copyright (C) 2013-2014, Itseez, Inc, all rights reserved. +// Copyright (C) 2014, Itseez, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // // @Authors From 7df92bbb77c2b213e9fd634246450bfcc5b78f11 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Mon, 31 Mar 2014 17:30:08 +0400 Subject: [PATCH 07/52] fixed C4505 --- modules/nonfree/perf/perf_main.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/modules/nonfree/perf/perf_main.cpp b/modules/nonfree/perf/perf_main.cpp index c9872a49ce..d46a36a13a 100644 --- a/modules/nonfree/perf/perf_main.cpp +++ b/modules/nonfree/perf/perf_main.cpp @@ -31,7 +31,9 @@ static const char * impls[] = { int main(int argc, char **argv) { ::perf::TestBase::setPerformanceStrategy(::perf::PERF_STRATEGY_SIMPLE); -#if defined(HAVE_CUDA) +#if defined(HAVE_CUDA) && defined(HAVE_OPENCL) + CV_PERF_TEST_MAIN_INTERNALS(nonfree, impls, perf::printCudaInfo(), dumpOpenCLDevice()); +#elif defined(HAVE_CUDA) CV_PERF_TEST_MAIN_INTERNALS(nonfree, impls, perf::printCudaInfo()); #elif defined(HAVE_OPENCL) CV_PERF_TEST_MAIN_INTERNALS(nonfree, impls, dumpOpenCLDevice()); From 9b9769169f4d30666af19ecb63329b7a04492877 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Mon, 31 Mar 2014 19:45:55 +0400 Subject: [PATCH 08/52] doc typos --- doc/tutorials/tutorials.rst | 2 +- .../video/table_of_content_video/table_of_content_video.rst | 2 +- modules/contrib/doc/facerec/facerec_api.rst | 2 +- .../doc/facerec/tutorial/facerec_gender_classification.rst | 2 +- modules/gpu/doc/introduction.rst | 2 +- modules/legacy/src/blobtrackanalysishist.cpp | 4 ++-- modules/legacy/src/levmar.cpp | 2 +- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/tutorials/tutorials.rst b/doc/tutorials/tutorials.rst index 54cc91acb8..3c4e9213e6 100644 --- a/doc/tutorials/tutorials.rst +++ b/doc/tutorials/tutorials.rst @@ -102,7 +102,7 @@ As always, we would be happy to hear your comments and receive your contribution .. cssclass:: toctableopencv =========== ======================================================= - |Video| Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. + |Video| Look here in order to find use on your video stream algorithms like: motion extraction, feature tracking and foreground extractions. =========== ======================================================= diff --git a/doc/tutorials/video/table_of_content_video/table_of_content_video.rst b/doc/tutorials/video/table_of_content_video/table_of_content_video.rst index a2521d6956..ddcad0c700 100644 --- a/doc/tutorials/video/table_of_content_video/table_of_content_video.rst +++ b/doc/tutorials/video/table_of_content_video/table_of_content_video.rst @@ -3,7 +3,7 @@ *video* module. Video analysis ----------------------------------------------------------- -Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. +Look here in order to find use on your video stream algorithms like: motion extraction, feature tracking and foreground extractions. .. include:: ../../definitions/noContent.rst diff --git a/modules/contrib/doc/facerec/facerec_api.rst b/modules/contrib/doc/facerec/facerec_api.rst index 3100cfd8f9..2aa3dcfa00 100644 --- a/modules/contrib/doc/facerec/facerec_api.rst +++ b/modules/contrib/doc/facerec/facerec_api.rst @@ -75,7 +75,7 @@ Moreover every :ocv:class:`FaceRecognizer` supports the: Setting the Thresholds +++++++++++++++++++++++ -Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, wether a face belongs to the training dataset or if it is unknown. You might wonder, why there's no public API in :ocv:class:`FaceRecognizer` to set the threshold for the prediction, but rest assured: It's supported. It just means there's no generic way in an abstract class to provide an interface for setting/getting the thresholds of *every possible* :ocv:class:`FaceRecognizer` algorithm. The appropriate place to set the thresholds is in the constructor of the specific :ocv:class:`FaceRecognizer` and since every :ocv:class:`FaceRecognizer` is a :ocv:class:`Algorithm` (see above), you can get/set the thresholds at runtime! +Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, whether a face belongs to the training dataset or if it is unknown. You might wonder, why there's no public API in :ocv:class:`FaceRecognizer` to set the threshold for the prediction, but rest assured: It's supported. It just means there's no generic way in an abstract class to provide an interface for setting/getting the thresholds of *every possible* :ocv:class:`FaceRecognizer` algorithm. The appropriate place to set the thresholds is in the constructor of the specific :ocv:class:`FaceRecognizer` and since every :ocv:class:`FaceRecognizer` is a :ocv:class:`Algorithm` (see above), you can get/set the thresholds at runtime! Here is an example of setting a threshold for the Eigenfaces method, when creating the model: diff --git a/modules/contrib/doc/facerec/tutorial/facerec_gender_classification.rst b/modules/contrib/doc/facerec/tutorial/facerec_gender_classification.rst index 770083170d..95c821298e 100644 --- a/modules/contrib/doc/facerec/tutorial/facerec_gender_classification.rst +++ b/modules/contrib/doc/facerec/tutorial/facerec_gender_classification.rst @@ -71,7 +71,7 @@ You really don't want to create the CSV file by hand. And you really don't want Fisherfaces for Gender Classification -------------------------------------- -If you want to decide wether a person is *male* or *female*, you have to learn the discriminative features of both classes. The Eigenfaces method is based on the Principal Component Analysis, which is an unsupervised statistical model and not suitable for this task. Please see the Face Recognition tutorial for insights into the algorithms. The Fisherfaces instead yields a class-specific linear projection, so it is much better suited for the gender classification task. `http://www.bytefish.de/blog/gender_classification `_ shows the recognition rate of the Fisherfaces method for gender classification. +If you want to decide whether a person is *male* or *female*, you have to learn the discriminative features of both classes. The Eigenfaces method is based on the Principal Component Analysis, which is an unsupervised statistical model and not suitable for this task. Please see the Face Recognition tutorial for insights into the algorithms. The Fisherfaces instead yields a class-specific linear projection, so it is much better suited for the gender classification task. `http://www.bytefish.de/blog/gender_classification `_ shows the recognition rate of the Fisherfaces method for gender classification. The Fisherfaces method achieves a 98% recognition rate in a subject-independent cross-validation. A subject-independent cross-validation means *images of the person under test are never used for learning the model*. And could you believe it: you can simply use the facerec_fisherfaces demo, that's inlcuded in OpenCV. diff --git a/modules/gpu/doc/introduction.rst b/modules/gpu/doc/introduction.rst index eacfd61a8f..776ed2fb48 100644 --- a/modules/gpu/doc/introduction.rst +++ b/modules/gpu/doc/introduction.rst @@ -43,7 +43,7 @@ Utilizing Multiple GPUs ----------------------- In the current version, each of the OpenCV GPU algorithms can use only a single GPU. So, to utilize multiple GPUs, you have to manually distribute the work between GPUs. -Switching active devie can be done using :ocv:func:`gpu::setDevice()` function. For more details please read Cuda C Programing Guide. +Switching active devie can be done using :ocv:func:`gpu::setDevice()` function. For more details please read Cuda C Programming Guide. While developing algorithms for multiple GPUs, note a data passing overhead. For primitive functions and small images, it can be significant, which may eliminate all the advantages of having multiple GPUs. But for high-level algorithms, consider using multi-GPU acceleration. For example, the Stereo Block Matching algorithm has been successfully parallelized using the following algorithm: diff --git a/modules/legacy/src/blobtrackanalysishist.cpp b/modules/legacy/src/blobtrackanalysishist.cpp index 0e349f9f4e..c75c954912 100644 --- a/modules/legacy/src/blobtrackanalysishist.cpp +++ b/modules/legacy/src/blobtrackanalysishist.cpp @@ -730,12 +730,12 @@ private: m_pFViVarRes = (int*)cvAlloc(sizeof(int)*m_Dim); m_Sizes = (int*)cvAlloc(sizeof(int)*m_Dim); - { /* Create init sparce matrix: */ + { /* Create init sparse matrix: */ int i; for(i=0;i Date: Mon, 31 Mar 2014 09:23:56 -0700 Subject: [PATCH 09/52] OpenCV version++. OpenCV Manager version++. --- .../android_binary_package/O4A_SDK.rst | 14 +++++++------- .../dev_with_OCV_on_Android.rst | 14 +++++++------- modules/core/include/opencv2/core/version.hpp | 2 +- .../generator/src/java/android+OpenCVLoader.java | 5 +++++ .../android/service/engine/AndroidManifest.xml | 4 ++-- .../engine/jni/BinderComponent/OpenCVEngine.cpp | 2 +- .../org/opencv/engine/manager/ManagerActivity.java | 2 +- platforms/android/service/readme.txt | 12 ++++++------ 8 files changed, 30 insertions(+), 25 deletions(-) diff --git a/doc/tutorials/introduction/android_binary_package/O4A_SDK.rst b/doc/tutorials/introduction/android_binary_package/O4A_SDK.rst index ef9337aae2..a70a98d52a 100644 --- a/doc/tutorials/introduction/android_binary_package/O4A_SDK.rst +++ b/doc/tutorials/introduction/android_binary_package/O4A_SDK.rst @@ -48,10 +48,10 @@ The structure of package contents looks as follows: :: - OpenCV-2.4.8-android-sdk + OpenCV-2.4.9-android-sdk |_ apk - | |_ OpenCV_2.4.8_binary_pack_armv7a.apk - | |_ OpenCV_2.4.8_Manager_2.16_XXX.apk + | |_ OpenCV_2.4.9_binary_pack_armv7a.apk + | |_ OpenCV_2.4.9_Manager_2.18_XXX.apk | |_ doc |_ samples @@ -157,10 +157,10 @@ Get the OpenCV4Android SDK .. code-block:: bash - unzip ~/Downloads/OpenCV-2.4.8-android-sdk.zip + unzip ~/Downloads/OpenCV-2.4.9-android-sdk.zip -.. |opencv_android_bin_pack| replace:: :file:`OpenCV-2.4.8-android-sdk.zip` -.. _opencv_android_bin_pack_url: http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.4.8/OpenCV-2.4.8-android-sdk.zip/download +.. |opencv_android_bin_pack| replace:: :file:`OpenCV-2.4.9-android-sdk.zip` +.. _opencv_android_bin_pack_url: http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.4.9/OpenCV-2.4.9-android-sdk.zip/download .. |opencv_android_bin_pack_url| replace:: |opencv_android_bin_pack| .. |seven_zip| replace:: 7-Zip .. _seven_zip: http://www.7-zip.org/ @@ -295,7 +295,7 @@ Well, running samples from Eclipse is very simple: .. code-block:: sh :linenos: - /platform-tools/adb install /apk/OpenCV_2.4.8_Manager_2.16_armv7a-neon.apk + /platform-tools/adb install /apk/OpenCV_2.4.9_Manager_2.18_armv7a-neon.apk .. note:: ``armeabi``, ``armv7a-neon``, ``arm7a-neon-android8``, ``mips`` and ``x86`` stand for platform targets: diff --git a/doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.rst b/doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.rst index bc9ff7a4a8..6fe8f6b941 100644 --- a/doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.rst +++ b/doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.rst @@ -55,14 +55,14 @@ Manager to access OpenCV libraries externally installed in the target system. :guilabel:`File -> Import -> Existing project in your workspace`. Press :guilabel:`Browse` button and locate OpenCV4Android SDK - (:file:`OpenCV-2.4.8-android-sdk/sdk`). + (:file:`OpenCV-2.4.9-android-sdk/sdk`). .. image:: images/eclipse_opencv_dependency0.png :alt: Add dependency from OpenCV library :align: center #. In application project add a reference to the OpenCV Java SDK in - :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.8``. + :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.9``. .. image:: images/eclipse_opencv_dependency1.png :alt: Add dependency from OpenCV library @@ -128,27 +128,27 @@ described above. #. Add the OpenCV library project to your workspace the same way as for the async initialization above. Use menu :guilabel:`File -> Import -> Existing project in your workspace`, press :guilabel:`Browse` button and select OpenCV SDK path - (:file:`OpenCV-2.4.8-android-sdk/sdk`). + (:file:`OpenCV-2.4.9-android-sdk/sdk`). .. image:: images/eclipse_opencv_dependency0.png :alt: Add dependency from OpenCV library :align: center #. In the application project add a reference to the OpenCV4Android SDK in - :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.8``; + :guilabel:`Project -> Properties -> Android -> Library -> Add` select ``OpenCV Library - 2.4.9``; .. image:: images/eclipse_opencv_dependency1.png :alt: Add dependency from OpenCV library :align: center #. If your application project **doesn't have a JNI part**, just copy the corresponding OpenCV - native libs from :file:`/sdk/native/libs/` to your + native libs from :file:`/sdk/native/libs/` to your project directory to folder :file:`libs/`. In case of the application project **with a JNI part**, instead of manual libraries copying you need to modify your ``Android.mk`` file: add the following two code lines after the ``"include $(CLEAR_VARS)"`` and before - ``"include path_to_OpenCV-2.4.8-android-sdk/sdk/native/jni/OpenCV.mk"`` + ``"include path_to_OpenCV-2.4.9-android-sdk/sdk/native/jni/OpenCV.mk"`` .. code-block:: make :linenos: @@ -221,7 +221,7 @@ taken: .. code-block:: make - include C:\Work\OpenCV4Android\OpenCV-2.4.8-android-sdk\sdk\native\jni\OpenCV.mk + include C:\Work\OpenCV4Android\OpenCV-2.4.9-android-sdk\sdk\native\jni\OpenCV.mk Should be inserted into the :file:`jni/Android.mk` file **after** this line: diff --git a/modules/core/include/opencv2/core/version.hpp b/modules/core/include/opencv2/core/version.hpp index 25e5892b6c..63c2935282 100644 --- a/modules/core/include/opencv2/core/version.hpp +++ b/modules/core/include/opencv2/core/version.hpp @@ -49,7 +49,7 @@ #define CV_VERSION_EPOCH 2 #define CV_VERSION_MAJOR 4 -#define CV_VERSION_MINOR 8 +#define CV_VERSION_MINOR 9 #define CV_VERSION_REVISION 0 #define CVAUX_STR_EXP(__A) #__A diff --git a/modules/java/generator/src/java/android+OpenCVLoader.java b/modules/java/generator/src/java/android+OpenCVLoader.java index 0892e3af3c..13cd428494 100644 --- a/modules/java/generator/src/java/android+OpenCVLoader.java +++ b/modules/java/generator/src/java/android+OpenCVLoader.java @@ -42,6 +42,11 @@ public class OpenCVLoader */ public static final String OPENCV_VERSION_2_4_8 = "2.4.8"; + /** + * OpenCV Library version 2.4.9. + */ + public static final String OPENCV_VERSION_2_4_9 = "2.4.9"; + /** * Loads and initializes OpenCV library from current application package. Roughly, it's an analog of system.loadLibrary("opencv_java"). * @return Returns true is initialization of OpenCV was successful. diff --git a/platforms/android/service/engine/AndroidManifest.xml b/platforms/android/service/engine/AndroidManifest.xml index 7cae6ce8a0..3ada75d0a2 100644 --- a/platforms/android/service/engine/AndroidManifest.xml +++ b/platforms/android/service/engine/AndroidManifest.xml @@ -1,8 +1,8 @@ + android:versionCode="218@ANDROID_PLATFORM_VERSION_CODE@" + android:versionName="2.18" > diff --git a/platforms/android/service/engine/jni/BinderComponent/OpenCVEngine.cpp b/platforms/android/service/engine/jni/BinderComponent/OpenCVEngine.cpp index 359906406e..2b113b4e22 100644 --- a/platforms/android/service/engine/jni/BinderComponent/OpenCVEngine.cpp +++ b/platforms/android/service/engine/jni/BinderComponent/OpenCVEngine.cpp @@ -15,7 +15,7 @@ using namespace android; const int OpenCVEngine::Platform = DetectKnownPlatforms(); const int OpenCVEngine::CpuID = GetCpuID(); -const int OpenCVEngine::KnownVersions[] = {2040000, 2040100, 2040200, 2040300, 2040301, 2040302, 2040400, 2040500, 2040600, 2040700, 2040701, 2040800}; +const int OpenCVEngine::KnownVersions[] = {2040000, 2040100, 2040200, 2040300, 2040301, 2040302, 2040400, 2040500, 2040600, 2040700, 2040701, 2040800, 2040900}; bool OpenCVEngine::ValidateVersion(int version) { diff --git a/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java b/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java index 8d40242033..0cd2fd58ef 100644 --- a/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java +++ b/platforms/android/service/engine/src/org/opencv/engine/manager/ManagerActivity.java @@ -117,7 +117,7 @@ public class ManagerActivity extends Activity } else { - HardwarePlatformView.setText("Tegra 5"); + HardwarePlatformView.setText("Tegra K1"); } } else diff --git a/platforms/android/service/readme.txt b/platforms/android/service/readme.txt index 65678093de..51853c24e5 100644 --- a/platforms/android/service/readme.txt +++ b/platforms/android/service/readme.txt @@ -14,20 +14,20 @@ manually using adb tool: .. code-block:: sh - adb install OpenCV-2.4.8-android-sdk/apk/OpenCV_2.4.8_Manager_2.16_.apk + adb install OpenCV-2.4.9-android-sdk/apk/OpenCV_2.4.9_Manager_2.18_.apk Use the table below to determine proper OpenCV Manager package for your device: +------------------------------+--------------+----------------------------------------------------+ | Hardware Platform | Android ver. | Package name | +==============================+==============+====================================================+ -| armeabi-v7a (ARMv7-A + NEON) | >= 2.3 | OpenCV_2.4.8_Manager_2.16_armv7a-neon.apk | +| armeabi-v7a (ARMv7-A + NEON) | >= 2.3 | OpenCV_2.4.9_Manager_2.18_armv7a-neon.apk | +------------------------------+--------------+----------------------------------------------------+ -| armeabi-v7a (ARMv7-A + NEON) | = 2.2 | OpenCV_2.4.8_Manager_2.16_armv7a-neon-android8.apk | +| armeabi-v7a (ARMv7-A + NEON) | = 2.2 | OpenCV_2.4.9_Manager_2.18_armv7a-neon-android8.apk | +------------------------------+--------------+----------------------------------------------------+ -| armeabi (ARMv5, ARMv6) | >= 2.3 | OpenCV_2.4.8_Manager_2.16_armeabi.apk | +| armeabi (ARMv5, ARMv6) | >= 2.3 | OpenCV_2.4.9_Manager_2.18_armeabi.apk | +------------------------------+--------------+----------------------------------------------------+ -| Intel x86 | >= 2.3 | OpenCV_2.4.8_Manager_2.16_x86.apk | +| Intel x86 | >= 2.3 | OpenCV_2.4.9_Manager_2.18_x86.apk | +------------------------------+--------------+----------------------------------------------------+ -| MIPS | >= 2.3 | OpenCV_2.4.8_Manager_2.16_mips.apk | +| MIPS | >= 2.3 | OpenCV_2.4.9_Manager_2.18_mips.apk | +------------------------------+--------------+----------------------------------------------------+ From fa2d79a15b441230ae9998d0856754aa955fc2ec Mon Sep 17 00:00:00 2001 From: Elena Gvozdeva Date: Mon, 24 Feb 2014 10:44:54 +0400 Subject: [PATCH 10/52] Added IPP Async converters, doc and sample --- CMakeLists.txt | 6 +- cmake/OpenCVFindIPPAsync.cmake | 45 +++++ cmake/OpenCVFindLibsPerf.cmake | 11 ++ cmake/templates/cvconfig.h.in | 3 + doc/conf.py | 4 +- .../how_to_use_ippa_conversion.rst | 156 ++++++++++++++++++ .../images/How_To_Use_IPPA_Result.jpg | Bin 0 -> 62891 bytes .../images/How_To_Use_IPPA.jpg | Bin 0 -> 6991 bytes .../table_of_content_core.rst | 21 +++ modules/core/doc/core.rst | 1 + modules/core/doc/ipp_async_converters.rst | 62 +++++++ .../core/include/opencv2/core/ippasync.hpp | 92 +++++++++++ modules/core/test/test_ippasync.cpp | 116 +++++++++++++ .../core/ippasync/ippasync_sample.cpp | 149 +++++++++++++++++ 14 files changed, 664 insertions(+), 2 deletions(-) create mode 100644 cmake/OpenCVFindIPPAsync.cmake create mode 100644 doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst create mode 100644 doc/tutorials/core/how_to_use_ippa_conversion/images/How_To_Use_IPPA_Result.jpg create mode 100644 doc/tutorials/core/table_of_content_core/images/How_To_Use_IPPA.jpg create mode 100644 modules/core/doc/ipp_async_converters.rst create mode 100644 modules/core/include/opencv2/core/ippasync.hpp create mode 100644 modules/core/test/test_ippasync.cpp create mode 100644 samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 442edf32c3..6c36347b76 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -157,7 +157,7 @@ OCV_OPTION(WITH_OPENCLAMDFFT "Include AMD OpenCL FFT library support" ON OCV_OPTION(WITH_OPENCLAMDBLAS "Include AMD OpenCL BLAS library support" ON IF (NOT ANDROID AND NOT IOS) ) OCV_OPTION(WITH_DIRECTX "Include DirectX support" ON IF WIN32 ) OCV_OPTION(WITH_INTELPERC "Include Intel Perceptual Computing support" OFF IF WIN32 ) - +OCV_OPTION(WITH_IPP_A "Include Intel IPP_A support" OFF IF (MSVC OR X86 OR X86_64) ) # OpenCV build components # =================================================== @@ -923,6 +923,10 @@ else() status(" Use IPP:" WITH_IPP AND NOT IPP_FOUND THEN "IPP not found" ELSE NO) endif() +if(DEFINED WITH_IPP_A) +status(" Use IPP Async:" HAVE_IPP_A THEN "YES" ELSE NO) +endif(DEFINED WITH_IPP_A) + status(" Use Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO) status(" Use TBB:" HAVE_TBB THEN "YES (ver ${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR} interface ${TBB_INTERFACE_VERSION})" ELSE NO) status(" Use OpenMP:" HAVE_OPENMP THEN YES ELSE NO) diff --git a/cmake/OpenCVFindIPPAsync.cmake b/cmake/OpenCVFindIPPAsync.cmake new file mode 100644 index 0000000000..0b5751ba07 --- /dev/null +++ b/cmake/OpenCVFindIPPAsync.cmake @@ -0,0 +1,45 @@ +# Main variables: +# IPP_A_LIBRARIES and IPP_A_INCLUDE to use IPP Async +# HAVE_IPP_A for conditional compilation OpenCV with/without IPP Async + +# IPPAROOT - root of IPP Async installation + +if(X86_64) + find_path( + IPP_A_INCLUDE_DIR + NAMES ipp_async_defs.h + PATHS $ENV{IPPAROOT} + PATH_SUFFIXES include + DOC "Path to Intel IPP Async interface headers") + + find_file( + IPP_A_LIBRARIES + NAMES ipp_async_preview.lib + PATHS $ENV{IPPAROOT} + PATH_SUFFIXES lib/intel64 + DOC "Path to Intel IPP Async interface libraries") + +else() + find_path( + IPP_A_INCLUDE_DIR + NAMES ipp_async_defs.h + PATHS $ENV{IPPAROOT} + PATH_SUFFIXES include + DOC "Path to Intel IPP Async interface headers") + + find_file( + IPP_A_LIBRARIES + NAMES ipp_async_preview.lib + PATHS $ENV{IPPAROOT} + PATH_SUFFIXES lib/ia32 + DOC "Path to Intel IPP Async interface libraries") +endif() + +if(IPP_A_INCLUDE_DIR AND IPP_A_LIBRARIES) + set(HAVE_IPP_A TRUE) +else() + set(HAVE_IPP_A FALSE) + message(WARNING "Intel IPP Async library directory (set by IPP_A_LIBRARIES_DIR variable) is not found or does not have Intel IPP Async libraries.") +endif() + +mark_as_advanced(FORCE IPP_A_LIBRARIES IPP_A_INCLUDE_DIR) \ No newline at end of file diff --git a/cmake/OpenCVFindLibsPerf.cmake b/cmake/OpenCVFindLibsPerf.cmake index 4b80b1f786..7d7b23928c 100644 --- a/cmake/OpenCVFindLibsPerf.cmake +++ b/cmake/OpenCVFindLibsPerf.cmake @@ -19,6 +19,17 @@ if(WITH_IPP) endif() endif(WITH_IPP) +# --- IPP Async --- + +if(WITH_IPP_A) + include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindIPPAsync.cmake") + if(IPP_A_INCLUDE_DIR AND IPP_A_LIBRARIES) + ocv_include_directories(${IPP_A_INCLUDE_DIR}) + link_directories(${IPP_A_LIBRARIES}) + set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${IPP_A_LIBRARIES}) + endif() +endif(WITH_IPP_A) + # --- CUDA --- if(WITH_CUDA) include("${OpenCV_SOURCE_DIR}/cmake/OpenCVDetectCUDA.cmake") diff --git a/cmake/templates/cvconfig.h.in b/cmake/templates/cvconfig.h.in index 3f316da46e..c02d9f6127 100644 --- a/cmake/templates/cvconfig.h.in +++ b/cmake/templates/cvconfig.h.in @@ -94,6 +94,9 @@ /* Intel Integrated Performance Primitives */ #cmakedefine HAVE_IPP +/* Intel IPP Async */ +#cmakedefine HAVE_IPP_A + /* JPEG-2000 codec */ #cmakedefine HAVE_JASPER diff --git a/doc/conf.py b/doc/conf.py index 0112725b92..08c6d128ee 100755 --- a/doc/conf.py +++ b/doc/conf.py @@ -416,5 +416,7 @@ extlinks = { 'background_subtractor' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractor#backgroundsubtractor%s', None), 'background_subtractor_mog' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractorMOG#backgroundsubtractormog%s', None), 'background_subtractor_mog_two' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractorMOG2#backgroundsubtractormog2%s', None), - 'video_capture' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=videocapture#videocapture%s', None) + 'video_capture' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=videocapture#videocapture%s', None), + 'ippa_convert': ('http://docs.opencv.org/modules/core/doc/ipp_async_converters.html#%s', None), + 'ptr':('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=Ptr#Ptr%s', None) } diff --git a/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst b/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst new file mode 100644 index 0000000000..bbdaa24a66 --- /dev/null +++ b/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst @@ -0,0 +1,156 @@ +.. _howToUseIPPAconversion: + +Intel® IPP Asynchronous C/C++ library in OpenCV +*********************************************** + +Goal +==== + +.. _hppiSobel: http://software.intel.com/en-us/node/474701 +.. _hppiMatrix: http://software.intel.com/en-us/node/501660 + +The tutorial demonstrates the `Intel® IPP Asynchronous C/C++ `_ library usage with OpenCV. +The code example below illustrates implementation of the Sobel operation, accelerated with Intel® IPP Asynchronous C/C++ functions. +In this code example, :ippa_convert:`hpp::getMat <>` and :ippa_convert:`hpp::getHpp <>` functions are used for data conversion between hppiMatrix_ and ``Mat`` matrices. + +Code +==== + +You may also find the source code in the :file:`samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp` +file of the OpenCV source library or :download:`download it from here +<../../../../samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp>`. + +.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp + :language: cpp + :linenos: + :tab-width: 4 + +Explanation +=========== + +#. Create parameters for OpenCV: + + .. code-block:: cpp + + VideoCapture cap; + Mat image, gray, result; + + and IPP Async: + + .. code-block:: cpp + + Ptr src, dst; + hppAccel accel = 0; + hppAccelType accelType; + hppStatus sts; + hppiVirtualMatrix * virtMatrix; + +#. Load input image or video. How to open and read video stream you can see in the :ref:`videoInputPSNRMSSIM` tutorial. + + .. code-block:: cpp + + if( useCamera ) + { + printf("used camera\n"); + cap.open(0); + } + else + { + printf("used image %s\n", file.c_str()); + cap.open(file.c_str()); + } + + if( !cap.isOpened() ) + { + printf("can not open camera or video file\n"); + return -1; + } + +#. Create accelerator instance using `hppCreateInstance `_: + + .. code-block:: cpp + + accelType = sAccel == "cpu" ? HPP_ACCEL_TYPE_CPU: + sAccel == "gpu" ? HPP_ACCEL_TYPE_GPU: + HPP_ACCEL_TYPE_ANY; + + //Create accelerator instance + sts = hppCreateInstance(accelType, 0, &accel); + CHECK_STATUS(sts, "hppCreateInstance"); + +#. Create an array of virtual matrices using `hppiCreateVirtualMatrices `_ function. + + .. code-block:: cpp + + virtMatrix = hppiCreateVirtualMatrices(accel, 1); + +#. Prepare a matrix for input and output data: + + .. code-block:: cpp + + cap >> image; + if(image.empty()) + break; + + cvtColor( image, gray, COLOR_BGR2GRAY ); + + result.create( image.rows, image.cols, CV_8U); + +#. Convert ``Mat`` to hppiMatrix_ using :ippa_convert:`getHpp <>` and call hppiSobel_ function. + + .. code-block:: cpp + + //convert Mat to hppiMatrix + src = getHpp(gray); + dst = getHpp(result); + + sts = hppiSobel(accel,src, HPP_MASK_SIZE_3X3,HPP_NORM_L1,virtMatrix[0]); + CHECK_STATUS(sts,"hppiSobel"); + + sts = hppiConvert(accel, virtMatrix[0], 0, HPP_RND_MODE_NEAR, dst, HPP_DATA_TYPE_8U); + CHECK_STATUS(sts,"hppiConvert"); + + // Wait for tasks to complete + sts = hppWait(accel, HPP_TIME_OUT_INFINITE); + CHECK_STATUS(sts, "hppWait"); + + We use `hppiConvert `_ because hppiSobel_ returns destination + matrix with ``HPP_DATA_TYPE_16S`` data type for source matrix with ``HPP_DATA_TYPE_8U`` type. + You should check ``hppStatus`` after each call IPP Async function. + +#. Create windows and show the images, the usual way. + + .. code-block:: cpp + + imshow("image", image); + imshow("rez", result); + + waitKey(15); + +#. Delete virtual matrices and accelerator instance. + + .. code-block:: cpp + + if (virtMatrix) + { + sts = hppiDeleteVirtualMatrices(accel, virtMatrix); + CHECK_DEL_STATUS(sts,"hppiDeleteVirtualMatrices"); + } + + if (accel) + { + sts = hppDeleteInstance(accel); + CHECK_DEL_STATUS(sts, "hppDeleteInstance"); + } + + We shouldn't delete hppiMatrix_ because we use :ptr:`Ptr <>` and so `hppiFreeMatrix `_ will be called implicitly. + +Result +======= + +After compiling the code above we can execute it giving an image or video path and accelerator type as an argument. +For this tutorial we use baboon.png image as input. The result is below. + + .. image:: images/How_To_Use_IPPA_Result.jpg + :alt: Final Result + :align: center \ No newline at end of file diff --git a/doc/tutorials/core/how_to_use_ippa_conversion/images/How_To_Use_IPPA_Result.jpg b/doc/tutorials/core/how_to_use_ippa_conversion/images/How_To_Use_IPPA_Result.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2bdeb830cb4309307fb476b860d44c6db1793b00 GIT binary patch literal 62891 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 OpenCV 2.0 + *Author:* |Author_ElenaG| + + You will see how to use the IPP Async with OpenCV. + + =============== ====================================================== + + .. |IPPIma| image:: images/How_To_Use_IPPA.jpg + :height: 90pt + :width: 90pt + .. |Author_ElenaG| unicode:: Elena U+0020 Gvozdeva + + =============== ====================================================== .. raw:: latex \pagebreak @@ -219,3 +239,4 @@ Here you will learn the about the basic building blocks of the library. A must r ../discrete_fourier_transform/discrete_fourier_transform ../file_input_output_with_xml_yml/file_input_output_with_xml_yml ../interoperability_with_OpenCV_1/interoperability_with_OpenCV_1 + ../how_to_use_ippa_conversion/how_to_use_ippa_conversion diff --git a/modules/core/doc/core.rst b/modules/core/doc/core.rst index 73bfc35367..669fddd46a 100644 --- a/modules/core/doc/core.rst +++ b/modules/core/doc/core.rst @@ -16,3 +16,4 @@ core. The Core Functionality clustering utility_and_system_functions_and_macros opengl_interop + ipp_async_converters diff --git a/modules/core/doc/ipp_async_converters.rst b/modules/core/doc/ipp_async_converters.rst new file mode 100644 index 0000000000..6fac234e2a --- /dev/null +++ b/modules/core/doc/ipp_async_converters.rst @@ -0,0 +1,62 @@ +Intel® IPP Asynchronous C/C++ Converters +======================================== + +.. highlight:: cpp + +General Information +------------------- + +This section describes conversion between OpenCV and `Intel® IPP Asynchronous C/C++ `_ library. +`Getting Started Guide `_ help you to install the library, configure header and library build paths. + +hpp::getHpp +----------- +Create ``hppiMatrix`` from ``Mat``. + +.. ocv:function:: Ptr hpp::getHpp(const Mat& src) + + :param src: input matrix. + +This function allocates and initializes the ``hppiMatrix`` that has the same size and type as input matrix, returns the ``Ptr``. +Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. + +.. note:: The ``hppiMatrix`` pointer to the image buffer in system memory refers to the ``src.data``. Control the lifetime of the matrix and don't change its data, if there is no special need. +.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat` + + +hpp::getMat +----------- +Create ``Mat`` from ``hppiMatrix``. + +.. ocv:function:: Mat hpp::getMat(hppiMatrix* src, hppAccel accel, int cn) + + :param src: input hppiMatrix. + + :param accel: accelerator instance. + + :param cn: number of channels. + +This function allocates and initializes the ``Mat`` that has the same size and type as input matrix. +Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. + +.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::copyHppToMat`, :ocv:func:`hpp::getHpp`. + + +hpp::copyHppToMat +----------------- +Convert ``hppiMatrix`` to ``Mat``. + +.. ocv:function:: void hpp::copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn) + + :param src: input hppiMatrix. + + :param dst: output matrix. + + :param accel: accelerator instance. + + :param cn: number of channels. + +This function allocates and initializes new matrix (if needed) that has the same size and type as input matrix. +Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. + +.. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat`, :ocv:func:`hpp::getHpp`. \ No newline at end of file diff --git a/modules/core/include/opencv2/core/ippasync.hpp b/modules/core/include/opencv2/core/ippasync.hpp new file mode 100644 index 0000000000..b17a803add --- /dev/null +++ b/modules/core/include/opencv2/core/ippasync.hpp @@ -0,0 +1,92 @@ +#ifndef __OPENCV_CORE_IPPASYNC_HPP__ +#define __OPENCV_CORE_IPPASYNC_HPP__ + +#include "opencv2/core.hpp" +#include +#include + +namespace cv +{ + void DefaultDeleter::operator () (hppiMatrix* p) const + { + hppiFreeMatrix(p); + } + +namespace hpp +{ + //convert OpenCV data type to hppDataType + inline int toHppType(const int cvType) + { + int depth = CV_MAT_DEPTH(cvType); + int hppType = depth == CV_8U ? HPP_DATA_TYPE_8U : + depth == CV_16U ? HPP_DATA_TYPE_16U : + depth == CV_16S ? HPP_DATA_TYPE_16S : + depth == CV_32S ? HPP_DATA_TYPE_32S : + depth == CV_32F ? HPP_DATA_TYPE_32F : + depth == CV_64F ? HPP_DATA_TYPE_64F : -1; + CV_Assert( hppType >= 0 ); + return hppType; + } + + //convert hppDataType to OpenCV data type + inline int toCvType(const int hppType) + { + int cvType = hppType == HPP_DATA_TYPE_8U ? CV_8U : + hppType == HPP_DATA_TYPE_16U ? CV_16U : + hppType == HPP_DATA_TYPE_16S ? CV_16S : + hppType == HPP_DATA_TYPE_32S ? CV_32S : + hppType == HPP_DATA_TYPE_32F ? CV_32F : + hppType == HPP_DATA_TYPE_64F ? CV_64F : -1; + CV_Assert( cvType >= 0 ); + return cvType; + } + + inline void copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn) + { + hppDataType type; + hpp32u width, height; + hppStatus sts; + + CV_Assert(src!=NULL); + + sts = hppiInquireMatrix(src, &type, &width, &height); + + CV_Assert( sts == HPP_STATUS_NO_ERROR); + + int matType = CV_MAKETYPE(toCvType(type), cn); + + CV_Assert(width%cn == 0); + + width /= cn; + + dst.create((int)height, (int)width, (int)matType); + + size_t newSize = (size_t)(height*(hpp32u)(dst.step)); + + sts = hppiGetMatrixData(accel,src,(hpp32u)(dst.step),dst.data,&newSize); + + CV_Assert( sts == HPP_STATUS_NO_ERROR); + } + + //create cv::Mat from hppiMatrix + inline Mat getMat(hppiMatrix* src, hppAccel accel, int cn) + { + Mat dst; + copyHppToMat(src, dst, accel, cn); + return dst; + } + + //create hppiMatrix from cv::Mat + inline Ptr getHpp(const Mat& src) + { + int htype = toHppType(src.type()); + int cn = src.channels(); + + CV_Assert(src.data); + hppiMatrix *dst = hppiCreateMatrix(htype, src.cols*cn, src.rows, src.data, (hpp32s)(src.step)); + + return Ptr(dst); + } +}} + +#endif \ No newline at end of file diff --git a/modules/core/test/test_ippasync.cpp b/modules/core/test/test_ippasync.cpp new file mode 100644 index 0000000000..61e407a8fe --- /dev/null +++ b/modules/core/test/test_ippasync.cpp @@ -0,0 +1,116 @@ +#include "test_precomp.hpp" +#include "opencv2/ts/ocl_test.hpp" + +#include "opencv2/core/ippasync.hpp" + +using namespace cv; +using namespace std; +using namespace cvtest; + +namespace cvtest { +namespace ocl { + +PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType) +{ + int type; + int cn; + int depth; + hppAccelType accelType; + + Mat matrix, result; + Ptr hppMat; + hppAccel accel; + hppiVirtualMatrix * virtMatrix; + hppStatus sts; + + virtual void SetUp() + { + type = CV_MAKE_TYPE(GET_PARAM(0), GET_PARAM(1)); + depth = GET_PARAM(0); + cn = GET_PARAM(1); + accelType = GET_PARAM(2); + } + + virtual void generateTestData() + { + Size matrix_Size = randomSize(2, 100); + const double upValue = 100; + + matrix = randomMat(matrix_Size, type, -upValue, upValue); + } + + void Near(double threshold = 0.0) + { + EXPECT_MAT_NEAR(matrix, result, threshold); + } +}; + +TEST_P(IPPAsync, accuracy) +{ + if (depth==CV_32S || depth==CV_64F) + return; + + sts = hppCreateInstance(accelType, 0, &accel); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + virtMatrix = hppiCreateVirtualMatrices(accel, 2); + + for (int j = 0; j < test_loop_times; j++) + { + generateTestData(); + hppMat = hpp::getHpp(matrix); + + hppScalar a = 3; + + sts = hppiAddC(accel, hppMat, a, 0, virtMatrix[0]); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + sts = hppiSubC(accel, virtMatrix[0], a, 0, virtMatrix[1]); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + + sts = hppWait(accel, HPP_TIME_OUT_INFINITE); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + + result = hpp::getMat(virtMatrix[1], accel, cn); + + Near(5.0e-6); + } + + sts = hppiDeleteVirtualMatrices(accel, virtMatrix); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + sts = hppDeleteInstance(accel); + CV_Assert(sts==HPP_STATUS_NO_ERROR); +} + +TEST_P(IPPAsync, conversion) +{ + sts = hppCreateInstance(accelType, 0, &accel); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + virtMatrix = hppiCreateVirtualMatrices(accel, 1); + + for (int j = 0; j < test_loop_times; j++) + { + generateTestData(); + hppMat = hpp::getHpp(matrix); + + sts = hppiCopy (accel, hppMat, virtMatrix[0]); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + + sts = hppWait(accel, HPP_TIME_OUT_INFINITE); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + + result = hpp::getMat(virtMatrix[0], accel, cn); + + Near(); + } + + sts = hppiDeleteVirtualMatrices(accel, virtMatrix); + CV_Assert(sts==HPP_STATUS_NO_ERROR); + sts = hppDeleteInstance(accel); + CV_Assert(sts==HPP_STATUS_NO_ERROR); +} + +INSTANTIATE_TEST_CASE_P(IppATest, IPPAsync, Combine(Values(CV_8U, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F), + Values(1, 2, 3, 4), + Values( HPP_ACCEL_TYPE_CPU, HPP_ACCEL_TYPE_GPU))); + +} +} \ No newline at end of file diff --git a/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp new file mode 100644 index 0000000000..f7bc80ac4d --- /dev/null +++ b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp @@ -0,0 +1,149 @@ +#include + +#include "opencv2/core/utility.hpp" +#include "opencv2/core/ippasync.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" + +#define CHECK_STATUS(STATUS, NAME)\ + if(STATUS!=HPP_STATUS_NO_ERROR){ printf("%s error %d\n", NAME, STATUS);\ + if (virtMatrix) {hppStatus delSts = hppiDeleteVirtualMatrices(accel, virtMatrix); CHECK_DEL_STATUS(delSts,"hppiDeleteVirtualMatrices");}\ + if (accel) {hppStatus delSts = hppDeleteInstance(accel); CHECK_DEL_STATUS(delSts, "hppDeleteInstance");}\ + return -1;} + +#define CHECK_DEL_STATUS(STATUS, NAME)\ + if(STATUS!=HPP_STATUS_NO_ERROR){ printf("%s error %d\n", NAME, STATUS); return -1;} + +using namespace std; +using namespace cv; +using namespace hpp; + +static void help() +{ + printf("\nThis program shows how to use the conversion for IPP Async.\n" +"This example uses the Sobel filter.\n" +"You can use cv::Sobel or hppiSobel.\n" +"Usage: \n" +"./ipp_async_sobel [--camera]=, \n" +" [--file_name]=\n" +" [--accel]=\n\n"); +} + +const char* keys = +{ + "{c camera | | use camera or not}" + "{fn file_name|baboon.jpg | image file }" + "{a accel |cpu | accelerator type: auto (default), cpu, gpu}" +}; + +//this is a sample for hppiSobel functions +int main(int argc, const char** argv) +{ + help(); + + VideoCapture cap; + Mat image, gray, result; + + Ptr src, dst; + hppAccel accel = 0; + hppAccelType accelType; + hppStatus sts; + hppiVirtualMatrix * virtMatrix; + + CommandLineParser parser(argc, argv, keys); + bool useCamera = parser.has("camera"); + string file = parser.get("file_name"); + string sAccel = parser.get("accel"); + + parser.printMessage(); + + if( useCamera ) + { + printf("used camera\n"); + cap.open(0); + } + else + { + printf("used image %s\n", file.c_str()); + cap.open(file.c_str()); + } + + if( !cap.isOpened() ) + { + printf("can not open camera or video file\n"); + return -1; + } + + accelType = sAccel == "cpu" ? HPP_ACCEL_TYPE_CPU: + sAccel == "gpu" ? HPP_ACCEL_TYPE_GPU: + HPP_ACCEL_TYPE_ANY; + + //Create accelerator instance + sts = hppCreateInstance(accelType, 0, &accel); + CHECK_STATUS(sts, "hppCreateInstance"); + + accelType = hppQueryAccelType(accel); + + sAccel = accelType == HPP_ACCEL_TYPE_CPU ? "cpu": + accelType == HPP_ACCEL_TYPE_GPU ? "gpu": + accelType == HPP_ACCEL_TYPE_GPU_VIA_DX9 ? "gpu": + accelType == HPP_ACCEL_TYPE_OCL ? "ocl": "?"; + + printf("accelType %s\n", sAccel.c_str()); + + virtMatrix = hppiCreateVirtualMatrices(accel, 1); + + for(;;) + { + cap >> image; + if(image.empty()) + break; + + cvtColor( image, gray, COLOR_BGR2GRAY ); + + result.create( image.rows, image.cols, CV_8U); + + double execTime = (double)getTickCount(); + + //convert Mat to hppiMatrix + src = getHpp(gray); + dst = getHpp(result); + + sts = hppiSobel(accel,src, HPP_MASK_SIZE_3X3,HPP_NORM_L1,virtMatrix[0]); + CHECK_STATUS(sts,"hppiSobel"); + + sts = hppiConvert(accel, virtMatrix[0], 0, HPP_RND_MODE_NEAR, dst, HPP_DATA_TYPE_8U); + CHECK_STATUS(sts,"hppiConvert"); + + // Wait for tasks to complete + sts = hppWait(accel, HPP_TIME_OUT_INFINITE); + CHECK_STATUS(sts, "hppWait"); + + execTime = ((double)getTickCount() - execTime)*1000./getTickFrequency(); + + printf("Time : %0.3fms\n", execTime); + + imshow("image", image); + imshow("rez", result); + + waitKey(15); + } + + if (!useCamera) + waitKey(0); + + if (virtMatrix) + { + sts = hppiDeleteVirtualMatrices(accel, virtMatrix); + CHECK_DEL_STATUS(sts,"hppiDeleteVirtualMatrices"); + } + + if (accel) + { + sts = hppDeleteInstance(accel); + CHECK_DEL_STATUS(sts, "hppDeleteInstance"); + } + + printf("SUCCESS\n"); + return -1; +} \ No newline at end of file From 037ac27ec831baf6be65f85fad3765e53f0d3f0a Mon Sep 17 00:00:00 2001 From: Elena Gvozdeva Date: Thu, 27 Mar 2014 17:40:50 +0400 Subject: [PATCH 11/52] Added SharedMatrix --- cmake/OpenCVFindIPPAsync.cmake | 16 ++-- .../how_to_use_ippa_conversion.rst | 48 ++++++---- .../table_of_content_core.rst | 9 +- .../windows_install/windows_install.rst | 6 ++ modules/core/doc/ipp_async_converters.rst | 28 ++++-- .../core/include/opencv2/core/ippasync.hpp | 33 +++++-- modules/core/test/test_ippasync.cpp | 93 ++++++++++++++++--- .../core/ippasync/ippasync_sample.cpp | 42 ++++++--- 8 files changed, 198 insertions(+), 77 deletions(-) diff --git a/cmake/OpenCVFindIPPAsync.cmake b/cmake/OpenCVFindIPPAsync.cmake index 0b5751ba07..6f4765cbc9 100644 --- a/cmake/OpenCVFindIPPAsync.cmake +++ b/cmake/OpenCVFindIPPAsync.cmake @@ -2,35 +2,35 @@ # IPP_A_LIBRARIES and IPP_A_INCLUDE to use IPP Async # HAVE_IPP_A for conditional compilation OpenCV with/without IPP Async -# IPPAROOT - root of IPP Async installation +# IPP_ASYNC_ROOT - root of IPP Async installation if(X86_64) find_path( IPP_A_INCLUDE_DIR NAMES ipp_async_defs.h - PATHS $ENV{IPPAROOT} + PATHS $ENV{IPP_ASYNC_ROOT} PATH_SUFFIXES include DOC "Path to Intel IPP Async interface headers") - + find_file( IPP_A_LIBRARIES NAMES ipp_async_preview.lib - PATHS $ENV{IPPAROOT} + PATHS $ENV{IPP_ASYNC_ROOT} PATH_SUFFIXES lib/intel64 DOC "Path to Intel IPP Async interface libraries") - + else() find_path( IPP_A_INCLUDE_DIR NAMES ipp_async_defs.h - PATHS $ENV{IPPAROOT} + PATHS $ENV{IPP_ASYNC_ROOT} PATH_SUFFIXES include DOC "Path to Intel IPP Async interface headers") - + find_file( IPP_A_LIBRARIES NAMES ipp_async_preview.lib - PATHS $ENV{IPPAROOT} + PATHS $ENV{IPP_ASYNC_ROOT} PATH_SUFFIXES lib/ia32 DOC "Path to Intel IPP Async interface libraries") endif() diff --git a/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst b/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst index bbdaa24a66..43f1f22d30 100644 --- a/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst +++ b/doc/tutorials/core/how_to_use_ippa_conversion/how_to_use_ippa_conversion.rst @@ -9,14 +9,14 @@ Goal .. _hppiSobel: http://software.intel.com/en-us/node/474701 .. _hppiMatrix: http://software.intel.com/en-us/node/501660 -The tutorial demonstrates the `Intel® IPP Asynchronous C/C++ `_ library usage with OpenCV. +The tutorial demonstrates the `Intel® IPP Asynchronous C/C++ `_ library usage with OpenCV. The code example below illustrates implementation of the Sobel operation, accelerated with Intel® IPP Asynchronous C/C++ functions. In this code example, :ippa_convert:`hpp::getMat <>` and :ippa_convert:`hpp::getHpp <>` functions are used for data conversion between hppiMatrix_ and ``Mat`` matrices. Code ==== -You may also find the source code in the :file:`samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp` +You may also find the source code in the :file:`samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp` file of the OpenCV source library or :download:`download it from here <../../../../samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp>`. @@ -24,7 +24,7 @@ file of the OpenCV source library or :download:`download it from here :language: cpp :linenos: :tab-width: 4 - + Explanation =========== @@ -38,17 +38,17 @@ Explanation and IPP Async: .. code-block:: cpp - - Ptr src, dst; + + hppiMatrix* src,* dst; hppAccel accel = 0; hppAccelType accelType; hppStatus sts; hppiVirtualMatrix * virtMatrix; #. Load input image or video. How to open and read video stream you can see in the :ref:`videoInputPSNRMSSIM` tutorial. - + .. code-block:: cpp - + if( useCamera ) { printf("used camera\n"); @@ -65,25 +65,25 @@ Explanation printf("can not open camera or video file\n"); return -1; } - + #. Create accelerator instance using `hppCreateInstance `_: .. code-block:: cpp - + accelType = sAccel == "cpu" ? HPP_ACCEL_TYPE_CPU: sAccel == "gpu" ? HPP_ACCEL_TYPE_GPU: HPP_ACCEL_TYPE_ANY; - + //Create accelerator instance sts = hppCreateInstance(accelType, 0, &accel); CHECK_STATUS(sts, "hppCreateInstance"); - + #. Create an array of virtual matrices using `hppiCreateVirtualMatrices `_ function. .. code-block:: cpp virtMatrix = hppiCreateVirtualMatrices(accel, 1); - + #. Prepare a matrix for input and output data: .. code-block:: cpp @@ -95,14 +95,14 @@ Explanation cvtColor( image, gray, COLOR_BGR2GRAY ); result.create( image.rows, image.cols, CV_8U); - + #. Convert ``Mat`` to hppiMatrix_ using :ippa_convert:`getHpp <>` and call hppiSobel_ function. .. code-block:: cpp //convert Mat to hppiMatrix - src = getHpp(gray); - dst = getHpp(result); + src = getHpp(gray, accel); + dst = getHpp(result, accel); sts = hppiSobel(accel,src, HPP_MASK_SIZE_3X3,HPP_NORM_L1,virtMatrix[0]); CHECK_STATUS(sts,"hppiSobel"); @@ -113,7 +113,7 @@ Explanation // Wait for tasks to complete sts = hppWait(accel, HPP_TIME_OUT_INFINITE); CHECK_STATUS(sts, "hppWait"); - + We use `hppiConvert `_ because hppiSobel_ returns destination matrix with ``HPP_DATA_TYPE_16S`` data type for source matrix with ``HPP_DATA_TYPE_8U`` type. You should check ``hppStatus`` after each call IPP Async function. @@ -126,7 +126,17 @@ Explanation imshow("rez", result); waitKey(15); - + +#. Delete hpp matrices. + + .. code-block:: cpp + + sts = hppiFreeMatrix(src); + CHECK_DEL_STATUS(sts,"hppiFreeMatrix"); + + sts = hppiFreeMatrix(dst); + CHECK_DEL_STATUS(sts,"hppiFreeMatrix"); + #. Delete virtual matrices and accelerator instance. .. code-block:: cpp @@ -143,12 +153,10 @@ Explanation CHECK_DEL_STATUS(sts, "hppDeleteInstance"); } - We shouldn't delete hppiMatrix_ because we use :ptr:`Ptr <>` and so `hppiFreeMatrix `_ will be called implicitly. - Result ======= -After compiling the code above we can execute it giving an image or video path and accelerator type as an argument. +After compiling the code above we can execute it giving an image or video path and accelerator type as an argument. For this tutorial we use baboon.png image as input. The result is below. .. image:: images/How_To_Use_IPPA_Result.jpg diff --git a/doc/tutorials/core/table_of_content_core/table_of_content_core.rst b/doc/tutorials/core/table_of_content_core/table_of_content_core.rst index 62a0e4f2f7..1fcf4ee2b1 100644 --- a/doc/tutorials/core/table_of_content_core/table_of_content_core.rst +++ b/doc/tutorials/core/table_of_content_core/table_of_content_core.rst @@ -204,7 +204,7 @@ Here you will learn the about the basic building blocks of the library. A must r + .. tabularcolumns:: m{100pt} m{300pt} .. cssclass:: toctableopencv - + =============== ====================================================== |IPPIma| **Title:** :ref:`howToUseIPPAconversion` @@ -213,15 +213,16 @@ Here you will learn the about the basic building blocks of the library. A must r *Author:* |Author_ElenaG| You will see how to use the IPP Async with OpenCV. - + =============== ====================================================== - + .. |IPPIma| image:: images/How_To_Use_IPPA.jpg :height: 90pt :width: 90pt - .. |Author_ElenaG| unicode:: Elena U+0020 Gvozdeva + .. |Author_ElenaG| unicode:: Elena U+0020 Gvozdeva =============== ====================================================== + .. raw:: latex \pagebreak diff --git a/doc/tutorials/introduction/windows_install/windows_install.rst b/doc/tutorials/introduction/windows_install/windows_install.rst index dd91027ba3..f4e9767e77 100644 --- a/doc/tutorials/introduction/windows_install/windows_install.rst +++ b/doc/tutorials/introduction/windows_install/windows_install.rst @@ -62,6 +62,8 @@ Building the OpenCV library from scratch requires a couple of tools installed be .. _IntelTBB: http://threadingbuildingblocks.org/file.php?fid=77 .. |IntelIIP| replace:: Intel |copy| Integrated Performance Primitives (*IPP*) .. _IntelIIP: http://software.intel.com/en-us/articles/intel-ipp/ +.. |IntelIIPA| replace:: Intel |copy| IPP Asynchronous C/C++ +.. _IntelIIPA: http://software.intel.com/en-us/intel-ipp-preview .. |qtframework| replace:: Qt framework .. _qtframework: http://qt.nokia.com/downloads .. |Eigen| replace:: Eigen @@ -97,6 +99,8 @@ OpenCV may come in multiple flavors. There is a "core" section that will work on + |IntelIIP|_ may be used to improve the performance of color conversion, Haar training and DFT functions of the OpenCV library. Watch out, since this isn't a free service. + + |IntelIIPA|_ is currently focused delivering Intel |copy| Graphics support for advanced image processing and computer vision functions. + + OpenCV offers a somewhat fancier and more useful graphical user interface, than the default one by using the |qtframework|_. For a quick overview of what this has to offer look into the documentations *highgui* module, under the *Qt New Functions* section. Version 4.6 or later of the framework is required. + |Eigen|_ is a C++ template library for linear algebra. @@ -168,6 +172,8 @@ Building the library :alt: The Miktex Install Screen :align: center + #) For the |IntelIIPA|_ download the source files and set environment variable **IPP_ASYNC_ROOT**. It should point to :file:`/Intel/IPP Preview */ipp directory`. Here ``*`` denotes the particular preview name. + #) In case of the |Eigen|_ library it is again a case of download and extract to the :file:`D:/OpenCV/dep` directory. #) Same as above with |OpenEXR|_. diff --git a/modules/core/doc/ipp_async_converters.rst b/modules/core/doc/ipp_async_converters.rst index 6fac234e2a..1be93d5584 100644 --- a/modules/core/doc/ipp_async_converters.rst +++ b/modules/core/doc/ipp_async_converters.rst @@ -6,21 +6,31 @@ Intel® IPP Asynchronous C/C++ Converters General Information ------------------- -This section describes conversion between OpenCV and `Intel® IPP Asynchronous C/C++ `_ library. +This section describes conversion between OpenCV and `Intel® IPP Asynchronous C/C++ `_ library. `Getting Started Guide `_ help you to install the library, configure header and library build paths. hpp::getHpp ----------- Create ``hppiMatrix`` from ``Mat``. -.. ocv:function:: Ptr hpp::getHpp(const Mat& src) +.. ocv:function:: hppiMatrix* hpp::getHpp(const Mat& src, hppAccel accel) :param src: input matrix. + :param accel: accelerator instance. Supports type: + + * **HPP_ACCEL_TYPE_CPU** - accelerated by optimized CPU instructions. + + * **HPP_ACCEL_TYPE_GPU** - accelerated by GPU programmable units or fixed-function accelerators. + + * **HPP_ACCEL_TYPE_ANY** - any acceleration or no acceleration available. + +This function allocates and initializes the ``hppiMatrix`` that has the same size and type as input matrix, returns the ``hppiMatrix*``. + +If you want to use zero-copy for GPU you should to have 4KB aligned matrix data. See details `hppiCreateSharedMatrix `_. -This function allocates and initializes the ``hppiMatrix`` that has the same size and type as input matrix, returns the ``Ptr``. Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. -.. note:: The ``hppiMatrix`` pointer to the image buffer in system memory refers to the ``src.data``. Control the lifetime of the matrix and don't change its data, if there is no special need. +.. note:: The ``hppiMatrix`` pointer to the image buffer in system memory refers to the ``src.data``. Control the lifetime of the matrix and don't change its data, if there is no special need. .. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat` @@ -32,11 +42,11 @@ Create ``Mat`` from ``hppiMatrix``. :param src: input hppiMatrix. - :param accel: accelerator instance. + :param accel: accelerator instance (see :ocv:func:`hpp::getHpp` for the list of acceleration framework types). :param cn: number of channels. -This function allocates and initializes the ``Mat`` that has the same size and type as input matrix. +This function allocates and initializes the ``Mat`` that has the same size and type as input matrix. Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. .. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::copyHppToMat`, :ocv:func:`hpp::getHpp`. @@ -49,14 +59,14 @@ Convert ``hppiMatrix`` to ``Mat``. .. ocv:function:: void hpp::copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn) :param src: input hppiMatrix. - + :param dst: output matrix. - :param accel: accelerator instance. + :param accel: accelerator instance (see :ocv:func:`hpp::getHpp` for the list of acceleration framework types). :param cn: number of channels. -This function allocates and initializes new matrix (if needed) that has the same size and type as input matrix. +This function allocates and initializes new matrix (if needed) that has the same size and type as input matrix. Supports ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32S``, ``CV_32F``, ``CV_64F``. .. seealso:: :ref:`howToUseIPPAconversion`, :ocv:func:`hpp::getMat`, :ocv:func:`hpp::getHpp`. \ No newline at end of file diff --git a/modules/core/include/opencv2/core/ippasync.hpp b/modules/core/include/opencv2/core/ippasync.hpp index b17a803add..e40a0aa2f1 100644 --- a/modules/core/include/opencv2/core/ippasync.hpp +++ b/modules/core/include/opencv2/core/ippasync.hpp @@ -1,16 +1,14 @@ #ifndef __OPENCV_CORE_IPPASYNC_HPP__ #define __OPENCV_CORE_IPPASYNC_HPP__ +#ifdef HAVE_IPP_A + #include "opencv2/core.hpp" #include #include namespace cv { - void DefaultDeleter::operator () (hppiMatrix* p) const - { - hppiFreeMatrix(p); - } namespace hpp { @@ -25,7 +23,7 @@ namespace hpp depth == CV_32F ? HPP_DATA_TYPE_32F : depth == CV_64F ? HPP_DATA_TYPE_64F : -1; CV_Assert( hppType >= 0 ); - return hppType; + return hppType; } //convert hppDataType to OpenCV data type @@ -47,7 +45,8 @@ namespace hpp hpp32u width, height; hppStatus sts; - CV_Assert(src!=NULL); + if (src == NULL) + return dst.release(); sts = hppiInquireMatrix(src, &type, &width, &height); @@ -76,17 +75,31 @@ namespace hpp return dst; } - //create hppiMatrix from cv::Mat - inline Ptr getHpp(const Mat& src) + //create hppiMatrix from cv::Mat + inline hppiMatrix* getHpp(const Mat& src, hppAccel accel) { int htype = toHppType(src.type()); int cn = src.channels(); CV_Assert(src.data); - hppiMatrix *dst = hppiCreateMatrix(htype, src.cols*cn, src.rows, src.data, (hpp32s)(src.step)); + hppAccelType accelType = hppQueryAccelType(accel); - return Ptr(dst); + if (accelType!=HPP_ACCEL_TYPE_CPU) + { + hpp32u pitch, size; + hppQueryMatrixAllocParams(accel, src.cols*cn, src.rows, htype, &pitch, &size); + if (pitch!=0 && size!=0) + if ((int)(src.data)%4096==0 && pitch==(hpp32u)(src.step)) + { + return hppiCreateSharedMatrix(htype, src.cols*cn, src.rows, src.data, pitch, size); + } + } + + return hppiCreateMatrix(htype, src.cols*cn, src.rows, src.data, (hpp32s)(src.step));; } + }} +#endif + #endif \ No newline at end of file diff --git a/modules/core/test/test_ippasync.cpp b/modules/core/test/test_ippasync.cpp index 61e407a8fe..2d30e7aa57 100644 --- a/modules/core/test/test_ippasync.cpp +++ b/modules/core/test/test_ippasync.cpp @@ -1,6 +1,7 @@ #include "test_precomp.hpp" #include "opencv2/ts/ocl_test.hpp" +#ifdef HAVE_IPP_A #include "opencv2/core/ippasync.hpp" using namespace cv; @@ -18,7 +19,7 @@ PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType) hppAccelType accelType; Mat matrix, result; - Ptr hppMat; + hppiMatrix * hppMat; hppAccel accel; hppiVirtualMatrix * virtMatrix; hppStatus sts; @@ -47,17 +48,16 @@ PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType) TEST_P(IPPAsync, accuracy) { - if (depth==CV_32S || depth==CV_64F) - return; - sts = hppCreateInstance(accelType, 0, &accel); + if (sts!=HPP_STATUS_NO_ERROR) printf("hppStatus= %d\n",sts); CV_Assert(sts==HPP_STATUS_NO_ERROR); + virtMatrix = hppiCreateVirtualMatrices(accel, 2); for (int j = 0; j < test_loop_times; j++) { generateTestData(); - hppMat = hpp::getHpp(matrix); + hppMat = hpp::getHpp(matrix,accel); hppScalar a = 3; @@ -68,10 +68,13 @@ TEST_P(IPPAsync, accuracy) sts = hppWait(accel, HPP_TIME_OUT_INFINITE); CV_Assert(sts==HPP_STATUS_NO_ERROR); - + result = hpp::getMat(virtMatrix[1], accel, cn); Near(5.0e-6); + + sts = hppiFreeMatrix(hppMat); + CV_Assert(sts==HPP_STATUS_NO_ERROR); } sts = hppiDeleteVirtualMatrices(accel, virtMatrix); @@ -80,26 +83,82 @@ TEST_P(IPPAsync, accuracy) CV_Assert(sts==HPP_STATUS_NO_ERROR); } -TEST_P(IPPAsync, conversion) +PARAM_TEST_CASE(IPPAsyncShared, Channels, hppAccelType) +{ + int cn; + int type; + hppAccelType accelType; + + Mat matrix, result; + hppiMatrix* hppMat; + hppAccel accel; + hppiVirtualMatrix * virtMatrix; + hppStatus sts; + + virtual void SetUp() + { + cn = GET_PARAM(0); + accelType = GET_PARAM(1); + type=CV_MAKE_TYPE(CV_8U, GET_PARAM(0)); + } + + virtual void generateTestData() + { + Size matrix_Size = randomSize(2, 100); + hpp32u pitch, size; + const int upValue = 100; + + sts = hppQueryMatrixAllocParams(accel, (hpp32u)(matrix_Size.width*cn), (hpp32u)matrix_Size.height, HPP_DATA_TYPE_8U, &pitch, &size); + + if (pitch!=0 && size!=0) + { + uchar *pData = (uchar*)_aligned_malloc(size, 4096); + + for (int j=0; j #include "opencv2/core/utility.hpp" -#include "opencv2/core/ippasync.hpp" #include "opencv2/imgproc.hpp" #include "opencv2/highgui.hpp" +#include "cvconfig.h" + +using namespace std; +using namespace cv; + +#ifdef HAVE_IPP_A +#include "opencv2/core/ippasync.hpp" #define CHECK_STATUS(STATUS, NAME)\ if(STATUS!=HPP_STATUS_NO_ERROR){ printf("%s error %d\n", NAME, STATUS);\ @@ -14,9 +20,7 @@ #define CHECK_DEL_STATUS(STATUS, NAME)\ if(STATUS!=HPP_STATUS_NO_ERROR){ printf("%s error %d\n", NAME, STATUS); return -1;} -using namespace std; -using namespace cv; -using namespace hpp; +#endif static void help() { @@ -42,15 +46,17 @@ int main(int argc, const char** argv) help(); VideoCapture cap; + CommandLineParser parser(argc, argv, keys); Mat image, gray, result; - Ptr src, dst; +#ifdef HAVE_IPP_A + + hppiMatrix* src,* dst; hppAccel accel = 0; hppAccelType accelType; hppStatus sts; hppiVirtualMatrix * virtMatrix; - CommandLineParser parser(argc, argv, keys); bool useCamera = parser.has("camera"); string file = parser.get("file_name"); string sAccel = parser.get("accel"); @@ -104,10 +110,10 @@ int main(int argc, const char** argv) result.create( image.rows, image.cols, CV_8U); double execTime = (double)getTickCount(); - + //convert Mat to hppiMatrix - src = getHpp(gray); - dst = getHpp(result); + src = hpp::getHpp(gray,accel); + dst = hpp::getHpp(result,accel); sts = hppiSobel(accel,src, HPP_MASK_SIZE_3X3,HPP_NORM_L1,virtMatrix[0]); CHECK_STATUS(sts,"hppiSobel"); @@ -127,6 +133,13 @@ int main(int argc, const char** argv) imshow("rez", result); waitKey(15); + + sts = hppiFreeMatrix(src); + CHECK_DEL_STATUS(sts,"hppiFreeMatrix"); + + sts = hppiFreeMatrix(dst); + CHECK_DEL_STATUS(sts,"hppiFreeMatrix"); + } if (!useCamera) @@ -145,5 +158,12 @@ int main(int argc, const char** argv) } printf("SUCCESS\n"); - return -1; -} \ No newline at end of file + +#else + + printf("IPP Async not supported\n"); + +#endif + + return 0; +} From bfc546d23c7ddeca653efbc87c530c8a58ef1ffb Mon Sep 17 00:00:00 2001 From: Alexander Alekhin Date: Wed, 2 Apr 2014 18:32:19 +0400 Subject: [PATCH 12/52] enable IPP ICV support --- CMakeLists.txt | 9 +- cmake/OpenCVFindIPP.cmake | 460 +++++++----------- cmake/OpenCVFindLibsPerf.cmake | 11 +- cmake/templates/cvconfig.h.in | 1 + modules/core/include/opencv2/core/private.hpp | 7 +- modules/core/src/arithm.cpp | 12 - modules/core/src/system.cpp | 9 +- modules/imgproc/src/imgwarp.cpp | 2 +- 8 files changed, 189 insertions(+), 322 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 442edf32c3..20522e0496 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -127,7 +127,8 @@ OCV_OPTION(WITH_FFMPEG "Include FFMPEG support" ON OCV_OPTION(WITH_GSTREAMER "Include Gstreamer support" ON IF (UNIX AND NOT APPLE AND NOT ANDROID) ) OCV_OPTION(WITH_GSTREAMER_0_10 "Enable Gstreamer 0.10 support (instead of 1.x)" OFF ) OCV_OPTION(WITH_GTK "Include GTK support" ON IF (UNIX AND NOT APPLE AND NOT ANDROID) ) -OCV_OPTION(WITH_IPP "Include Intel IPP support" OFF IF (MSVC OR X86 OR X86_64) ) +OCV_OPTION(WITH_ICV "Include Intel IPP ICV support" ON IF (NOT IOS) ) +OCV_OPTION(WITH_IPP "Include Intel IPP support" OFF IF (NOT IOS) ) OCV_OPTION(WITH_JASPER "Include JPEG2K support" ON IF (NOT IOS) ) OCV_OPTION(WITH_JPEG "Include JPEG support" ON) OCV_OPTION(WITH_WEBP "Include WebP support" ON IF (NOT IOS) ) @@ -916,11 +917,11 @@ endif(DEFINED WITH_INTELPERC) status("") status(" Other third-party libraries:") -if(WITH_IPP AND IPP_FOUND) - status(" Use IPP:" "${IPP_LATEST_VERSION_STR} [${IPP_LATEST_VERSION_MAJOR}.${IPP_LATEST_VERSION_MINOR}.${IPP_LATEST_VERSION_BUILD}]") +if((WITH_IPP OR WITH_ICV) AND HAVE_IPP) + status(" Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]") status(" at:" "${IPP_ROOT_DIR}") else() - status(" Use IPP:" WITH_IPP AND NOT IPP_FOUND THEN "IPP not found" ELSE NO) + status(" Use IPP:" (WITH_IPP OR WITH_ICV) AND NOT HAVE_IPP THEN "IPP not found" ELSE NO) endif() status(" Use Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO) diff --git a/cmake/OpenCVFindIPP.cmake b/cmake/OpenCVFindIPP.cmake index db02e6acbf..780ee51b87 100644 --- a/cmake/OpenCVFindIPP.cmake +++ b/cmake/OpenCVFindIPP.cmake @@ -2,35 +2,41 @@ # The script to detect Intel(R) Integrated Performance Primitives (IPP) # installation/package # -# This will try to find Intel IPP libraries, and include path by automatic -# search through typical install locations and if failed it will -# examine IPPROOT environment variable. -# Note, IPPROOT is not set by IPP installer, it should be set manually. +# Windows host: +# Run script like this before cmake: +# call "\bin\ippvars.bat" intel64 +# for example: +# call "C:\Program Files (x86)\Intel\Composer XE\ipp\bin\ippvars.bat" intel64 +# +# Linux host: +# Run script like this before cmake: +# source /opt/intel/ipp/bin/ippvars.sh [ia32|intel64] # # On return this will define: # -# IPP_FOUND - True if Intel IPP found -# IPP_ROOT_DIR - root of IPP installation -# IPP_INCLUDE_DIRS - IPP include folder -# IPP_LIBRARY_DIRS - IPP libraries folder -# IPP_LIBRARIES - IPP libraries names that are used by OpenCV -# IPP_LATEST_VERSION_STR - string with the newest detected IPP version -# IPP_LATEST_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) -# IPP_LATEST_VERSION_MINOR -# IPP_LATEST_VERSION_BUILD +# HAVE_IPP - True if Intel IPP found +# HAVE_IPP_ICV_ONLY - True if Intel IPP ICV version is available +# IPP_ROOT_DIR - root of IPP installation +# IPP_INCLUDE_DIRS - IPP include folder +# IPP_LIBRARIES - IPP libraries that are used by OpenCV +# IPP_VERSION_STR - string with the newest detected IPP version +# IPP_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) +# IPP_VERSION_MINOR +# IPP_VERSION_BUILD # # Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) # -set(IPP_FOUND) -set(IPP_VERSION_STR "5.3.0.0") # will not detect earlier versions -set(IPP_VERSION_MAJOR 0) -set(IPP_VERSION_MINOR 0) -set(IPP_VERSION_BUILD 0) -set(IPP_ROOT_DIR) -set(IPP_INCLUDE_DIRS) -set(IPP_LIBRARY_DIRS) -set(IPP_LIBRARIES) +unset(HAVE_IPP CACHE) +unset(HAVE_IPP_ICV_ONLY) +unset(IPP_ROOT_DIR) +unset(IPP_INCLUDE_DIRS) +unset(IPP_LIBRARIES) +unset(IPP_VERSION_STR) +unset(IPP_VERSION_MAJOR) +unset(IPP_VERSION_MINOR) +unset(IPP_VERSION_BUILD) + set(IPP_LIB_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) set(IPP_LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) set(IPP_PREFIX "ipp") @@ -42,322 +48,184 @@ set(IPPCC "cc") # color conversion set(IPPCV "cv") # computer vision set(IPPVM "vm") # vector math - set(IPP_X64 0) -if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) +if(CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) set(IPP_X64 1) endif() -if (CMAKE_CL_64) +if(CMAKE_CL_64) set(IPP_X64 1) endif() -# ------------------------------------------------------------------------ -# This function detect IPP version by analyzing ippversion.h file -# Note, ippversion.h file was inroduced since IPP 5.3 -# ------------------------------------------------------------------------ -function(get_ipp_version _ROOT_DIR) - set(_VERSION_STR) - set(_MAJOR) - set(_MINOR) - set(_BUILD) +# This function detects IPP version by analyzing ippversion.h file +macro(ipp_get_version _ROOT_DIR) + unset(_VERSION_STR) + unset(_MAJOR) + unset(_MINOR) + unset(_BUILD) - # read IPP version info from file - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") - if("${STR3}" STREQUAL "") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") - endif() - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR4 REGEX "IPP_VERSION_STR") + # read IPP version info from file + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") + if("${STR3}" STREQUAL "") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") + endif() + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR4 REGEX "IPP_VERSION_STR") - # extract info and assign to variables - string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) - string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) - string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) - string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) + # extract info and assign to variables + string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) + string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) + string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) + string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) - # export info to parent scope - set(IPP_VERSION_STR ${_VERSION_STR} PARENT_SCOPE) - set(IPP_VERSION_MAJOR ${_MAJOR} PARENT_SCOPE) - set(IPP_VERSION_MINOR ${_MINOR} PARENT_SCOPE) - set(IPP_VERSION_BUILD ${_BUILD} PARENT_SCOPE) + # export info to parent scope + set(IPP_VERSION_STR ${_VERSION_STR}) + set(IPP_VERSION_MAJOR ${_MAJOR}) + set(IPP_VERSION_MINOR ${_MINOR}) + set(IPP_VERSION_BUILD ${_BUILD}) - message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") - message(STATUS "at: ${_ROOT_DIR}") + set(__msg) + if(EXISTS ${_ROOT_DIR}/include/ippicv.h) + ocv_assert(WITH_ICV AND NOT WITH_IPP) + set(__msg " ICV version") + set(HAVE_IPP_ICV_ONLY 1) + endif() + message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]${__msg}") + message(STATUS "at: ${_ROOT_DIR}") +endmacro() + + +# This function sets IPP_INCLUDE_DIRS and IPP_LIBRARIES variables +macro(ipp_set_variables _LATEST_VERSION) + if(${_LATEST_VERSION} VERSION_LESS "7.0") + message(SEND_ERROR "IPP ${_LATEST_VERSION} is not supported") + unset(HAVE_IPP) return() + endif() -endfunction() + # set INCLUDE and LIB folders + set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include) - -# ------------------------------------------------------------------------ -# This is auxiliary function called from set_ipp_variables() -# to set IPP_LIBRARIES variable in IPP 6.x style (IPP 5.3 should also work) -# ------------------------------------------------------------------------ -function(set_ipp_old_libraries) - set(IPP_PREFIX "ipp") - set(IPP_SUFFIX) # old style static core libs suffix - set(IPP_ARCH) # architecture suffix - set(IPP_DISP "emerged") # old style dipatcher and cpu-specific - set(IPP_MRGD "merged") # static libraries - set(IPPCORE "core") # core functionality - set(IPPSP "s") # signal processing - set(IPPIP "i") # image processing - set(IPPCC "cc") # color conversion - set(IPPCV "cv") # computer vision - set(IPPVM "vm") # vector math - - if (IPP_X64) - set(IPP_ARCH "em64t") + if(NOT HAVE_IPP_ICV_ONLY) + if(APPLE) + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/lib) + elseif(IPP_X64) + if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64) + message(SEND_ERROR "IPP EM64T libraries not found") + endif() + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/lib/intel64) + else() + if(NOT EXISTS ${IPP_ROOT_DIR}/lib/ia32) + message(SEND_ERROR "IPP IA32 libraries not found") + endif() + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/lib/ia32) endif() + else() + if(APPLE) + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/libs/macosx) + elseif(WIN32 AND NOT ARM) + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/libs/windows) + elseif(UNIX) + set(IPP_LIBRARY_DIR ${IPP_ROOT_DIR}/libs/linux) + else() + message(MESSAGE "IPP ${_LATEST_VERSION} at ${IPP_ROOT_DIR} is not supported") + unset(HAVE_IPP) + return() + endif() + if(X86_64) + set(IPP_LIBRARY_DIR ${IPP_LIBRARY_DIR}/intel64) + else() + set(IPP_LIBRARY_DIR ${IPP_LIBRARY_DIR}/ia32) + endif() + endif() + set(IPP_PREFIX "ipp") + if(${_LATEST_VERSION} VERSION_LESS "8.0") + set(IPP_SUFFIX "_l") # static not threaded libs suffix IPP 7.x + else() if(WIN32) - set(IPP_SUFFIX "l") - endif() - - set(IPP_LIBRARIES - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_ARCH}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - PARENT_SCOPE) - - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This is auxiliary function called from set_ipp_variables() -# to set IPP_LIBRARIES variable in IPP 7.x and 8.x style -# ------------------------------------------------------------------------ -function(set_ipp_new_libraries _LATEST_VERSION) - set(IPP_PREFIX "ipp") - - if(${_LATEST_VERSION} VERSION_LESS "8.0") - set(IPP_SUFFIX "_l") # static not threaded libs suffix IPP 7.x + set(IPP_SUFFIX "mt") # static not threaded libs suffix IPP 8.x for Windows else() - if(WIN32) - set(IPP_SUFFIX "mt") # static not threaded libs suffix IPP 8.x for Windows - else() - set(IPP_SUFFIX "") # static not threaded libs suffix IPP 8.x for Linux/OS X - endif() + set(IPP_SUFFIX "") # static not threaded libs suffix IPP 8.x for Linux/OS X endif() - set(IPPCORE "core") # core functionality - set(IPPSP "s") # signal processing - set(IPPIP "i") # image processing - set(IPPCC "cc") # color conversion - set(IPPCV "cv") # computer vision - set(IPPVM "vm") # vector math + endif() + set(IPPCORE "core") # core functionality + set(IPPSP "s") # signal processing + set(IPPIP "i") # image processing + set(IPPCC "cc") # color conversion + set(IPPCV "cv") # computer vision + set(IPPVM "vm") # vector math - set(IPP_LIBRARIES - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPI}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPS}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) - - if (UNIX) - set(IPP_LIBRARIES - ${IPP_LIBRARIES} - ${IPP_LIB_PREFIX}irc${CMAKE_SHARED_LIBRARY_SUFFIX} - ${IPP_LIB_PREFIX}imf${CMAKE_SHARED_LIBRARY_SUFFIX} - ${IPP_LIB_PREFIX}svml${CMAKE_SHARED_LIBRARY_SUFFIX}) - endif() - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This function will set -# IPP_INCLUDE_DIRS, IPP_LIBRARY_DIRS and IPP_LIBRARIES variables depending -# on IPP version parameter. -# Since IPP 7.0 version library names and install folder structure -# was changed -# ------------------------------------------------------------------------ -function(set_ipp_variables _LATEST_VERSION) - if(${_LATEST_VERSION} VERSION_LESS "7.0") -# message(STATUS "old") - - # set INCLUDE and LIB folders - set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib PARENT_SCOPE) - - if (IPP_X64) - if(NOT EXISTS ${IPP_ROOT_DIR}/../em64t) - message(SEND_ERROR "IPP EM64T libraries not found") - endif() - else() - if(NOT EXISTS ${IPP_ROOT_DIR}/../ia32) - message(SEND_ERROR "IPP IA32 libraries not found") - endif() - endif() - - # set IPP_LIBRARIES variable (6.x lib names) - set_ipp_old_libraries() - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - message(STATUS "IPP libs: ${IPP_LIBRARIES}") + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPI}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPS}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + list(APPEND IPP_LIBRARIES ${IPP_LIBRARY_DIR}/${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) +# FIXIT +# if(UNIX AND NOT HAVE_IPP_ICV_ONLY) +# get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH) + if(UNIX) + if(NOT HAVE_IPP_ICV_ONLY) + get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH) else() -# message(STATUS "new") - - # set INCLUDE and LIB folders - set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) - - if (APPLE) - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib) - elseif (IPP_X64) - if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64) - message(SEND_ERROR "IPP EM64T libraries not found") - endif() - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/intel64) - else() - if(NOT EXISTS ${IPP_ROOT_DIR}/lib/ia32) - message(SEND_ERROR "IPP IA32 libraries not found") - endif() - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/ia32) - endif() - - if (UNIX) - get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH) - if (IPP_X64) - if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/intel64) - message(SEND_ERROR "Intel compiler EM64T libraries not found") - endif() - set(IPP_LIBRARY_DIRS - ${IPP_LIBRARY_DIRS} - ${INTEL_COMPILER_LIBRARY_DIR}/intel64) - else() - if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/ia32) - message(SEND_ERROR "Intel compiler IA32 libraries not found") - endif() - set(IPP_LIBRARY_DIRS - ${IPP_LIBRARY_DIRS} - ${INTEL_COMPILER_LIBRARY_DIR}/ia32) - endif() - endif() - set(IPP_LIBRARY_DIRS ${IPP_LIBRARY_DIRS} PARENT_SCOPE) - - # set IPP_LIBRARIES variable (7.x or 8.x lib names) - set_ipp_new_libraries(${_LATEST_VERSION}) - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - message(STATUS "IPP libs: ${IPP_LIBRARIES}") - + set(INTEL_COMPILER_LIBRARY_DIR "/opt/intel/lib") endif() + if(IPP_X64) + if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/intel64) + message(SEND_ERROR "Intel compiler EM64T libraries not found") + endif() + set(INTEL_COMPILER_LIBRARY_DIR ${INTEL_COMPILER_LIBRARY_DIR}/intel64) + else() + if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/ia32) + message(SEND_ERROR "Intel compiler IA32 libraries not found") + endif() + set(INTEL_COMPILER_LIBRARY_DIR ${INTEL_COMPILER_LIBRARY_DIR}/ia32) + endif() + list(APPEND IPP_LIBRARIES ${INTEL_COMPILER_LIBRARY_DIR}/${IPP_LIB_PREFIX}irc${CMAKE_SHARED_LIBRARY_SUFFIX}) + list(APPEND IPP_LIBRARIES ${INTEL_COMPILER_LIBRARY_DIR}/${IPP_LIB_PREFIX}imf${CMAKE_SHARED_LIBRARY_SUFFIX}) + list(APPEND IPP_LIBRARIES ${INTEL_COMPILER_LIBRARY_DIR}/${IPP_LIB_PREFIX}svml${CMAKE_SHARED_LIBRARY_SUFFIX}) + endif() - return() + #message(STATUS "IPP libs: ${IPP_LIBRARIES}") +endmacro() -endfunction() +if(WITH_IPP) + set(IPPPATH $ENV{IPPROOT}) + if(UNIX) + list(APPEND IPPPATH /opt/intel/ipp) + endif() +elseif(WITH_ICV) + if(DEFINED ENV{IPPICVROOT}) + set(IPPPATH $ENV{IPPICVROOT}) + else() + set(IPPPATH ${OpenCV_SOURCE_DIR}/3rdparty/ippicv) + endif() +endif() -# ------------------------------------------------------------------------ -# This section will look for IPP through IPPROOT env variable -# Note, IPPROOT is not set by IPP installer, you may need to set it manually -# ------------------------------------------------------------------------ find_path( IPP_H_PATH NAMES ippversion.h - PATHS $ENV{IPPROOT} + PATHS ${IPPPATH} PATH_SUFFIXES include DOC "The path to Intel(R) IPP header files" NO_DEFAULT_PATH NO_CMAKE_PATH) if(IPP_H_PATH) - set(IPP_FOUND 1) + set(HAVE_IPP 1) - # traverse up to IPPROOT level get_filename_component(IPP_ROOT_DIR ${IPP_H_PATH} PATH) - # extract IPP version info - get_ipp_version(${IPP_ROOT_DIR}) - - # keep info in the same vars for auto search and search by IPPROOT - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) - set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) - set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) - - # set IPP INCLUDE, LIB dirs and library names - set_ipp_variables(${IPP_LATEST_VERSION_STR}) + ipp_get_version(${IPP_ROOT_DIR}) + ipp_set_variables(${IPP_VERSION_STR}) endif() -if(NOT IPP_FOUND) - # reset var from previous search - set(IPP_H_PATH) - - - # ------------------------------------------------------------------------ - # This section will look for IPP through system program folders - # Note, if several IPP installations found the newest version will be - # selected - # ------------------------------------------------------------------------ - foreach(curdir ${CMAKE_SYSTEM_PREFIX_PATH}) - set(curdir ${curdir}/intel) - file(TO_CMAKE_PATH ${curdir} CURDIR) - - if(EXISTS ${curdir}) - file(GLOB_RECURSE IPP_H_DIR ${curdir}/ippversion.h) - - if(IPP_H_DIR) - set(IPP_FOUND 1) - endif() - - # init IPP_LATEST_VERSION version with oldest detectable version (5.3.0.0) - # IPP prior 5.3 did not have ippversion.h file - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - - # look through all dirs where ippversion.h was found - foreach(item ${IPP_H_DIR}) - - # traverse up to IPPROOT level - get_filename_component(_FILE_PATH ${item} PATH) - get_filename_component(_ROOT_DIR ${_FILE_PATH} PATH) - - # extract IPP version info - get_ipp_version(${_ROOT_DIR}) - - # remember the latest version (if many found) - if(${IPP_LATEST_VERSION_STR} VERSION_LESS ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) - set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) - set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) - set(IPP_ROOT_DIR ${_ROOT_DIR}) - endif() - endforeach() - endif() - endforeach() -endif() - -if(IPP_FOUND) - # set IPP INCLUDE, LIB dirs and library names - set_ipp_variables(${IPP_LATEST_VERSION_STR}) - - # set CACHE variable IPP_H_PATH, - # path to IPP header files for the latest version - find_path( - IPP_H_PATH - NAMES ippversion.h - PATHS ${IPP_ROOT_DIR} - PATH_SUFFIXES include - DOC "The path to Intel(R) IPP header files" - NO_DEFAULT_PATH - NO_CMAKE_PATH) -endif() - -if(WIN32 AND MINGW AND NOT IPP_LATEST_VERSION_MAJOR LESS 7) +if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) # Since IPP built with Microsoft compiler and /GS option # ====================================================== # From Windows SDK 7.1 diff --git a/cmake/OpenCVFindLibsPerf.cmake b/cmake/OpenCVFindLibsPerf.cmake index 4b80b1f786..6addbd5ef4 100644 --- a/cmake/OpenCVFindLibsPerf.cmake +++ b/cmake/OpenCVFindLibsPerf.cmake @@ -8,16 +8,13 @@ if(WITH_TBB) endif(WITH_TBB) # --- IPP --- -ocv_clear_vars(IPP_FOUND) -if(WITH_IPP) +if(WITH_IPP OR WITH_ICV) include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindIPP.cmake") - if(IPP_FOUND) - add_definitions(-DHAVE_IPP) + if(HAVE_IPP) ocv_include_directories(${IPP_INCLUDE_DIRS}) - link_directories(${IPP_LIBRARY_DIRS}) - set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${IPP_LIBRARIES}) + list(APPEND OPENCV_LINKER_LIBS ${IPP_LIBRARIES}) endif() -endif(WITH_IPP) +endif() # --- CUDA --- if(WITH_CUDA) diff --git a/cmake/templates/cvconfig.h.in b/cmake/templates/cvconfig.h.in index 3f316da46e..279eb29d38 100644 --- a/cmake/templates/cvconfig.h.in +++ b/cmake/templates/cvconfig.h.in @@ -93,6 +93,7 @@ /* Intel Integrated Performance Primitives */ #cmakedefine HAVE_IPP +#cmakedefine HAVE_IPP_ICV_ONLY /* JPEG-2000 codec */ #cmakedefine HAVE_JASPER diff --git a/modules/core/include/opencv2/core/private.hpp b/modules/core/include/opencv2/core/private.hpp index a1cc0e5c89..561499219f 100644 --- a/modules/core/include/opencv2/core/private.hpp +++ b/modules/core/include/opencv2/core/private.hpp @@ -210,7 +210,12 @@ CV_EXPORTS void scalarToRawData(const cv::Scalar& s, void* buf, int type, int un \****************************************************************************************/ #ifdef HAVE_IPP -# include "ipp.h" +# ifdef HAVE_IPP_ICV_ONLY +# include "ippicv.h" +# include "ippicv_fn_map.h" +# else +# include "ipp.h" +# endif static inline IppiSize ippiSize(int width, int height) { diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index a27e34c13c..912f38e5f0 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -52,18 +52,6 @@ namespace cv { -#if ARITHM_USE_IPP -struct IPPArithmInitializer -{ - IPPArithmInitializer(void) - { - ippStaticInit(); - } -}; - -IPPArithmInitializer ippArithmInitializer; -#endif - struct NOP {}; #if CV_SSE2 diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp index 1e6f592d57..5b8a696491 100644 --- a/modules/core/src/system.cpp +++ b/modules/core/src/system.cpp @@ -274,7 +274,14 @@ volatile bool useOptimizedFlag = true; #ifdef HAVE_IPP struct IPPInitializer { - IPPInitializer(void) { ippStaticInit(); } + IPPInitializer(void) + { +#if IPP_VERSION_MAJOR >= 8 + ippInit(); +#else + ippStaticInit(); +#endif + } }; IPPInitializer ippInitializer; diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index da392b055b..9d3eabaad3 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -1982,7 +1982,7 @@ public: } private: - Mat & src; + const Mat & src; Mat & dst; double inv_scale_x; double inv_scale_y; From f8d922ad3ee26f8e3f0f01d9b41ab45497034dc5 Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Fri, 4 Apr 2014 10:31:33 +0400 Subject: [PATCH 13/52] disable gpu::GeneralizedHough compilation on gcc 4.7 --- modules/gpu/src/cuda/generalized_hough.cu | 4 ++++ modules/gpu/src/generalized_hough.cpp | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/modules/gpu/src/cuda/generalized_hough.cu b/modules/gpu/src/cuda/generalized_hough.cu index 5e2041eae4..b07ef0f6b9 100644 --- a/modules/gpu/src/cuda/generalized_hough.cu +++ b/modules/gpu/src/cuda/generalized_hough.cu @@ -40,6 +40,10 @@ // //M*/ +#if defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ == 47) +# define CUDA_DISABLER +#endif + #if !defined CUDA_DISABLER #include diff --git a/modules/gpu/src/generalized_hough.cpp b/modules/gpu/src/generalized_hough.cpp index a92c37d1a5..6f48161c9e 100644 --- a/modules/gpu/src/generalized_hough.cpp +++ b/modules/gpu/src/generalized_hough.cpp @@ -46,6 +46,10 @@ using namespace std; using namespace cv; using namespace cv::gpu; +#if defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ == 47) +# define CUDA_DISABLER +#endif + #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER) Ptr cv::gpu::GeneralizedHough_GPU::create(int) { throw_nogpu(); return Ptr(); } From d822d6f1013badd5c48531c0f1e27f0eb2f27129 Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Mon, 7 Apr 2014 09:49:17 +0400 Subject: [PATCH 14/52] disable GeneralizedHough tests on gcc 4.7 --- modules/gpu/perf/perf_imgproc.cpp | 4 ++++ modules/gpu/test/test_hough.cpp | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index fa0a42cfef..01327d2a93 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/modules/gpu/perf/perf_imgproc.cpp @@ -1832,6 +1832,8 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, ////////////////////////////////////////////////////////////////////// // GeneralizedHough +#if !defined(__GNUC__) || (__GNUC__ * 10 + __GNUC_MINOR__ != 47) + CV_FLAGS(GHMethod, GHT_POSITION, GHT_SCALE, GHT_ROTATION) DEF_PARAM_TEST(Method_Sz, GHMethod, cv::Size); @@ -1918,3 +1920,5 @@ PERF_TEST_P(Method_Sz, DISABLED_ImgProc_GeneralizedHough, CPU_SANITY_CHECK(positions); } } + +#endif diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp index f876a7a2b0..4ae00cfd08 100644 --- a/modules/gpu/test/test_hough.cpp +++ b/modules/gpu/test/test_hough.cpp @@ -185,6 +185,8 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughCircles, testing::Combine( /////////////////////////////////////////////////////////////////////////////////////////////////////// // GeneralizedHough +#if !defined(__GNUC__) || (__GNUC__ * 10 + __GNUC_MINOR__ != 47) + PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi) { }; @@ -252,4 +254,6 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine( ALL_DEVICES, WHOLE_SUBMAT)); +#endif + #endif // HAVE_CUDA From 01a66a29385c4b44016b1b1190781b435fb32d97 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 21 Mar 2014 15:27:56 +0400 Subject: [PATCH 15/52] Prepare codes for ippicv library --- CMakeLists.txt | 5 + cmake/OpenCVFindIPP.cmake | 63 +++- modules/core/src/arithm.cpp | 279 +++++++++------- modules/core/src/dxt.cpp | 56 ++-- modules/core/src/mathfuncs.cpp | 57 +++- modules/core/src/matmul.cpp | 54 +-- modules/core/src/precomp.hpp | 2 - modules/core/src/stat.cpp | 472 +++++++++++++-------------- modules/core/src/system.cpp | 14 +- modules/imgproc/src/color.cpp | 218 ++++++------- modules/imgproc/src/deriv.cpp | 62 ++-- modules/imgproc/src/distransform.cpp | 2 +- modules/imgproc/src/filter.cpp | 61 ++-- modules/imgproc/src/imgwarp.cpp | 222 +++++++------ modules/imgproc/src/morph.cpp | 30 +- modules/imgproc/src/samplers.cpp | 10 +- modules/imgproc/src/smooth.cpp | 32 +- modules/imgproc/src/sumpixels.cpp | 16 +- modules/objdetect/src/haar.cpp | 6 +- 19 files changed, 913 insertions(+), 748 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 20522e0496..e7ceb6281e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -917,9 +917,14 @@ endif(DEFINED WITH_INTELPERC) status("") status(" Other third-party libraries:") +<<<<<<< HEAD if((WITH_IPP OR WITH_ICV) AND HAVE_IPP) status(" Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]") status(" at:" "${IPP_ROOT_DIR}") +======= +if(WITH_IPP AND IPP_FOUND) + status(" Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]") +>>>>>>> Prepare codes for ippicv library else() status(" Use IPP:" (WITH_IPP OR WITH_ICV) AND NOT HAVE_IPP THEN "IPP not found" ELSE NO) endif() diff --git a/cmake/OpenCVFindIPP.cmake b/cmake/OpenCVFindIPP.cmake index 780ee51b87..ab4d7c7b9b 100644 --- a/cmake/OpenCVFindIPP.cmake +++ b/cmake/OpenCVFindIPP.cmake @@ -1,5 +1,5 @@ # -# The script to detect Intel(R) Integrated Performance Primitives (IPP) +# The script to setting up Intel(R) Integrated Performance Primitives (IPP) # installation/package # # Windows host: @@ -19,10 +19,10 @@ # IPP_ROOT_DIR - root of IPP installation # IPP_INCLUDE_DIRS - IPP include folder # IPP_LIBRARIES - IPP libraries that are used by OpenCV -# IPP_VERSION_STR - string with the newest detected IPP version -# IPP_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) -# IPP_VERSION_MINOR -# IPP_VERSION_BUILD +# IPP_FOUND - True if Intel IPP found +# IPP_INCLUDE_DIR - IPP include folder +# IPP_LIBRARY_DIR - IPP libraries folder +# IPP_LIBRARIES - IPP libraries names that are used by OpenCV # # Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) # @@ -222,9 +222,53 @@ if(IPP_H_PATH) ipp_get_version(${IPP_ROOT_DIR}) ipp_set_variables(${IPP_VERSION_STR}) +======= + +set(IPP_FOUND TRUE) +set(IPP_VERSION_STR "5.3.0.0") # will not detect earlier versions +set(IPP_VERSION_MAJOR 0) +set(IPP_VERSION_MINOR 0) +set(IPP_VERSION_BUILD 0) +set(IPP_INCLUDE_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/include) +set(IPP_LIBRARY_DIRS) +set(IPP_LIBRARIES) +if(WIN32 AND NOT ARM) + if (X86_64) + set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/windows/intel64) + else() + set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/windows/ia32/) + endif() + set(IPP_LIBRARIES ippccmt.lib ippcoremt.lib ippcvmt.lib ippimt.lib ippsmt.lib ippvmmt.lib) +elseif(UNIX) + if (X86_64) + set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/linux/intel64) + else() + set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/linux/ia32/) + endif() + set(IPP_LIBRARIES libippcc.a libippcore.a libippcv.a libippi.a libipps.a libippvm.a) endif() +# read IPP version info from file +set(_VERSION_STR) +set(_MAJOR) +set(_MINOR) +set(_BUILD) +file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") +file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") +file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") +if("${STR3}" STREQUAL "") + file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") +>>>>>>> Prepare codes for ippicv library +endif() +file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR4 REGEX "IPP_VERSION_STR") +# extract info and assign to variables +string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) +string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) +string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) +string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) + +<<<<<<< HEAD if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) # Since IPP built with Microsoft compiler and /GS option # ====================================================== @@ -242,3 +286,12 @@ if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) set(MSV_NTDLL "ntdll") set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_NTDLL}${IPP_LIB_SUFFIX}) endif() +======= +# export info to parent scope +set(IPP_VERSION_STR ${_VERSION_STR}) +set(IPP_VERSION_MAJOR ${_MAJOR}) +set(IPP_VERSION_MINOR ${_MINOR}) +set(IPP_VERSION_BUILD ${_BUILD}) + +message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") +>>>>>>> Prepare codes for ippicv library diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index 17bd34cba1..3e343f6b6b 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -458,9 +458,12 @@ static void add8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAdd_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAdd_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); } static void add8s( const schar* src1, size_t step1, @@ -474,18 +477,24 @@ static void add16u( const ushort* src1, size_t step1, const ushort* src2, size_t step2, ushort* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAdd_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAdd_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); } static void add16s( const short* src1, size_t step1, const short* src2, size_t step2, short* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAdd_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAdd_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); } static void add32s( const int* src1, size_t step1, @@ -499,9 +508,12 @@ static void add32f( const float* src1, size_t step1, const float* src2, size_t step2, float* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAdd_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp32, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAdd_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp32, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); } static void add64f( const double* src1, size_t step1, @@ -515,9 +527,12 @@ static void sub8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiSub_8u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviSub_8u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); } static void sub8s( const schar* src1, size_t step1, @@ -531,18 +546,24 @@ static void sub16u( const ushort* src1, size_t step1, const ushort* src2, size_t step2, ushort* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiSub_16u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviSub_16u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); } static void sub16s( const short* src1, size_t step1, const short* src2, size_t step2, short* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiSub_16s_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0), - (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviSub_16s_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + return; +#endif + (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); } static void sub32s( const int* src1, size_t step1, @@ -556,9 +577,12 @@ static void sub32f( const float* src1, size_t step1, const float* src2, size_t step2, float* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiSub_32f_C1R(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz), - (vBinOp32, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviSub_32f_C1R(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp32, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); } static void sub64f( const double* src1, size_t step1, @@ -576,26 +600,23 @@ static void max8u( const uchar* src1, size_t step1, uchar* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { uchar* s1 = (uchar*)src1; uchar* s2 = (uchar*)src2; uchar* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMaxEvery_8u(s1, s2, d, sz.width); - s1 += step1; - s2 += step2; - d += step; + if (0 > ippicvsMaxEvery_8u(s1, s2, d, sz.width)) + break; + s1 += step1; + s2 += step2; + d += step; } - } -#else - vBinOp, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif - -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMaxEvery_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp8, IF_SIMD(_VMax8u)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); } static void max8s( const schar* src1, size_t step1, @@ -610,26 +631,23 @@ static void max16u( const ushort* src1, size_t step1, ushort* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { ushort* s1 = (ushort*)src1; ushort* s2 = (ushort*)src2; ushort* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMaxEvery_16u(s1, s2, d, sz.width); - s1 = (ushort*)((uchar*)s1 + step1); - s2 = (ushort*)((uchar*)s2 + step2); - d = (ushort*)((uchar*)d + step); + if (0 > ippicvsMaxEvery_16u(s1, s2, d, sz.width)) + break; + s1 = (ushort*)((uchar*)s1 + step1); + s2 = (ushort*)((uchar*)s2 + step2); + d = (ushort*)((uchar*)d + step); } - } -#else - vBinOp, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif - -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMaxEvery_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp16, IF_SIMD(_VMax16u)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); } static void max16s( const short* src1, size_t step1, @@ -651,25 +669,23 @@ static void max32f( const float* src1, size_t step1, float* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { float* s1 = (float*)src1; float* s2 = (float*)src2; float* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMaxEvery_32f(s1, s2, d, sz.width); - s1 = (float*)((uchar*)s1 + step1); - s2 = (float*)((uchar*)s2 + step2); - d = (float*)((uchar*)d + step); + if (0 > ippicvsMaxEvery_32f(s1, s2, d, sz.width)) + break; + s1 = (float*)((uchar*)s1 + step1); + s2 = (float*)((uchar*)s2 + step2); + d = (float*)((uchar*)d + step); } - } -#else - vBinOp32, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMaxEvery_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp32f, IF_SIMD(_VMax32f)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp32, IF_SIMD(VMax)>(src1, step1, src2, step2, dst, step, sz); } static void max64f( const double* src1, size_t step1, @@ -684,26 +700,23 @@ static void min8u( const uchar* src1, size_t step1, uchar* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { uchar* s1 = (uchar*)src1; uchar* s2 = (uchar*)src2; uchar* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMinEvery_8u(s1, s2, d, sz.width); - s1 += step1; - s2 += step2; - d += step; + if (0 > ippicvsMinEvery_8u(s1, s2, d, sz.width)) + break; + s1 += step1; + s2 += step2; + d += step; } - } -#else - vBinOp, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif - -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMinEvery_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp8, IF_SIMD(_VMin8u)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); } static void min8s( const schar* src1, size_t step1, @@ -718,26 +731,23 @@ static void min16u( const ushort* src1, size_t step1, ushort* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { ushort* s1 = (ushort*)src1; ushort* s2 = (ushort*)src2; ushort* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMinEvery_16u(s1, s2, d, sz.width); - s1 = (ushort*)((uchar*)s1 + step1); - s2 = (ushort*)((uchar*)s2 + step2); - d = (ushort*)((uchar*)d + step); + if (0 > ippicvsMinEvery_16u(s1, s2, d, sz.width)) + break; + s1 = (ushort*)((uchar*)s1 + step1); + s2 = (ushort*)((uchar*)s2 + step2); + d = (ushort*)((uchar*)d + step); } - } -#else - vBinOp, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif - -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMinEvery_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp16, IF_SIMD(_VMin16u)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); } static void min16s( const short* src1, size_t step1, @@ -759,25 +769,23 @@ static void min32f( const float* src1, size_t step1, float* dst, size_t step, Size sz, void* ) { #if (ARITHM_USE_IPP == 1) - { float* s1 = (float*)src1; float* s2 = (float*)src2; float* d = dst; fixSteps(sz, sizeof(dst[0]), step1, step2, step); - for(int i = 0; i < sz.height; i++) + int i = 0; + for(; i < sz.height; i++) { - ippsMinEvery_32f(s1, s2, d, sz.width); - s1 = (float*)((uchar*)s1 + step1); - s2 = (float*)((uchar*)s2 + step2); - d = (float*)((uchar*)d + step); + if (0 > ippicvsMinEvery_32f(s1, s2, d, sz.width)) + break; + s1 = (float*)((uchar*)s1 + step1); + s2 = (float*)((uchar*)s2 + step2); + d = (float*)((uchar*)d + step); } - } -#else - vBinOp32, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); + if (i == sz.height) + return; #endif -// IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); -// ippiMinEvery_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (IppiSize&)sz), -// (vBinOp32f, IF_SIMD(_VMin32f)>(src1, step1, src2, step2, dst, step, sz))); + vBinOp32, IF_SIMD(VMin)>(src1, step1, src2, step2, dst, step, sz); } static void min64f( const double* src1, size_t step1, @@ -791,9 +799,12 @@ static void absdiff8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAbsDiff_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAbsDiff_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); } static void absdiff8s( const schar* src1, size_t step1, @@ -807,9 +818,12 @@ static void absdiff16u( const ushort* src1, size_t step1, const ushort* src2, size_t step2, ushort* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAbsDiff_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAbsDiff_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); } static void absdiff16s( const short* src1, size_t step1, @@ -830,9 +844,12 @@ static void absdiff32f( const float* src1, size_t step1, const float* src2, size_t step2, float* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAbsDiff_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp32, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAbsDiff_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp32, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); } static void absdiff64f( const double* src1, size_t step1, @@ -847,36 +864,48 @@ static void and8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiAnd_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VAnd)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviAnd_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VAnd)>(src1, step1, src2, step2, dst, step, sz)); } static void or8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiOr_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VOr)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviOr_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VOr)>(src1, step1, src2, step2, dst, step, sz)); } static void xor8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); - ippiXor_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VXor)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); + if (0 <= ippicviXor_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VXor)>(src1, step1, src2, step2, dst, step, sz)); } static void not8u( const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, Size sz, void* ) { - IF_IPP(fixSteps(sz, sizeof(dst[0]), step1, step2, step); (void *)src2; - ippiNot_8u_C1R(src1, (int)step1, dst, (int)step, (IppiSize&)sz), - (vBinOp, IF_SIMD(VNot)>(src1, step1, src2, step2, dst, step, sz))); +#if (ARITHM_USE_IPP == 1) + fixSteps(sz, sizeof(dst[0]), step1, step2, step); (void *)src2; + if (0 <= ippicviNot_8u_C1R(src1, (int)step1, dst, (int)step, (IppiSize&)sz)) + return; +#endif + (vBinOp, IF_SIMD(VNot)>(src1, step1, src2, step2, dst, step, sz)); } /****************************************************************************************\ @@ -2357,7 +2386,7 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if( ippiCompare_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op) >= 0 ) + if (0 <= ippicviCompare_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2440,7 +2469,7 @@ static void cmp16u(const ushort* src1, size_t step1, const ushort* src2, size_t if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if( ippiCompare_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op) >= 0 ) + if (0 <= ippicviCompare_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2455,7 +2484,7 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st if( op > 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if( ippiCompare_16s_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op) >= 0 ) + if (0 <= ippicviCompare_16s_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2561,7 +2590,7 @@ static void cmp32f(const float* src1, size_t step1, const float* src2, size_t st if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if( ippiCompare_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op) >= 0 ) + if (0 <= ippicviCompare_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 4cdb6a16d2..73335e3589 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -466,56 +466,56 @@ template<> struct DFT_VecR4 #endif #ifdef USE_IPP_DFT -static void ippsDFTFwd_CToC( const Complex* src, Complex* dst, +static void ippicvsDFTFwd_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippsDFTFwd_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, + ippicvsDFTFwd_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, (const IppsDFTSpec_C_32fc*)spec, buf); } -static void ippsDFTFwd_CToC( const Complex* src, Complex* dst, +static void ippicvsDFTFwd_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippsDFTFwd_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, + ippicvsDFTFwd_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, (const IppsDFTSpec_C_64fc*)spec, buf); } -static void ippsDFTInv_CToC( const Complex* src, Complex* dst, +static void ippicvsDFTInv_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippsDFTInv_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, + ippicvsDFTInv_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, (const IppsDFTSpec_C_32fc*)spec, buf); } -static void ippsDFTInv_CToC( const Complex* src, Complex* dst, +static void ippicvsDFTInv_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippsDFTInv_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, + ippicvsDFTInv_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, (const IppsDFTSpec_C_64fc*)spec, buf); } -static void ippsDFTFwd_RToPack( const float* src, float* dst, +static void ippicvsDFTFwd_RToPack( const float* src, float* dst, const void* spec, uchar* buf) { - ippsDFTFwd_RToPack_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); + ippicvsDFTFwd_RToPack_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); } -static void ippsDFTFwd_RToPack( const double* src, double* dst, +static void ippicvsDFTFwd_RToPack( const double* src, double* dst, const void* spec, uchar* buf) { - ippsDFTFwd_RToPack_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); + ippicvsDFTFwd_RToPack_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); } -static void ippsDFTInv_PackToR( const float* src, float* dst, +static void ippicvsDFTInv_PackToR( const float* src, float* dst, const void* spec, uchar* buf) { - ippsDFTInv_PackToR_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); + ippicvsDFTInv_PackToR_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); } -static void ippsDFTInv_PackToR( const double* src, double* dst, +static void ippicvsDFTInv_PackToR( const double* src, double* dst, const void* spec, uchar* buf) { - ippsDFTInv_PackToR_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); + ippicvsDFTInv_PackToR_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); } #endif @@ -551,9 +551,9 @@ DFT( const Complex* src, Complex* dst, int n, if( spec ) { if( !inv ) - ippsDFTFwd_CToC( src, dst, spec, (uchar*)buf ); + ippicvsDFTFwd_CToC( src, dst, spec, (uchar*)buf ); else - ippsDFTInv_CToC( src, dst, spec, (uchar*)buf ); + ippicvsDFTInv_CToC( src, dst, spec, (uchar*)buf ); return; } #endif @@ -981,7 +981,7 @@ RealDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab, #ifdef USE_IPP_DFT if( spec ) { - ippsDFTFwd_RToPack( src, dst, spec, (uchar*)buf ); + ippicvsDFTFwd_RToPack( src, dst, spec, (uchar*)buf ); if( complex_output ) { dst[-1] = dst[0]; @@ -1113,7 +1113,7 @@ CCSIDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab, #ifdef USE_IPP_DFT if( spec ) { - ippsDFTInv_PackToR( src, dst, spec, (uchar*)buf ); + ippicvsDFTInv_PackToR( src, dst, spec, (uchar*)buf ); goto finalize; } #endif @@ -1824,26 +1824,26 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows ) { if( depth == CV_32F ) { - getSizeFunc = ippsDFTGetSize_R_32f; - initFunc = (IppDFTInitFunc)ippsDFTInit_R_32f; + getSizeFunc = ippicvsDFTGetSize_R_32f; + initFunc = (IppDFTInitFunc)ippicvsDFTInit_R_32f; } else { - getSizeFunc = ippsDFTGetSize_R_64f; - initFunc = (IppDFTInitFunc)ippsDFTInit_R_64f; + getSizeFunc = ippicvsDFTGetSize_R_64f; + initFunc = (IppDFTInitFunc)ippicvsDFTInit_R_64f; } } else { if( depth == CV_32F ) { - getSizeFunc = ippsDFTGetSize_C_32fc; - initFunc = (IppDFTInitFunc)ippsDFTInit_C_32fc; + getSizeFunc = ippicvsDFTGetSize_C_32fc; + initFunc = (IppDFTInitFunc)ippicvsDFTInit_C_32fc; } else { - getSizeFunc = ippsDFTGetSize_C_64fc; - initFunc = (IppDFTInitFunc)ippsDFTInit_C_64fc; + getSizeFunc = ippicvsDFTGetSize_C_64fc; + initFunc = (IppDFTInitFunc)ippicvsDFTInit_C_64fc; } } if( getSizeFunc(len, ipp_norm_flag, ippAlgHintNone, &specsize, &initsize, &worksize) >= 0 ) diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 16df02cafa..95a5f0a461 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -812,8 +812,6 @@ typedef union } DBLINT; -#ifndef HAVE_IPP - #define EXPTAB_SCALE 6 #define EXPTAB_MASK ((1 << EXPTAB_SCALE) - 1) @@ -898,7 +896,7 @@ static const double exp_prescale = 1.4426950408889634073599246810019 * (1 << EXP static const double exp_postscale = 1./(1 << EXPTAB_SCALE); static const double exp_max_val = 3000.*(1 << EXPTAB_SCALE); // log10(DBL_MAX) < 3000 -static void Exp_32f( const float *_x, float *y, int n ) +static void Exp_32fnoipp( const float *_x, float *y, int n ) { static const float A4 = (float)(1.000000000000002438532970795181890933776 / EXPPOLY_32F_A0), @@ -1098,7 +1096,7 @@ static void Exp_32f( const float *_x, float *y, int n ) } -static void Exp_64f( const double *_x, double *y, int n ) +static void Exp_64fnoipp( const double *_x, double *y, int n ) { static const double A5 = .99999999999999999998285227504999 / EXPPOLY_32F_A0, @@ -1275,13 +1273,26 @@ static void Exp_64f( const double *_x, double *y, int n ) #undef EXPTAB_MASK #undef EXPPOLY_32F_A0 +#ifdef HAVE_IPP +static void Exp_32f(const float *x, float *y, int n) +{ + if (ippStsNoErr == ippicvsExp_32f_A21(x, y, n)) + return; + Exp_32fnoipp(x, y, n); +} + +static void Exp_64f(const double *x, double *y, int n) +{ + if (ippStsNoErr == ippicvsExp_64f_A50(x, y, n)) + return; + Exp_64fnoipp(x, y, n); +} #else - -#define Exp_32f ippsExp_32f_A21 -#define Exp_64f ippsExp_64f_A50 - + #define Exp_32f Exp_32fnoipp + #define Exp_64f Exp_64fnoipp #endif + void exp( InputArray _src, OutputArray _dst ) { int type = _src.type(), depth = _src.depth(), cn = _src.channels(); @@ -1302,9 +1313,9 @@ void exp( InputArray _src, OutputArray _dst ) for( size_t i = 0; i < it.nplanes; i++, ++it ) { if( depth == CV_32F ) - Exp_32f( (const float*)ptrs[0], (float*)ptrs[1], len ); + Exp_32f((const float*)ptrs[0], (float*)ptrs[1], len); else - Exp_64f( (const double*)ptrs[0], (double*)ptrs[1], len ); + Exp_64f((const double*)ptrs[0], (double*)ptrs[1], len); } } @@ -1313,8 +1324,6 @@ void exp( InputArray _src, OutputArray _dst ) * L O G * \****************************************************************************************/ -#ifndef HAVE_IPP - #define LOGTAB_SCALE 8 #define LOGTAB_MASK ((1 << LOGTAB_SCALE) - 1) #define LOGTAB_MASK2 ((1 << (20 - LOGTAB_SCALE)) - 1) @@ -1584,7 +1593,7 @@ static const double CV_DECL_ALIGNED(16) icvLogTab[] = { #define LOGTAB_TRANSLATE(x,h) (((x) - 1.)*icvLogTab[(h)+1]) static const double ln_2 = 0.69314718055994530941723212145818; -static void Log_32f( const float *_x, float *y, int n ) +static void Log_32fnoipp( const float *_x, float *y, int n ) { static const float shift[] = { 0, -1.f/512 }; static const float @@ -1733,7 +1742,7 @@ static void Log_32f( const float *_x, float *y, int n ) } -static void Log_64f( const double *x, double *y, int n ) +static void Log_64fnoipp( const double *x, double *y, int n ) { static const double shift[] = { 0, -1./512 }; static const double @@ -1922,11 +1931,23 @@ static void Log_64f( const double *x, double *y, int n ) } } +#ifdef HAVE_IPP +static void Log_32f(const float *x, float *y, int n) +{ + if (ippStsNoErr == ippicvsLn_32f_A21(x, y, n)) + return; + Log_32fnoipp(x, y, n); +} + +static void Log_64f(const double *x, double *y, int n) +{ + if (ippStsNoErr == ippicvsLn_64f_A50(x, y, n)) + return; + Log_64fnoipp(x, y, n); +} #else - -#define Log_32f ippsLn_32f_A21 -#define Log_64f ippsLn_64f_A50 - + #define Log_32f Log_32fnoipp + #define Log_64f Log_64fnoipp #endif void log( InputArray _src, OutputArray _dst ) diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp index daad86a0f1..60c117385b 100644 --- a/modules/core/src/matmul.cpp +++ b/modules/core/src/matmul.cpp @@ -44,9 +44,9 @@ #include "opencl_kernels.hpp" #include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" -#ifdef HAVE_IPP -#include "ippversion.h" -#endif +//#ifdef HAVE_IPP +//#include "ippversion.h" +//#endif namespace cv { @@ -2803,7 +2803,7 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len) { double r = 0; #if ARITHM_USE_IPP - ippiDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), + ippicviDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r); return r; @@ -2864,48 +2864,52 @@ static double dotProd_8s(const schar* src1, const schar* src2, int len) static double dotProd_16u(const ushort* src1, const ushort* src2, int len) { +#if (ARITHM_USE_IPP == 1) double r = 0; - IF_IPP(ippiDotProd_16u64f_C1R(src1, (int)(len*sizeof(src1[0])), - src2, (int)(len*sizeof(src2[0])), - ippiSize(len, 1), &r), - r = dotProd_(src1, src2, len)); - return r; + if (0 <= ippicviDotProd_16u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + return r; +#endif + return dotProd_(src1, src2, len); } static double dotProd_16s(const short* src1, const short* src2, int len) { +#if (ARITHM_USE_IPP == 1) double r = 0; - IF_IPP(ippiDotProd_16s64f_C1R(src1, (int)(len*sizeof(src1[0])), - src2, (int)(len*sizeof(src2[0])), - ippiSize(len, 1), &r), - r = dotProd_(src1, src2, len)); - return r; + if (0 <= ippicviDotProd_16s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + return r; +#endif + return dotProd_(src1, src2, len); } static double dotProd_32s(const int* src1, const int* src2, int len) { +#if (ARITHM_USE_IPP == 1) double r = 0; - IF_IPP(ippiDotProd_32s64f_C1R(src1, (int)(len*sizeof(src1[0])), - src2, (int)(len*sizeof(src2[0])), - ippiSize(len, 1), &r), - r = dotProd_(src1, src2, len)); - return r; + if (0 <= ippicviDotProd_32s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + return r; +#endif + return dotProd_(src1, src2, len); } static double dotProd_32f(const float* src1, const float* src2, int len) { +#if (ARITHM_USE_IPP == 1) double r = 0; - IF_IPP(ippsDotProd_32f64f(src1, src2, len, &r), - r = dotProd_(src1, src2, len)); - return r; + if (0 <= ippicvsDotProd_32f64f(src1, src2, len, &r)) + return r; +#endif + return dotProd_(src1, src2, len); } static double dotProd_64f(const double* src1, const double* src2, int len) { +#if (ARITHM_USE_IPP == 1) double r = 0; - IF_IPP(ippsDotProd_64f(src1, src2, len, &r), - r = dotProd_(src1, src2, len)); - return r; + if (0 <= ippicvsDotProd_64f(src1, src2, len, &r)) + return r; +#endif + return dotProd_(src1, src2, len); } diff --git a/modules/core/src/precomp.hpp b/modules/core/src/precomp.hpp index ff5943bc63..1c498cd012 100644 --- a/modules/core/src/precomp.hpp +++ b/modules/core/src/precomp.hpp @@ -199,10 +199,8 @@ enum { BLOCK_SIZE = 1024 }; #if defined HAVE_IPP && (IPP_VERSION_MAJOR >= 7) #define ARITHM_USE_IPP 1 -#define IF_IPP(then_call, else_call) then_call #else #define ARITHM_USE_IPP 0 -#define IF_IPP(then_call, else_call) else_call #endif inline bool checkScalar(const Mat& sc, int atype, int sckind, int akind) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index a4605d1605..6080e632dc 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -551,23 +551,23 @@ cv::Scalar cv::sum( InputArray _src ) { IppiSize sz = { cols, rows }; int type = src.type(); - typedef IppStatus (CV_STDCALL* ippiSumFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); - typedef IppStatus (CV_STDCALL* ippiSumFuncNoHint)(const void*, int, IppiSize, double *); - ippiSumFuncHint ippFuncHint = - type == CV_32FC1 ? (ippiSumFuncHint)ippiSum_32f_C1R : - type == CV_32FC3 ? (ippiSumFuncHint)ippiSum_32f_C3R : - type == CV_32FC4 ? (ippiSumFuncHint)ippiSum_32f_C4R : + typedef IppStatus (CV_STDCALL* ippicviSumFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); + typedef IppStatus (CV_STDCALL* ippicviSumFuncNoHint)(const void*, int, IppiSize, double *); + ippicviSumFuncHint ippFuncHint = + type == CV_32FC1 ? (ippicviSumFuncHint)ippicviSum_32f_C1R : + type == CV_32FC3 ? (ippicviSumFuncHint)ippicviSum_32f_C3R : + type == CV_32FC4 ? (ippicviSumFuncHint)ippicviSum_32f_C4R : 0; - ippiSumFuncNoHint ippFuncNoHint = - type == CV_8UC1 ? (ippiSumFuncNoHint)ippiSum_8u_C1R : - type == CV_8UC3 ? (ippiSumFuncNoHint)ippiSum_8u_C3R : - type == CV_8UC4 ? (ippiSumFuncNoHint)ippiSum_8u_C4R : - type == CV_16UC1 ? (ippiSumFuncNoHint)ippiSum_16u_C1R : - type == CV_16UC3 ? (ippiSumFuncNoHint)ippiSum_16u_C3R : - type == CV_16UC4 ? (ippiSumFuncNoHint)ippiSum_16u_C4R : - type == CV_16SC1 ? (ippiSumFuncNoHint)ippiSum_16s_C1R : - type == CV_16SC3 ? (ippiSumFuncNoHint)ippiSum_16s_C3R : - type == CV_16SC4 ? (ippiSumFuncNoHint)ippiSum_16s_C4R : + ippicviSumFuncNoHint ippFuncNoHint = + type == CV_8UC1 ? (ippicviSumFuncNoHint)ippicviSum_8u_C1R : + type == CV_8UC3 ? (ippicviSumFuncNoHint)ippicviSum_8u_C3R : + type == CV_8UC4 ? (ippicviSumFuncNoHint)ippicviSum_8u_C4R : + type == CV_16UC1 ? (ippicviSumFuncNoHint)ippicviSum_16u_C1R : + type == CV_16UC3 ? (ippicviSumFuncNoHint)ippicviSum_16u_C3R : + type == CV_16UC4 ? (ippicviSumFuncNoHint)ippicviSum_16u_C4R : + type == CV_16SC1 ? (ippicviSumFuncNoHint)ippicviSum_16s_C1R : + type == CV_16SC3 ? (ippicviSumFuncNoHint)ippicviSum_16s_C3R : + type == CV_16SC4 ? (ippicviSumFuncNoHint)ippicviSum_16s_C4R : 0; CV_Assert(!ippFuncHint || !ippFuncNoHint); if( ippFuncHint || ippFuncNoHint ) @@ -721,11 +721,11 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *); - ippiMaskMeanFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippiMaskMeanFuncC1)ippiMean_8u_C1MR : - type == CV_16UC1 ? (ippiMaskMeanFuncC1)ippiMean_16u_C1MR : - type == CV_32FC1 ? (ippiMaskMeanFuncC1)ippiMean_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippicviMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *); + ippicviMaskMeanFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippicviMaskMeanFuncC1)ippicviMean_8u_C1MR : + type == CV_16UC1 ? (ippicviMaskMeanFuncC1)ippicviMean_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskMeanFuncC1)ippicviMean_32f_C1MR : 0; if( ippFuncC1 ) { @@ -735,11 +735,11 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) return Scalar(res); } } - typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *); - ippiMaskMeanFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippiMaskMeanFuncC3)ippiMean_8u_C3CMR : - type == CV_16UC3 ? (ippiMaskMeanFuncC3)ippiMean_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskMeanFuncC3)ippiMean_32f_C3CMR : + typedef IppStatus (CV_STDCALL* ippicviMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *); + ippicviMaskMeanFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippicviMaskMeanFuncC3)ippicviMean_8u_C3CMR : + type == CV_16UC3 ? (ippicviMaskMeanFuncC3)ippicviMean_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskMeanFuncC3)ippicviMean_32f_C3CMR : 0; if( ippFuncC3 ) { @@ -754,23 +754,23 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) } else { - typedef IppStatus (CV_STDCALL* ippiMeanFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); - typedef IppStatus (CV_STDCALL* ippiMeanFuncNoHint)(const void*, int, IppiSize, double *); - ippiMeanFuncHint ippFuncHint = - type == CV_32FC1 ? (ippiMeanFuncHint)ippiMean_32f_C1R : - type == CV_32FC3 ? (ippiMeanFuncHint)ippiMean_32f_C3R : - type == CV_32FC4 ? (ippiMeanFuncHint)ippiMean_32f_C4R : + typedef IppStatus (CV_STDCALL* ippicviMeanFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); + typedef IppStatus (CV_STDCALL* ippicviMeanFuncNoHint)(const void*, int, IppiSize, double *); + ippicviMeanFuncHint ippFuncHint = + type == CV_32FC1 ? (ippicviMeanFuncHint)ippicviMean_32f_C1R : + type == CV_32FC3 ? (ippicviMeanFuncHint)ippicviMean_32f_C3R : + type == CV_32FC4 ? (ippicviMeanFuncHint)ippicviMean_32f_C4R : 0; - ippiMeanFuncNoHint ippFuncNoHint = - type == CV_8UC1 ? (ippiMeanFuncNoHint)ippiMean_8u_C1R : - type == CV_8UC3 ? (ippiMeanFuncNoHint)ippiMean_8u_C3R : - type == CV_8UC4 ? (ippiMeanFuncNoHint)ippiMean_8u_C4R : - type == CV_16UC1 ? (ippiMeanFuncNoHint)ippiMean_16u_C1R : - type == CV_16UC3 ? (ippiMeanFuncNoHint)ippiMean_16u_C3R : - type == CV_16UC4 ? (ippiMeanFuncNoHint)ippiMean_16u_C4R : - type == CV_16SC1 ? (ippiMeanFuncNoHint)ippiMean_16s_C1R : - type == CV_16SC3 ? (ippiMeanFuncNoHint)ippiMean_16s_C3R : - type == CV_16SC4 ? (ippiMeanFuncNoHint)ippiMean_16s_C4R : + ippicviMeanFuncNoHint ippFuncNoHint = + type == CV_8UC1 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C1R : + type == CV_8UC3 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C3R : + type == CV_8UC4 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C4R : + type == CV_16UC1 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C1R : + type == CV_16UC3 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C3R : + type == CV_16UC4 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C4R : + type == CV_16SC1 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C1R : + type == CV_16SC3 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C3R : + type == CV_16SC4 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C4R : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); @@ -941,22 +941,22 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *); - ippiMaskMeanStdDevFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_8u_C1MR : - type == CV_16UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_16u_C1MR : - type == CV_32FC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippicviMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *); + ippicviMaskMeanStdDevFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1MR : + type == CV_16UC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1MR : 0; if( ippFuncC1 ) { if( ippFuncC1(src.data, (int)src.step[0], mask.data, (int)mask.step[0], sz, pmean, pstddev) >= 0 ) return; } - typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *); - ippiMaskMeanStdDevFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CMR : - type == CV_16UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_32f_C3CMR : + typedef IppStatus (CV_STDCALL* ippicviMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *); + ippicviMaskMeanStdDevFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_8u_C3CMR : + type == CV_16UC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_32f_C3CMR : 0; if( ippFuncC3 ) { @@ -968,22 +968,22 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input } else { - typedef IppStatus (CV_STDCALL* ippiMeanStdDevFuncC1)(const void *, int, IppiSize, Ipp64f *, Ipp64f *); - ippiMeanStdDevFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_8u_C1R : - type == CV_16UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_16u_C1R : - //type == CV_32FC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 + typedef IppStatus (CV_STDCALL* ippicviMeanStdDevFuncC1)(const void *, int, IppiSize, Ipp64f *, Ipp64f *); + ippicviMeanStdDevFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1R : + type == CV_16UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1R : + //type == CV_32FC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 0; if( ippFuncC1 ) { if( ippFuncC1(src.data, (int)src.step[0], sz, pmean, pstddev) >= 0 ) return; } - typedef IppStatus (CV_STDCALL* ippiMeanStdDevFuncC3)(const void *, int, IppiSize, int, Ipp64f *, Ipp64f *); - ippiMeanStdDevFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CR : - type == CV_16UC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CR : - type == CV_32FC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_32f_C3CR : + typedef IppStatus (CV_STDCALL* ippicviMeanStdDevFuncC3)(const void *, int, IppiSize, int, Ipp64f *, Ipp64f *); + ippicviMeanStdDevFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_8u_C3CR : + type == CV_16UC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_16u_C3CR : + type == CV_32FC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_32f_C3CR : 0; if( ippFuncC3 ) { @@ -1346,11 +1346,11 @@ void cv::minMaxIdx(InputArray _src, double* minVal, int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskMinMaxIndxFuncC1)(const void *, int, const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); - ippiMaskMinMaxIndxFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_8u_C1MR : - type == CV_16UC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_16u_C1MR : - type == CV_32FC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippicviMaskMinMaxIndxFuncC1)(const void *, int, const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); + ippicviMaskMinMaxIndxFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_8u_C1MR : + type == CV_16UC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_32f_C1MR : 0; if( ippFuncC1 ) { @@ -1380,11 +1380,11 @@ void cv::minMaxIdx(InputArray _src, double* minVal, } else { - typedef IppStatus (CV_STDCALL* ippiMinMaxIndxFuncC1)(const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); - ippiMinMaxIndxFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_8u_C1R : - type == CV_16UC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_16u_C1R : - type == CV_32FC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_32f_C1R : + typedef IppStatus (CV_STDCALL* ippicviMinMaxIndxFuncC1)(const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); + ippicviMinMaxIndxFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_8u_C1R : + type == CV_16UC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_16u_C1R : + type == CV_32FC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_32f_C1R : 0; if( ippFuncC1 ) { @@ -2023,25 +2023,25 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *); - ippiMaskNormFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippicviMaskNormFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *); + ippicviMaskNormFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2051,25 +2051,25 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm; } } - typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *); - ippiMaskNormFuncC3 ippFuncC3 = + typedef IppStatus (CV_STDCALL* ippicviMaskNormFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *); + ippicviMaskNormFuncC3 ippFuncC3 = normType == NORM_INF ? - (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_32f_C3CMR : 0) : normType == NORM_L1 ? - (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_32f_C3CMR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_32f_C3CMR : 0) : 0; if( ippFuncC3 ) { @@ -2089,55 +2089,55 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) } else { - typedef IppStatus (CV_STDCALL* ippiNormFuncHint)(const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - typedef IppStatus (CV_STDCALL* ippiNormFuncNoHint)(const void *, int, IppiSize, Ipp64f *); - ippiNormFuncHint ippFuncHint = + typedef IppStatus (CV_STDCALL* ippicviNormFuncHint)(const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + typedef IppStatus (CV_STDCALL* ippicviNormFuncNoHint)(const void *, int, IppiSize, Ipp64f *); + ippicviNormFuncHint ippFuncHint = normType == NORM_L1 ? - (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L1_32f_C1R : - type == CV_32FC3 ? (ippiNormFuncHint)ippiNorm_L1_32f_C3R : - type == CV_32FC4 ? (ippiNormFuncHint)ippiNorm_L1_32f_C4R : + (type == CV_32FC1 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C1R : + type == CV_32FC3 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C3R : + type == CV_32FC4 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L2_32f_C1R : - type == CV_32FC3 ? (ippiNormFuncHint)ippiNorm_L2_32f_C3R : - type == CV_32FC4 ? (ippiNormFuncHint)ippiNorm_L2_32f_C4R : + (type == CV_32FC1 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C1R : + type == CV_32FC3 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C3R : + type == CV_32FC4 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C4R : 0) : 0; - ippiNormFuncNoHint ippFuncNoHint = + ippicviNormFuncNoHint ippFuncNoHint = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C1R : - type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C3R : - type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C4R : - type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C1R : - type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C3R : - type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C4R : - type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R : - //type == CV_16SC3 ? (ippiNormFunc)ippiNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - //type == CV_16SC4 ? (ippiNormFunc)ippiNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - type == CV_32FC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C1R : - type == CV_32FC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C3R : - type == CV_32FC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C4R : + (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C1R : + type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C3R : + type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C4R : + type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C1R : + type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C3R : + type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C4R : + type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C1R : + //type == CV_16SC3 ? (ippicviNormFunc)ippicviNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + //type == CV_16SC4 ? (ippicviNormFunc)ippicviNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_32FC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C1R : + type == CV_32FC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C3R : + type == CV_32FC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C4R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C1R : - type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C3R : - type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C4R : - type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C1R : - type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C3R : - type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C4R : - type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C1R : - type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C3R : - type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C4R : + (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C1R : + type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C3R : + type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C4R : + type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C1R : + type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C3R : + type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C4R : + type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C1R : + type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C3R : + type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C1R : - type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C3R : - type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C4R : - type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C1R : - type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C3R : - type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C4R : - type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C1R : - type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C3R : - type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C4R : + (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C1R : + type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C3R : + type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C4R : + type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C1R : + type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C3R : + type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C4R : + type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C1R : + type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C3R : + type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C4R : 0) : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); @@ -2374,25 +2374,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m int type = src1.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskNormRelFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); - ippiMaskNormRelFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippicviMaskNormRelFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); + ippicviMaskNormRelFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2403,25 +2403,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m } else { - typedef IppStatus (CV_STDCALL* ippiNormRelFunc)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - ippiNormRelFunc ippFunc = + typedef IppStatus (CV_STDCALL* ippicviNormRelFunc)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + ippicviNormRelFunc ippFunc = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_Inf_8u_C1R : - type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_Inf_16u_C1R : - type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_Inf_16s_C1R : - type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_Inf_32f_C1R : + (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_8u_C1R : + type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_16u_C1R : + type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_16s_C1R : + type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_32f_C1R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_L1_8u_C1R : - type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_L1_16u_C1R : - type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_L1_16s_C1R : - type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_L1_32f_C1R : + (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_8u_C1R : + type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_16u_C1R : + type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_16s_C1R : + type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_32f_C1R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_L2_8u_C1R : - type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_L2_16u_C1R : - type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_L2_16s_C1R : - type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_L2_32f_C1R : + (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_8u_C1R : + type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_16u_C1R : + type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_16s_C1R : + type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_32f_C1R : 0) : 0; if( ippFunc ) { @@ -2455,25 +2455,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m int type = src1.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); - ippiMaskNormDiffFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippicviMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); + ippicviMaskNormDiffFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_8u_C1MR : - type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_8s_C1MR : - type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_16u_C1MR : - type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_32f_C1MR : + (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_8u_C1MR : + type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_8s_C1MR : + type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_16u_C1MR : + type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2481,25 +2481,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m if( ippFuncC1(src1.data, (int)src1.step[0], src2.data, (int)src2.step[0], mask.data, (int)mask.step[0], sz, &norm) >= 0 ) return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm; } - typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC3)(const void *, int, const void *, int, const void *, int, IppiSize, int, Ipp64f *); - ippiMaskNormDiffFuncC3 ippFuncC3 = + typedef IppStatus (CV_STDCALL* ippicviMaskNormDiffFuncC3)(const void *, int, const void *, int, const void *, int, IppiSize, int, Ipp64f *); + ippicviMaskNormDiffFuncC3 ippFuncC3 = normType == NORM_INF ? - (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_32f_C3CMR : 0) : normType == NORM_L1 ? - (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_32f_C3CMR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_8u_C3CMR : - type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_8s_C3CMR : - type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_16u_C3CMR : - type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_32f_C3CMR : + (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_8u_C3CMR : + type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_8s_C3CMR : + type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_16u_C3CMR : + type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_32f_C3CMR : 0) : 0; if( ippFuncC3 ) { @@ -2519,55 +2519,55 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m } else { - typedef IppStatus (CV_STDCALL* ippiNormDiffFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - typedef IppStatus (CV_STDCALL* ippiNormDiffFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *); - ippiNormDiffFuncHint ippFuncHint = + typedef IppStatus (CV_STDCALL* ippicviNormDiffFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + typedef IppStatus (CV_STDCALL* ippicviNormDiffFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *); + ippicviNormDiffFuncHint ippFuncHint = normType == NORM_L1 ? - (type == CV_32FC1 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C1R : - type == CV_32FC3 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C3R : - type == CV_32FC4 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C4R : + (type == CV_32FC1 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C1R : + type == CV_32FC3 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C3R : + type == CV_32FC4 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_32FC1 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C1R : - type == CV_32FC3 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C3R : - type == CV_32FC4 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C4R : + (type == CV_32FC1 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C1R : + type == CV_32FC3 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C3R : + type == CV_32FC4 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C4R : 0) : 0; - ippiNormDiffFuncNoHint ippFuncNoHint = + ippicviNormDiffFuncNoHint ippFuncNoHint = normType == NORM_INF ? - (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C1R : - type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C3R : - type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C4R : - type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C1R : - type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C3R : - type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C4R : - type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R : - //type == CV_16SC3 ? (ippiNormDiffFunc)ippiNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - //type == CV_16SC4 ? (ippiNormDiffFunc)ippiNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - type == CV_32FC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C1R : - type == CV_32FC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C3R : - type == CV_32FC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C4R : + (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C1R : + type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C3R : + type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C4R : + type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C1R : + type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C3R : + type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C4R : + type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C1R : + //type == CV_16SC3 ? (ippicviNormDiffFunc)ippicviNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + //type == CV_16SC4 ? (ippicviNormDiffFunc)ippicviNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_32FC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C1R : + type == CV_32FC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C3R : + type == CV_32FC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C4R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C1R : - type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C3R : - type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C4R : - type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C1R : - type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C3R : - type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C4R : - type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C1R : - type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C3R : - type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C4R : + (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C1R : + type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C3R : + type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C4R : + type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C1R : + type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C3R : + type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C4R : + type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C1R : + type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C3R : + type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C1R : - type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C3R : - type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C4R : - type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C1R : - type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C3R : - type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C4R : - type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C1R : - type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C3R : - type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C4R : + (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C1R : + type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C3R : + type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C4R : + type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C1R : + type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C3R : + type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C4R : + type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C1R : + type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C3R : + type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C4R : 0) : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp index 5b8a696491..4b3efce4a8 100644 --- a/modules/core/src/system.cpp +++ b/modules/core/src/system.cpp @@ -397,17 +397,17 @@ int64 getCPUTickCount(void) #else -#ifdef HAVE_IPP -int64 getCPUTickCount(void) -{ - return ippGetCpuClocks(); -} -#else +//#ifdef HAVE_IPP +//int64 getCPUTickCount(void) +//{ +// return ippGetCpuClocks(); +//} +//#else int64 getCPUTickCount(void) { return getTickCount(); } -#endif +//#endif #endif diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 3822ab3c16..b2699d22e5 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -99,7 +99,7 @@ #define MAX_IPP8u 255 #define MAX_IPP16u 65535 #define MAX_IPP32f 1.0 -static IppStatus sts = ippInit(); +static IppStatus sts = ippicvInit(); #endif namespace cv @@ -200,9 +200,9 @@ void CvtColorLoop(const Mat& src, Mat& dst, const Cvt& cvt) } #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -typedef IppStatus (CV_STDCALL* ippiReorderFunc)(const void *, int, void *, int, IppiSize, const int *); -typedef IppStatus (CV_STDCALL* ippiGeneralFunc)(const void *, int, void *, int, IppiSize); -typedef IppStatus (CV_STDCALL* ippiColor2GrayFunc)(const void *, int, void *, int, IppiSize, const Ipp32f *); +typedef IppStatus (CV_STDCALL* ippicviReorderFunc)(const void *, int, void *, int, IppiSize, const int *); +typedef IppStatus (CV_STDCALL* ippicviGeneralFunc)(const void *, int, void *, int, IppiSize); +typedef IppStatus (CV_STDCALL* ippicviColor2GrayFunc)(const void *, int, void *, int, IppiSize, const Ipp32f *); template class CvtColorIPPLoop_Invoker : public ParallelLoopBody @@ -255,134 +255,134 @@ bool CvtColorIPPLoopCopy(Mat& src, Mat& dst, const Cvt& cvt) return ok; } -static IppStatus CV_STDCALL ippiSwapChannels_8u_C3C4Rf(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, +static IppStatus CV_STDCALL ippicviSwapChannels_8u_C3C4Rf(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippiSwapChannels_8u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP8u); + return ippicviSwapChannels_8u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP8u); } -static IppStatus CV_STDCALL ippiSwapChannels_16u_C3C4Rf(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, +static IppStatus CV_STDCALL ippicviSwapChannels_16u_C3C4Rf(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippiSwapChannels_16u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP16u); + return ippicviSwapChannels_16u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP16u); } -static IppStatus CV_STDCALL ippiSwapChannels_32f_C3C4Rf(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, +static IppStatus CV_STDCALL ippicviSwapChannels_32f_C3C4Rf(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippiSwapChannels_32f_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP32f); + return ippicviSwapChannels_32f_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP32f); } -static ippiReorderFunc ippiSwapChannelsC3C4RTab[] = +static ippicviReorderFunc ippicviSwapChannelsC3C4RTab[] = { - (ippiReorderFunc)ippiSwapChannels_8u_C3C4Rf, 0, (ippiReorderFunc)ippiSwapChannels_16u_C3C4Rf, 0, - 0, (ippiReorderFunc)ippiSwapChannels_32f_C3C4Rf, 0, 0 + (ippicviReorderFunc)ippicviSwapChannels_8u_C3C4Rf, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C3C4Rf, 0, + 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C3C4Rf, 0, 0 }; -static ippiGeneralFunc ippiCopyAC4C3RTab[] = +static ippicviGeneralFunc ippicviCopyAC4C3RTab[] = { - (ippiGeneralFunc)ippiCopy_8u_AC4C3R, 0, (ippiGeneralFunc)ippiCopy_16u_AC4C3R, 0, - 0, (ippiGeneralFunc)ippiCopy_32f_AC4C3R, 0, 0 + (ippicviGeneralFunc)ippicviCopy_8u_AC4C3R, 0, (ippicviGeneralFunc)ippicviCopy_16u_AC4C3R, 0, + 0, (ippicviGeneralFunc)ippicviCopy_32f_AC4C3R, 0, 0 }; -static ippiReorderFunc ippiSwapChannelsC4C3RTab[] = +static ippicviReorderFunc ippicviSwapChannelsC4C3RTab[] = { - (ippiReorderFunc)ippiSwapChannels_8u_C4C3R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4C3R, 0, - 0, (ippiReorderFunc)ippiSwapChannels_32f_C4C3R, 0, 0 + (ippicviReorderFunc)ippicviSwapChannels_8u_C4C3R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C4C3R, 0, + 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C4C3R, 0, 0 }; -static ippiReorderFunc ippiSwapChannelsC3RTab[] = +static ippicviReorderFunc ippicviSwapChannelsC3RTab[] = { - (ippiReorderFunc)ippiSwapChannels_8u_C3R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C3R, 0, - 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 + (ippicviReorderFunc)ippicviSwapChannels_8u_C3R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C3R, 0, + 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C3R, 0, 0 }; -static ippiReorderFunc ippiSwapChannelsC4RTab[] = +static ippicviReorderFunc ippicviSwapChannelsC4RTab[] = { - (ippiReorderFunc)ippiSwapChannels_8u_AC4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_AC4R, 0, - 0, (ippiReorderFunc)ippiSwapChannels_32f_AC4R, 0, 0 + (ippicviReorderFunc)ippicviSwapChannels_8u_AC4R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_AC4R, 0, + 0, (ippicviReorderFunc)ippicviSwapChannels_32f_AC4R, 0, 0 }; -static ippiColor2GrayFunc ippiColor2GrayC3Tab[] = +static ippicviColor2GrayFunc ippicviColor2GrayC3Tab[] = { - (ippiColor2GrayFunc)ippiColorToGray_8u_C3C1R, 0, (ippiColor2GrayFunc)ippiColorToGray_16u_C3C1R, 0, - 0, (ippiColor2GrayFunc)ippiColorToGray_32f_C3C1R, 0, 0 + (ippicviColor2GrayFunc)ippicviColorToGray_8u_C3C1R, 0, (ippicviColor2GrayFunc)ippicviColorToGray_16u_C3C1R, 0, + 0, (ippicviColor2GrayFunc)ippicviColorToGray_32f_C3C1R, 0, 0 }; -static ippiColor2GrayFunc ippiColor2GrayC4Tab[] = +static ippicviColor2GrayFunc ippicviColor2GrayC4Tab[] = { - (ippiColor2GrayFunc)ippiColorToGray_8u_AC4C1R, 0, (ippiColor2GrayFunc)ippiColorToGray_16u_AC4C1R, 0, - 0, (ippiColor2GrayFunc)ippiColorToGray_32f_AC4C1R, 0, 0 + (ippicviColor2GrayFunc)ippicviColorToGray_8u_AC4C1R, 0, (ippicviColor2GrayFunc)ippicviColorToGray_16u_AC4C1R, 0, + 0, (ippicviColor2GrayFunc)ippicviColorToGray_32f_AC4C1R, 0, 0 }; -static ippiGeneralFunc ippiRGB2GrayC3Tab[] = +static ippicviGeneralFunc ippicviRGB2GrayC3Tab[] = { - (ippiGeneralFunc)ippiRGBToGray_8u_C3C1R, 0, (ippiGeneralFunc)ippiRGBToGray_16u_C3C1R, 0, - 0, (ippiGeneralFunc)ippiRGBToGray_32f_C3C1R, 0, 0 + (ippicviGeneralFunc)ippicviRGBToGray_8u_C3C1R, 0, (ippicviGeneralFunc)ippicviRGBToGray_16u_C3C1R, 0, + 0, (ippicviGeneralFunc)ippicviRGBToGray_32f_C3C1R, 0, 0 }; -static ippiGeneralFunc ippiRGB2GrayC4Tab[] = +static ippicviGeneralFunc ippicviRGB2GrayC4Tab[] = { - (ippiGeneralFunc)ippiRGBToGray_8u_AC4C1R, 0, (ippiGeneralFunc)ippiRGBToGray_16u_AC4C1R, 0, - 0, (ippiGeneralFunc)ippiRGBToGray_32f_AC4C1R, 0, 0 + (ippicviGeneralFunc)ippicviRGBToGray_8u_AC4C1R, 0, (ippicviGeneralFunc)ippicviRGBToGray_16u_AC4C1R, 0, + 0, (ippicviGeneralFunc)ippicviRGBToGray_32f_AC4C1R, 0, 0 }; -static ippiGeneralFunc ippiCopyP3C3RTab[] = +static ippicviGeneralFunc ippicviCopyP3C3RTab[] = { - (ippiGeneralFunc)ippiCopy_8u_P3C3R, 0, (ippiGeneralFunc)ippiCopy_16u_P3C3R, 0, - 0, (ippiGeneralFunc)ippiCopy_32f_P3C3R, 0, 0 + (ippicviGeneralFunc)ippicviCopy_8u_P3C3R, 0, (ippicviGeneralFunc)ippicviCopy_16u_P3C3R, 0, + 0, (ippicviGeneralFunc)ippicviCopy_32f_P3C3R, 0, 0 }; -static ippiGeneralFunc ippiRGB2XYZTab[] = +static ippicviGeneralFunc ippicviRGB2XYZTab[] = { - (ippiGeneralFunc)ippiRGBToXYZ_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToXYZ_16u_C3R, 0, - 0, (ippiGeneralFunc)ippiRGBToXYZ_32f_C3R, 0, 0 + (ippicviGeneralFunc)ippicviRGBToXYZ_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToXYZ_16u_C3R, 0, + 0, (ippicviGeneralFunc)ippicviRGBToXYZ_32f_C3R, 0, 0 }; -static ippiGeneralFunc ippiXYZ2RGBTab[] = +static ippicviGeneralFunc ippicviXYZ2RGBTab[] = { - (ippiGeneralFunc)ippiXYZToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiXYZToRGB_16u_C3R, 0, - 0, (ippiGeneralFunc)ippiXYZToRGB_32f_C3R, 0, 0 + (ippicviGeneralFunc)ippicviXYZToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviXYZToRGB_16u_C3R, 0, + 0, (ippicviGeneralFunc)ippicviXYZToRGB_32f_C3R, 0, 0 }; -static ippiGeneralFunc ippiRGB2HSVTab[] = +static ippicviGeneralFunc ippicviRGB2HSVTab[] = { - (ippiGeneralFunc)ippiRGBToHSV_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHSV_16u_C3R, 0, + (ippicviGeneralFunc)ippicviRGBToHSV_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToHSV_16u_C3R, 0, 0, 0, 0, 0 }; -static ippiGeneralFunc ippiHSV2RGBTab[] = +static ippicviGeneralFunc ippicviHSV2RGBTab[] = { - (ippiGeneralFunc)ippiHSVToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHSVToRGB_16u_C3R, 0, + (ippicviGeneralFunc)ippicviHSVToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviHSVToRGB_16u_C3R, 0, 0, 0, 0, 0 }; -static ippiGeneralFunc ippiRGB2HLSTab[] = +static ippicviGeneralFunc ippicviRGB2HLSTab[] = { - (ippiGeneralFunc)ippiRGBToHLS_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHLS_16u_C3R, 0, - 0, (ippiGeneralFunc)ippiRGBToHLS_32f_C3R, 0, 0 + (ippicviGeneralFunc)ippicviRGBToHLS_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToHLS_16u_C3R, 0, + 0, (ippicviGeneralFunc)ippicviRGBToHLS_32f_C3R, 0, 0 }; -static ippiGeneralFunc ippiHLS2RGBTab[] = +static ippicviGeneralFunc ippicviHLS2RGBTab[] = { - (ippiGeneralFunc)ippiHLSToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHLSToRGB_16u_C3R, 0, - 0, (ippiGeneralFunc)ippiHLSToRGB_32f_C3R, 0, 0 + (ippicviGeneralFunc)ippicviHLSToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviHLSToRGB_16u_C3R, 0, + 0, (ippicviGeneralFunc)ippicviHLSToRGB_32f_C3R, 0, 0 }; struct IPPGeneralFunctor { - IPPGeneralFunctor(ippiGeneralFunc _func) : func(_func){} + IPPGeneralFunctor(ippicviGeneralFunc _func) : func(_func){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { return func(src, srcStep, dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippiGeneralFunc func; + ippicviGeneralFunc func; }; struct IPPReorderFunctor { - IPPReorderFunctor(ippiReorderFunc _func, int _order0, int _order1, int _order2) : func(_func) + IPPReorderFunctor(ippicviReorderFunc _func, int _order0, int _order1, int _order2) : func(_func) { order[0] = _order0; order[1] = _order1; @@ -394,13 +394,13 @@ struct IPPReorderFunctor return func(src, srcStep, dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippiReorderFunc func; + ippicviReorderFunc func; int order[4]; }; struct IPPColor2GrayFunctor { - IPPColor2GrayFunctor(ippiColor2GrayFunc _func) : func(_func) + IPPColor2GrayFunctor(ippicviColor2GrayFunc _func) : func(_func) { coeffs[0] = 0.114f; coeffs[1] = 0.587f; @@ -411,25 +411,25 @@ struct IPPColor2GrayFunctor return func(src, srcStep, dst, dstStep, ippiSize(cols, rows), coeffs) >= 0; } private: - ippiColor2GrayFunc func; + ippicviColor2GrayFunc func; Ipp32f coeffs[3]; }; struct IPPGray2BGRFunctor { - IPPGray2BGRFunctor(ippiGeneralFunc _func) : func(_func){} + IPPGray2BGRFunctor(ippicviGeneralFunc _func) : func(_func){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { const void* srcarray[3] = { src, src, src }; return func(srcarray, srcStep, dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippiGeneralFunc func; + ippicviGeneralFunc func; }; struct IPPGray2BGRAFunctor { - IPPGray2BGRAFunctor(ippiGeneralFunc _func1, ippiReorderFunc _func2, int _depth) : func1(_func1), func2(_func2), depth(_depth){} + IPPGray2BGRAFunctor(ippicviGeneralFunc _func1, ippicviReorderFunc _func2, int _depth) : func1(_func1), func2(_func2), depth(_depth){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { const void* srcarray[3] = { src, src, src }; @@ -440,14 +440,14 @@ struct IPPGray2BGRAFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippiGeneralFunc func1; - ippiReorderFunc func2; + ippicviGeneralFunc func1; + ippicviReorderFunc func2; int depth; }; struct IPPReorderGeneralFunctor { - IPPReorderGeneralFunctor(ippiReorderFunc _func1, ippiGeneralFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) + IPPReorderGeneralFunctor(ippicviReorderFunc _func1, ippicviGeneralFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) { order[0] = _order0; order[1] = _order1; @@ -463,15 +463,15 @@ struct IPPReorderGeneralFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippiReorderFunc func1; - ippiGeneralFunc func2; + ippicviReorderFunc func1; + ippicviGeneralFunc func2; int order[4]; int depth; }; struct IPPGeneralReorderFunctor { - IPPGeneralReorderFunctor(ippiGeneralFunc _func1, ippiReorderFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) + IPPGeneralReorderFunctor(ippicviGeneralFunc _func1, ippicviReorderFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) { order[0] = _order0; order[1] = _order1; @@ -487,8 +487,8 @@ struct IPPGeneralReorderFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippiGeneralFunc func1; - ippiReorderFunc func2; + ippicviGeneralFunc func1; + ippicviReorderFunc func2; int order[4]; int depth; }; @@ -3228,32 +3228,32 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2BGRA || code == CV_RGB2RGBA) { - if ( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 0, 1, 2)) ) + if ( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2)) ) return; } else if( code == CV_BGRA2BGR ) { - if ( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiCopyAC4C3RTab[depth])) ) + if ( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviCopyAC4C3RTab[depth])) ) return; } else if( code == CV_BGR2RGBA ) { - if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGBA2BGR ) { - if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC4C3RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC4C3RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGB2BGR ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGBA2BGRA ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippicviSwapChannelsC4RTab[depth], 2, 1, 0)) ) return; } #endif @@ -3314,22 +3314,22 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC3Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippicviColor2GrayC3Tab[depth])) ) return; } else if( code == CV_RGB2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC3Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviRGB2GrayC3Tab[depth])) ) return; } else if( code == CV_BGRA2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC4Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippicviColor2GrayC4Tab[depth])) ) return; } else if( code == CV_RGBA2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC4Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviRGB2GrayC4Tab[depth])) ) return; } #endif @@ -3366,12 +3366,12 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_GRAY2BGR ) { - if( CvtColorIPPLoop(src, dst, IPPGray2BGRFunctor(ippiCopyP3C3RTab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGray2BGRFunctor(ippicviCopyP3C3RTab[depth])) ) return; } else if( code == CV_GRAY2BGRA ) { - if( CvtColorIPPLoop(src, dst, IPPGray2BGRAFunctor(ippiCopyP3C3RTab[depth], ippiSwapChannelsC3C4RTab[depth], depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGray2BGRAFunctor(ippicviCopyP3C3RTab[depth], ippicviSwapChannelsC3C4RTab[depth], depth)) ) return; } #endif @@ -3459,22 +3459,22 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2XYZ && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2XYZTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2XYZ && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2XYZTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2XYZ && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2XYZTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2XYZTab[depth])) ) return; } else if( code == CV_RGB2XYZ && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2XYZTab[depth], 0, 1, 2, depth)) ) return; } #endif @@ -3498,22 +3498,22 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_XYZ2BGR && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_XYZ2BGR && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } if( code == CV_XYZ2RGB && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiXYZ2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviXYZ2RGBTab[depth])) ) return; } else if( code == CV_XYZ2RGB && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } #endif @@ -3543,42 +3543,42 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) { if( code == CV_BGR2HSV_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2HSVTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2HSV_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HSVTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2HSV_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HSVTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2HSVTab[depth])) ) return; } else if( code == CV_RGB2HSV_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HSVTab[depth], 0, 1, 2, depth)) ) return; } else if( code == CV_BGR2HLS_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2HLSTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2HLS_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HLSTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2HLS_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HLSTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2HLSTab[depth])) ) return; } else if( code == CV_RGB2HLS_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HLSTab[depth], 0, 1, 2, depth)) ) return; } } @@ -3624,42 +3624,42 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) { if( code == CV_HSV2BGR_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HSV2BGR_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HSV2RGB_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHSV2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviHSV2RGBTab[depth])) ) return; } else if( code == CV_HSV2RGB_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } else if( code == CV_HLS2BGR_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HLS2BGR_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HLS2RGB_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHLS2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviHLS2RGBTab[depth])) ) return; } else if( code == CV_HLS2RGB_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } } diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp index df2f371f55..0004431b10 100644 --- a/modules/imgproc/src/deriv.cpp +++ b/modules/imgproc/src/deriv.cpp @@ -44,7 +44,7 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippInit(); +static IppStatus sts = ippicvInit(); #endif /****************************************************************************************\ @@ -212,10 +212,10 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, { if((dx == 1) && (dy == 0)) { - ippiFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize); + ippicviFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize); buffer.allocate(bufSize); - ippiFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer); return true; @@ -223,10 +223,10 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, if((dx == 0) && (dy == 1)) { - ippiFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize); + ippicviFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize); buffer.allocate(bufSize); - ippiFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer); return true; @@ -245,29 +245,29 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, case CV_32F: if((dx == 1) && (dy == 0)) { - ippiFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); + ippicviFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); buffer.allocate(bufSize); - ippiFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) /* IPP is fast, so MulC produce very little perf degradation */ - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 0) && (dy == 1)) { - ippiFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); + ippicviFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); buffer.allocate(bufSize); - ippiFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } @@ -297,10 +297,10 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if((dx == 1) && (dy == 0)) { - ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); return true; @@ -308,10 +308,10 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if((dx == 0) && (dy == 1)) { - ippiFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); @@ -320,10 +320,10 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if((dx == 2) && (dy == 0)) { - ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); @@ -332,10 +332,10 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if((dx == 0) && (dy == 2)) { - ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + ippicviFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); @@ -347,56 +347,56 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if((dx == 1) && (dy == 0)) { - ippiFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize); + ippicviFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize); buffer.allocate(bufSize); - ippiFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 0) && (dy == 1)) { - ippiFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 2) && (dy == 0)) { - ippiFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 0) && (dy == 2)) { - ippiFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); + ippicviFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); buffer.allocate(bufSize); - ippiFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + ippicviFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer); if(scale != 1) - ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } diff --git a/modules/imgproc/src/distransform.cpp b/modules/imgproc/src/distransform.cpp index 94a5592858..4c28735c05 100644 --- a/modules/imgproc/src/distransform.cpp +++ b/modules/imgproc/src/distransform.cpp @@ -748,7 +748,7 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe if( maskSize == CV_DIST_MASK_5 ) { IppiSize roi = { src.cols, src.rows }; - if( ippiDistanceTransform_5x5_8u32f_C1R( + if( ippicviDistanceTransform_5x5_8u32f_C1R( src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, _mask) >= 0 ) return; diff --git a/modules/imgproc/src/filter.cpp b/modules/imgproc/src/filter.cpp index 2bc6b8a706..62a62ded9c 100644 --- a/modules/imgproc/src/filter.cpp +++ b/modules/imgproc/src/filter.cpp @@ -1420,36 +1420,16 @@ struct RowVec_32f int operator()(const uchar* _src, uchar* _dst, int width, int cn) const { +#ifdef USE_IPP_SEP_FILTERS + int ret = ippicviOperator(_src, _dst, width, cn); + if (ret > 0) + return ret; +#endif int _ksize = kernel.rows + kernel.cols - 1; const float* src0 = (const float*)_src; float* dst = (float*)_dst; const float* _kx = (const float*)kernel.data; -#ifdef USE_IPP_SEP_FILTERS - IppiSize roisz = { width, 1 }; - if( (cn == 1 || cn == 3) && width >= _ksize*8 ) - { - if( bufsz < 0 ) - { - if( (cn == 1 && ippiFilterRowBorderPipelineGetBufferSize_32f_C1R(roisz, _ksize, &bufsz) < 0) || - (cn == 3 && ippiFilterRowBorderPipelineGetBufferSize_32f_C3R(roisz, _ksize, &bufsz) < 0)) - return 0; - } - AutoBuffer buf(bufsz + 64); - uchar* bufptr = alignPtr((uchar*)buf, 32); - int step = (int)(width*sizeof(dst[0])*cn); - float borderValue[] = {0.f, 0.f, 0.f}; - // here is the trick. IPP needs border type and extrapolates the row. We did it already. - // So we pass anchor=0 and ignore the right tail of results since they are incorrect there. - if( (cn == 1 && ippiFilterRowBorderPipeline_32f_C1R(src0, step, &dst, roisz, _kx, _ksize, 0, - ippBorderRepl, borderValue[0], bufptr) < 0) || - (cn == 3 && ippiFilterRowBorderPipeline_32f_C3R(src0, step, &dst, roisz, _kx, _ksize, 0, - ippBorderRepl, borderValue, bufptr) < 0)) - return 0; - return width - _ksize + 1; - } -#endif - if( !haveSSE ) return 0; @@ -1479,7 +1459,38 @@ struct RowVec_32f Mat kernel; bool haveSSE; #ifdef USE_IPP_SEP_FILTERS +private: mutable int bufsz; + int ippicviOperator(const uchar* _src, uchar* _dst, int width, int cn) const + { + int _ksize = kernel.rows + kernel.cols - 1; + if ((1 != cn && 3 != cn) || width < _ksize*8) + return 0; + + const float* src = (const float*)_src; + float* dst = (float*)_dst; + const float* _kx = (const float*)kernel.data; + + IppiSize roisz = { width, 1 }; + if( bufsz < 0 ) + { + if( (cn == 1 && ippicviFilterRowBorderPipelineGetBufferSize_32f_C1R(roisz, _ksize, &bufsz) < 0) || + (cn == 3 && ippicviFilterRowBorderPipelineGetBufferSize_32f_C3R(roisz, _ksize, &bufsz) < 0)) + return 0; + } + AutoBuffer buf(bufsz + 64); + uchar* bufptr = alignPtr((uchar*)buf, 32); + int step = (int)(width*sizeof(dst[0])*cn); + float borderValue[] = {0.f, 0.f, 0.f}; + // here is the trick. IPP needs border type and extrapolates the row. We did it already. + // So we pass anchor=0 and ignore the right tail of results since they are incorrect there. + if( (cn == 1 && ippicviFilterRowBorderPipeline_32f_C1R(src, step, &dst, roisz, _kx, _ksize, 0, + ippBorderRepl, borderValue[0], bufptr) < 0) || + (cn == 3 && ippicviFilterRowBorderPipeline_32f_C3R(src, step, &dst, roisz, _kx, _ksize, 0, + ippBorderRepl, borderValue, bufptr) < 0)) + return 0; + return width - _ksize + 1; + } #endif }; diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 9d3eabaad3..d12c7851bd 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -50,24 +50,24 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippInit(); +static IppStatus sts = ippicvInit(); #endif namespace cv { #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) - typedef IppStatus (CV_STDCALL* ippiResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); - typedef IppStatus (CV_STDCALL* ippiResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); - typedef IppStatus (CV_STDCALL* ippiResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); + typedef IppStatus (CV_STDCALL* ippicviResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); + typedef IppStatus (CV_STDCALL* ippicviResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); + typedef IppStatus (CV_STDCALL* ippicviResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); #endif #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) - typedef IppStatus (CV_STDCALL* ippiSetFunc)(const void*, void *, int, IppiSize); - typedef IppStatus (CV_STDCALL* ippiWarpPerspectiveBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [3][3], int); - typedef IppStatus (CV_STDCALL* ippiWarpAffineBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [2][3], int); + typedef IppStatus (CV_STDCALL* ippicviSetFunc)(const void*, void *, int, IppiSize); + typedef IppStatus (CV_STDCALL* ippicviWarpPerspectiveBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [3][3], int); + typedef IppStatus (CV_STDCALL* ippicviWarpAffineBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [2][3], int); template - bool IPPSetSimple(cv::Scalar value, void *dataPointer, int step, IppiSize &size, ippiSetFunc func) + bool IPPSetSimple(cv::Scalar value, void *dataPointer, int step, IppiSize &size, ippicviSetFunc func) { Type values[channels]; for( int i = 0; i < channels; i++ ) @@ -82,11 +82,11 @@ namespace cv switch( depth ) { case CV_8U: - return ippiSet_8u_C1R((Ipp8u)value[0], (Ipp8u *)dataPointer, step, size) >= 0; + return ippicviSet_8u_C1R((Ipp8u)value[0], (Ipp8u *)dataPointer, step, size) >= 0; case CV_16U: - return ippiSet_16u_C1R((Ipp16u)value[0], (Ipp16u *)dataPointer, step, size) >= 0; + return ippicviSet_16u_C1R((Ipp16u)value[0], (Ipp16u *)dataPointer, step, size) >= 0; case CV_32F: - return ippiSet_32f_C1R((Ipp32f)value[0], (Ipp32f *)dataPointer, step, size) >= 0; + return ippicviSet_32f_C1R((Ipp32f)value[0], (Ipp32f *)dataPointer, step, size) >= 0; } } else @@ -96,11 +96,11 @@ namespace cv switch( depth ) { case CV_8U: - return IPPSetSimple<3, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C3R); + return IPPSetSimple<3, Ipp8u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_8u_C3R); case CV_16U: - return IPPSetSimple<3, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C3R); + return IPPSetSimple<3, Ipp16u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_16u_C3R); case CV_32F: - return IPPSetSimple<3, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C3R); + return IPPSetSimple<3, Ipp32f>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_32f_C3R); } } else if( channels == 4 ) @@ -108,11 +108,11 @@ namespace cv switch( depth ) { case CV_8U: - return IPPSetSimple<4, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C4R); + return IPPSetSimple<4, Ipp8u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_8u_C4R); case CV_16U: - return IPPSetSimple<4, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C4R); + return IPPSetSimple<4, Ipp16u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_16u_C4R); case CV_32F: - return IPPSetSimple<4, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C4R); + return IPPSetSimple<4, Ipp32f>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_32f_C4R); } } } @@ -1880,37 +1880,37 @@ static int computeResizeAreaTab( int ssize, int dsize, int cn, double scale, Dec #define CHECK_IPP_STATUS(STATUS) if( STATUS!=ippStsNoErr ) { *ok = false; return;} #define SET_IPP_RESIZE_LINEAR_FUNC_PTR(TYPE, CN) \ - func = (ippiResizeFunc)ippiResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippicviResizeFunc)ippicviResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ - CHECK_IPP_STATUS(ippiResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_32f*)pSpec)); + CHECK_IPP_STATUS(ippicviResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_32f*)pSpec)); #define SET_IPP_RESIZE_LINEAR_FUNC_64_PTR(TYPE, CN) \ if (mode==(int)ippCubic) { *ok = false; return;}\ - func = (ippiResizeFunc)ippiResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippicviResizeFunc)ippicviResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ - CHECK_IPP_STATUS(ippiResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_64f*)pSpec));\ - getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ - getSrcOffsetFunc = (ippiResizeGetSrcOffset) ippiResizeGetBufferSize_##TYPE; + CHECK_IPP_STATUS(ippicviResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_64f*)pSpec));\ + getBufferSizeFunc = (ippicviResizeGetBufferSize)ippicviResizeGetBufferSize_##TYPE;\ + getSrcOffsetFunc = (ippicviResizeGetSrcOffset) ippicviResizeGetBufferSize_##TYPE; #define SET_IPP_RESIZE_CUBIC_FUNC_PTR(TYPE, CN) \ - func = (ippiResizeFunc)ippiResizeCubic_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippicviResizeFunc)ippicviResizeCubic_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ AutoBuffer buf(initSize);\ uchar* pInit = (uchar*)buf;\ - CHECK_IPP_STATUS(ippiResizeCubicInit_##TYPE(srcSize, dstSize, 0.f, 0.75f, (IppiResizeSpec_32f*)pSpec, pInit)); + CHECK_IPP_STATUS(ippicviResizeCubicInit_##TYPE(srcSize, dstSize, 0.f, 0.75f, (IppiResizeSpec_32f*)pSpec, pInit)); #define SET_IPP_RESIZE_PTR(TYPE, CN) \ if (mode == (int)ippLinear) { SET_IPP_RESIZE_LINEAR_FUNC_PTR(TYPE, CN);}\ else if (mode == (int)ippCubic) { SET_IPP_RESIZE_CUBIC_FUNC_PTR(TYPE, CN);}\ else { *ok = false; return;}\ - getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ - getSrcOffsetFunc = (ippiResizeGetSrcOffset)ippiResizeGetSrcOffset_##TYPE; + getBufferSizeFunc = (ippicviResizeGetBufferSize)ippicviResizeGetBufferSize_##TYPE;\ + getSrcOffsetFunc = (ippicviResizeGetSrcOffset)ippicviResizeGetSrcOffset_##TYPE; #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) class IPPresizeInvoker : @@ -1929,6 +1929,7 @@ public: dstSize.width = dst.cols; dstSize.height = dst.rows; +<<<<<<< HEAD switch (type) { case CV_8UC1: SET_IPP_RESIZE_PTR(8u,C1); break; @@ -1981,6 +1982,37 @@ public: *ok = false; } +======= + ~IPPresizeInvoker() + { + } + + virtual void operator() (const Range& range) const + { + if (*ok == false) return; + + int cn = src.channels(); + int dsty = min(cvRound(range.start * inv_scale_y), dst.rows); + int dstwidth = min(cvRound(src.cols * inv_scale_x), dst.cols); + int dstheight = min(cvRound(range.end * inv_scale_y), dst.rows); + + IppiPoint dstOffset = { 0, dsty }, srcOffset = {0, 0}; + IppiSize dstSize = { dstwidth, dstheight - dsty }; + int bufsize = 0, itemSize = (int)src.elemSize1(); + + CHECK_IPP_STATUS(getBufferSizeFunc(pSpec, dstSize, cn, &bufsize)); + CHECK_IPP_STATUS(getSrcOffsetFunc(pSpec, dstOffset, &srcOffset)); + + Ipp8u* pSrc = (Ipp8u*)src.data + (int)src.step[0] * srcOffset.y + srcOffset.x * cn * itemSize; + Ipp8u* pDst = (Ipp8u*)dst.data + (int)dst.step[0] * dstOffset.y + dstOffset.x * cn * itemSize; + + AutoBuffer buf(bufsize + 64); + uchar* bufptr = alignPtr((uchar*)buf, 32); + + if( func( pSrc, (int)src.step[0], pDst, (int)dst.step[0], dstOffset, dstSize, ippBorderRepl, 0, pSpec, bufptr ) < 0 ) + *ok = false; + } +>>>>>>> Prepare codes for ippicv library private: const Mat & src; Mat & dst; @@ -1989,9 +2021,9 @@ private: void *pSpec; AutoBuffer specBuf; int mode; - ippiResizeFunc func; - ippiResizeGetBufferSize getBufferSizeFunc; - ippiResizeGetSrcOffset getSrcOffsetFunc; + ippicviResizeFunc func; + ippicviResizeGetBufferSize getBufferSizeFunc; + ippicviResizeGetSrcOffset getSrcOffsetFunc; bool *ok; const IPPresizeInvoker& operator= (const IPPresizeInvoker&); }; @@ -4019,31 +4051,31 @@ class IPPwarpAffineInvoker : public ParallelLoopBody { public: - IPPwarpAffineInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[2][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippiWarpAffineBackFunc _func, bool *_ok) : + IPPwarpAffineInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[2][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippicviWarpAffineBackFunc _func, bool *_ok) : ParallelLoopBody(), src(_src), dst(_dst), mode(_interpolation), coeffs(_coeffs), borderType(_borderType), borderValue(_borderValue), func(_func), ok(_ok) { *ok = true; } - virtual void operator() (const Range& range) const - { - IppiSize srcsize = { src.cols, src.rows }; - IppiRect srcroi = { 0, 0, src.cols, src.rows }; - IppiRect dstroi = { 0, range.start, dst.cols, range.end - range.start }; - int cnn = src.channels(); - if( borderType == BORDER_CONSTANT ) - { - IppiSize setSize = { dst.cols, range.end - range.start }; - void *dataPointer = dst.data + dst.step[0] * range.start; - if( !IPPSet( borderValue, dataPointer, (int)dst.step[0], setSize, cnn, src.depth() ) ) - { - *ok = false; - return; - } - } - if( func( src.data, srcsize, (int)src.step[0], srcroi, dst.data, (int)dst.step[0], dstroi, coeffs, mode ) < 0) ////Aug 2013: problem in IPP 7.1, 8.0 : sometimes function return ippStsCoeffErr - *ok = false; - } + virtual void operator() (const Range& range) const + { + IppiSize srcsize = { src.cols, src.rows }; + IppiRect srcroi = { 0, 0, src.cols, src.rows }; + IppiRect dstroi = { 0, range.start, dst.cols, range.end - range.start }; + int cnn = src.channels(); + if( borderType == BORDER_CONSTANT ) + { + IppiSize setSize = { dst.cols, range.end - range.start }; + void *dataPointer = dst.data + dst.step[0] * range.start; + if( !IPPSet( borderValue, dataPointer, (int)dst.step[0], setSize, cnn, src.depth() ) ) + { + *ok = false; + return; + } + } + if( func( src.data, srcsize, (int)src.step[0], srcroi, dst.data, (int)dst.step[0], dstroi, coeffs, mode ) < 0) ////Aug 2013: problem in IPP 7.1, 8.0 : sometimes function return ippStsCoeffErr + *ok = false; + } private: Mat &src; Mat &dst; @@ -4051,7 +4083,7 @@ private: int mode; int borderType; Scalar borderValue; - ippiWarpAffineBackFunc func; + ippicviWarpAffineBackFunc func; bool *ok; const IPPwarpAffineInvoker& operator= (const IPPwarpAffineInvoker&); }; @@ -4214,16 +4246,16 @@ void cv::warpAffine( InputArray _src, OutputArray _dst, ( borderType == cv::BORDER_TRANSPARENT || ( borderType == cv::BORDER_CONSTANT ) ) ) { int type = src.type(); - ippiWarpAffineBackFunc ippFunc = - type == CV_8UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C1R : - type == CV_8UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C3R : - type == CV_8UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C4R : - type == CV_16UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C1R : - type == CV_16UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C3R : - type == CV_16UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C4R : - type == CV_32FC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C1R : - type == CV_32FC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C3R : - type == CV_32FC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C4R : + ippicviWarpAffineBackFunc ippFunc = + type == CV_8UC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C1R : + type == CV_8UC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C3R : + type == CV_8UC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C4R : + type == CV_16UC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C1R : + type == CV_16UC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C3R : + type == CV_16UC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C4R : + type == CV_32FC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C1R : + type == CV_32FC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C3R : + type == CV_32FC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C4R : 0; int mode = flags == INTER_LINEAR ? IPPI_INTER_LINEAR : @@ -4362,32 +4394,32 @@ class IPPwarpPerspectiveInvoker : public ParallelLoopBody { public: - IPPwarpPerspectiveInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[3][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippiWarpPerspectiveBackFunc _func, bool *_ok) : + IPPwarpPerspectiveInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[3][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippicviWarpPerspectiveBackFunc _func, bool *_ok) : ParallelLoopBody(), src(_src), dst(_dst), mode(_interpolation), coeffs(_coeffs), borderType(_borderType), borderValue(_borderValue), func(_func), ok(_ok) { *ok = true; } - virtual void operator() (const Range& range) const - { - IppiSize srcsize = {src.cols, src.rows}; - IppiRect srcroi = {0, 0, src.cols, src.rows}; - IppiRect dstroi = {0, range.start, dst.cols, range.end - range.start}; - int cnn = src.channels(); + virtual void operator() (const Range& range) const + { + IppiSize srcsize = {src.cols, src.rows}; + IppiRect srcroi = {0, 0, src.cols, src.rows}; + IppiRect dstroi = {0, range.start, dst.cols, range.end - range.start}; + int cnn = src.channels(); - if( borderType == BORDER_CONSTANT ) - { - IppiSize setSize = {dst.cols, range.end - range.start}; - void *dataPointer = dst.data + dst.step[0] * range.start; - if( !IPPSet( borderValue, dataPointer, (int)dst.step[0], setSize, cnn, src.depth() ) ) - { - *ok = false; - return; - } - } - if( func(src.data, srcsize, (int)src.step[0], srcroi, dst.data, (int)dst.step[0], dstroi, coeffs, mode) < 0) - *ok = false; - } + if( borderType == BORDER_CONSTANT ) + { + IppiSize setSize = {dst.cols, range.end - range.start}; + void *dataPointer = dst.data + dst.step[0] * range.start; + if( !IPPSet( borderValue, dataPointer, (int)dst.step[0], setSize, cnn, src.depth() ) ) + { + *ok = false; + return; + } + } + if( func(src.data, srcsize, (int)src.step[0], srcroi, dst.data, (int)dst.step[0], dstroi, coeffs, mode) < 0) + *ok = false; + } private: Mat &src; Mat &dst; @@ -4395,7 +4427,7 @@ private: int mode; int borderType; const Scalar borderValue; - ippiWarpPerspectiveBackFunc func; + ippicviWarpPerspectiveBackFunc func; bool *ok; const IPPwarpPerspectiveInvoker& operator= (const IPPwarpPerspectiveInvoker&); }; @@ -4444,16 +4476,16 @@ void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0, ( borderType == cv::BORDER_TRANSPARENT || borderType == cv::BORDER_CONSTANT ) ) { int type = src.type(); - ippiWarpPerspectiveBackFunc ippFunc = - type == CV_8UC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C1R : - type == CV_8UC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C3R : - type == CV_8UC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C4R : - type == CV_16UC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C1R : - type == CV_16UC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C3R : - type == CV_16UC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C4R : - type == CV_32FC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C1R : - type == CV_32FC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C3R : - type == CV_32FC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C4R : + ippicviWarpPerspectiveBackFunc ippFunc = + type == CV_8UC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C1R : + type == CV_8UC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C3R : + type == CV_8UC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C4R : + type == CV_16UC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C1R : + type == CV_16UC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C3R : + type == CV_16UC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C4R : + type == CV_32FC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C1R : + type == CV_32FC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C3R : + type == CV_32FC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C4R : 0; int mode = flags == INTER_LINEAR ? IPPI_INTER_LINEAR : diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 1dd0a252e8..bdbffd8975 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1149,26 +1149,26 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne _src = &temp; } //DEPRECATED. Allocates and initializes morphology state structure for erosion or dilation operation. - typedef IppStatus (CV_STDCALL* ippiMorphologyInitAllocFunc)(int, const void*, IppiSize, IppiPoint, IppiMorphState **); - typedef IppStatus (CV_STDCALL* ippiMorphologyBorderReplicateFunc)(const void*, int, void *, int, + typedef IppStatus (CV_STDCALL* ippicviMorphologyInitAllocFunc)(int, const void*, IppiSize, IppiPoint, IppiMorphState **); + typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderReplicateFunc)(const void*, int, void *, int, IppiSize, IppiBorderType, IppiMorphState *); - typedef IppStatus (CV_STDCALL* ippiFilterMinMaxGetBufferSizeFunc)(int, IppiSize, int*); - typedef IppStatus (CV_STDCALL* ippiFilterMinMaxBorderReplicateFunc)(const void*, int, void*, int, + typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxGetBufferSizeFunc)(int, IppiSize, int*); + typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxBorderReplicateFunc)(const void*, int, void*, int, IppiSize, IppiSize, IppiPoint, void*); - ippiMorphologyInitAllocFunc initAllocFunc = 0; - ippiMorphologyBorderReplicateFunc morphFunc = 0; - ippiFilterMinMaxGetBufferSizeFunc getBufSizeFunc = 0; - ippiFilterMinMaxBorderReplicateFunc morphRectFunc = 0; + ippicviMorphologyInitAllocFunc initAllocFunc = 0; + ippicviMorphologyBorderReplicateFunc morphFunc = 0; + ippicviFilterMinMaxGetBufferSizeFunc getBufSizeFunc = 0; + ippicviFilterMinMaxBorderReplicateFunc morphRectFunc = 0; #define IPP_MORPH_CASE(type, flavor) \ case type: \ - initAllocFunc = (ippiMorphologyInitAllocFunc)ippiMorphologyInitAlloc_##flavor; \ - morphFunc = op == MORPH_ERODE ? (ippiMorphologyBorderReplicateFunc)ippiErodeBorderReplicate_##flavor : \ - (ippiMorphologyBorderReplicateFunc)ippiDilateBorderReplicate_##flavor; \ - getBufSizeFunc = (ippiFilterMinMaxGetBufferSizeFunc)ippiFilterMinGetBufferSize_##flavor; \ - morphRectFunc = op == MORPH_ERODE ? (ippiFilterMinMaxBorderReplicateFunc)ippiFilterMinBorderReplicate_##flavor : \ - (ippiFilterMinMaxBorderReplicateFunc)ippiFilterMaxBorderReplicate_##flavor; \ + initAllocFunc = (ippicviMorphologyInitAllocFunc)ippicviMorphologyInitAlloc_##flavor; \ + morphFunc = op == MORPH_ERODE ? (ippicviMorphologyBorderReplicateFunc)ippicviErodeBorderReplicate_##flavor : \ + (ippicviMorphologyBorderReplicateFunc)ippicviDilateBorderReplicate_##flavor; \ + getBufSizeFunc = (ippicviFilterMinMaxGetBufferSizeFunc)ippicviFilterMinGetBufferSize_##flavor; \ + morphRectFunc = op == MORPH_ERODE ? (ippicviFilterMinMaxBorderReplicateFunc)ippicviFilterMinBorderReplicate_##flavor : \ + (ippicviFilterMinMaxBorderReplicateFunc)ippicviFilterMaxBorderReplicate_##flavor; \ break switch( type ) @@ -1196,7 +1196,7 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne bool is_ok = morphFunc( _src->data, (int)_src->step[0], dst.data, (int)dst.step[0], roiSize, ippBorderRepl, pState ) >= 0; - ippiMorphologyFree(pState); + ippicviMorphologyFree(pState); return is_ok; } else if( rectKernel && morphRectFunc && getBufSizeFunc ) diff --git a/modules/imgproc/src/samplers.cpp b/modules/imgproc/src/samplers.cpp index d6cc8a56fe..81bbf7656d 100644 --- a/modules/imgproc/src/samplers.cpp +++ b/modules/imgproc/src/samplers.cpp @@ -375,7 +375,7 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center, Mat patch = _patch.getMat(); #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) - typedef IppStatus (CV_STDCALL *ippiGetRectSubPixFunc)( const void* src, int src_step, + typedef IppStatus (CV_STDCALL *ippicviGetRectSubPixFunc)( const void* src, int src_step, IppiSize src_size, void* dst, int dst_step, IppiSize win_size, IppiPoint_32f center, @@ -385,10 +385,10 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center, IppiPoint_32f icenter = {center.x, center.y}; IppiSize src_size={image.cols, image.rows}, win_size={patch.cols, patch.rows}; int srctype = image.type(); - ippiGetRectSubPixFunc ippfunc = - srctype == CV_8UC1 && ddepth == CV_8U ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u_C1R : - srctype == CV_8UC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u32f_C1R : - srctype == CV_32FC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_32f_C1R : 0; + ippicviGetRectSubPixFunc ippfunc = + srctype == CV_8UC1 && ddepth == CV_8U ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_8u_C1R : + srctype == CV_8UC1 && ddepth == CV_32F ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_8u32f_C1R : + srctype == CV_32FC1 && ddepth == CV_32F ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_32f_C1R : 0; if( ippfunc && ippfunc(image.data, (int)image.step, src_size, patch.data, (int)patch.step, win_size, icenter, &minpt, &maxpt) >= 0 ) diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 6a18af5c2d..28fbb42f47 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1115,14 +1115,16 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, Mat src = _src.getMat(), dst = _dst.getMat(); IppiSize roi = { src.cols, src.rows }; int bufSize = 0; - ippiFilterGaussGetBufferSize_32f_C1R(roi, ksize.width, &bufSize); - AutoBuffer buf(bufSize+128); - if( ippiFilterGaussBorder_32f_C1R((const Ipp32f *)src.data, (int)src.step, - (Ipp32f *)dst.data, (int)dst.step, - roi, ksize.width, (Ipp32f)sigma1, - (IppiBorderType)borderType, 0.0, - alignPtr(&buf[0],32)) >= 0 ) - return; + if (ippStsNoErr == ippicviFilterGaussGetBufferSize_32f_C1R(roi, ksize.width, &bufSize)) + { + AutoBuffer buf(bufSize+128); + if( ippicviFilterGaussBorder_32f_C1R((const Ipp32f *)src.data, (int)src.step, + (Ipp32f *)dst.data, (int)dst.step, + roi, ksize.width, (Ipp32f)sigma1, + (IppiBorderType)borderType, 0.0, + alignPtr(&buf[0],32)) >= 0 ) + return; + } } #endif @@ -2180,11 +2182,19 @@ public: IppiSize kernel = {d, d}; IppiSize roi={dst.cols, range.end - range.start}; int bufsize=0; - ippiFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize); + if (ippStsNoErr != ippicviFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize)) + { + *ok = false; + return; + } AutoBuffer buf(bufsize); IppiFilterBilateralSpec *pSpec = (IppiFilterBilateralSpec *)alignPtr(&buf[0], 32); - ippiFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec ); - if( ippiFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec ) < 0) + if (ippStsNoErr != ippicviFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec )) + { + *ok = false; + return; + } + if( ippicviFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec ) < 0) *ok = false; } private: diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index 4e18f119fa..d7bf9a0bfc 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -44,7 +44,7 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippInit(); +static IppStatus sts = ippicvInit(); #endif namespace cv @@ -365,30 +365,32 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( ( depth == CV_8U ) && ( sdepth == CV_32F || sdepth == CV_32S ) && ( !_tilted.needed() ) && ( !_sqsum.needed() || sqdepth == CV_64F ) && ( cn == 1 ) ) { + IppStatus status; IppiSize srcRoiSize = ippiSize( src.cols, src.rows ); if( sdepth == CV_32F ) { if( _sqsum.needed() ) { - ippiSqrIntegral_8u32f64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); + status = ippicviSqrIntegral_8u32f64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); } else { - ippiIntegral_8u32f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, srcRoiSize, 0 ); + status = ippicviIntegral_8u32f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } - else if( sdepth == CV_32S ) + else// if( sdepth == CV_32S ) { if( _sqsum.needed() ) { - ippiSqrIntegral_8u32s64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); + status = ippicviSqrIntegral_8u32s64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); } else { - ippiIntegral_8u32s_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, srcRoiSize, 0 ); + status = ippicviIntegral_8u32s_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } - return; + if (ippStsNoErr == status) + return; } #endif diff --git a/modules/objdetect/src/haar.cpp b/modules/objdetect/src/haar.cpp index 2f864797fb..2f954abece 100644 --- a/modules/objdetect/src/haar.cpp +++ b/modules/objdetect/src/haar.cpp @@ -165,7 +165,7 @@ icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade ) for( i = 0; i < cascade->count; i++ ) { if( cascade->ipp_stages[i] ) - ippiHaarClassifierFree_32f( (IppiHaarClassifier_32f*)cascade->ipp_stages[i] ); + ippicviHaarClassifierFree_32f( (IppiHaarClassifier_32f*)cascade->ipp_stages[i] ); } } cvFree( &cascade->ipp_stages ); @@ -1318,7 +1318,7 @@ public: if( cascade->hid_cascade->ipp_stages ) { IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height}; - ippiRectStdDev_32f_C1R(sum1.ptr(y1), sum1.step, + ippicviRectStdDev_32f_C1R(sum1.ptr(y1), sum1.step, sqsum1.ptr(y1), sqsum1.step, norm1->ptr(y1), norm1->step, ippiSize(ssz.width, ssz.height), iequRect ); @@ -1340,7 +1340,7 @@ public: for( int j = 0; j < cascade->count; j++ ) { - if( ippiApplyHaarClassifier_32f_C1R( + if( ippicviApplyHaarClassifier_32f_C1R( sum1.ptr(y1), sum1.step, norm1->ptr(y1), norm1->step, mask1->ptr(y1), mask1->step, From 58de8bc91779a254e740be68cb9066600487e8e6 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 26 Mar 2014 16:25:14 +0400 Subject: [PATCH 16/52] Change deprecated functions to valid --- modules/imgproc/src/morph.cpp | 186 +++++++++++++++++++++++++++++----- 1 file changed, 163 insertions(+), 23 deletions(-) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index bdbffd8975..f446f98810 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1137,33 +1137,40 @@ private: }; #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +#if 0 static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { int type = src.type(); const Mat* _src = &src; Mat temp; - if( src.data == dst.data ) + if (src.data == dst.data) { src.copyTo(temp); _src = &temp; } //DEPRECATED. Allocates and initializes morphology state structure for erosion or dilation operation. - typedef IppStatus (CV_STDCALL* ippicviMorphologyInitAllocFunc)(int, const void*, IppiSize, IppiPoint, IppiMorphState **); - typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderReplicateFunc)(const void*, int, void *, int, - IppiSize, IppiBorderType, IppiMorphState *); +// typedef IppStatus (CV_STDCALL* ippicviMorphologyInitAllocFunc)(int, const void*, IppiSize, IppiPoint, IppiMorphState **); + typedef IppStatus (CV_STDCALL* ippicviMorphologyGetSizeFunc)(int, const Ipp8u*, IppiSize, int*); + typedef IppStatus (CV_STDCALL* ippicviMorphologyInit)(int, const Ipp8u*, IppiSize, IppiPoint, IppiMorphState*); + typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderReplicateFunc)(const void*, int, void *, int, IppiSize, IppiBorderType, IppiMorphState *); + typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderFunc8u)(const Ipp8u*, int, Ipp8u*, int, IppiSize, IppiBorderType, Ipp8u, IppiMorphState*, Ipp8u*); + typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderFunc32f)(const Ipp32f*, int, Ipp32f*, int, IppiSize, IppiBorderType, Ipp32f, IppiMorphState*, Ipp8u*); typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxGetBufferSizeFunc)(int, IppiSize, int*); - typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxBorderReplicateFunc)(const void*, int, void*, int, - IppiSize, IppiSize, IppiPoint, void*); + typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxBorderReplicateFunc)(const void*, int, void*, int, IppiSize, IppiSize, IppiPoint, void*); - ippicviMorphologyInitAllocFunc initAllocFunc = 0; + //ippicviMorphologyInitAllocFunc initAllocFunc = 0; + ippicviMorphologyGetSizeFunc getSizeFunc = 0; + ippicviMorphologyInit initFunc = 0; ippicviMorphologyBorderReplicateFunc morphFunc = 0; ippicviFilterMinMaxGetBufferSizeFunc getBufSizeFunc = 0; ippicviFilterMinMaxBorderReplicateFunc morphRectFunc = 0; - #define IPP_MORPH_CASE(type, flavor) \ + #define IPP_MORPH_CASE(type, flavor, datatype) \ case type: \ - initAllocFunc = (ippicviMorphologyInitAllocFunc)ippicviMorphologyInitAlloc_##flavor; \ +/* initAllocFunc = (ippicviMorphologyInitAllocFunc)ippicviMorphologyInitAlloc_##flavor; */\ + getSizeFunc = (ippicviMorphologyGetSizeFunc)ippicviMorphologyGetSize_##flavor ; \ + initFunc = (ippicviMorphologyInit)ippicviMorphologyInit_##flavor ; \ morphFunc = op == MORPH_ERODE ? (ippicviMorphologyBorderReplicateFunc)ippicviErodeBorderReplicate_##flavor : \ (ippicviMorphologyBorderReplicateFunc)ippicviDilateBorderReplicate_##flavor; \ getBufSizeFunc = (ippicviFilterMinMaxGetBufferSizeFunc)ippicviFilterMinGetBufferSize_##flavor; \ @@ -1173,12 +1180,12 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne switch( type ) { - IPP_MORPH_CASE(CV_8UC1, 8u_C1R); - IPP_MORPH_CASE(CV_8UC3, 8u_C3R); - IPP_MORPH_CASE(CV_8UC4, 8u_C4R); - IPP_MORPH_CASE(CV_32FC1, 32f_C1R); - IPP_MORPH_CASE(CV_32FC3, 32f_C3R); - IPP_MORPH_CASE(CV_32FC4, 32f_C4R); + IPP_MORPH_CASE(CV_8UC1, 8u_C1R, 8u); + IPP_MORPH_CASE(CV_8UC3, 8u_C3R, 8u); + IPP_MORPH_CASE(CV_8UC4, 8u_C4R, 8u); + IPP_MORPH_CASE(CV_32FC1, 32f_C1R, 32f); + IPP_MORPH_CASE(CV_32FC3, 32f_C3R, 32f); + IPP_MORPH_CASE(CV_32FC4, 32f_C4R, 32f); default: return false; } @@ -1188,16 +1195,26 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne IppiSize kernelSize = {ksize.width, ksize.height}; IppiPoint point = {anchor.x, anchor.y}; - if( !rectKernel && morphFunc && initAllocFunc ) + if( !rectKernel && morphFunc && getSizeFunc && initFunc) { - IppiMorphState* pState; - if( initAllocFunc( roiSize.width, kernel.data, kernelSize, point, &pState ) < 0 ) + //IppiMorphState* pState; + //if( initAllocFunc( roiSize.width, kernel.data, kernelSize, point, &pState ) < 0 ) + // return false; + int stateSize = 0; + if (getSizeFunc(roiSize.width, kernel.data, kernelSize, &stateSize) < 0) return false; - bool is_ok = morphFunc( _src->data, (int)_src->step[0], - dst.data, (int)dst.step[0], - roiSize, ippBorderRepl, pState ) >= 0; - ippicviMorphologyFree(pState); - return is_ok; + + bool ok = false; + IppiMorphState* pState = (IppiMorphState*)ippicvMalloc(stateSize); + if (initFunc(roiSize.width, kernel.data, kernelSize, point, pState) >= 0) + { + ok = morphFunc( _src->data, (int)_src->step[0], + dst.data, (int)dst.step[0], + roiSize, ippBorderRepl, pState ) >= 0; + } + ippicvFree(pState); + //ippicviMorphologyFree(pState); + return ok; } else if( rectKernel && morphRectFunc && getBufSizeFunc ) { @@ -1211,6 +1228,129 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne } return false; } +#endif +static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, + const Size& ksize, const Point &anchor, bool rectKernel) +{ + int type = src.type(); + const Mat* _src = &src; + Mat temp; + if (src.data == dst.data) + { + src.copyTo(temp); + _src = &temp; + } + + IppiSize roiSize = {src.cols, src.rows}; + IppiSize kernelSize = {ksize.width, ksize.height}; + + if (!rectKernel) + { +#if 1 + if (((kernel.cols - 1) / 2 != anchor.x) || ((kernel.rows - 1) / 2 != anchor.y)) + return false; + #define IPP_MORPH_CASE(cvtype, flavor, data_type) \ + case cvtype: \ + {\ + int specSize = 0, bufferSize = 0;\ + if (ippStsNoErr != ippicviMorphologyBorderGetSize_##flavor(roiSize.width, kernelSize, &specSize, &bufferSize))\ + return false;\ + IppiMorphState *pSpec = (IppiMorphState*)ippicvMalloc(specSize);\ + Ipp8u *pBuffer = (Ipp8u*)ippicvMalloc(bufferSize);\ + if (ippStsNoErr != ippicviMorphologyBorderInit_##flavor(roiSize.width, kernel.data, kernelSize, pSpec, pBuffer))\ + {\ + ippicvFree(pBuffer);\ + ippicvFree(pSpec);\ + return false;\ + }\ + bool ok = false;\ + if (op == MORPH_ERODE)\ + ok = (ippStsNoErr == ippicviErodeBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ + else\ + ok = (ippStsNoErr == ippicviDilateBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ + ippicvFree(pBuffer);\ + ippicvFree(pSpec);\ + return ok;\ + }\ + break; +#else + IppiPoint point = {anchor.x, anchor.y}; + // this is case, which can be used with the anchor not in center of the kernel, but + // ippicviMorphologyBorderGetSize_, ippicviErodeBorderReplicate_ and ippicviDilateBorderReplicate_ are deprecate. + #define IPP_MORPH_CASE(cvtype, flavor, data_type) \ + case cvtype: \ + {\ + int specSize = 0;\ + int bufferSize = 0;\ + if (ippStsNoErr != ippicviMorphologyBorderGetSize_##flavor( roiSize.width, kernelSize, &specSize, &bufferSize))\ + return false;\ + bool ok = false;\ + IppiMorphState* pState = (IppiMorphState*)ippicvMalloc(specSize);;\ + if (ippicviMorphologyInit_##flavor(roiSize.width, kernel.data, kernelSize, point, pState) >= 0)\ + {\ + if (op == MORPH_ERODE)\ + ok = ippicviErodeBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ + (Ipp##data_type *)dst.data, (int)dst.step[0],\ + roiSize, ippBorderRepl, pState ) >= 0;\ + else\ + ok = ippicviDilateBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ + (Ipp##data_type *)dst.data, (int)dst.step[0],\ + roiSize, ippBorderRepl, pState ) >= 0;\ + }\ + ippicvFree(pState);\ + return ok;\ + }\ + break; +#endif + switch (type) + { + IPP_MORPH_CASE(CV_8UC1, 8u_C1R, 8u); + IPP_MORPH_CASE(CV_8UC3, 8u_C3R, 8u); + IPP_MORPH_CASE(CV_8UC4, 8u_C4R, 8u); + IPP_MORPH_CASE(CV_32FC1, 32f_C1R, 32f); + IPP_MORPH_CASE(CV_32FC3, 32f_C3R, 32f); + IPP_MORPH_CASE(CV_32FC4, 32f_C4R, 32f); + default: + return false; + } + + #undef IPP_MORPH_CASE + } + else + { + IppiPoint point = {anchor.x, anchor.y}; + + #define IPP_MORPH_CASE(cvtype, flavor, data_type) \ + case cvtype: \ + {\ + int bufSize = 0;\ + if (ippStsNoErr != ippicviFilterMinGetBufferSize_##flavor(src.cols, kernelSize, &bufSize))\ + return false;\ + AutoBuffer buf(bufSize + 64);\ + uchar* buffer = alignPtr((uchar*)buf, 32);\ + if (op == MORPH_ERODE)\ + return (ippStsNoErr == ippicviFilterMinBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + return (ippStsNoErr == ippicviFilterMaxBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + }\ + break; + + switch (type) + { + IPP_MORPH_CASE(CV_8UC1, 8u_C1R, 8u); + IPP_MORPH_CASE(CV_8UC3, 8u_C3R, 8u); + IPP_MORPH_CASE(CV_8UC4, 8u_C4R, 8u); + IPP_MORPH_CASE(CV_32FC1, 32f_C1R, 32f); + IPP_MORPH_CASE(CV_32FC3, 32f_C3R, 32f); + IPP_MORPH_CASE(CV_32FC4, 32f_C4R, 32f); + default: + return false; + } + + #undef IPP_MORPH_CASE + } +} static bool IPPMorphOp(int op, InputArray _src, OutputArray _dst, const Mat& _kernel, Point anchor, int iterations, From 3b0304404737bb025ca11c6b62e172f4b0128412 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 26 Mar 2014 16:27:06 +0400 Subject: [PATCH 17/52] Fix warning --- modules/objdetect/src/haar.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/modules/objdetect/src/haar.cpp b/modules/objdetect/src/haar.cpp index 2f954abece..a2dfdd26fd 100644 --- a/modules/objdetect/src/haar.cpp +++ b/modules/objdetect/src/haar.cpp @@ -1318,9 +1318,9 @@ public: if( cascade->hid_cascade->ipp_stages ) { IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height}; - ippicviRectStdDev_32f_C1R(sum1.ptr(y1), sum1.step, - sqsum1.ptr(y1), sqsum1.step, - norm1->ptr(y1), norm1->step, + ippicviRectStdDev_32f_C1R(sum1.ptr(y1), (int)sum1.step, + sqsum1.ptr(y1), (int)sqsum1.step, + norm1->ptr(y1), (int)norm1->step, ippiSize(ssz.width, ssz.height), iequRect ); int positive = (ssz.width/ystep)*((ssz.height + ystep-1)/ystep); @@ -1341,9 +1341,9 @@ public: for( int j = 0; j < cascade->count; j++ ) { if( ippicviApplyHaarClassifier_32f_C1R( - sum1.ptr(y1), sum1.step, - norm1->ptr(y1), norm1->step, - mask1->ptr(y1), mask1->step, + sum1.ptr(y1), (int)sum1.step, + norm1->ptr(y1), (int)norm1->step, + mask1->ptr(y1), (int)mask1->step, ippiSize(ssz.width, ssz.height), &positive, cascade->hid_cascade->stage_classifier[j].threshold, (IppiHaarClassifier_32f*)cascade->hid_cascade->ipp_stages[j]) < 0 ) From 06434bedfd1b52430e990ab5885c5777889b3c95 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 26 Mar 2014 16:30:48 +0400 Subject: [PATCH 18/52] Change deprecated function ippicviMulC_32f_C1IR to ippicviMulC_32f_C1R. Check results of ipp function, if error was return run opencv branch of code --- modules/imgproc/src/deriv.cpp | 366 +++++++++++++++++----------------- 1 file changed, 187 insertions(+), 179 deletions(-) diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp index 0004431b10..30a267f44c 100644 --- a/modules/imgproc/src/deriv.cpp +++ b/modules/imgproc/src/deriv.cpp @@ -190,223 +190,231 @@ namespace cv static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, double scale) { - int bufSize = 0; - cv::AutoBuffer buffer; - IppiSize roi = ippiSize(src.cols, src.rows); + int bufSize = 0; + cv::AutoBuffer buffer; + IppiSize roi = ippiSize(src.cols, src.rows); - if( ddepth < 0 ) - ddepth = src.depth(); + if( ddepth < 0 ) + ddepth = src.depth(); - dst.create( src.size(), CV_MAKETYPE(ddepth, src.channels()) ); + dst.create( src.size(), CV_MAKETYPE(ddepth, src.channels()) ); - switch(src.type()) - { - case CV_8U: - { + switch(src.type()) + { + case CV_8U: + { if(scale != 1) return false; switch(dst.type()) { - case CV_16S: - { - if((dx == 1) && (dy == 0)) - { - ippicviFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize); - buffer.allocate(bufSize); - - ippicviFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - - return true; - } - - if((dx == 0) && (dy == 1)) - { - ippicviFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize); - buffer.allocate(bufSize); - - ippicviFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - - return true; - } - } - - default: - return false; + case CV_16S: + { + if ((dx == 1) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize)) + return false; + buffer.allocate(bufSize); + return (ippStsNoErr == ippicviFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } + if ((dx == 0) && (dy == 1)) + { + if (ippStsNoErr != ippicviFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize)) + return false; + buffer.allocate(bufSize); + return (ippStsNoErr == ippicviFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } + return false; + } + default: + return false; } - } - - case CV_32F: - { + } + case CV_32F: + { switch(dst.type()) { - case CV_32F: - if((dx == 1) && (dy == 0)) - { - ippicviFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); - buffer.allocate(bufSize); + case CV_32F: + { + if ((dx == 1) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + return false; + buffer.allocate(bufSize); - ippicviFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - /* IPP is fast, so MulC produce very little perf degradation */ - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + if (ippStsNoErr != ippicviFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + { + return false; + } - return true; - } + if (scale != 1) + /* IPP is fast, so MulC produce very little perf degradation.*/ + //ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippicviMulC_32f_C1R((Ipp32f*)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } + if ((dx == 0) && (dy == 1)) + { + if (ippStsNoErr != ippicviFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + return false; + buffer.allocate(bufSize); - if((dx == 0) && (dy == 1)) - { - ippicviFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize); - buffer.allocate(bufSize); + if (ippStsNoErr != ippicviFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + return false; - ippicviFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); - - return true; - } - - default: - return false; + if (scale != 1) + ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } + } + default: + return false; } - } - - default: - return false; - } + } + default: + return false; + } } static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int ksize, double scale) { - int bufSize = 0; - cv::AutoBuffer buffer; + int bufSize = 0; + cv::AutoBuffer buffer; + if (ksize == 3 || ksize == 5) + { + if ( ddepth < 0 ) + ddepth = src.depth(); - if(ksize == 3 || ksize == 5) - { - if( ddepth < 0 ) - ddepth = src.depth(); + if (src.type() == CV_8U && dst.type() == CV_16S && scale == 1) + { + if ((dx == 1) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - if(src.type() == CV_8U && dst.type() == CV_16S && scale == 1) - { - if((dx == 1) && (dy == 0)) - { - ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); + return (ippStsNoErr == ippicviFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } - ippicviFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - return true; - } + if ((dx == 0) && (dy == 1)) + { + if (ippStsNoErr != ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - if((dx == 0) && (dy == 1)) - { - ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); + return (ippStsNoErr == ippicviFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } - ippicviFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); + if ((dx == 2) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - return true; - } + return (ippStsNoErr == ippicviFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } - if((dx == 2) && (dy == 0)) - { - ippicviFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); + if ((dx == 0) && (dy == 2)) + { + if (ippStsNoErr != ippicviFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - ippicviFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); + return (ippStsNoErr == ippicviFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); + } + } - return true; - } + if (src.type() == CV_32F && dst.type() == CV_32F) + { + if ((dx == 1) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize)) + return false; + buffer.allocate(bufSize); - if((dx == 0) && (dy == 2)) - { - ippicviFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); + if (ippStsNoErr != ippicviFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + { + return false; + } + if(scale != 1) + ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } - ippicviFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, - (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); + if ((dx == 0) && (dy == 1)) + { + if (ippStsNoErr != ippicviFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - return true; - } - } + if (ippStsNoErr != ippicviFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + { + return false; + } + if(scale != 1) + ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } - if(src.type() == CV_32F && dst.type() == CV_32F) - { - if((dx == 1) && (dy == 0)) - { - ippicviFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize); - buffer.allocate(bufSize); + if((dx == 2) && (dy == 0)) + { + if (ippStsNoErr != ippicviFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - ippicviFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + if (ippStsNoErr != ippicviFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + { + return false; + } + if(scale != 1) + ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } - return true; - } + if((dx == 0) && (dy == 2)) + { + if (ippStsNoErr != ippicviFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + return false; + buffer.allocate(bufSize); - if((dx == 0) && (dy == 1)) - { - ippicviFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); + if (ippStsNoErr != ippicviFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), + ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) + { + return false; + } - ippicviFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + if(scale != 1) + ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + return true; + } + } + } - return true; - } - - if((dx == 2) && (dy == 0)) - { - ippicviFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); - - ippicviFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); - - return true; - } - - if((dx == 0) && (dy == 2)) - { - ippicviFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize); - buffer.allocate(bufSize); - - ippicviFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, - (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), - ippBorderRepl, 0, (Ipp8u*)(char*)buffer); - if(scale != 1) - ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); - - return true; - } - } - } - - if(ksize <= 0) - return IPPDerivScharr(src, dst, ddepth, dx, dy, scale); - - return false; + if(ksize <= 0) + return IPPDerivScharr(src, dst, ddepth, dx, dy, scale); + return false; } } @@ -436,7 +444,7 @@ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy, if(dx < 3 && dy < 3 && cn == 1 && borderType == BORDER_REPLICATE) { Mat src = _src.getMat(), dst = _dst.getMat(); - if(IPPDeriv(src, dst, ddepth, dx, dy, ksize,scale)) + if (IPPDeriv(src, dst, ddepth, dx, dy, ksize,scale)) return; } #endif From 07e84c635a576a201fa3877bff47db5dd70c06e9 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 26 Mar 2014 17:43:21 +0400 Subject: [PATCH 19/52] Remove unused code --- modules/imgproc/src/smooth.cpp | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 28fbb42f47..139dd9577e 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1114,16 +1114,21 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, { Mat src = _src.getMat(), dst = _dst.getMat(); IppiSize roi = { src.cols, src.rows }; - int bufSize = 0; - if (ippStsNoErr == ippicviFilterGaussGetBufferSize_32f_C1R(roi, ksize.width, &bufSize)) + int specSize = 0, bufferSize = 0; + if (ippStsNoErr == ippicviFilterGaussianGetBufferSize(roi, (Ipp32u)ksize.width, ipp32f, 1, &specSize, &bufferSize)) { - AutoBuffer buf(bufSize+128); - if( ippicviFilterGaussBorder_32f_C1R((const Ipp32f *)src.data, (int)src.step, - (Ipp32f *)dst.data, (int)dst.step, - roi, ksize.width, (Ipp32f)sigma1, - (IppiBorderType)borderType, 0.0, - alignPtr(&buf[0],32)) >= 0 ) - return; + IppFilterGaussianSpec *pSpec = (IppFilterGaussianSpec*)ippicvMalloc(specSize); + Ipp8u *pBuffer = (Ipp8u*)ippicvMalloc(bufferSize); + if (ippStsNoErr == ippicviFilterGaussianInit(roi, (Ipp32u)ksize.width, (Ipp32f)sigma1, (IppiBorderType)borderType, ipp32f, 1, pSpec, pBuffer)) + { + IppStatus sts = ippicviFilterGaussianBorder_32f_C1R( (const Ipp32f *)src.data, (int)src.step, + (Ipp32f *)dst.data, (int)dst.step, + roi, 0.0, pSpec, pBuffer); + ippicvFree(pBuffer); + ippicvFree(pSpec); + if (ippStsNoErr == sts) + return; + } } } #endif From b3db990daa29c523e3db12f0b67799d3861ac344 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 27 Mar 2014 11:39:25 +0400 Subject: [PATCH 20/52] Remove unused code --- modules/imgproc/src/morph.cpp | 92 ----------------------------------- 1 file changed, 92 deletions(-) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index f446f98810..6030c7e6c8 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1137,98 +1137,6 @@ private: }; #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -#if 0 -static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, - const Size& ksize, const Point &anchor, bool rectKernel) -{ - int type = src.type(); - const Mat* _src = &src; - Mat temp; - if (src.data == dst.data) - { - src.copyTo(temp); - _src = &temp; - } - //DEPRECATED. Allocates and initializes morphology state structure for erosion or dilation operation. -// typedef IppStatus (CV_STDCALL* ippicviMorphologyInitAllocFunc)(int, const void*, IppiSize, IppiPoint, IppiMorphState **); - typedef IppStatus (CV_STDCALL* ippicviMorphologyGetSizeFunc)(int, const Ipp8u*, IppiSize, int*); - typedef IppStatus (CV_STDCALL* ippicviMorphologyInit)(int, const Ipp8u*, IppiSize, IppiPoint, IppiMorphState*); - typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderReplicateFunc)(const void*, int, void *, int, IppiSize, IppiBorderType, IppiMorphState *); - typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderFunc8u)(const Ipp8u*, int, Ipp8u*, int, IppiSize, IppiBorderType, Ipp8u, IppiMorphState*, Ipp8u*); - typedef IppStatus (CV_STDCALL* ippicviMorphologyBorderFunc32f)(const Ipp32f*, int, Ipp32f*, int, IppiSize, IppiBorderType, Ipp32f, IppiMorphState*, Ipp8u*); - typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxGetBufferSizeFunc)(int, IppiSize, int*); - typedef IppStatus (CV_STDCALL* ippicviFilterMinMaxBorderReplicateFunc)(const void*, int, void*, int, IppiSize, IppiSize, IppiPoint, void*); - - //ippicviMorphologyInitAllocFunc initAllocFunc = 0; - ippicviMorphologyGetSizeFunc getSizeFunc = 0; - ippicviMorphologyInit initFunc = 0; - ippicviMorphologyBorderReplicateFunc morphFunc = 0; - ippicviFilterMinMaxGetBufferSizeFunc getBufSizeFunc = 0; - ippicviFilterMinMaxBorderReplicateFunc morphRectFunc = 0; - - #define IPP_MORPH_CASE(type, flavor, datatype) \ - case type: \ -/* initAllocFunc = (ippicviMorphologyInitAllocFunc)ippicviMorphologyInitAlloc_##flavor; */\ - getSizeFunc = (ippicviMorphologyGetSizeFunc)ippicviMorphologyGetSize_##flavor ; \ - initFunc = (ippicviMorphologyInit)ippicviMorphologyInit_##flavor ; \ - morphFunc = op == MORPH_ERODE ? (ippicviMorphologyBorderReplicateFunc)ippicviErodeBorderReplicate_##flavor : \ - (ippicviMorphologyBorderReplicateFunc)ippicviDilateBorderReplicate_##flavor; \ - getBufSizeFunc = (ippicviFilterMinMaxGetBufferSizeFunc)ippicviFilterMinGetBufferSize_##flavor; \ - morphRectFunc = op == MORPH_ERODE ? (ippicviFilterMinMaxBorderReplicateFunc)ippicviFilterMinBorderReplicate_##flavor : \ - (ippicviFilterMinMaxBorderReplicateFunc)ippicviFilterMaxBorderReplicate_##flavor; \ - break - - switch( type ) - { - IPP_MORPH_CASE(CV_8UC1, 8u_C1R, 8u); - IPP_MORPH_CASE(CV_8UC3, 8u_C3R, 8u); - IPP_MORPH_CASE(CV_8UC4, 8u_C4R, 8u); - IPP_MORPH_CASE(CV_32FC1, 32f_C1R, 32f); - IPP_MORPH_CASE(CV_32FC3, 32f_C3R, 32f); - IPP_MORPH_CASE(CV_32FC4, 32f_C4R, 32f); - default: - return false; - } - #undef IPP_MORPH_CASE - - IppiSize roiSize = {src.cols, src.rows}; - IppiSize kernelSize = {ksize.width, ksize.height}; - IppiPoint point = {anchor.x, anchor.y}; - - if( !rectKernel && morphFunc && getSizeFunc && initFunc) - { - //IppiMorphState* pState; - //if( initAllocFunc( roiSize.width, kernel.data, kernelSize, point, &pState ) < 0 ) - // return false; - int stateSize = 0; - if (getSizeFunc(roiSize.width, kernel.data, kernelSize, &stateSize) < 0) - return false; - - bool ok = false; - IppiMorphState* pState = (IppiMorphState*)ippicvMalloc(stateSize); - if (initFunc(roiSize.width, kernel.data, kernelSize, point, pState) >= 0) - { - ok = morphFunc( _src->data, (int)_src->step[0], - dst.data, (int)dst.step[0], - roiSize, ippBorderRepl, pState ) >= 0; - } - ippicvFree(pState); - //ippicviMorphologyFree(pState); - return ok; - } - else if( rectKernel && morphRectFunc && getBufSizeFunc ) - { - int bufSize = 0; - if( getBufSizeFunc( src.cols, kernelSize, &bufSize) < 0 ) - return false; - AutoBuffer buf(bufSize + 64); - uchar* buffer = alignPtr((uchar*)buf, 32); - return morphRectFunc(_src->data, (int)_src->step[0], dst.data, (int)dst.step[0], - roiSize, kernelSize, point, buffer) >= 0; - } - return false; -} -#endif static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { From c65e5a1e7b271ad4a4a87503d01e2f9c10ca9f7f Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 28 Mar 2014 11:33:19 +0400 Subject: [PATCH 21/52] Fix error BGRA2RGBA color convertion by ipp. Uncomment ipp color converstion, which pass tests --- modules/imgproc/src/color.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index b2699d22e5..4cc2382394 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -252,6 +252,7 @@ bool CvtColorIPPLoopCopy(Mat& src, Mat& dst, const Cvt& cvt) } bool ok; parallel_for_(Range(0, source.rows), CvtColorIPPLoop_Invoker(source, dst, cvt, &ok), source.total()/(double)(1<<16) ); + //ok = cvt(src.ptr(0), (int)src.step[0], dst.ptr(0), (int)dst.step[0], src.cols, src.rows); return ok; } @@ -299,8 +300,8 @@ static ippicviReorderFunc ippicviSwapChannelsC3RTab[] = static ippicviReorderFunc ippicviSwapChannelsC4RTab[] = { - (ippicviReorderFunc)ippicviSwapChannels_8u_AC4R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_AC4R, 0, - 0, (ippicviReorderFunc)ippicviSwapChannels_32f_AC4R, 0, 0 + (ippicviReorderFunc)ippicviSwapChannels_8u_C4R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C4R, 0, + 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C4R, 0, 0 }; static ippicviColor2GrayFunc ippicviColor2GrayC3Tab[] = @@ -3310,7 +3311,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) CV_Assert( scn == 3 || scn == 4 ); _dst.create(sz, CV_MAKETYPE(depth, 1)); dst = _dst.getMat(); -/* +/**/ #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2GRAY ) { @@ -3333,7 +3334,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) return; } #endif -*/ +/**/ bidx = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2; if( depth == CV_8U ) From aece433b15667093765486e1767d74c056a52ae5 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 28 Mar 2014 12:49:12 +0400 Subject: [PATCH 22/52] Check ippStsNoErr as result of ipp function instead >=0 --- modules/imgproc/src/smooth.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 139dd9577e..2282290ffe 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -2199,7 +2199,7 @@ public: *ok = false; return; } - if( ippicviFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec ) < 0) + if (ippStsNoErr != ippicviFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec )) *ok = false; } private: From a6b53489e6ff0673d2ead369fd4ec7f5e7a95e2f Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 28 Mar 2014 14:36:25 +0400 Subject: [PATCH 23/52] Change sanity check for perfomance test of bilateral filter --- modules/imgproc/perf/perf_bilateral.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/imgproc/perf/perf_bilateral.cpp b/modules/imgproc/perf/perf_bilateral.cpp index af565f8a5e..4ed0c4db6e 100644 --- a/modules/imgproc/perf/perf_bilateral.cpp +++ b/modules/imgproc/perf/perf_bilateral.cpp @@ -34,5 +34,5 @@ PERF_TEST_P( TestBilateralFilter, BilateralFilter, TEST_CYCLE() bilateralFilter(src, dst, d, sigmaColor, sigmaSpace, BORDER_DEFAULT); - SANITY_CHECK(dst); + SANITY_CHECK(dst, .01, ERROR_RELATIVE); } From 9b6feee1a55e6553074e282b496c32877f81c0cd Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 28 Mar 2014 15:49:16 +0400 Subject: [PATCH 24/52] Change sanity check for perfomance test of dft --- modules/core/perf/perf_dft.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/core/perf/perf_dft.cpp b/modules/core/perf/perf_dft.cpp index 05ae4bc509..a33bcf51e1 100644 --- a/modules/core/perf/perf_dft.cpp +++ b/modules/core/perf/perf_dft.cpp @@ -22,5 +22,5 @@ PERF_TEST_P(Size_MatType, dft, TEST_MATS_DFT) TEST_CYCLE() dft(src, dst); - SANITY_CHECK(dst, 1e-5); + SANITY_CHECK(dst, 1e-5, ERROR_RELATIVE); } From ee2df645f40a29969955040ab03d7e8d12536c96 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 2 Apr 2014 12:20:12 +0400 Subject: [PATCH 25/52] Canny uncommented, prefix of ipp function changed. Ipp version of Canny called only for images with one channels --- modules/imgproc/src/canny.cpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/modules/imgproc/src/canny.cpp b/modules/imgproc/src/canny.cpp index fbc92dde21..2d4983bb30 100644 --- a/modules/imgproc/src/canny.cpp +++ b/modules/imgproc/src/canny.cpp @@ -42,13 +42,13 @@ #include "precomp.hpp" #include "opencl_kernels.hpp" -/* + #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) #define USE_IPP_CANNY 1 #else #undef USE_IPP_CANNY #endif -*/ + namespace cv { @@ -59,30 +59,30 @@ static bool ippCanny(const Mat& _src, Mat& _dst, float low, float high) int size = 0, size1 = 0; IppiSize roi = { _src.cols, _src.rows }; - ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size); - ippiFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1); + ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size); + ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1); size = std::max(size, size1); - ippiCannyGetSize(roi, &size1); + ippicviCannyGetSize(roi, &size1); size = std::max(size, size1); AutoBuffer buf(size + 64); uchar* buffer = alignPtr((uchar*)buf, 32); Mat _dx(_src.rows, _src.cols, CV_16S); - if( ippiFilterSobelNegVertBorder_8u16s_C1R(_src.data, (int)_src.step, + if( ippicviFilterSobelNegVertBorder_8u16s_C1R(_src.data, (int)_src.step, _dx.ptr(), (int)_dx.step, roi, ippMskSize3x3, ippBorderRepl, 0, buffer) < 0 ) return false; Mat _dy(_src.rows, _src.cols, CV_16S); - if( ippiFilterSobelHorizBorder_8u16s_C1R(_src.data, (int)_src.step, + if( ippicviFilterSobelHorizBorder_8u16s_C1R(_src.data, (int)_src.step, _dy.ptr(), (int)_dy.step, roi, ippMskSize3x3, ippBorderRepl, 0, buffer) < 0 ) return false; - if( ippiCanny_16s8u_C1R(_dx.ptr(), (int)_dx.step, - _dy.ptr(), (int)_dy.step, - _dst.data, (int)_dst.step, roi, low, high, buffer) < 0 ) + if( ippicviCanny_16s8u_C1R(_dx.ptr(), (int)_dx.step, + _dy.ptr(), (int)_dy.step, + _dst.data, (int)_dst.step, roi, low, high, buffer) < 0 ) return false; return true; } @@ -286,7 +286,7 @@ void cv::Canny( InputArray _src, OutputArray _dst, #endif #ifdef USE_IPP_CANNY - if( aperture_size == 3 && !L2gradient && + if( aperture_size == 3 && !L2gradient && 1 == cn && ippCanny(src, dst, (float)low_thresh, (float)high_thresh) ) return; #endif From c29583eacc589f77e727a535eefa0c30ccc7bf64 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 2 Apr 2014 13:27:29 +0400 Subject: [PATCH 26/52] Change Canny input image description, we can use multichannel image now --- modules/imgproc/doc/feature_detection.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/imgproc/doc/feature_detection.rst b/modules/imgproc/doc/feature_detection.rst index de16c07514..2187b8fd86 100644 --- a/modules/imgproc/doc/feature_detection.rst +++ b/modules/imgproc/doc/feature_detection.rst @@ -1,4 +1,4 @@ -Feature Detection +Feature Detection ================= .. highlight:: cpp @@ -15,9 +15,9 @@ Finds edges in an image using the [Canny86]_ algorithm. .. ocv:cfunction:: void cvCanny( const CvArr* image, CvArr* edges, double threshold1, double threshold2, int aperture_size=3 ) - :param image: single-channel 8-bit input image. + :param image: 8-bit input image. - :param edges: output edge map; it has the same size and type as ``image`` . + :param edges: output edge map; single channels 8-bit image, which has the same size as ``image`` . :param threshold1: first threshold for the hysteresis procedure. From 9d138b2bbe4122678a0d427aac1bf59b57423e33 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Wed, 2 Apr 2014 15:45:03 +0400 Subject: [PATCH 27/52] Enable ipp MeanStdDev calculation for 32F_C1 images. Decrease accuracy sanity check of the perfomance test --- modules/core/perf/perf_stat.cpp | 4 ++-- modules/core/src/stat.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/core/perf/perf_stat.cpp b/modules/core/perf/perf_stat.cpp index 6b5f0ff524..25bad4f527 100644 --- a/modules/core/perf/perf_stat.cpp +++ b/modules/core/perf/perf_stat.cpp @@ -65,8 +65,8 @@ PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS) TEST_CYCLE() meanStdDev(src, mean, dev); - SANITY_CHECK(mean, 1e-6); - SANITY_CHECK(dev, 1e-6); + SANITY_CHECK(mean, 1e-5, ERROR_RELATIVE); + SANITY_CHECK(dev, 1e-5, ERROR_RELATIVE); } PERF_TEST_P(Size_MatType, meanStdDev_mask, TYPICAL_MATS) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 6080e632dc..b7b600e5fa 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -972,7 +972,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input ippicviMeanStdDevFuncC1 ippFuncC1 = type == CV_8UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1R : type == CV_16UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1R : - //type == CV_32FC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 + type == CV_32FC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 0; if( ippFuncC1 ) { From ad23ef2a425d5068d290f426e978564787f979d9 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 10:44:23 +0400 Subject: [PATCH 28/52] Remove unused #include "ippverdion.h" --- modules/core/src/matmul.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp index 60c117385b..14dd1918fa 100644 --- a/modules/core/src/matmul.cpp +++ b/modules/core/src/matmul.cpp @@ -44,10 +44,6 @@ #include "opencl_kernels.hpp" #include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp" -//#ifdef HAVE_IPP -//#include "ippversion.h" -//#endif - namespace cv { From c3213307772adc72dbc59e27f38acafd8f8e8930 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 10:47:06 +0400 Subject: [PATCH 29/52] Comment ipp version of CV_BGR2GRAY color convertion, by problems in BRIEF accuracy test and Path_Idx_Cn_NPoints_WSize perfomance test --- modules/imgproc/src/color.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 4cc2382394..b105ee3267 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -3313,12 +3313,15 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) dst = _dst.getMat(); /**/ #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +/* if( code == CV_BGR2GRAY ) { if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippicviColor2GrayC3Tab[depth])) ) return; } - else if( code == CV_RGB2GRAY ) + else +*/ + if( code == CV_RGB2GRAY ) { if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviRGB2GrayC3Tab[depth])) ) return; From a9a0ea37064b49e177e74ee369dfd138fc7797da Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 10:48:20 +0400 Subject: [PATCH 30/52] Fix error not initialized IppStatus before ipp functions call --- modules/imgproc/src/sumpixels.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index d7bf9a0bfc..240bcad680 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -362,10 +362,10 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output sqsum = _sqsum.getMat(); }; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) && 0 if( ( depth == CV_8U ) && ( sdepth == CV_32F || sdepth == CV_32S ) && ( !_tilted.needed() ) && ( !_sqsum.needed() || sqdepth == CV_64F ) && ( cn == 1 ) ) { - IppStatus status; + IppStatus status = ippStsErr; IppiSize srcRoiSize = ippiSize( src.cols, src.rows ); if( sdepth == CV_32F ) { @@ -378,7 +378,7 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output status = ippicviIntegral_8u32f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } - else// if( sdepth == CV_32S ) + else if( sdepth == CV_32S ) { if( _sqsum.needed() ) { From ec6f9777837d9a614b9d7d2de0bd3fcb2ba5ff46 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 10:49:07 +0400 Subject: [PATCH 31/52] Uncomment ippicviNorm_Inf_16s_C3R, ippicviNorm_Inf_16s_C4R functions --- modules/core/src/stat.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index b7b600e5fa..6eb13cbda7 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -43,7 +43,6 @@ #include "precomp.hpp" #include "opencl_kernels.hpp" #include -#include namespace cv { @@ -544,7 +543,7 @@ cv::Scalar cv::sum( InputArray _src ) Mat src = _src.getMat(); int k, cn = src.channels(), depth = src.depth(); -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) && 0 size_t total_size = src.total(); int rows = src.size[0], cols = (int)(total_size/rows); if( src.dims == 2 || (src.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) ) @@ -2111,8 +2110,8 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C3R : type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C4R : type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C1R : - //type == CV_16SC3 ? (ippicviNormFunc)ippicviNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - //type == CV_16SC4 ? (ippicviNormFunc)ippicviNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_32FC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C1R : type == CV_32FC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C3R : type == CV_32FC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C4R : From 188c50623791212844f8c0af35d7f8937adb8021 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 12:14:28 +0400 Subject: [PATCH 32/52] Uncomment ippiNormDiff_Inf_16s_C3R, ippiNormDiff_Inf_16s_C4R --- modules/core/src/stat.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 6eb13cbda7..53c0892f65 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -2540,8 +2540,8 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C3R : type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C4R : type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C1R : - //type == CV_16SC3 ? (ippicviNormDiffFunc)ippicviNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - //type == CV_16SC4 ? (ippicviNormDiffFunc)ippicviNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_32FC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C1R : type == CV_32FC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C3R : type == CV_32FC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C4R : From eb8c531791cb6db5f273c77b65d6ba02c64d7b78 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 12:26:40 +0400 Subject: [PATCH 33/52] Add preprocessor check for IPP version greater 8.1 on some code --- modules/core/src/stat.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 53c0892f65..2cf335ca1d 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -971,7 +971,9 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input ippicviMeanStdDevFuncC1 ippFuncC1 = type == CV_8UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1R : type == CV_16UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1R : +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) type == CV_32FC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 +#endif 0; if( ippFuncC1 ) { @@ -2110,8 +2112,10 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C3R : type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C4R : type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C1R : +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 +#endif type == CV_32FC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C1R : type == CV_32FC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C3R : type == CV_32FC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C4R : @@ -2540,8 +2544,10 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C3R : type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C4R : type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C1R : +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 +#endif type == CV_32FC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C1R : type == CV_32FC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C3R : type == CV_32FC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C4R : From 1b3651d8ee346dd39e0bdf359cb08e66137ce78c Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 13:18:28 +0400 Subject: [PATCH 34/52] Undo changes ipp to ippicv prefix of function names --- cmake/OpenCVFindIPP.cmake | 386 ++++++++++++++++++++-- modules/core/src/arithm.cpp | 50 +-- modules/core/src/dxt.cpp | 56 ++-- modules/core/src/mathfuncs.cpp | 8 +- modules/core/src/matmul.cpp | 12 +- modules/core/src/stat.cpp | 474 +++++++++++++-------------- modules/imgproc/src/canny.cpp | 12 +- modules/imgproc/src/color.cpp | 218 ++++++------ modules/imgproc/src/deriv.cpp | 64 ++-- modules/imgproc/src/distransform.cpp | 2 +- modules/imgproc/src/filter.cpp | 12 +- modules/imgproc/src/imgwarp.cpp | 114 +++---- modules/imgproc/src/morph.cpp | 40 +-- modules/imgproc/src/samplers.cpp | 10 +- modules/imgproc/src/smooth.cpp | 20 +- modules/imgproc/src/sumpixels.cpp | 10 +- modules/objdetect/src/haar.cpp | 6 +- 17 files changed, 915 insertions(+), 579 deletions(-) diff --git a/cmake/OpenCVFindIPP.cmake b/cmake/OpenCVFindIPP.cmake index ab4d7c7b9b..d42a371a3f 100644 --- a/cmake/OpenCVFindIPP.cmake +++ b/cmake/OpenCVFindIPP.cmake @@ -1,7 +1,8 @@ # -# The script to setting up Intel(R) Integrated Performance Primitives (IPP) +# The script to detect Intel(R) Integrated Performance Primitives (IPP) # installation/package # +<<<<<<< HEAD # Windows host: # Run script like this before cmake: # call "\bin\ippvars.bat" intel64 @@ -20,8 +21,9 @@ # IPP_INCLUDE_DIRS - IPP include folder # IPP_LIBRARIES - IPP libraries that are used by OpenCV # IPP_FOUND - True if Intel IPP found -# IPP_INCLUDE_DIR - IPP include folder -# IPP_LIBRARY_DIR - IPP libraries folder +# IPP_ROOT_DIR - root of IPP installation +# IPP_INCLUDE_DIRS - IPP include folder +# IPP_LIBRARY_DIRS - IPP libraries folder # IPP_LIBRARIES - IPP libraries names that are used by OpenCV # # Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) @@ -223,31 +225,198 @@ if(IPP_H_PATH) ipp_get_version(${IPP_ROOT_DIR}) ipp_set_variables(${IPP_VERSION_STR}) ======= +======= +# IPP_LATEST_VERSION_STR - string with the newest detected IPP version +# IPP_LATEST_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) +# IPP_LATEST_VERSION_MINOR +# IPP_LATEST_VERSION_BUILD +# +# Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) +# +>>>>>>> Undo changes ipp to ippicv prefix of function names -set(IPP_FOUND TRUE) +set(IPP_FOUND) set(IPP_VERSION_STR "5.3.0.0") # will not detect earlier versions set(IPP_VERSION_MAJOR 0) set(IPP_VERSION_MINOR 0) set(IPP_VERSION_BUILD 0) -set(IPP_INCLUDE_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/include) +set(IPP_ROOT_DIR) +set(IPP_INCLUDE_DIRS) set(IPP_LIBRARY_DIRS) set(IPP_LIBRARIES) -if(WIN32 AND NOT ARM) - if (X86_64) - set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/windows/intel64) - else() - set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/windows/ia32/) - endif() - set(IPP_LIBRARIES ippccmt.lib ippcoremt.lib ippcvmt.lib ippimt.lib ippsmt.lib ippvmmt.lib) -elseif(UNIX) - if (X86_64) - set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/linux/intel64) - else() - set(IPP_LIBRARY_DIR ${OpenCV_SOURCE_DIR}/3rdparty/ippicv/libs/linux/ia32/) - endif() - set(IPP_LIBRARIES libippcc.a libippcore.a libippcv.a libippi.a libipps.a libippvm.a) +set(IPP_LIB_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) +set(IPP_LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) +set(IPP_PREFIX "ipp") +set(IPP_SUFFIX "_l") +set(IPPCORE "core") # core functionality +set(IPPS "s") # signal processing +set(IPPI "i") # image processing +set(IPPCC "cc") # color conversion +set(IPPCV "cv") # computer vision +set(IPPVM "vm") # vector math + + +set(IPP_X64 0) +if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) + set(IPP_X64 1) +endif() +if (CMAKE_CL_64) + set(IPP_X64 1) endif() +# ------------------------------------------------------------------------ +# This function detect IPP version by analyzing ippversion.h file +# Note, ippversion.h file was inroduced since IPP 5.3 +# ------------------------------------------------------------------------ +function(get_ipp_version _ROOT_DIR) + set(_VERSION_STR) + set(_MAJOR) + set(_MINOR) + set(_BUILD) + + # read IPP version info from file + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") + if("${STR3}" STREQUAL "") + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") + endif() + file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR4 REGEX "IPP_VERSION_STR") + + # extract info and assign to variables + string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) + string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) + string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) + string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) + + # export info to parent scope + set(IPP_VERSION_STR ${_VERSION_STR} PARENT_SCOPE) + set(IPP_VERSION_MAJOR ${_MAJOR} PARENT_SCOPE) + set(IPP_VERSION_MINOR ${_MINOR} PARENT_SCOPE) + set(IPP_VERSION_BUILD ${_BUILD} PARENT_SCOPE) + + message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") + message(STATUS "at: ${_ROOT_DIR}") + + return() + +endfunction() + + +# ------------------------------------------------------------------------ +# This is auxiliary function called from set_ipp_variables() +# to set IPP_LIBRARIES variable in IPP 6.x style (IPP 5.3 should also work) +# ------------------------------------------------------------------------ +function(set_ipp_old_libraries) + set(IPP_PREFIX "ipp") + set(IPP_SUFFIX) # old style static core libs suffix + set(IPP_ARCH) # architecture suffix + set(IPP_DISP "emerged") # old style dipatcher and cpu-specific + set(IPP_MRGD "merged") # static libraries + set(IPPCORE "core") # core functionality + set(IPPSP "s") # signal processing + set(IPPIP "i") # image processing + set(IPPCC "cc") # color conversion + set(IPPCV "cv") # computer vision + set(IPPVM "vm") # vector math + + if (IPP_X64) + set(IPP_ARCH "em64t") + endif() + + if(WIN32) + set(IPP_SUFFIX "l") + endif() + + set(IPP_LIBRARIES + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_ARCH}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + PARENT_SCOPE) + + return() + +endfunction() + + +# ------------------------------------------------------------------------ +# This is auxiliary function called from set_ipp_variables() +# to set IPP_LIBRARIES variable in IPP 7.x and 8.x style +# ------------------------------------------------------------------------ +function(set_ipp_new_libraries _LATEST_VERSION) + set(IPP_PREFIX "ipp") + + if(${_LATEST_VERSION} VERSION_LESS "8.0") + set(IPP_SUFFIX "_l") # static not threaded libs suffix IPP 7.x + else() + if(WIN32) + set(IPP_SUFFIX "mt") # static not threaded libs suffix IPP 8.x for Windows + else() + set(IPP_SUFFIX "") # static not threaded libs suffix IPP 8.x for Linux/OS X + endif() + endif() + set(IPPCORE "core") # core functionality + set(IPPSP "s") # signal processing + set(IPPIP "i") # image processing + set(IPPCC "cc") # color conversion + set(IPPCV "cv") # computer vision + set(IPPVM "vm") # vector math + + set(IPP_LIBRARIES + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPI}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPS}${IPP_SUFFIX}${IPP_LIB_SUFFIX} + ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) + + if (UNIX) + set(IPP_LIBRARIES + ${IPP_LIBRARIES} + ${IPP_LIB_PREFIX}irc${CMAKE_SHARED_LIBRARY_SUFFIX} + ${IPP_LIB_PREFIX}imf${CMAKE_SHARED_LIBRARY_SUFFIX} + ${IPP_LIB_PREFIX}svml${CMAKE_SHARED_LIBRARY_SUFFIX}) + endif() + set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) + return() + +endfunction() + + +# ------------------------------------------------------------------------ +# This function will set +# IPP_INCLUDE_DIRS, IPP_LIBRARY_DIRS and IPP_LIBRARIES variables depending +# on IPP version parameter. +# Since IPP 7.0 version library names and install folder structure +# was changed +# ------------------------------------------------------------------------ +function(set_ipp_variables _LATEST_VERSION) + if(${_LATEST_VERSION} VERSION_LESS "7.0") +# message(STATUS "old") + + # set INCLUDE and LIB folders + set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) + set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib PARENT_SCOPE) + + if (IPP_X64) + if(NOT EXISTS ${IPP_ROOT_DIR}/../em64t) + message(SEND_ERROR "IPP EM64T libraries not found") + endif() + else() + if(NOT EXISTS ${IPP_ROOT_DIR}/../ia32) + message(SEND_ERROR "IPP IA32 libraries not found") + endif() + endif() + +<<<<<<< HEAD # read IPP version info from file set(_VERSION_STR) set(_MAJOR) @@ -259,15 +428,99 @@ file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") if("${STR3}" STREQUAL "") file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") >>>>>>> Prepare codes for ippicv library +======= + # set IPP_LIBRARIES variable (6.x lib names) + set_ipp_old_libraries() + set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) + message(STATUS "IPP libs: ${IPP_LIBRARIES}") + + else() +# message(STATUS "new") + + # set INCLUDE and LIB folders + set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) + + if (APPLE) + set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib) + elseif (IPP_X64) + if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64) + message(SEND_ERROR "IPP EM64T libraries not found") + endif() + set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/intel64) + else() + if(NOT EXISTS ${IPP_ROOT_DIR}/lib/ia32) + message(SEND_ERROR "IPP IA32 libraries not found") + endif() + set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/ia32) + endif() + + if (UNIX) + get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH) + if (IPP_X64) + if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/intel64) + message(SEND_ERROR "Intel compiler EM64T libraries not found") + endif() + set(IPP_LIBRARY_DIRS + ${IPP_LIBRARY_DIRS} + ${INTEL_COMPILER_LIBRARY_DIR}/intel64) + else() + if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/ia32) + message(SEND_ERROR "Intel compiler IA32 libraries not found") + endif() + set(IPP_LIBRARY_DIRS + ${IPP_LIBRARY_DIRS} + ${INTEL_COMPILER_LIBRARY_DIR}/ia32) + endif() + endif() + set(IPP_LIBRARY_DIRS ${IPP_LIBRARY_DIRS} PARENT_SCOPE) + + # set IPP_LIBRARIES variable (7.x or 8.x lib names) + set_ipp_new_libraries(${_LATEST_VERSION}) + set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) + message(STATUS "IPP libs: ${IPP_LIBRARIES}") + + endif() + + return() + +endfunction() + + +# ------------------------------------------------------------------------ +# This section will look for IPP through IPPROOT env variable +# Note, IPPROOT is not set by IPP installer, you may need to set it manually +# ------------------------------------------------------------------------ +find_path( + IPP_H_PATH + NAMES ippversion.h + PATHS $ENV{IPPROOT} + PATH_SUFFIXES include + DOC "The path to Intel(R) IPP header files" + NO_DEFAULT_PATH + NO_CMAKE_PATH) + +if(IPP_H_PATH) + set(IPP_FOUND 1) + + # traverse up to IPPROOT level + get_filename_component(IPP_ROOT_DIR ${IPP_H_PATH} PATH) + + # extract IPP version info + get_ipp_version(${IPP_ROOT_DIR}) + + # keep info in the same vars for auto search and search by IPPROOT + set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) + set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) + set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) + set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) + + # set IPP INCLUDE, LIB dirs and library names + set_ipp_variables(${IPP_LATEST_VERSION_STR}) +>>>>>>> Undo changes ipp to ippicv prefix of function names endif() -file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR4 REGEX "IPP_VERSION_STR") -# extract info and assign to variables -string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) -string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) -string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) -string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) +<<<<<<< HEAD <<<<<<< HEAD if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) # Since IPP built with Microsoft compiler and /GS option @@ -295,3 +548,86 @@ set(IPP_VERSION_BUILD ${_BUILD}) message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") >>>>>>> Prepare codes for ippicv library +======= +if(NOT IPP_FOUND) + # reset var from previous search + set(IPP_H_PATH) + + + # ------------------------------------------------------------------------ + # This section will look for IPP through system program folders + # Note, if several IPP installations found the newest version will be + # selected + # ------------------------------------------------------------------------ + foreach(curdir ${CMAKE_SYSTEM_PREFIX_PATH}) + set(curdir ${curdir}/intel) + file(TO_CMAKE_PATH ${curdir} CURDIR) + + if(EXISTS ${curdir}) + file(GLOB_RECURSE IPP_H_DIR ${curdir}/ippversion.h) + + if(IPP_H_DIR) + set(IPP_FOUND 1) + endif() + + # init IPP_LATEST_VERSION version with oldest detectable version (5.3.0.0) + # IPP prior 5.3 did not have ippversion.h file + set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) + + # look through all dirs where ippversion.h was found + foreach(item ${IPP_H_DIR}) + + # traverse up to IPPROOT level + get_filename_component(_FILE_PATH ${item} PATH) + get_filename_component(_ROOT_DIR ${_FILE_PATH} PATH) + + # extract IPP version info + get_ipp_version(${_ROOT_DIR}) + + # remember the latest version (if many found) + if(${IPP_LATEST_VERSION_STR} VERSION_LESS ${IPP_VERSION_STR}) + set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) + set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) + set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) + set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) + set(IPP_ROOT_DIR ${_ROOT_DIR}) + endif() + endforeach() + endif() + endforeach() +endif() + +if(IPP_FOUND) + # set IPP INCLUDE, LIB dirs and library names + set_ipp_variables(${IPP_LATEST_VERSION_STR}) + + # set CACHE variable IPP_H_PATH, + # path to IPP header files for the latest version + find_path( + IPP_H_PATH + NAMES ippversion.h + PATHS ${IPP_ROOT_DIR} + PATH_SUFFIXES include + DOC "The path to Intel(R) IPP header files" + NO_DEFAULT_PATH + NO_CMAKE_PATH) +endif() + +if(WIN32 AND MINGW AND NOT IPP_LATEST_VERSION_MAJOR LESS 7) + # Since IPP built with Microsoft compiler and /GS option + # ====================================================== + # From Windows SDK 7.1 + # (usually in "C:\Program Files\Microsoft Visual Studio 10.0\VC\lib"), + # to avoid undefined reference to __security_cookie and _chkstk: + set(MSV_RUNTMCHK "RunTmChk") + set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_RUNTMCHK}${IPP_LIB_SUFFIX}) + + # To avoid undefined reference to _alldiv and _chkstk + # =================================================== + # NB: it may require a recompilation of w32api (after having modified + # the file ntdll.def) to export the required functions + # See http://code.opencv.org/issues/1906 for additional details + set(MSV_NTDLL "ntdll") + set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_NTDLL}${IPP_LIB_SUFFIX}) +endif() +>>>>>>> Undo changes ipp to ippicv prefix of function names diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp index 3e343f6b6b..ecc2ca0648 100644 --- a/modules/core/src/arithm.cpp +++ b/modules/core/src/arithm.cpp @@ -460,7 +460,7 @@ static void add8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAdd_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiAdd_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); @@ -479,7 +479,7 @@ static void add16u( const ushort* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAdd_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiAdd_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); @@ -491,7 +491,7 @@ static void add16s( const short* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAdd_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiAdd_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); @@ -510,7 +510,7 @@ static void add32f( const float* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAdd_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiAdd_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp32, IF_SIMD(VAdd)>(src1, step1, src2, step2, dst, step, sz)); @@ -529,7 +529,7 @@ static void sub8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviSub_8u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiSub_8u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); @@ -548,7 +548,7 @@ static void sub16u( const ushort* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviSub_16u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiSub_16u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); @@ -560,7 +560,7 @@ static void sub16s( const short* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviSub_16s_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) + if (0 <= ippiSub_16s_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz, 0)) return; #endif (vBinOp, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); @@ -579,7 +579,7 @@ static void sub32f( const float* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviSub_32f_C1R(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiSub_32f_C1R(src2, (int)step2, src1, (int)step1, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp32, IF_SIMD(VSub)>(src1, step1, src2, step2, dst, step, sz)); @@ -607,7 +607,7 @@ static void max8u( const uchar* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMaxEvery_8u(s1, s2, d, sz.width)) + if (0 > ippsMaxEvery_8u(s1, s2, d, sz.width)) break; s1 += step1; s2 += step2; @@ -638,7 +638,7 @@ static void max16u( const ushort* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMaxEvery_16u(s1, s2, d, sz.width)) + if (0 > ippsMaxEvery_16u(s1, s2, d, sz.width)) break; s1 = (ushort*)((uchar*)s1 + step1); s2 = (ushort*)((uchar*)s2 + step2); @@ -676,7 +676,7 @@ static void max32f( const float* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMaxEvery_32f(s1, s2, d, sz.width)) + if (0 > ippsMaxEvery_32f(s1, s2, d, sz.width)) break; s1 = (float*)((uchar*)s1 + step1); s2 = (float*)((uchar*)s2 + step2); @@ -707,7 +707,7 @@ static void min8u( const uchar* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMinEvery_8u(s1, s2, d, sz.width)) + if (0 > ippsMinEvery_8u(s1, s2, d, sz.width)) break; s1 += step1; s2 += step2; @@ -738,7 +738,7 @@ static void min16u( const ushort* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMinEvery_16u(s1, s2, d, sz.width)) + if (0 > ippsMinEvery_16u(s1, s2, d, sz.width)) break; s1 = (ushort*)((uchar*)s1 + step1); s2 = (ushort*)((uchar*)s2 + step2); @@ -776,7 +776,7 @@ static void min32f( const float* src1, size_t step1, int i = 0; for(; i < sz.height; i++) { - if (0 > ippicvsMinEvery_32f(s1, s2, d, sz.width)) + if (0 > ippsMinEvery_32f(s1, s2, d, sz.width)) break; s1 = (float*)((uchar*)s1 + step1); s2 = (float*)((uchar*)s2 + step2); @@ -801,7 +801,7 @@ static void absdiff8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAbsDiff_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiAbsDiff_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); @@ -820,7 +820,7 @@ static void absdiff16u( const ushort* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAbsDiff_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiAbsDiff_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); @@ -846,7 +846,7 @@ static void absdiff32f( const float* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAbsDiff_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiAbsDiff_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp32, IF_SIMD(VAbsDiff)>(src1, step1, src2, step2, dst, step, sz)); @@ -866,7 +866,7 @@ static void and8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviAnd_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiAnd_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VAnd)>(src1, step1, src2, step2, dst, step, sz)); @@ -878,7 +878,7 @@ static void or8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviOr_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiOr_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VOr)>(src1, step1, src2, step2, dst, step, sz)); @@ -890,7 +890,7 @@ static void xor8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviXor_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiXor_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VXor)>(src1, step1, src2, step2, dst, step, sz)); @@ -902,7 +902,7 @@ static void not8u( const uchar* src1, size_t step1, { #if (ARITHM_USE_IPP == 1) fixSteps(sz, sizeof(dst[0]), step1, step2, step); (void *)src2; - if (0 <= ippicviNot_8u_C1R(src1, (int)step1, dst, (int)step, (IppiSize&)sz)) + if (0 <= ippiNot_8u_C1R(src1, (int)step1, dst, (int)step, (IppiSize&)sz)) return; #endif (vBinOp, IF_SIMD(VNot)>(src1, step1, src2, step2, dst, step, sz)); @@ -2386,7 +2386,7 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviCompare_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) + if (0 <= ippiCompare_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2469,7 +2469,7 @@ static void cmp16u(const ushort* src1, size_t step1, const ushort* src2, size_t if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviCompare_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) + if (0 <= ippiCompare_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2484,7 +2484,7 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st if( op > 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviCompare_16s_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) + if (0 <= ippiCompare_16s_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif @@ -2590,7 +2590,7 @@ static void cmp32f(const float* src1, size_t step1, const float* src2, size_t st if( op >= 0 ) { fixSteps(size, sizeof(dst[0]), step1, step2, step); - if (0 <= ippicviCompare_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) + if (0 <= ippiCompare_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, (IppiSize&)size, op)) return; } #endif diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 73335e3589..4cdb6a16d2 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -466,56 +466,56 @@ template<> struct DFT_VecR4 #endif #ifdef USE_IPP_DFT -static void ippicvsDFTFwd_CToC( const Complex* src, Complex* dst, +static void ippsDFTFwd_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippicvsDFTFwd_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, + ippsDFTFwd_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, (const IppsDFTSpec_C_32fc*)spec, buf); } -static void ippicvsDFTFwd_CToC( const Complex* src, Complex* dst, +static void ippsDFTFwd_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippicvsDFTFwd_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, + ippsDFTFwd_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, (const IppsDFTSpec_C_64fc*)spec, buf); } -static void ippicvsDFTInv_CToC( const Complex* src, Complex* dst, +static void ippsDFTInv_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippicvsDFTInv_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, + ippsDFTInv_CToC_32fc( (const Ipp32fc*)src, (Ipp32fc*)dst, (const IppsDFTSpec_C_32fc*)spec, buf); } -static void ippicvsDFTInv_CToC( const Complex* src, Complex* dst, +static void ippsDFTInv_CToC( const Complex* src, Complex* dst, const void* spec, uchar* buf) { - ippicvsDFTInv_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, + ippsDFTInv_CToC_64fc( (const Ipp64fc*)src, (Ipp64fc*)dst, (const IppsDFTSpec_C_64fc*)spec, buf); } -static void ippicvsDFTFwd_RToPack( const float* src, float* dst, +static void ippsDFTFwd_RToPack( const float* src, float* dst, const void* spec, uchar* buf) { - ippicvsDFTFwd_RToPack_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); + ippsDFTFwd_RToPack_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); } -static void ippicvsDFTFwd_RToPack( const double* src, double* dst, +static void ippsDFTFwd_RToPack( const double* src, double* dst, const void* spec, uchar* buf) { - ippicvsDFTFwd_RToPack_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); + ippsDFTFwd_RToPack_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); } -static void ippicvsDFTInv_PackToR( const float* src, float* dst, +static void ippsDFTInv_PackToR( const float* src, float* dst, const void* spec, uchar* buf) { - ippicvsDFTInv_PackToR_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); + ippsDFTInv_PackToR_32f( src, dst, (const IppsDFTSpec_R_32f*)spec, buf); } -static void ippicvsDFTInv_PackToR( const double* src, double* dst, +static void ippsDFTInv_PackToR( const double* src, double* dst, const void* spec, uchar* buf) { - ippicvsDFTInv_PackToR_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); + ippsDFTInv_PackToR_64f( src, dst, (const IppsDFTSpec_R_64f*)spec, buf); } #endif @@ -551,9 +551,9 @@ DFT( const Complex* src, Complex* dst, int n, if( spec ) { if( !inv ) - ippicvsDFTFwd_CToC( src, dst, spec, (uchar*)buf ); + ippsDFTFwd_CToC( src, dst, spec, (uchar*)buf ); else - ippicvsDFTInv_CToC( src, dst, spec, (uchar*)buf ); + ippsDFTInv_CToC( src, dst, spec, (uchar*)buf ); return; } #endif @@ -981,7 +981,7 @@ RealDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab, #ifdef USE_IPP_DFT if( spec ) { - ippicvsDFTFwd_RToPack( src, dst, spec, (uchar*)buf ); + ippsDFTFwd_RToPack( src, dst, spec, (uchar*)buf ); if( complex_output ) { dst[-1] = dst[0]; @@ -1113,7 +1113,7 @@ CCSIDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab, #ifdef USE_IPP_DFT if( spec ) { - ippicvsDFTInv_PackToR( src, dst, spec, (uchar*)buf ); + ippsDFTInv_PackToR( src, dst, spec, (uchar*)buf ); goto finalize; } #endif @@ -1824,26 +1824,26 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows ) { if( depth == CV_32F ) { - getSizeFunc = ippicvsDFTGetSize_R_32f; - initFunc = (IppDFTInitFunc)ippicvsDFTInit_R_32f; + getSizeFunc = ippsDFTGetSize_R_32f; + initFunc = (IppDFTInitFunc)ippsDFTInit_R_32f; } else { - getSizeFunc = ippicvsDFTGetSize_R_64f; - initFunc = (IppDFTInitFunc)ippicvsDFTInit_R_64f; + getSizeFunc = ippsDFTGetSize_R_64f; + initFunc = (IppDFTInitFunc)ippsDFTInit_R_64f; } } else { if( depth == CV_32F ) { - getSizeFunc = ippicvsDFTGetSize_C_32fc; - initFunc = (IppDFTInitFunc)ippicvsDFTInit_C_32fc; + getSizeFunc = ippsDFTGetSize_C_32fc; + initFunc = (IppDFTInitFunc)ippsDFTInit_C_32fc; } else { - getSizeFunc = ippicvsDFTGetSize_C_64fc; - initFunc = (IppDFTInitFunc)ippicvsDFTInit_C_64fc; + getSizeFunc = ippsDFTGetSize_C_64fc; + initFunc = (IppDFTInitFunc)ippsDFTInit_C_64fc; } } if( getSizeFunc(len, ipp_norm_flag, ippAlgHintNone, &specsize, &initsize, &worksize) >= 0 ) diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 95a5f0a461..596c193388 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -1276,14 +1276,14 @@ static void Exp_64fnoipp( const double *_x, double *y, int n ) #ifdef HAVE_IPP static void Exp_32f(const float *x, float *y, int n) { - if (ippStsNoErr == ippicvsExp_32f_A21(x, y, n)) + if (ippStsNoErr == ippsExp_32f_A21(x, y, n)) return; Exp_32fnoipp(x, y, n); } static void Exp_64f(const double *x, double *y, int n) { - if (ippStsNoErr == ippicvsExp_64f_A50(x, y, n)) + if (ippStsNoErr == ippsExp_64f_A50(x, y, n)) return; Exp_64fnoipp(x, y, n); } @@ -1934,14 +1934,14 @@ static void Log_64fnoipp( const double *x, double *y, int n ) #ifdef HAVE_IPP static void Log_32f(const float *x, float *y, int n) { - if (ippStsNoErr == ippicvsLn_32f_A21(x, y, n)) + if (ippStsNoErr == ippsLn_32f_A21(x, y, n)) return; Log_32fnoipp(x, y, n); } static void Log_64f(const double *x, double *y, int n) { - if (ippStsNoErr == ippicvsLn_64f_A50(x, y, n)) + if (ippStsNoErr == ippsLn_64f_A50(x, y, n)) return; Log_64fnoipp(x, y, n); } diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp index 14dd1918fa..b3004707e6 100644 --- a/modules/core/src/matmul.cpp +++ b/modules/core/src/matmul.cpp @@ -2799,7 +2799,7 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len) { double r = 0; #if ARITHM_USE_IPP - ippicviDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), + ippiDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r); return r; @@ -2862,7 +2862,7 @@ static double dotProd_16u(const ushort* src1, const ushort* src2, int len) { #if (ARITHM_USE_IPP == 1) double r = 0; - if (0 <= ippicviDotProd_16u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + if (0 <= ippiDotProd_16u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) return r; #endif return dotProd_(src1, src2, len); @@ -2872,7 +2872,7 @@ static double dotProd_16s(const short* src1, const short* src2, int len) { #if (ARITHM_USE_IPP == 1) double r = 0; - if (0 <= ippicviDotProd_16s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + if (0 <= ippiDotProd_16s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) return r; #endif return dotProd_(src1, src2, len); @@ -2882,7 +2882,7 @@ static double dotProd_32s(const int* src1, const int* src2, int len) { #if (ARITHM_USE_IPP == 1) double r = 0; - if (0 <= ippicviDotProd_32s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) + if (0 <= ippiDotProd_32s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r)) return r; #endif return dotProd_(src1, src2, len); @@ -2892,7 +2892,7 @@ static double dotProd_32f(const float* src1, const float* src2, int len) { #if (ARITHM_USE_IPP == 1) double r = 0; - if (0 <= ippicvsDotProd_32f64f(src1, src2, len, &r)) + if (0 <= ippsDotProd_32f64f(src1, src2, len, &r)) return r; #endif return dotProd_(src1, src2, len); @@ -2902,7 +2902,7 @@ static double dotProd_64f(const double* src1, const double* src2, int len) { #if (ARITHM_USE_IPP == 1) double r = 0; - if (0 <= ippicvsDotProd_64f(src1, src2, len, &r)) + if (0 <= ippsDotProd_64f(src1, src2, len, &r)) return r; #endif return dotProd_(src1, src2, len); diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 2cf335ca1d..b7e5d34224 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -543,30 +543,30 @@ cv::Scalar cv::sum( InputArray _src ) Mat src = _src.getMat(); int k, cn = src.channels(), depth = src.depth(); -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) && 0 +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) size_t total_size = src.total(); int rows = src.size[0], cols = (int)(total_size/rows); if( src.dims == 2 || (src.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) ) { IppiSize sz = { cols, rows }; int type = src.type(); - typedef IppStatus (CV_STDCALL* ippicviSumFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); - typedef IppStatus (CV_STDCALL* ippicviSumFuncNoHint)(const void*, int, IppiSize, double *); - ippicviSumFuncHint ippFuncHint = - type == CV_32FC1 ? (ippicviSumFuncHint)ippicviSum_32f_C1R : - type == CV_32FC3 ? (ippicviSumFuncHint)ippicviSum_32f_C3R : - type == CV_32FC4 ? (ippicviSumFuncHint)ippicviSum_32f_C4R : + typedef IppStatus (CV_STDCALL* ippiSumFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); + typedef IppStatus (CV_STDCALL* ippiSumFuncNoHint)(const void*, int, IppiSize, double *); + ippiSumFuncHint ippFuncHint = + type == CV_32FC1 ? (ippiSumFuncHint)ippiSum_32f_C1R : + type == CV_32FC3 ? (ippiSumFuncHint)ippiSum_32f_C3R : + type == CV_32FC4 ? (ippiSumFuncHint)ippiSum_32f_C4R : 0; - ippicviSumFuncNoHint ippFuncNoHint = - type == CV_8UC1 ? (ippicviSumFuncNoHint)ippicviSum_8u_C1R : - type == CV_8UC3 ? (ippicviSumFuncNoHint)ippicviSum_8u_C3R : - type == CV_8UC4 ? (ippicviSumFuncNoHint)ippicviSum_8u_C4R : - type == CV_16UC1 ? (ippicviSumFuncNoHint)ippicviSum_16u_C1R : - type == CV_16UC3 ? (ippicviSumFuncNoHint)ippicviSum_16u_C3R : - type == CV_16UC4 ? (ippicviSumFuncNoHint)ippicviSum_16u_C4R : - type == CV_16SC1 ? (ippicviSumFuncNoHint)ippicviSum_16s_C1R : - type == CV_16SC3 ? (ippicviSumFuncNoHint)ippicviSum_16s_C3R : - type == CV_16SC4 ? (ippicviSumFuncNoHint)ippicviSum_16s_C4R : + ippiSumFuncNoHint ippFuncNoHint = + type == CV_8UC1 ? (ippiSumFuncNoHint)ippiSum_8u_C1R : + type == CV_8UC3 ? (ippiSumFuncNoHint)ippiSum_8u_C3R : + type == CV_8UC4 ? (ippiSumFuncNoHint)ippiSum_8u_C4R : + type == CV_16UC1 ? (ippiSumFuncNoHint)ippiSum_16u_C1R : + type == CV_16UC3 ? (ippiSumFuncNoHint)ippiSum_16u_C3R : + type == CV_16UC4 ? (ippiSumFuncNoHint)ippiSum_16u_C4R : + type == CV_16SC1 ? (ippiSumFuncNoHint)ippiSum_16s_C1R : + type == CV_16SC3 ? (ippiSumFuncNoHint)ippiSum_16s_C3R : + type == CV_16SC4 ? (ippiSumFuncNoHint)ippiSum_16s_C4R : 0; CV_Assert(!ippFuncHint || !ippFuncNoHint); if( ippFuncHint || ippFuncNoHint ) @@ -720,11 +720,11 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *); - ippicviMaskMeanFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippicviMaskMeanFuncC1)ippicviMean_8u_C1MR : - type == CV_16UC1 ? (ippicviMaskMeanFuncC1)ippicviMean_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskMeanFuncC1)ippicviMean_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *); + ippiMaskMeanFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippiMaskMeanFuncC1)ippiMean_8u_C1MR : + type == CV_16UC1 ? (ippiMaskMeanFuncC1)ippiMean_16u_C1MR : + type == CV_32FC1 ? (ippiMaskMeanFuncC1)ippiMean_32f_C1MR : 0; if( ippFuncC1 ) { @@ -734,11 +734,11 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) return Scalar(res); } } - typedef IppStatus (CV_STDCALL* ippicviMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *); - ippicviMaskMeanFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippicviMaskMeanFuncC3)ippicviMean_8u_C3CMR : - type == CV_16UC3 ? (ippicviMaskMeanFuncC3)ippicviMean_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskMeanFuncC3)ippicviMean_32f_C3CMR : + typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *); + ippiMaskMeanFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippiMaskMeanFuncC3)ippiMean_8u_C3CMR : + type == CV_16UC3 ? (ippiMaskMeanFuncC3)ippiMean_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskMeanFuncC3)ippiMean_32f_C3CMR : 0; if( ippFuncC3 ) { @@ -753,23 +753,23 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask ) } else { - typedef IppStatus (CV_STDCALL* ippicviMeanFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); - typedef IppStatus (CV_STDCALL* ippicviMeanFuncNoHint)(const void*, int, IppiSize, double *); - ippicviMeanFuncHint ippFuncHint = - type == CV_32FC1 ? (ippicviMeanFuncHint)ippicviMean_32f_C1R : - type == CV_32FC3 ? (ippicviMeanFuncHint)ippicviMean_32f_C3R : - type == CV_32FC4 ? (ippicviMeanFuncHint)ippicviMean_32f_C4R : + typedef IppStatus (CV_STDCALL* ippiMeanFuncHint)(const void*, int, IppiSize, double *, IppHintAlgorithm); + typedef IppStatus (CV_STDCALL* ippiMeanFuncNoHint)(const void*, int, IppiSize, double *); + ippiMeanFuncHint ippFuncHint = + type == CV_32FC1 ? (ippiMeanFuncHint)ippiMean_32f_C1R : + type == CV_32FC3 ? (ippiMeanFuncHint)ippiMean_32f_C3R : + type == CV_32FC4 ? (ippiMeanFuncHint)ippiMean_32f_C4R : 0; - ippicviMeanFuncNoHint ippFuncNoHint = - type == CV_8UC1 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C1R : - type == CV_8UC3 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C3R : - type == CV_8UC4 ? (ippicviMeanFuncNoHint)ippicviMean_8u_C4R : - type == CV_16UC1 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C1R : - type == CV_16UC3 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C3R : - type == CV_16UC4 ? (ippicviMeanFuncNoHint)ippicviMean_16u_C4R : - type == CV_16SC1 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C1R : - type == CV_16SC3 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C3R : - type == CV_16SC4 ? (ippicviMeanFuncNoHint)ippicviMean_16s_C4R : + ippiMeanFuncNoHint ippFuncNoHint = + type == CV_8UC1 ? (ippiMeanFuncNoHint)ippiMean_8u_C1R : + type == CV_8UC3 ? (ippiMeanFuncNoHint)ippiMean_8u_C3R : + type == CV_8UC4 ? (ippiMeanFuncNoHint)ippiMean_8u_C4R : + type == CV_16UC1 ? (ippiMeanFuncNoHint)ippiMean_16u_C1R : + type == CV_16UC3 ? (ippiMeanFuncNoHint)ippiMean_16u_C3R : + type == CV_16UC4 ? (ippiMeanFuncNoHint)ippiMean_16u_C4R : + type == CV_16SC1 ? (ippiMeanFuncNoHint)ippiMean_16s_C1R : + type == CV_16SC3 ? (ippiMeanFuncNoHint)ippiMean_16s_C3R : + type == CV_16SC4 ? (ippiMeanFuncNoHint)ippiMean_16s_C4R : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); @@ -940,22 +940,22 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *); - ippicviMaskMeanStdDevFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1MR : - type == CV_16UC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *); + ippiMaskMeanStdDevFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_8u_C1MR : + type == CV_16UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_16u_C1MR : + type == CV_32FC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_32f_C1MR : 0; if( ippFuncC1 ) { if( ippFuncC1(src.data, (int)src.step[0], mask.data, (int)mask.step[0], sz, pmean, pstddev) >= 0 ) return; } - typedef IppStatus (CV_STDCALL* ippicviMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *); - ippicviMaskMeanStdDevFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_8u_C3CMR : - type == CV_16UC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskMeanStdDevFuncC3)ippicviMean_StdDev_32f_C3CMR : + typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *); + ippiMaskMeanStdDevFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CMR : + type == CV_16UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_32f_C3CMR : 0; if( ippFuncC3 ) { @@ -967,12 +967,12 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input } else { - typedef IppStatus (CV_STDCALL* ippicviMeanStdDevFuncC1)(const void *, int, IppiSize, Ipp64f *, Ipp64f *); - ippicviMeanStdDevFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_8u_C1R : - type == CV_16UC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_16u_C1R : + typedef IppStatus (CV_STDCALL* ippiMeanStdDevFuncC1)(const void *, int, IppiSize, Ipp64f *, Ipp64f *); + ippiMeanStdDevFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_8u_C1R : + type == CV_16UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_16u_C1R : #if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) - type == CV_32FC1 ? (ippicviMeanStdDevFuncC1)ippicviMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 + type == CV_32FC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 #endif 0; if( ippFuncC1 ) @@ -980,11 +980,11 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input if( ippFuncC1(src.data, (int)src.step[0], sz, pmean, pstddev) >= 0 ) return; } - typedef IppStatus (CV_STDCALL* ippicviMeanStdDevFuncC3)(const void *, int, IppiSize, int, Ipp64f *, Ipp64f *); - ippicviMeanStdDevFuncC3 ippFuncC3 = - type == CV_8UC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_8u_C3CR : - type == CV_16UC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_16u_C3CR : - type == CV_32FC3 ? (ippicviMeanStdDevFuncC3)ippicviMean_StdDev_32f_C3CR : + typedef IppStatus (CV_STDCALL* ippiMeanStdDevFuncC3)(const void *, int, IppiSize, int, Ipp64f *, Ipp64f *); + ippiMeanStdDevFuncC3 ippFuncC3 = + type == CV_8UC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CR : + type == CV_16UC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CR : + type == CV_32FC3 ? (ippiMeanStdDevFuncC3)ippiMean_StdDev_32f_C3CR : 0; if( ippFuncC3 ) { @@ -1347,11 +1347,11 @@ void cv::minMaxIdx(InputArray _src, double* minVal, int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskMinMaxIndxFuncC1)(const void *, int, const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); - ippicviMaskMinMaxIndxFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_8u_C1MR : - type == CV_16UC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskMinMaxIndxFuncC1)ippicviMinMaxIndx_32f_C1MR : + typedef IppStatus (CV_STDCALL* ippiMaskMinMaxIndxFuncC1)(const void *, int, const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); + ippiMaskMinMaxIndxFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_8u_C1MR : + type == CV_16UC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_16u_C1MR : + type == CV_32FC1 ? (ippiMaskMinMaxIndxFuncC1)ippiMinMaxIndx_32f_C1MR : 0; if( ippFuncC1 ) { @@ -1381,11 +1381,11 @@ void cv::minMaxIdx(InputArray _src, double* minVal, } else { - typedef IppStatus (CV_STDCALL* ippicviMinMaxIndxFuncC1)(const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); - ippicviMinMaxIndxFuncC1 ippFuncC1 = - type == CV_8UC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_8u_C1R : - type == CV_16UC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_16u_C1R : - type == CV_32FC1 ? (ippicviMinMaxIndxFuncC1)ippicviMinMaxIndx_32f_C1R : + typedef IppStatus (CV_STDCALL* ippiMinMaxIndxFuncC1)(const void *, int, IppiSize, Ipp32f *, Ipp32f *, IppiPoint *, IppiPoint *); + ippiMinMaxIndxFuncC1 ippFuncC1 = + type == CV_8UC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_8u_C1R : + type == CV_16UC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_16u_C1R : + type == CV_32FC1 ? (ippiMinMaxIndxFuncC1)ippiMinMaxIndx_32f_C1R : 0; if( ippFuncC1 ) { @@ -2024,25 +2024,25 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) int type = src.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskNormFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *); - ippicviMaskNormFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *); + ippiMaskNormFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L1_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormFuncC1)ippicviNorm_L2_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2052,25 +2052,25 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm; } } - typedef IppStatus (CV_STDCALL* ippicviMaskNormFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *); - ippicviMaskNormFuncC3 ippFuncC3 = + typedef IppStatus (CV_STDCALL* ippiMaskNormFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *); + ippiMaskNormFuncC3 ippFuncC3 = normType == NORM_INF ? - (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_Inf_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_32f_C3CMR : 0) : normType == NORM_L1 ? - (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L1_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_32f_C3CMR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormFuncC3)ippicviNorm_L2_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_L2_32f_C3CMR : 0) : 0; if( ippFuncC3 ) { @@ -2090,57 +2090,57 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) } else { - typedef IppStatus (CV_STDCALL* ippicviNormFuncHint)(const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - typedef IppStatus (CV_STDCALL* ippicviNormFuncNoHint)(const void *, int, IppiSize, Ipp64f *); - ippicviNormFuncHint ippFuncHint = + typedef IppStatus (CV_STDCALL* ippiNormFuncHint)(const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + typedef IppStatus (CV_STDCALL* ippiNormFuncNoHint)(const void *, int, IppiSize, Ipp64f *); + ippiNormFuncHint ippFuncHint = normType == NORM_L1 ? - (type == CV_32FC1 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C1R : - type == CV_32FC3 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C3R : - type == CV_32FC4 ? (ippicviNormFuncHint)ippicviNorm_L1_32f_C4R : + (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L1_32f_C1R : + type == CV_32FC3 ? (ippiNormFuncHint)ippiNorm_L1_32f_C3R : + type == CV_32FC4 ? (ippiNormFuncHint)ippiNorm_L1_32f_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_32FC1 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C1R : - type == CV_32FC3 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C3R : - type == CV_32FC4 ? (ippicviNormFuncHint)ippicviNorm_L2_32f_C4R : + (type == CV_32FC1 ? (ippiNormFuncHint)ippiNorm_L2_32f_C1R : + type == CV_32FC3 ? (ippiNormFuncHint)ippiNorm_L2_32f_C3R : + type == CV_32FC4 ? (ippiNormFuncHint)ippiNorm_L2_32f_C4R : 0) : 0; - ippicviNormFuncNoHint ippFuncNoHint = + ippiNormFuncNoHint ippFuncNoHint = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C1R : - type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C3R : - type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_8u_C4R : - type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C1R : - type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C3R : - type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16u_C4R : - type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C1R : + (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C1R : + type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C3R : + type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_8u_C4R : + type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C1R : + type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C3R : + type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C4R : + type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R : #if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) - type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif - type == CV_32FC1 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C1R : - type == CV_32FC3 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C3R : - type == CV_32FC4 ? (ippicviNormFuncNoHint)ippicviNorm_Inf_32f_C4R : + type == CV_32FC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C1R : + type == CV_32FC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C3R : + type == CV_32FC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_32f_C4R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C1R : - type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C3R : - type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_8u_C4R : - type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C1R : - type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C3R : - type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16u_C4R : - type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C1R : - type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C3R : - type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_L1_16s_C4R : + (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C1R : + type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C3R : + type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_L1_8u_C4R : + type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C1R : + type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C3R : + type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_L1_16u_C4R : + type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C1R : + type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C3R : + type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_L1_16s_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C1R : - type == CV_8UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C3R : - type == CV_8UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_8u_C4R : - type == CV_16UC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C1R : - type == CV_16UC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C3R : - type == CV_16UC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16u_C4R : - type == CV_16SC1 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C1R : - type == CV_16SC3 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C3R : - type == CV_16SC4 ? (ippicviNormFuncNoHint)ippicviNorm_L2_16s_C4R : + (type == CV_8UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C1R : + type == CV_8UC3 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C3R : + type == CV_8UC4 ? (ippiNormFuncNoHint)ippiNorm_L2_8u_C4R : + type == CV_16UC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C1R : + type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C3R : + type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_L2_16u_C4R : + type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C1R : + type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C3R : + type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_L2_16s_C4R : 0) : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); @@ -2377,25 +2377,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m int type = src1.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskNormRelFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); - ippicviMaskNormRelFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippiMaskNormRelFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); + ippiMaskNormRelFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L1_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormRelFuncC1)ippicviNormRel_L2_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormRelFuncC1)ippiNormRel_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2406,25 +2406,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m } else { - typedef IppStatus (CV_STDCALL* ippicviNormRelFunc)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - ippicviNormRelFunc ippFunc = + typedef IppStatus (CV_STDCALL* ippiNormRelFunc)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + ippiNormRelFunc ippFunc = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_8u_C1R : - type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_16u_C1R : - type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_16s_C1R : - type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_Inf_32f_C1R : + (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_Inf_8u_C1R : + type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_Inf_16u_C1R : + type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_Inf_16s_C1R : + type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_Inf_32f_C1R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_8u_C1R : - type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_16u_C1R : - type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_16s_C1R : - type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_L1_32f_C1R : + (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_L1_8u_C1R : + type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_L1_16u_C1R : + type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_L1_16s_C1R : + type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_L1_32f_C1R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_8u_C1R : - type == CV_16UC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_16u_C1R : - type == CV_16SC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_16s_C1R : - type == CV_32FC1 ? (ippicviNormRelFunc)ippicviNormRel_L2_32f_C1R : + (type == CV_8UC1 ? (ippiNormRelFunc)ippiNormRel_L2_8u_C1R : + type == CV_16UC1 ? (ippiNormRelFunc)ippiNormRel_L2_16u_C1R : + type == CV_16SC1 ? (ippiNormRelFunc)ippiNormRel_L2_16s_C1R : + type == CV_32FC1 ? (ippiNormRelFunc)ippiNormRel_L2_32f_C1R : 0) : 0; if( ippFunc ) { @@ -2458,25 +2458,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m int type = src1.type(); if( !mask.empty() ) { - typedef IppStatus (CV_STDCALL* ippicviMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); - ippicviMaskNormDiffFuncC1 ippFuncC1 = + typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC1)(const void *, int, const void *, int, const void *, int, IppiSize, Ipp64f *); + ippiMaskNormDiffFuncC1 ippFuncC1 = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_Inf_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_Inf_32f_C1MR : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L1_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L1_32f_C1MR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_8u_C1MR : - type == CV_8SC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_8s_C1MR : - type == CV_16UC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_16u_C1MR : - type == CV_32FC1 ? (ippicviMaskNormDiffFuncC1)ippicviNormDiff_L2_32f_C1MR : + (type == CV_8UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_8u_C1MR : + type == CV_8SC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_8s_C1MR : + type == CV_16UC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_16u_C1MR : + type == CV_32FC1 ? (ippiMaskNormDiffFuncC1)ippiNormDiff_L2_32f_C1MR : 0) : 0; if( ippFuncC1 ) { @@ -2484,25 +2484,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m if( ippFuncC1(src1.data, (int)src1.step[0], src2.data, (int)src2.step[0], mask.data, (int)mask.step[0], sz, &norm) >= 0 ) return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm; } - typedef IppStatus (CV_STDCALL* ippicviMaskNormDiffFuncC3)(const void *, int, const void *, int, const void *, int, IppiSize, int, Ipp64f *); - ippicviMaskNormDiffFuncC3 ippFuncC3 = + typedef IppStatus (CV_STDCALL* ippiMaskNormDiffFuncC3)(const void *, int, const void *, int, const void *, int, IppiSize, int, Ipp64f *); + ippiMaskNormDiffFuncC3 ippFuncC3 = normType == NORM_INF ? - (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_Inf_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_32f_C3CMR : 0) : normType == NORM_L1 ? - (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L1_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_32f_C3CMR : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_8u_C3CMR : - type == CV_8SC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_8s_C3CMR : - type == CV_16UC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_16u_C3CMR : - type == CV_32FC3 ? (ippicviMaskNormDiffFuncC3)ippicviNormDiff_L2_32f_C3CMR : + (type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_8u_C3CMR : + type == CV_8SC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_8s_C3CMR : + type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_16u_C3CMR : + type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L2_32f_C3CMR : 0) : 0; if( ippFuncC3 ) { @@ -2522,57 +2522,57 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m } else { - typedef IppStatus (CV_STDCALL* ippicviNormDiffFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); - typedef IppStatus (CV_STDCALL* ippicviNormDiffFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *); - ippicviNormDiffFuncHint ippFuncHint = + typedef IppStatus (CV_STDCALL* ippiNormDiffFuncHint)(const void *, int, const void *, int, IppiSize, Ipp64f *, IppHintAlgorithm hint); + typedef IppStatus (CV_STDCALL* ippiNormDiffFuncNoHint)(const void *, int, const void *, int, IppiSize, Ipp64f *); + ippiNormDiffFuncHint ippFuncHint = normType == NORM_L1 ? - (type == CV_32FC1 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C1R : - type == CV_32FC3 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C3R : - type == CV_32FC4 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L1_32f_C4R : + (type == CV_32FC1 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C1R : + type == CV_32FC3 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C3R : + type == CV_32FC4 ? (ippiNormDiffFuncHint)ippiNormDiff_L1_32f_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_32FC1 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C1R : - type == CV_32FC3 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C3R : - type == CV_32FC4 ? (ippicviNormDiffFuncHint)ippicviNormDiff_L2_32f_C4R : + (type == CV_32FC1 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C1R : + type == CV_32FC3 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C3R : + type == CV_32FC4 ? (ippiNormDiffFuncHint)ippiNormDiff_L2_32f_C4R : 0) : 0; - ippicviNormDiffFuncNoHint ippFuncNoHint = + ippiNormDiffFuncNoHint ippFuncNoHint = normType == NORM_INF ? - (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C1R : - type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C3R : - type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_8u_C4R : - type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C1R : - type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C3R : - type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16u_C4R : - type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C1R : + (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C1R : + type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C3R : + type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_8u_C4R : + type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C1R : + type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C3R : + type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C4R : + type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R : #if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) - type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 - type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 + type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif - type == CV_32FC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C1R : - type == CV_32FC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C3R : - type == CV_32FC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_Inf_32f_C4R : + type == CV_32FC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C1R : + type == CV_32FC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C3R : + type == CV_32FC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_32f_C4R : 0) : normType == NORM_L1 ? - (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C1R : - type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C3R : - type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_8u_C4R : - type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C1R : - type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C3R : - type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16u_C4R : - type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C1R : - type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C3R : - type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L1_16s_C4R : + (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C1R : + type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C3R : + type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_8u_C4R : + type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C1R : + type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C3R : + type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C4R : + type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C1R : + type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C3R : + type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C4R : 0) : normType == NORM_L2 || normType == NORM_L2SQR ? - (type == CV_8UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C1R : - type == CV_8UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C3R : - type == CV_8UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_8u_C4R : - type == CV_16UC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C1R : - type == CV_16UC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C3R : - type == CV_16UC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16u_C4R : - type == CV_16SC1 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C1R : - type == CV_16SC3 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C3R : - type == CV_16SC4 ? (ippicviNormDiffFuncNoHint)ippicviNormDiff_L2_16s_C4R : + (type == CV_8UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C1R : + type == CV_8UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C3R : + type == CV_8UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_8u_C4R : + type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C1R : + type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C3R : + type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16u_C4R : + type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C1R : + type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C3R : + type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L2_16s_C4R : 0) : 0; // Make sure only zero or one version of the function pointer is valid CV_Assert(!ippFuncHint || !ippFuncNoHint); diff --git a/modules/imgproc/src/canny.cpp b/modules/imgproc/src/canny.cpp index 2d4983bb30..65e8173065 100644 --- a/modules/imgproc/src/canny.cpp +++ b/modules/imgproc/src/canny.cpp @@ -59,28 +59,28 @@ static bool ippCanny(const Mat& _src, Mat& _dst, float low, float high) int size = 0, size1 = 0; IppiSize roi = { _src.cols, _src.rows }; - ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size); - ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1); + ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size); + ippiFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1); size = std::max(size, size1); - ippicviCannyGetSize(roi, &size1); + ippiCannyGetSize(roi, &size1); size = std::max(size, size1); AutoBuffer buf(size + 64); uchar* buffer = alignPtr((uchar*)buf, 32); Mat _dx(_src.rows, _src.cols, CV_16S); - if( ippicviFilterSobelNegVertBorder_8u16s_C1R(_src.data, (int)_src.step, + if( ippiFilterSobelNegVertBorder_8u16s_C1R(_src.data, (int)_src.step, _dx.ptr(), (int)_dx.step, roi, ippMskSize3x3, ippBorderRepl, 0, buffer) < 0 ) return false; Mat _dy(_src.rows, _src.cols, CV_16S); - if( ippicviFilterSobelHorizBorder_8u16s_C1R(_src.data, (int)_src.step, + if( ippiFilterSobelHorizBorder_8u16s_C1R(_src.data, (int)_src.step, _dy.ptr(), (int)_dy.step, roi, ippMskSize3x3, ippBorderRepl, 0, buffer) < 0 ) return false; - if( ippicviCanny_16s8u_C1R(_dx.ptr(), (int)_dx.step, + if( ippiCanny_16s8u_C1R(_dx.ptr(), (int)_dx.step, _dy.ptr(), (int)_dy.step, _dst.data, (int)_dst.step, roi, low, high, buffer) < 0 ) return false; diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index b105ee3267..4c9abe190f 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -99,7 +99,7 @@ #define MAX_IPP8u 255 #define MAX_IPP16u 65535 #define MAX_IPP32f 1.0 -static IppStatus sts = ippicvInit(); +static IppStatus sts = ippInit(); #endif namespace cv @@ -200,9 +200,9 @@ void CvtColorLoop(const Mat& src, Mat& dst, const Cvt& cvt) } #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -typedef IppStatus (CV_STDCALL* ippicviReorderFunc)(const void *, int, void *, int, IppiSize, const int *); -typedef IppStatus (CV_STDCALL* ippicviGeneralFunc)(const void *, int, void *, int, IppiSize); -typedef IppStatus (CV_STDCALL* ippicviColor2GrayFunc)(const void *, int, void *, int, IppiSize, const Ipp32f *); +typedef IppStatus (CV_STDCALL* ippiReorderFunc)(const void *, int, void *, int, IppiSize, const int *); +typedef IppStatus (CV_STDCALL* ippiGeneralFunc)(const void *, int, void *, int, IppiSize); +typedef IppStatus (CV_STDCALL* ippiColor2GrayFunc)(const void *, int, void *, int, IppiSize, const Ipp32f *); template class CvtColorIPPLoop_Invoker : public ParallelLoopBody @@ -256,134 +256,134 @@ bool CvtColorIPPLoopCopy(Mat& src, Mat& dst, const Cvt& cvt) return ok; } -static IppStatus CV_STDCALL ippicviSwapChannels_8u_C3C4Rf(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, +static IppStatus CV_STDCALL ippiSwapChannels_8u_C3C4Rf(const Ipp8u* pSrc, int srcStep, Ipp8u* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippicviSwapChannels_8u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP8u); + return ippiSwapChannels_8u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP8u); } -static IppStatus CV_STDCALL ippicviSwapChannels_16u_C3C4Rf(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, +static IppStatus CV_STDCALL ippiSwapChannels_16u_C3C4Rf(const Ipp16u* pSrc, int srcStep, Ipp16u* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippicviSwapChannels_16u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP16u); + return ippiSwapChannels_16u_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP16u); } -static IppStatus CV_STDCALL ippicviSwapChannels_32f_C3C4Rf(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, +static IppStatus CV_STDCALL ippiSwapChannels_32f_C3C4Rf(const Ipp32f* pSrc, int srcStep, Ipp32f* pDst, int dstStep, IppiSize roiSize, const int *dstOrder) { - return ippicviSwapChannels_32f_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP32f); + return ippiSwapChannels_32f_C3C4R(pSrc, srcStep, pDst, dstStep, roiSize, dstOrder, MAX_IPP32f); } -static ippicviReorderFunc ippicviSwapChannelsC3C4RTab[] = +static ippiReorderFunc ippiSwapChannelsC3C4RTab[] = { - (ippicviReorderFunc)ippicviSwapChannels_8u_C3C4Rf, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C3C4Rf, 0, - 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C3C4Rf, 0, 0 + (ippiReorderFunc)ippiSwapChannels_8u_C3C4Rf, 0, (ippiReorderFunc)ippiSwapChannels_16u_C3C4Rf, 0, + 0, (ippiReorderFunc)ippiSwapChannels_32f_C3C4Rf, 0, 0 }; -static ippicviGeneralFunc ippicviCopyAC4C3RTab[] = +static ippiGeneralFunc ippiCopyAC4C3RTab[] = { - (ippicviGeneralFunc)ippicviCopy_8u_AC4C3R, 0, (ippicviGeneralFunc)ippicviCopy_16u_AC4C3R, 0, - 0, (ippicviGeneralFunc)ippicviCopy_32f_AC4C3R, 0, 0 + (ippiGeneralFunc)ippiCopy_8u_AC4C3R, 0, (ippiGeneralFunc)ippiCopy_16u_AC4C3R, 0, + 0, (ippiGeneralFunc)ippiCopy_32f_AC4C3R, 0, 0 }; -static ippicviReorderFunc ippicviSwapChannelsC4C3RTab[] = +static ippiReorderFunc ippiSwapChannelsC4C3RTab[] = { - (ippicviReorderFunc)ippicviSwapChannels_8u_C4C3R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C4C3R, 0, - 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C4C3R, 0, 0 + (ippiReorderFunc)ippiSwapChannels_8u_C4C3R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4C3R, 0, + 0, (ippiReorderFunc)ippiSwapChannels_32f_C4C3R, 0, 0 }; -static ippicviReorderFunc ippicviSwapChannelsC3RTab[] = +static ippiReorderFunc ippiSwapChannelsC3RTab[] = { - (ippicviReorderFunc)ippicviSwapChannels_8u_C3R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C3R, 0, - 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C3R, 0, 0 + (ippiReorderFunc)ippiSwapChannels_8u_C3R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C3R, 0, + 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; -static ippicviReorderFunc ippicviSwapChannelsC4RTab[] = +static ippiReorderFunc ippiSwapChannelsC4RTab[] = { - (ippicviReorderFunc)ippicviSwapChannels_8u_C4R, 0, (ippicviReorderFunc)ippicviSwapChannels_16u_C4R, 0, - 0, (ippicviReorderFunc)ippicviSwapChannels_32f_C4R, 0, 0 + (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, + 0, (ippiReorderFunc)ippiSwapChannels_32f_C4R, 0, 0 }; -static ippicviColor2GrayFunc ippicviColor2GrayC3Tab[] = +static ippiColor2GrayFunc ippiColor2GrayC3Tab[] = { - (ippicviColor2GrayFunc)ippicviColorToGray_8u_C3C1R, 0, (ippicviColor2GrayFunc)ippicviColorToGray_16u_C3C1R, 0, - 0, (ippicviColor2GrayFunc)ippicviColorToGray_32f_C3C1R, 0, 0 + (ippiColor2GrayFunc)ippiColorToGray_8u_C3C1R, 0, (ippiColor2GrayFunc)ippiColorToGray_16u_C3C1R, 0, + 0, (ippiColor2GrayFunc)ippiColorToGray_32f_C3C1R, 0, 0 }; -static ippicviColor2GrayFunc ippicviColor2GrayC4Tab[] = +static ippiColor2GrayFunc ippiColor2GrayC4Tab[] = { - (ippicviColor2GrayFunc)ippicviColorToGray_8u_AC4C1R, 0, (ippicviColor2GrayFunc)ippicviColorToGray_16u_AC4C1R, 0, - 0, (ippicviColor2GrayFunc)ippicviColorToGray_32f_AC4C1R, 0, 0 + (ippiColor2GrayFunc)ippiColorToGray_8u_AC4C1R, 0, (ippiColor2GrayFunc)ippiColorToGray_16u_AC4C1R, 0, + 0, (ippiColor2GrayFunc)ippiColorToGray_32f_AC4C1R, 0, 0 }; -static ippicviGeneralFunc ippicviRGB2GrayC3Tab[] = +static ippiGeneralFunc ippiRGB2GrayC3Tab[] = { - (ippicviGeneralFunc)ippicviRGBToGray_8u_C3C1R, 0, (ippicviGeneralFunc)ippicviRGBToGray_16u_C3C1R, 0, - 0, (ippicviGeneralFunc)ippicviRGBToGray_32f_C3C1R, 0, 0 + (ippiGeneralFunc)ippiRGBToGray_8u_C3C1R, 0, (ippiGeneralFunc)ippiRGBToGray_16u_C3C1R, 0, + 0, (ippiGeneralFunc)ippiRGBToGray_32f_C3C1R, 0, 0 }; -static ippicviGeneralFunc ippicviRGB2GrayC4Tab[] = +static ippiGeneralFunc ippiRGB2GrayC4Tab[] = { - (ippicviGeneralFunc)ippicviRGBToGray_8u_AC4C1R, 0, (ippicviGeneralFunc)ippicviRGBToGray_16u_AC4C1R, 0, - 0, (ippicviGeneralFunc)ippicviRGBToGray_32f_AC4C1R, 0, 0 + (ippiGeneralFunc)ippiRGBToGray_8u_AC4C1R, 0, (ippiGeneralFunc)ippiRGBToGray_16u_AC4C1R, 0, + 0, (ippiGeneralFunc)ippiRGBToGray_32f_AC4C1R, 0, 0 }; -static ippicviGeneralFunc ippicviCopyP3C3RTab[] = +static ippiGeneralFunc ippiCopyP3C3RTab[] = { - (ippicviGeneralFunc)ippicviCopy_8u_P3C3R, 0, (ippicviGeneralFunc)ippicviCopy_16u_P3C3R, 0, - 0, (ippicviGeneralFunc)ippicviCopy_32f_P3C3R, 0, 0 + (ippiGeneralFunc)ippiCopy_8u_P3C3R, 0, (ippiGeneralFunc)ippiCopy_16u_P3C3R, 0, + 0, (ippiGeneralFunc)ippiCopy_32f_P3C3R, 0, 0 }; -static ippicviGeneralFunc ippicviRGB2XYZTab[] = +static ippiGeneralFunc ippiRGB2XYZTab[] = { - (ippicviGeneralFunc)ippicviRGBToXYZ_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToXYZ_16u_C3R, 0, - 0, (ippicviGeneralFunc)ippicviRGBToXYZ_32f_C3R, 0, 0 + (ippiGeneralFunc)ippiRGBToXYZ_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToXYZ_16u_C3R, 0, + 0, (ippiGeneralFunc)ippiRGBToXYZ_32f_C3R, 0, 0 }; -static ippicviGeneralFunc ippicviXYZ2RGBTab[] = +static ippiGeneralFunc ippiXYZ2RGBTab[] = { - (ippicviGeneralFunc)ippicviXYZToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviXYZToRGB_16u_C3R, 0, - 0, (ippicviGeneralFunc)ippicviXYZToRGB_32f_C3R, 0, 0 + (ippiGeneralFunc)ippiXYZToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiXYZToRGB_16u_C3R, 0, + 0, (ippiGeneralFunc)ippiXYZToRGB_32f_C3R, 0, 0 }; -static ippicviGeneralFunc ippicviRGB2HSVTab[] = +static ippiGeneralFunc ippiRGB2HSVTab[] = { - (ippicviGeneralFunc)ippicviRGBToHSV_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToHSV_16u_C3R, 0, + (ippiGeneralFunc)ippiRGBToHSV_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHSV_16u_C3R, 0, 0, 0, 0, 0 }; -static ippicviGeneralFunc ippicviHSV2RGBTab[] = +static ippiGeneralFunc ippiHSV2RGBTab[] = { - (ippicviGeneralFunc)ippicviHSVToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviHSVToRGB_16u_C3R, 0, + (ippiGeneralFunc)ippiHSVToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHSVToRGB_16u_C3R, 0, 0, 0, 0, 0 }; -static ippicviGeneralFunc ippicviRGB2HLSTab[] = +static ippiGeneralFunc ippiRGB2HLSTab[] = { - (ippicviGeneralFunc)ippicviRGBToHLS_8u_C3R, 0, (ippicviGeneralFunc)ippicviRGBToHLS_16u_C3R, 0, - 0, (ippicviGeneralFunc)ippicviRGBToHLS_32f_C3R, 0, 0 + (ippiGeneralFunc)ippiRGBToHLS_8u_C3R, 0, (ippiGeneralFunc)ippiRGBToHLS_16u_C3R, 0, + 0, (ippiGeneralFunc)ippiRGBToHLS_32f_C3R, 0, 0 }; -static ippicviGeneralFunc ippicviHLS2RGBTab[] = +static ippiGeneralFunc ippiHLS2RGBTab[] = { - (ippicviGeneralFunc)ippicviHLSToRGB_8u_C3R, 0, (ippicviGeneralFunc)ippicviHLSToRGB_16u_C3R, 0, - 0, (ippicviGeneralFunc)ippicviHLSToRGB_32f_C3R, 0, 0 + (ippiGeneralFunc)ippiHLSToRGB_8u_C3R, 0, (ippiGeneralFunc)ippiHLSToRGB_16u_C3R, 0, + 0, (ippiGeneralFunc)ippiHLSToRGB_32f_C3R, 0, 0 }; struct IPPGeneralFunctor { - IPPGeneralFunctor(ippicviGeneralFunc _func) : func(_func){} + IPPGeneralFunctor(ippiGeneralFunc _func) : func(_func){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { return func(src, srcStep, dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippicviGeneralFunc func; + ippiGeneralFunc func; }; struct IPPReorderFunctor { - IPPReorderFunctor(ippicviReorderFunc _func, int _order0, int _order1, int _order2) : func(_func) + IPPReorderFunctor(ippiReorderFunc _func, int _order0, int _order1, int _order2) : func(_func) { order[0] = _order0; order[1] = _order1; @@ -395,13 +395,13 @@ struct IPPReorderFunctor return func(src, srcStep, dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippicviReorderFunc func; + ippiReorderFunc func; int order[4]; }; struct IPPColor2GrayFunctor { - IPPColor2GrayFunctor(ippicviColor2GrayFunc _func) : func(_func) + IPPColor2GrayFunctor(ippiColor2GrayFunc _func) : func(_func) { coeffs[0] = 0.114f; coeffs[1] = 0.587f; @@ -412,25 +412,25 @@ struct IPPColor2GrayFunctor return func(src, srcStep, dst, dstStep, ippiSize(cols, rows), coeffs) >= 0; } private: - ippicviColor2GrayFunc func; + ippiColor2GrayFunc func; Ipp32f coeffs[3]; }; struct IPPGray2BGRFunctor { - IPPGray2BGRFunctor(ippicviGeneralFunc _func) : func(_func){} + IPPGray2BGRFunctor(ippiGeneralFunc _func) : func(_func){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { const void* srcarray[3] = { src, src, src }; return func(srcarray, srcStep, dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippicviGeneralFunc func; + ippiGeneralFunc func; }; struct IPPGray2BGRAFunctor { - IPPGray2BGRAFunctor(ippicviGeneralFunc _func1, ippicviReorderFunc _func2, int _depth) : func1(_func1), func2(_func2), depth(_depth){} + IPPGray2BGRAFunctor(ippiGeneralFunc _func1, ippiReorderFunc _func2, int _depth) : func1(_func1), func2(_func2), depth(_depth){} bool operator()(const void *src, int srcStep, void *dst, int dstStep, int cols, int rows) const { const void* srcarray[3] = { src, src, src }; @@ -441,14 +441,14 @@ struct IPPGray2BGRAFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippicviGeneralFunc func1; - ippicviReorderFunc func2; + ippiGeneralFunc func1; + ippiReorderFunc func2; int depth; }; struct IPPReorderGeneralFunctor { - IPPReorderGeneralFunctor(ippicviReorderFunc _func1, ippicviGeneralFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) + IPPReorderGeneralFunctor(ippiReorderFunc _func1, ippiGeneralFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) { order[0] = _order0; order[1] = _order1; @@ -464,15 +464,15 @@ struct IPPReorderGeneralFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows)) >= 0; } private: - ippicviReorderFunc func1; - ippicviGeneralFunc func2; + ippiReorderFunc func1; + ippiGeneralFunc func2; int order[4]; int depth; }; struct IPPGeneralReorderFunctor { - IPPGeneralReorderFunctor(ippicviGeneralFunc _func1, ippicviReorderFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) + IPPGeneralReorderFunctor(ippiGeneralFunc _func1, ippiReorderFunc _func2, int _order0, int _order1, int _order2, int _depth) : func1(_func1), func2(_func2), depth(_depth) { order[0] = _order0; order[1] = _order1; @@ -488,8 +488,8 @@ struct IPPGeneralReorderFunctor return func2(temp.data, (int)temp.step[0], dst, dstStep, ippiSize(cols, rows), order) >= 0; } private: - ippicviGeneralFunc func1; - ippicviReorderFunc func2; + ippiGeneralFunc func1; + ippiReorderFunc func2; int order[4]; int depth; }; @@ -3229,32 +3229,32 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2BGRA || code == CV_RGB2RGBA) { - if ( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2)) ) + if ( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 0, 1, 2)) ) return; } else if( code == CV_BGRA2BGR ) { - if ( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviCopyAC4C3RTab[depth])) ) + if ( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiCopyAC4C3RTab[depth])) ) return; } else if( code == CV_BGR2RGBA ) { - if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGBA2BGR ) { - if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippicviSwapChannelsC4C3RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC4C3RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGB2BGR ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippicviSwapChannelsC3RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } else if( code == CV_RGBA2BGRA ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippicviSwapChannelsC4RTab[depth], 2, 1, 0)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) return; } #endif @@ -3316,24 +3316,24 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) /* if( code == CV_BGR2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippicviColor2GrayC3Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC3Tab[depth])) ) return; } else */ if( code == CV_RGB2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviRGB2GrayC3Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC3Tab[depth])) ) return; } else if( code == CV_BGRA2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippicviColor2GrayC4Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC4Tab[depth])) ) return; } else if( code == CV_RGBA2GRAY ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippicviRGB2GrayC4Tab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC4Tab[depth])) ) return; } #endif @@ -3370,12 +3370,12 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_GRAY2BGR ) { - if( CvtColorIPPLoop(src, dst, IPPGray2BGRFunctor(ippicviCopyP3C3RTab[depth])) ) + if( CvtColorIPPLoop(src, dst, IPPGray2BGRFunctor(ippiCopyP3C3RTab[depth])) ) return; } else if( code == CV_GRAY2BGRA ) { - if( CvtColorIPPLoop(src, dst, IPPGray2BGRAFunctor(ippicviCopyP3C3RTab[depth], ippicviSwapChannelsC3C4RTab[depth], depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGray2BGRAFunctor(ippiCopyP3C3RTab[depth], ippiSwapChannelsC3C4RTab[depth], depth)) ) return; } #endif @@ -3463,22 +3463,22 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_BGR2XYZ && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2XYZTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2XYZ && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2XYZTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2XYZ && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2XYZTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2XYZTab[depth])) ) return; } else if( code == CV_RGB2XYZ && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2XYZTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 0, 1, 2, depth)) ) return; } #endif @@ -3502,22 +3502,22 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( code == CV_XYZ2BGR && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_XYZ2BGR && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } if( code == CV_XYZ2RGB && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviXYZ2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiXYZ2RGBTab[depth])) ) return; } else if( code == CV_XYZ2RGB && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviXYZ2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } #endif @@ -3547,42 +3547,42 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) { if( code == CV_BGR2HSV_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2HSVTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2HSV_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HSVTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2HSV_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2HSVTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HSVTab[depth])) ) return; } else if( code == CV_RGB2HSV_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HSVTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 0, 1, 2, depth)) ) return; } else if( code == CV_BGR2HLS_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC3RTab[depth], ippicviRGB2HLSTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_BGR2HLS_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HLSTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_RGB2HLS_FULL && scn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviRGB2HLSTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HLSTab[depth])) ) return; } else if( code == CV_RGB2HLS_FULL && scn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippicviSwapChannelsC4C3RTab[depth], ippicviRGB2HLSTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 0, 1, 2, depth)) ) return; } } @@ -3628,42 +3628,42 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) { if( code == CV_HSV2BGR_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HSV2BGR_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HSV2RGB_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviHSV2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHSV2RGBTab[depth])) ) return; } else if( code == CV_HSV2RGB_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHSV2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } else if( code == CV_HLS2BGR_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HLS2BGR_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) ) return; } else if( code == CV_HLS2RGB_FULL && dcn == 3 ) { - if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippicviHLS2RGBTab[depth])) ) + if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHLS2RGBTab[depth])) ) return; } else if( code == CV_HLS2RGB_FULL && dcn == 4 ) { - if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippicviHLS2RGBTab[depth], ippicviSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) + if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) ) return; } } diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp index 30a267f44c..887162ee03 100644 --- a/modules/imgproc/src/deriv.cpp +++ b/modules/imgproc/src/deriv.cpp @@ -44,7 +44,7 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippicvInit(); +static IppStatus sts = ippInit(); #endif /****************************************************************************************\ @@ -212,18 +212,18 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize)) + if (ippStsNoErr != ippiFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippicviFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize)) + if (ippStsNoErr != ippiFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } return false; @@ -240,11 +240,11 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + if (ippStsNoErr != ippiFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -253,23 +253,23 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, if (scale != 1) /* IPP is fast, so MulC produce very little perf degradation.*/ - //ippicviMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); - ippicviMulC_32f_C1R((Ipp32f*)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + //ippiMulC_32f_C1IR((Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f*)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f*)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippicviFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + if (ippStsNoErr != ippiFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) return false; if (scale != 1) - ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } } @@ -296,44 +296,44 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippicviFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 2) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 2)) { - if (ippStsNoErr != ippicviFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippicviFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (ippStsNoErr == ippiFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } @@ -343,62 +343,62 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize)) + if (ippStsNoErr != ippiFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { return false; } if(scale != 1) - ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippicviFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { return false; } if(scale != 1) - ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 2) && (dy == 0)) { - if (ippStsNoErr != ippicviFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { return false; } if(scale != 1) - ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } if((dx == 0) && (dy == 2)) { - if (ippStsNoErr != ippicviFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (ippStsNoErr != ippiFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippicviFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (ippStsNoErr != ippiFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -406,7 +406,7 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k } if(scale != 1) - ippicviMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); + ippiMulC_32f_C1R((Ipp32f *)dst.data, (int)dst.step, (Ipp32f)scale, (Ipp32f *)dst.data, (int)dst.step, ippiSize(dst.cols*dst.channels(), dst.rows)); return true; } } diff --git a/modules/imgproc/src/distransform.cpp b/modules/imgproc/src/distransform.cpp index 4c28735c05..94a5592858 100644 --- a/modules/imgproc/src/distransform.cpp +++ b/modules/imgproc/src/distransform.cpp @@ -748,7 +748,7 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe if( maskSize == CV_DIST_MASK_5 ) { IppiSize roi = { src.cols, src.rows }; - if( ippicviDistanceTransform_5x5_8u32f_C1R( + if( ippiDistanceTransform_5x5_8u32f_C1R( src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, _mask) >= 0 ) return; diff --git a/modules/imgproc/src/filter.cpp b/modules/imgproc/src/filter.cpp index 62a62ded9c..d23f87ef47 100644 --- a/modules/imgproc/src/filter.cpp +++ b/modules/imgproc/src/filter.cpp @@ -1421,7 +1421,7 @@ struct RowVec_32f int operator()(const uchar* _src, uchar* _dst, int width, int cn) const { #ifdef USE_IPP_SEP_FILTERS - int ret = ippicviOperator(_src, _dst, width, cn); + int ret = ippiOperator(_src, _dst, width, cn); if (ret > 0) return ret; #endif @@ -1461,7 +1461,7 @@ struct RowVec_32f #ifdef USE_IPP_SEP_FILTERS private: mutable int bufsz; - int ippicviOperator(const uchar* _src, uchar* _dst, int width, int cn) const + int ippiOperator(const uchar* _src, uchar* _dst, int width, int cn) const { int _ksize = kernel.rows + kernel.cols - 1; if ((1 != cn && 3 != cn) || width < _ksize*8) @@ -1474,8 +1474,8 @@ private: IppiSize roisz = { width, 1 }; if( bufsz < 0 ) { - if( (cn == 1 && ippicviFilterRowBorderPipelineGetBufferSize_32f_C1R(roisz, _ksize, &bufsz) < 0) || - (cn == 3 && ippicviFilterRowBorderPipelineGetBufferSize_32f_C3R(roisz, _ksize, &bufsz) < 0)) + if( (cn == 1 && ippiFilterRowBorderPipelineGetBufferSize_32f_C1R(roisz, _ksize, &bufsz) < 0) || + (cn == 3 && ippiFilterRowBorderPipelineGetBufferSize_32f_C3R(roisz, _ksize, &bufsz) < 0)) return 0; } AutoBuffer buf(bufsz + 64); @@ -1484,9 +1484,9 @@ private: float borderValue[] = {0.f, 0.f, 0.f}; // here is the trick. IPP needs border type and extrapolates the row. We did it already. // So we pass anchor=0 and ignore the right tail of results since they are incorrect there. - if( (cn == 1 && ippicviFilterRowBorderPipeline_32f_C1R(src, step, &dst, roisz, _kx, _ksize, 0, + if( (cn == 1 && ippiFilterRowBorderPipeline_32f_C1R(src, step, &dst, roisz, _kx, _ksize, 0, ippBorderRepl, borderValue[0], bufptr) < 0) || - (cn == 3 && ippicviFilterRowBorderPipeline_32f_C3R(src, step, &dst, roisz, _kx, _ksize, 0, + (cn == 3 && ippiFilterRowBorderPipeline_32f_C3R(src, step, &dst, roisz, _kx, _ksize, 0, ippBorderRepl, borderValue, bufptr) < 0)) return 0; return width - _ksize + 1; diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index d12c7851bd..fdb8302f14 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -50,24 +50,24 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippicvInit(); +static IppStatus sts = ippInit(); #endif namespace cv { #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) - typedef IppStatus (CV_STDCALL* ippicviResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); - typedef IppStatus (CV_STDCALL* ippicviResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); - typedef IppStatus (CV_STDCALL* ippicviResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); + typedef IppStatus (CV_STDCALL* ippiResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); + typedef IppStatus (CV_STDCALL* ippiResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); + typedef IppStatus (CV_STDCALL* ippiResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); #endif #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) - typedef IppStatus (CV_STDCALL* ippicviSetFunc)(const void*, void *, int, IppiSize); - typedef IppStatus (CV_STDCALL* ippicviWarpPerspectiveBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [3][3], int); - typedef IppStatus (CV_STDCALL* ippicviWarpAffineBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [2][3], int); + typedef IppStatus (CV_STDCALL* ippiSetFunc)(const void*, void *, int, IppiSize); + typedef IppStatus (CV_STDCALL* ippiWarpPerspectiveBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [3][3], int); + typedef IppStatus (CV_STDCALL* ippiWarpAffineBackFunc)(const void*, IppiSize, int, IppiRect, void *, int, IppiRect, double [2][3], int); template - bool IPPSetSimple(cv::Scalar value, void *dataPointer, int step, IppiSize &size, ippicviSetFunc func) + bool IPPSetSimple(cv::Scalar value, void *dataPointer, int step, IppiSize &size, ippiSetFunc func) { Type values[channels]; for( int i = 0; i < channels; i++ ) @@ -82,11 +82,11 @@ namespace cv switch( depth ) { case CV_8U: - return ippicviSet_8u_C1R((Ipp8u)value[0], (Ipp8u *)dataPointer, step, size) >= 0; + return ippiSet_8u_C1R((Ipp8u)value[0], (Ipp8u *)dataPointer, step, size) >= 0; case CV_16U: - return ippicviSet_16u_C1R((Ipp16u)value[0], (Ipp16u *)dataPointer, step, size) >= 0; + return ippiSet_16u_C1R((Ipp16u)value[0], (Ipp16u *)dataPointer, step, size) >= 0; case CV_32F: - return ippicviSet_32f_C1R((Ipp32f)value[0], (Ipp32f *)dataPointer, step, size) >= 0; + return ippiSet_32f_C1R((Ipp32f)value[0], (Ipp32f *)dataPointer, step, size) >= 0; } } else @@ -96,11 +96,11 @@ namespace cv switch( depth ) { case CV_8U: - return IPPSetSimple<3, Ipp8u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_8u_C3R); + return IPPSetSimple<3, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C3R); case CV_16U: - return IPPSetSimple<3, Ipp16u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_16u_C3R); + return IPPSetSimple<3, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C3R); case CV_32F: - return IPPSetSimple<3, Ipp32f>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_32f_C3R); + return IPPSetSimple<3, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C3R); } } else if( channels == 4 ) @@ -108,11 +108,11 @@ namespace cv switch( depth ) { case CV_8U: - return IPPSetSimple<4, Ipp8u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_8u_C4R); + return IPPSetSimple<4, Ipp8u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_8u_C4R); case CV_16U: - return IPPSetSimple<4, Ipp16u>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_16u_C4R); + return IPPSetSimple<4, Ipp16u>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_16u_C4R); case CV_32F: - return IPPSetSimple<4, Ipp32f>(value, dataPointer, step, size, (ippicviSetFunc)ippicviSet_32f_C4R); + return IPPSetSimple<4, Ipp32f>(value, dataPointer, step, size, (ippiSetFunc)ippiSet_32f_C4R); } } } @@ -1880,37 +1880,37 @@ static int computeResizeAreaTab( int ssize, int dsize, int cn, double scale, Dec #define CHECK_IPP_STATUS(STATUS) if( STATUS!=ippStsNoErr ) { *ok = false; return;} #define SET_IPP_RESIZE_LINEAR_FUNC_PTR(TYPE, CN) \ - func = (ippicviResizeFunc)ippicviResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippiResizeFunc)ippiResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ - CHECK_IPP_STATUS(ippicviResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_32f*)pSpec)); + CHECK_IPP_STATUS(ippiResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_32f*)pSpec)); #define SET_IPP_RESIZE_LINEAR_FUNC_64_PTR(TYPE, CN) \ if (mode==(int)ippCubic) { *ok = false; return;}\ - func = (ippicviResizeFunc)ippicviResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippiResizeFunc)ippiResizeLinear_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ - CHECK_IPP_STATUS(ippicviResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_64f*)pSpec));\ - getBufferSizeFunc = (ippicviResizeGetBufferSize)ippicviResizeGetBufferSize_##TYPE;\ - getSrcOffsetFunc = (ippicviResizeGetSrcOffset) ippicviResizeGetBufferSize_##TYPE; + CHECK_IPP_STATUS(ippiResizeLinearInit_##TYPE(srcSize, dstSize, (IppiResizeSpec_64f*)pSpec));\ + getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ + getSrcOffsetFunc = (ippiResizeGetSrcOffset) ippiResizeGetBufferSize_##TYPE; #define SET_IPP_RESIZE_CUBIC_FUNC_PTR(TYPE, CN) \ - func = (ippicviResizeFunc)ippicviResizeCubic_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ - CHECK_IPP_STATUS(ippicviResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ + func = (ippiResizeFunc)ippiResizeCubic_##TYPE##_##CN##R; CHECK_IPP_FUNC(func);\ + CHECK_IPP_STATUS(ippiResizeGetSize_##TYPE(srcSize, dstSize, (IppiInterpolationType)mode, 0, &specSize, &initSize));\ specBuf.allocate(specSize);\ pSpec = (uchar*)specBuf;\ AutoBuffer buf(initSize);\ uchar* pInit = (uchar*)buf;\ - CHECK_IPP_STATUS(ippicviResizeCubicInit_##TYPE(srcSize, dstSize, 0.f, 0.75f, (IppiResizeSpec_32f*)pSpec, pInit)); + CHECK_IPP_STATUS(ippiResizeCubicInit_##TYPE(srcSize, dstSize, 0.f, 0.75f, (IppiResizeSpec_32f*)pSpec, pInit)); #define SET_IPP_RESIZE_PTR(TYPE, CN) \ if (mode == (int)ippLinear) { SET_IPP_RESIZE_LINEAR_FUNC_PTR(TYPE, CN);}\ else if (mode == (int)ippCubic) { SET_IPP_RESIZE_CUBIC_FUNC_PTR(TYPE, CN);}\ else { *ok = false; return;}\ - getBufferSizeFunc = (ippicviResizeGetBufferSize)ippicviResizeGetBufferSize_##TYPE;\ - getSrcOffsetFunc = (ippicviResizeGetSrcOffset)ippicviResizeGetSrcOffset_##TYPE; + getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ + getSrcOffsetFunc = (ippiResizeGetSrcOffset)ippiResizeGetSrcOffset_##TYPE; #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) class IPPresizeInvoker : @@ -2021,9 +2021,9 @@ private: void *pSpec; AutoBuffer specBuf; int mode; - ippicviResizeFunc func; - ippicviResizeGetBufferSize getBufferSizeFunc; - ippicviResizeGetSrcOffset getSrcOffsetFunc; + ippiResizeFunc func; + ippiResizeGetBufferSize getBufferSizeFunc; + ippiResizeGetSrcOffset getSrcOffsetFunc; bool *ok; const IPPresizeInvoker& operator= (const IPPresizeInvoker&); }; @@ -4051,7 +4051,7 @@ class IPPwarpAffineInvoker : public ParallelLoopBody { public: - IPPwarpAffineInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[2][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippicviWarpAffineBackFunc _func, bool *_ok) : + IPPwarpAffineInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[2][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippiWarpAffineBackFunc _func, bool *_ok) : ParallelLoopBody(), src(_src), dst(_dst), mode(_interpolation), coeffs(_coeffs), borderType(_borderType), borderValue(_borderValue), func(_func), ok(_ok) { *ok = true; @@ -4083,7 +4083,7 @@ private: int mode; int borderType; Scalar borderValue; - ippicviWarpAffineBackFunc func; + ippiWarpAffineBackFunc func; bool *ok; const IPPwarpAffineInvoker& operator= (const IPPwarpAffineInvoker&); }; @@ -4246,16 +4246,16 @@ void cv::warpAffine( InputArray _src, OutputArray _dst, ( borderType == cv::BORDER_TRANSPARENT || ( borderType == cv::BORDER_CONSTANT ) ) ) { int type = src.type(); - ippicviWarpAffineBackFunc ippFunc = - type == CV_8UC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C1R : - type == CV_8UC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C3R : - type == CV_8UC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_8u_C4R : - type == CV_16UC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C1R : - type == CV_16UC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C3R : - type == CV_16UC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_16u_C4R : - type == CV_32FC1 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C1R : - type == CV_32FC3 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C3R : - type == CV_32FC4 ? (ippicviWarpAffineBackFunc)ippicviWarpAffineBack_32f_C4R : + ippiWarpAffineBackFunc ippFunc = + type == CV_8UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C1R : + type == CV_8UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C3R : + type == CV_8UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_8u_C4R : + type == CV_16UC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C1R : + type == CV_16UC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C3R : + type == CV_16UC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_16u_C4R : + type == CV_32FC1 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C1R : + type == CV_32FC3 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C3R : + type == CV_32FC4 ? (ippiWarpAffineBackFunc)ippiWarpAffineBack_32f_C4R : 0; int mode = flags == INTER_LINEAR ? IPPI_INTER_LINEAR : @@ -4394,7 +4394,7 @@ class IPPwarpPerspectiveInvoker : public ParallelLoopBody { public: - IPPwarpPerspectiveInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[3][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippicviWarpPerspectiveBackFunc _func, bool *_ok) : + IPPwarpPerspectiveInvoker(Mat &_src, Mat &_dst, double (&_coeffs)[3][3], int &_interpolation, int &_borderType, const Scalar &_borderValue, ippiWarpPerspectiveBackFunc _func, bool *_ok) : ParallelLoopBody(), src(_src), dst(_dst), mode(_interpolation), coeffs(_coeffs), borderType(_borderType), borderValue(_borderValue), func(_func), ok(_ok) { *ok = true; @@ -4427,7 +4427,7 @@ private: int mode; int borderType; const Scalar borderValue; - ippicviWarpPerspectiveBackFunc func; + ippiWarpPerspectiveBackFunc func; bool *ok; const IPPwarpPerspectiveInvoker& operator= (const IPPwarpPerspectiveInvoker&); }; @@ -4476,16 +4476,16 @@ void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0, ( borderType == cv::BORDER_TRANSPARENT || borderType == cv::BORDER_CONSTANT ) ) { int type = src.type(); - ippicviWarpPerspectiveBackFunc ippFunc = - type == CV_8UC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C1R : - type == CV_8UC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C3R : - type == CV_8UC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_8u_C4R : - type == CV_16UC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C1R : - type == CV_16UC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C3R : - type == CV_16UC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_16u_C4R : - type == CV_32FC1 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C1R : - type == CV_32FC3 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C3R : - type == CV_32FC4 ? (ippicviWarpPerspectiveBackFunc)ippicviWarpPerspectiveBack_32f_C4R : + ippiWarpPerspectiveBackFunc ippFunc = + type == CV_8UC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C1R : + type == CV_8UC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C3R : + type == CV_8UC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_8u_C4R : + type == CV_16UC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C1R : + type == CV_16UC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C3R : + type == CV_16UC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_16u_C4R : + type == CV_32FC1 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C1R : + type == CV_32FC3 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C3R : + type == CV_32FC4 ? (ippiWarpPerspectiveBackFunc)ippiWarpPerspectiveBack_32f_C4R : 0; int mode = flags == INTER_LINEAR ? IPPI_INTER_LINEAR : diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 6030c7e6c8..9303b8d8c3 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1161,53 +1161,53 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne case cvtype: \ {\ int specSize = 0, bufferSize = 0;\ - if (ippStsNoErr != ippicviMorphologyBorderGetSize_##flavor(roiSize.width, kernelSize, &specSize, &bufferSize))\ + if (ippStsNoErr != ippiMorphologyBorderGetSize_##flavor(roiSize.width, kernelSize, &specSize, &bufferSize))\ return false;\ - IppiMorphState *pSpec = (IppiMorphState*)ippicvMalloc(specSize);\ - Ipp8u *pBuffer = (Ipp8u*)ippicvMalloc(bufferSize);\ - if (ippStsNoErr != ippicviMorphologyBorderInit_##flavor(roiSize.width, kernel.data, kernelSize, pSpec, pBuffer))\ + IppiMorphState *pSpec = (IppiMorphState*)ippMalloc(specSize);\ + Ipp8u *pBuffer = (Ipp8u*)ippMalloc(bufferSize);\ + if (ippStsNoErr != ippiMorphologyBorderInit_##flavor(roiSize.width, kernel.data, kernelSize, pSpec, pBuffer))\ {\ - ippicvFree(pBuffer);\ - ippicvFree(pSpec);\ + ippFree(pBuffer);\ + ippFree(pSpec);\ return false;\ }\ bool ok = false;\ if (op == MORPH_ERODE)\ - ok = (ippStsNoErr == ippicviErodeBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + ok = (ippStsNoErr == ippiErodeBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ else\ - ok = (ippStsNoErr == ippicviDilateBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + ok = (ippStsNoErr == ippiDilateBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ - ippicvFree(pBuffer);\ - ippicvFree(pSpec);\ + ippFree(pBuffer);\ + ippFree(pSpec);\ return ok;\ }\ break; #else IppiPoint point = {anchor.x, anchor.y}; // this is case, which can be used with the anchor not in center of the kernel, but - // ippicviMorphologyBorderGetSize_, ippicviErodeBorderReplicate_ and ippicviDilateBorderReplicate_ are deprecate. + // ippiMorphologyBorderGetSize_, ippiErodeBorderReplicate_ and ippiDilateBorderReplicate_ are deprecate. #define IPP_MORPH_CASE(cvtype, flavor, data_type) \ case cvtype: \ {\ int specSize = 0;\ int bufferSize = 0;\ - if (ippStsNoErr != ippicviMorphologyBorderGetSize_##flavor( roiSize.width, kernelSize, &specSize, &bufferSize))\ + if (ippStsNoErr != ippiMorphologyBorderGetSize_##flavor( roiSize.width, kernelSize, &specSize, &bufferSize))\ return false;\ bool ok = false;\ - IppiMorphState* pState = (IppiMorphState*)ippicvMalloc(specSize);;\ - if (ippicviMorphologyInit_##flavor(roiSize.width, kernel.data, kernelSize, point, pState) >= 0)\ + IppiMorphState* pState = (IppiMorphState*)ippMalloc(specSize);;\ + if (ippiMorphologyInit_##flavor(roiSize.width, kernel.data, kernelSize, point, pState) >= 0)\ {\ if (op == MORPH_ERODE)\ - ok = ippicviErodeBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ + ok = ippiErodeBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, pState ) >= 0;\ else\ - ok = ippicviDilateBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ + ok = ippiDilateBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0],\ (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, pState ) >= 0;\ }\ - ippicvFree(pState);\ + ippFree(pState);\ return ok;\ }\ break; @@ -1234,13 +1234,13 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne case cvtype: \ {\ int bufSize = 0;\ - if (ippStsNoErr != ippicviFilterMinGetBufferSize_##flavor(src.cols, kernelSize, &bufSize))\ + if (ippStsNoErr != ippiFilterMinGetBufferSize_##flavor(src.cols, kernelSize, &bufSize))\ return false;\ AutoBuffer buf(bufSize + 64);\ uchar* buffer = alignPtr((uchar*)buf, 32);\ if (op == MORPH_ERODE)\ - return (ippStsNoErr == ippicviFilterMinBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ - return (ippStsNoErr == ippicviFilterMaxBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + return (ippStsNoErr == ippiFilterMinBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + return (ippStsNoErr == ippiFilterMaxBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ }\ break; diff --git a/modules/imgproc/src/samplers.cpp b/modules/imgproc/src/samplers.cpp index 81bbf7656d..d6cc8a56fe 100644 --- a/modules/imgproc/src/samplers.cpp +++ b/modules/imgproc/src/samplers.cpp @@ -375,7 +375,7 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center, Mat patch = _patch.getMat(); #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) - typedef IppStatus (CV_STDCALL *ippicviGetRectSubPixFunc)( const void* src, int src_step, + typedef IppStatus (CV_STDCALL *ippiGetRectSubPixFunc)( const void* src, int src_step, IppiSize src_size, void* dst, int dst_step, IppiSize win_size, IppiPoint_32f center, @@ -385,10 +385,10 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center, IppiPoint_32f icenter = {center.x, center.y}; IppiSize src_size={image.cols, image.rows}, win_size={patch.cols, patch.rows}; int srctype = image.type(); - ippicviGetRectSubPixFunc ippfunc = - srctype == CV_8UC1 && ddepth == CV_8U ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_8u_C1R : - srctype == CV_8UC1 && ddepth == CV_32F ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_8u32f_C1R : - srctype == CV_32FC1 && ddepth == CV_32F ? (ippicviGetRectSubPixFunc)ippicviCopySubpixIntersect_32f_C1R : 0; + ippiGetRectSubPixFunc ippfunc = + srctype == CV_8UC1 && ddepth == CV_8U ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u_C1R : + srctype == CV_8UC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u32f_C1R : + srctype == CV_32FC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_32f_C1R : 0; if( ippfunc && ippfunc(image.data, (int)image.step, src_size, patch.data, (int)patch.step, win_size, icenter, &minpt, &maxpt) >= 0 ) diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 2282290ffe..9de25bdf77 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1115,17 +1115,17 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, Mat src = _src.getMat(), dst = _dst.getMat(); IppiSize roi = { src.cols, src.rows }; int specSize = 0, bufferSize = 0; - if (ippStsNoErr == ippicviFilterGaussianGetBufferSize(roi, (Ipp32u)ksize.width, ipp32f, 1, &specSize, &bufferSize)) + if (ippStsNoErr == ippiFilterGaussianGetBufferSize(roi, (Ipp32u)ksize.width, ipp32f, 1, &specSize, &bufferSize)) { - IppFilterGaussianSpec *pSpec = (IppFilterGaussianSpec*)ippicvMalloc(specSize); - Ipp8u *pBuffer = (Ipp8u*)ippicvMalloc(bufferSize); - if (ippStsNoErr == ippicviFilterGaussianInit(roi, (Ipp32u)ksize.width, (Ipp32f)sigma1, (IppiBorderType)borderType, ipp32f, 1, pSpec, pBuffer)) + IppFilterGaussianSpec *pSpec = (IppFilterGaussianSpec*)ippMalloc(specSize); + Ipp8u *pBuffer = (Ipp8u*)ippMalloc(bufferSize); + if (ippStsNoErr == ippiFilterGaussianInit(roi, (Ipp32u)ksize.width, (Ipp32f)sigma1, (IppiBorderType)borderType, ipp32f, 1, pSpec, pBuffer)) { - IppStatus sts = ippicviFilterGaussianBorder_32f_C1R( (const Ipp32f *)src.data, (int)src.step, + IppStatus sts = ippiFilterGaussianBorder_32f_C1R( (const Ipp32f *)src.data, (int)src.step, (Ipp32f *)dst.data, (int)dst.step, roi, 0.0, pSpec, pBuffer); - ippicvFree(pBuffer); - ippicvFree(pSpec); + ippFree(pBuffer); + ippFree(pSpec); if (ippStsNoErr == sts) return; } @@ -2187,19 +2187,19 @@ public: IppiSize kernel = {d, d}; IppiSize roi={dst.cols, range.end - range.start}; int bufsize=0; - if (ippStsNoErr != ippicviFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize)) + if (ippStsNoErr != ippiFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize)) { *ok = false; return; } AutoBuffer buf(bufsize); IppiFilterBilateralSpec *pSpec = (IppiFilterBilateralSpec *)alignPtr(&buf[0], 32); - if (ippStsNoErr != ippicviFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec )) + if (ippStsNoErr != ippiFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec )) { *ok = false; return; } - if (ippStsNoErr != ippicviFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec )) + if (ippStsNoErr != ippiFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec )) *ok = false; } private: diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index 240bcad680..f7749d4c18 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -44,7 +44,7 @@ #include "opencl_kernels.hpp" #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) -static IppStatus sts = ippicvInit(); +static IppStatus sts = ippInit(); #endif namespace cv @@ -371,22 +371,22 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output { if( _sqsum.needed() ) { - status = ippicviSqrIntegral_8u32f64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); + status = ippiSqrIntegral_8u32f64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); } else { - status = ippicviIntegral_8u32f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, srcRoiSize, 0 ); + status = ippiIntegral_8u32f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32f*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } else if( sdepth == CV_32S ) { if( _sqsum.needed() ) { - status = ippicviSqrIntegral_8u32s64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); + status = ippiSqrIntegral_8u32s64f_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, (Ipp64f*)sqsum.data, (int)sqsum.step, srcRoiSize, 0, 0 ); } else { - status = ippicviIntegral_8u32s_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, srcRoiSize, 0 ); + status = ippiIntegral_8u32s_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } if (ippStsNoErr == status) diff --git a/modules/objdetect/src/haar.cpp b/modules/objdetect/src/haar.cpp index a2dfdd26fd..4b2d2b0d51 100644 --- a/modules/objdetect/src/haar.cpp +++ b/modules/objdetect/src/haar.cpp @@ -165,7 +165,7 @@ icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade ) for( i = 0; i < cascade->count; i++ ) { if( cascade->ipp_stages[i] ) - ippicviHaarClassifierFree_32f( (IppiHaarClassifier_32f*)cascade->ipp_stages[i] ); + ippiHaarClassifierFree_32f( (IppiHaarClassifier_32f*)cascade->ipp_stages[i] ); } } cvFree( &cascade->ipp_stages ); @@ -1318,7 +1318,7 @@ public: if( cascade->hid_cascade->ipp_stages ) { IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height}; - ippicviRectStdDev_32f_C1R(sum1.ptr(y1), (int)sum1.step, + ippiRectStdDev_32f_C1R(sum1.ptr(y1), (int)sum1.step, sqsum1.ptr(y1), (int)sqsum1.step, norm1->ptr(y1), (int)norm1->step, ippiSize(ssz.width, ssz.height), iequRect ); @@ -1340,7 +1340,7 @@ public: for( int j = 0; j < cascade->count; j++ ) { - if( ippicviApplyHaarClassifier_32f_C1R( + if( ippiApplyHaarClassifier_32f_C1R( sum1.ptr(y1), (int)sum1.step, norm1->ptr(y1), (int)norm1->step, mask1->ptr(y1), (int)mask1->step, From 824ed8a3aeed2a354a437d0e66e2d9c0bb319603 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 17:40:46 +0400 Subject: [PATCH 35/52] Fix errors --- modules/imgproc/src/imgwarp.cpp | 33 ------------------------------- modules/imgproc/src/sumpixels.cpp | 2 +- 2 files changed, 1 insertion(+), 34 deletions(-) diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index fdb8302f14..e6cea8fd59 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -1929,7 +1929,6 @@ public: dstSize.width = dst.cols; dstSize.height = dst.rows; -<<<<<<< HEAD switch (type) { case CV_8UC1: SET_IPP_RESIZE_PTR(8u,C1); break; @@ -1981,38 +1980,6 @@ public: if( func( pSrc, (int)src.step[0], pDst, (int)dst.step[0], dstOffset, dstSize, ippBorderRepl, 0, pSpec, bufptr ) < 0 ) *ok = false; } - -======= - ~IPPresizeInvoker() - { - } - - virtual void operator() (const Range& range) const - { - if (*ok == false) return; - - int cn = src.channels(); - int dsty = min(cvRound(range.start * inv_scale_y), dst.rows); - int dstwidth = min(cvRound(src.cols * inv_scale_x), dst.cols); - int dstheight = min(cvRound(range.end * inv_scale_y), dst.rows); - - IppiPoint dstOffset = { 0, dsty }, srcOffset = {0, 0}; - IppiSize dstSize = { dstwidth, dstheight - dsty }; - int bufsize = 0, itemSize = (int)src.elemSize1(); - - CHECK_IPP_STATUS(getBufferSizeFunc(pSpec, dstSize, cn, &bufsize)); - CHECK_IPP_STATUS(getSrcOffsetFunc(pSpec, dstOffset, &srcOffset)); - - Ipp8u* pSrc = (Ipp8u*)src.data + (int)src.step[0] * srcOffset.y + srcOffset.x * cn * itemSize; - Ipp8u* pDst = (Ipp8u*)dst.data + (int)dst.step[0] * dstOffset.y + dstOffset.x * cn * itemSize; - - AutoBuffer buf(bufsize + 64); - uchar* bufptr = alignPtr((uchar*)buf, 32); - - if( func( pSrc, (int)src.step[0], pDst, (int)dst.step[0], dstOffset, dstSize, ippBorderRepl, 0, pSpec, bufptr ) < 0 ) - *ok = false; - } ->>>>>>> Prepare codes for ippicv library private: const Mat & src; Mat & dst; diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index f7749d4c18..649eeb6074 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -362,7 +362,7 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output sqsum = _sqsum.getMat(); }; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) && 0 +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) if( ( depth == CV_8U ) && ( sdepth == CV_32F || sdepth == CV_32S ) && ( !_tilted.needed() ) && ( !_sqsum.needed() || sqdepth == CV_64F ) && ( cn == 1 ) ) { IppStatus status = ippStsErr; From 4512d06484c84e585dce011d17aaac070e9b5061 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Thu, 3 Apr 2014 17:58:54 +0400 Subject: [PATCH 36/52] Fix const src matrix in IPPresizeInvoker --- modules/imgproc/src/imgwarp.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index e6cea8fd59..9e5540a7b5 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -1971,7 +1971,7 @@ public: CHECK_IPP_STATUS(getBufferSizeFunc(pSpec, dstSize, cn, &bufsize)); CHECK_IPP_STATUS(getSrcOffsetFunc(pSpec, dstOffset, &srcOffset)); - Ipp8u* pSrc = (Ipp8u*)src.data + (int)src.step[0] * srcOffset.y + srcOffset.x * cn * itemSize; + const Ipp8u* pSrc = (const Ipp8u*)src.data + (int)src.step[0] * srcOffset.y + srcOffset.x * cn * itemSize; Ipp8u* pDst = (Ipp8u*)dst.data + (int)dst.step[0] * dstOffset.y + dstOffset.x * cn * itemSize; AutoBuffer buf(bufsize + 64); From be29d628d3187151441a72b9326a3bfefba67e1d Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 4 Apr 2014 12:34:45 +0400 Subject: [PATCH 37/52] Check 8.1 ipp version for morphology functions, which not exists in versions before this. --- modules/imgproc/src/morph.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 9303b8d8c3..d8eaa0abe0 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1136,7 +1136,7 @@ private: Scalar borderValue; }; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { @@ -1186,16 +1186,16 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne #else IppiPoint point = {anchor.x, anchor.y}; // this is case, which can be used with the anchor not in center of the kernel, but - // ippiMorphologyBorderGetSize_, ippiErodeBorderReplicate_ and ippiDilateBorderReplicate_ are deprecate. + // ippiMorphologyBorderGetSize_, ippiErodeBorderReplicate_ and ippiDilateBorderReplicate_ are deprecated. #define IPP_MORPH_CASE(cvtype, flavor, data_type) \ case cvtype: \ {\ int specSize = 0;\ int bufferSize = 0;\ - if (ippStsNoErr != ippiMorphologyBorderGetSize_##flavor( roiSize.width, kernelSize, &specSize, &bufferSize))\ + if (ippStsNoErr != ippiMorphologyGetSize_##flavor( roiSize.width, kernel.data kernelSize, &specSize))\ return false;\ bool ok = false;\ - IppiMorphState* pState = (IppiMorphState*)ippMalloc(specSize);;\ + IppiMorphState* pState = (IppiMorphState*)ippMalloc(specSize);\ if (ippiMorphologyInit_##flavor(roiSize.width, kernel.data, kernelSize, point, pState) >= 0)\ {\ if (op == MORPH_ERODE)\ From 06acb8b0ee58b2fa8710a4f73d3ef54e65e7d4a8 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 4 Apr 2014 13:00:18 +0400 Subject: [PATCH 38/52] Check 8.1 ipp version for gaussian functions, which not exists in versions before this. --- modules/imgproc/src/morph.cpp | 2 +- modules/imgproc/src/smooth.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index d8eaa0abe0..7c6d08ca79 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1459,7 +1459,7 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, Size ksize = kernel.data ? kernel.size() : Size(3,3); anchor = normalizeAnchor(anchor, ksize); -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) ) return; #endif diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 9de25bdf77..85978c9b5f 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1109,7 +1109,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, return; #endif -#if defined HAVE_IPP && (IPP_VERSION_MAJOR >= 7) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) if( type == CV_32FC1 && sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 ) { Mat src = _src.getMat(), dst = _dst.getMat(); From 23e1b508379ce84951052cf68c61f210f8cb9d92 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 4 Apr 2014 13:12:37 +0400 Subject: [PATCH 39/52] Check 8.1 ipp version for color convertion functions, which not exists in versions before this. --- modules/imgproc/src/color.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 4c9abe190f..9d203ff5e9 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -298,11 +298,13 @@ static ippiReorderFunc ippiSwapChannelsC3RTab[] = 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MAJOR >= 1) static ippiReorderFunc ippiSwapChannelsC4RTab[] = { (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, 0, (ippiReorderFunc)ippiSwapChannels_32f_C4R, 0, 0 }; +#endif static ippiColor2GrayFunc ippiColor2GrayC3Tab[] = { @@ -3252,11 +3254,13 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MAJOR >= 1) else if( code == CV_RGBA2BGRA ) { if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) return; } +#endif #endif if( depth == CV_8U ) From 566f783968226a95402ab8b1006f763624882d9b Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 4 Apr 2014 13:24:08 +0400 Subject: [PATCH 40/52] Fix errors --- modules/imgproc/src/color.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 9d203ff5e9..30b04c2381 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -298,7 +298,7 @@ static ippiReorderFunc ippiSwapChannelsC3RTab[] = 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MAJOR >= 1) +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) static ippiReorderFunc ippiSwapChannelsC4RTab[] = { (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, @@ -3254,7 +3254,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MAJOR >= 1) +#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) else if( code == CV_RGBA2BGRA ) { if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) From 67484e027b84fe310b41f1777737ec1997b9fb20 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Fri, 4 Apr 2014 14:32:15 +0400 Subject: [PATCH 41/52] Fix function names (log, exp) --- modules/core/src/mathfuncs.cpp | 36 +++++++++++++++++----------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 596c193388..30307aaf37 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -896,7 +896,7 @@ static const double exp_prescale = 1.4426950408889634073599246810019 * (1 << EXP static const double exp_postscale = 1./(1 << EXPTAB_SCALE); static const double exp_max_val = 3000.*(1 << EXPTAB_SCALE); // log10(DBL_MAX) < 3000 -static void Exp_32fnoipp( const float *_x, float *y, int n ) +static void Exp_32f( const float *_x, float *y, int n ) { static const float A4 = (float)(1.000000000000002438532970795181890933776 / EXPPOLY_32F_A0), @@ -1096,7 +1096,7 @@ static void Exp_32fnoipp( const float *_x, float *y, int n ) } -static void Exp_64fnoipp( const double *_x, double *y, int n ) +static void Exp_64f( const double *_x, double *y, int n ) { static const double A5 = .99999999999999999998285227504999 / EXPPOLY_32F_A0, @@ -1274,22 +1274,22 @@ static void Exp_64fnoipp( const double *_x, double *y, int n ) #undef EXPPOLY_32F_A0 #ifdef HAVE_IPP -static void Exp_32f(const float *x, float *y, int n) +static void Exp_32f_ipp(const float *x, float *y, int n) { if (ippStsNoErr == ippsExp_32f_A21(x, y, n)) return; - Exp_32fnoipp(x, y, n); + Exp_32f(x, y, n); } -static void Exp_64f(const double *x, double *y, int n) +static void Exp_64f_ipp(const double *x, double *y, int n) { if (ippStsNoErr == ippsExp_64f_A50(x, y, n)) return; - Exp_64fnoipp(x, y, n); + Exp_64f(x, y, n); } -#else - #define Exp_32f Exp_32fnoipp - #define Exp_64f Exp_64fnoipp + +#define Exp_32f Exp_32f_ipp +#define Exp_64f Exp_64f_ipp #endif @@ -1593,7 +1593,7 @@ static const double CV_DECL_ALIGNED(16) icvLogTab[] = { #define LOGTAB_TRANSLATE(x,h) (((x) - 1.)*icvLogTab[(h)+1]) static const double ln_2 = 0.69314718055994530941723212145818; -static void Log_32fnoipp( const float *_x, float *y, int n ) +static void Log_32f( const float *_x, float *y, int n ) { static const float shift[] = { 0, -1.f/512 }; static const float @@ -1742,7 +1742,7 @@ static void Log_32fnoipp( const float *_x, float *y, int n ) } -static void Log_64fnoipp( const double *x, double *y, int n ) +static void Log_64f( const double *x, double *y, int n ) { static const double shift[] = { 0, -1./512 }; static const double @@ -1932,22 +1932,22 @@ static void Log_64fnoipp( const double *x, double *y, int n ) } #ifdef HAVE_IPP -static void Log_32f(const float *x, float *y, int n) +static void Log_32f_ipp(const float *x, float *y, int n) { if (ippStsNoErr == ippsLn_32f_A21(x, y, n)) return; - Log_32fnoipp(x, y, n); + Log_32f(x, y, n); } -static void Log_64f(const double *x, double *y, int n) +static void Log_64f_ipp(const double *x, double *y, int n) { if (ippStsNoErr == ippsLn_64f_A50(x, y, n)) return; - Log_64fnoipp(x, y, n); + Log_64f(x, y, n); } -#else - #define Log_32f Log_32fnoipp - #define Log_64f Log_64fnoipp + +#define Log_32f Log_32f_ipp +#define Log_64f Log_64f_ipp #endif void log( InputArray _src, OutputArray _dst ) From 38913bf5f6e1e160b9768893fef4e792d0edad47 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 10:51:22 +0400 Subject: [PATCH 42/52] Change all 'ippStsNoErr==' to '0<=', and all 'ippStsNoErr!=' to '0>' --- modules/core/src/mathfuncs.cpp | 8 +++--- modules/imgproc/src/deriv.cpp | 48 +++++++++++++++---------------- modules/imgproc/src/morph.cpp | 16 +++++------ modules/imgproc/src/smooth.cpp | 12 ++++---- modules/imgproc/src/sumpixels.cpp | 2 +- 5 files changed, 43 insertions(+), 43 deletions(-) diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 30307aaf37..12ba4fa5b1 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -1276,14 +1276,14 @@ static void Exp_64f( const double *_x, double *y, int n ) #ifdef HAVE_IPP static void Exp_32f_ipp(const float *x, float *y, int n) { - if (ippStsNoErr == ippsExp_32f_A21(x, y, n)) + if (0 <= ippsExp_32f_A21(x, y, n)) return; Exp_32f(x, y, n); } static void Exp_64f_ipp(const double *x, double *y, int n) { - if (ippStsNoErr == ippsExp_64f_A50(x, y, n)) + if (0 <= ippsExp_64f_A50(x, y, n)) return; Exp_64f(x, y, n); } @@ -1934,14 +1934,14 @@ static void Log_64f( const double *x, double *y, int n ) #ifdef HAVE_IPP static void Log_32f_ipp(const float *x, float *y, int n) { - if (ippStsNoErr == ippsLn_32f_A21(x, y, n)) + if (0 <= ippsLn_32f_A21(x, y, n)) return; Log_32f(x, y, n); } static void Log_64f_ipp(const double *x, double *y, int n) { - if (ippStsNoErr == ippsLn_64f_A50(x, y, n)) + if (0 <= ippsLn_64f_A50(x, y, n)) return; Log_64f(x, y, n); } diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp index 887162ee03..0b19f22be4 100644 --- a/modules/imgproc/src/deriv.cpp +++ b/modules/imgproc/src/deriv.cpp @@ -212,18 +212,18 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippiFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize)) + if (0 > ippiFilterScharrVertGetBufferSize_8u16s_C1R(roi,&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterScharrVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippiFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize)) + if (0 > ippiFilterScharrHorizGetBufferSize_8u16s_C1R(roi,&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterScharrHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, roi, ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } return false; @@ -240,11 +240,11 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippiFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + if (0 > ippiFilterScharrVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterScharrVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -259,11 +259,11 @@ static bool IPPDerivScharr(const Mat& src, Mat& dst, int ddepth, int dx, int dy, } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippiFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) + if (0 > ippiFilterScharrHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterScharrHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) return false; @@ -296,44 +296,44 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterSobelNegVertBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippiFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelHorizGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterSobelHorizBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 2) && (dy == 0)) { - if (ippStsNoErr != ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelVertSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterSobelVertSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } if ((dx == 0) && (dy == 2)) { - if (ippStsNoErr != ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelHorizSecondGetBufferSize_8u16s_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - return (ippStsNoErr == ippiFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, + return (0 <= ippiFilterSobelHorizSecondBorder_8u16s_C1R((const Ipp8u*)src.data, (int)src.step, (Ipp16s*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)); } @@ -343,11 +343,11 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k { if ((dx == 1) && (dy == 0)) { - if (ippStsNoErr != ippiFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize)) + if (0 > ippiFilterSobelNegVertGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), &bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterSobelNegVertBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -360,11 +360,11 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if ((dx == 0) && (dy == 1)) { - if (ippStsNoErr != ippiFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelHorizGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterSobelHorizBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -377,11 +377,11 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if((dx == 2) && (dy == 0)) { - if (ippStsNoErr != ippiFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelVertSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterSobelVertSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { @@ -394,11 +394,11 @@ static bool IPPDeriv(const Mat& src, Mat& dst, int ddepth, int dx, int dy, int k if((dx == 0) && (dy == 2)) { - if (ippStsNoErr != ippiFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) + if (0 > ippiFilterSobelHorizSecondGetBufferSize_32f_C1R(ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize),&bufSize)) return false; buffer.allocate(bufSize); - if (ippStsNoErr != ippiFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, + if (0 > ippiFilterSobelHorizSecondBorder_32f_C1R((const Ipp32f*)src.data, (int)src.step, (Ipp32f*)dst.data, (int)dst.step, ippiSize(src.cols, src.rows), (IppiMaskSize)(ksize*10+ksize), ippBorderRepl, 0, (Ipp8u*)(char*)buffer)) { diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 7c6d08ca79..b3433549d0 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1161,11 +1161,11 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne case cvtype: \ {\ int specSize = 0, bufferSize = 0;\ - if (ippStsNoErr != ippiMorphologyBorderGetSize_##flavor(roiSize.width, kernelSize, &specSize, &bufferSize))\ + if (0 > ippiMorphologyBorderGetSize_##flavor(roiSize.width, kernelSize, &specSize, &bufferSize))\ return false;\ IppiMorphState *pSpec = (IppiMorphState*)ippMalloc(specSize);\ Ipp8u *pBuffer = (Ipp8u*)ippMalloc(bufferSize);\ - if (ippStsNoErr != ippiMorphologyBorderInit_##flavor(roiSize.width, kernel.data, kernelSize, pSpec, pBuffer))\ + if (0 > ippiMorphologyBorderInit_##flavor(roiSize.width, kernel.data, kernelSize, pSpec, pBuffer))\ {\ ippFree(pBuffer);\ ippFree(pSpec);\ @@ -1173,10 +1173,10 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne }\ bool ok = false;\ if (op == MORPH_ERODE)\ - ok = (ippStsNoErr == ippiErodeBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + ok = (0 <= ippiErodeBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ else\ - ok = (ippStsNoErr == ippiDilateBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ + ok = (0 <= ippiDilateBorder_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0],\ roiSize, ippBorderRepl, 0, pSpec, pBuffer));\ ippFree(pBuffer);\ ippFree(pSpec);\ @@ -1192,7 +1192,7 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne {\ int specSize = 0;\ int bufferSize = 0;\ - if (ippStsNoErr != ippiMorphologyGetSize_##flavor( roiSize.width, kernel.data kernelSize, &specSize))\ + if (0 > ippiMorphologyGetSize_##flavor( roiSize.width, kernel.data kernelSize, &specSize))\ return false;\ bool ok = false;\ IppiMorphState* pState = (IppiMorphState*)ippMalloc(specSize);\ @@ -1234,13 +1234,13 @@ static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kerne case cvtype: \ {\ int bufSize = 0;\ - if (ippStsNoErr != ippiFilterMinGetBufferSize_##flavor(src.cols, kernelSize, &bufSize))\ + if (0 > ippiFilterMinGetBufferSize_##flavor(src.cols, kernelSize, &bufSize))\ return false;\ AutoBuffer buf(bufSize + 64);\ uchar* buffer = alignPtr((uchar*)buf, 32);\ if (op == MORPH_ERODE)\ - return (ippStsNoErr == ippiFilterMinBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ - return (ippStsNoErr == ippiFilterMaxBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + return (0 <= ippiFilterMinBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ + return (0 <= ippiFilterMaxBorderReplicate_##flavor((Ipp##data_type *)_src->data, (int)_src->step[0], (Ipp##data_type *)dst.data, (int)dst.step[0], roiSize, kernelSize, point, buffer));\ }\ break; diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 85978c9b5f..7499e24687 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1115,18 +1115,18 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, Mat src = _src.getMat(), dst = _dst.getMat(); IppiSize roi = { src.cols, src.rows }; int specSize = 0, bufferSize = 0; - if (ippStsNoErr == ippiFilterGaussianGetBufferSize(roi, (Ipp32u)ksize.width, ipp32f, 1, &specSize, &bufferSize)) + if (0 <= ippiFilterGaussianGetBufferSize(roi, (Ipp32u)ksize.width, ipp32f, 1, &specSize, &bufferSize)) { IppFilterGaussianSpec *pSpec = (IppFilterGaussianSpec*)ippMalloc(specSize); Ipp8u *pBuffer = (Ipp8u*)ippMalloc(bufferSize); - if (ippStsNoErr == ippiFilterGaussianInit(roi, (Ipp32u)ksize.width, (Ipp32f)sigma1, (IppiBorderType)borderType, ipp32f, 1, pSpec, pBuffer)) + if (0 <= ippiFilterGaussianInit(roi, (Ipp32u)ksize.width, (Ipp32f)sigma1, (IppiBorderType)borderType, ipp32f, 1, pSpec, pBuffer)) { IppStatus sts = ippiFilterGaussianBorder_32f_C1R( (const Ipp32f *)src.data, (int)src.step, (Ipp32f *)dst.data, (int)dst.step, roi, 0.0, pSpec, pBuffer); ippFree(pBuffer); ippFree(pSpec); - if (ippStsNoErr == sts) + if (0 <= sts) return; } } @@ -2187,19 +2187,19 @@ public: IppiSize kernel = {d, d}; IppiSize roi={dst.cols, range.end - range.start}; int bufsize=0; - if (ippStsNoErr != ippiFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize)) + if (0 > ippiFilterBilateralGetBufSize_8u_C1R( ippiFilterBilateralGauss, roi, kernel, &bufsize)) { *ok = false; return; } AutoBuffer buf(bufsize); IppiFilterBilateralSpec *pSpec = (IppiFilterBilateralSpec *)alignPtr(&buf[0], 32); - if (ippStsNoErr != ippiFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec )) + if (0 > ippiFilterBilateralInit_8u_C1R( ippiFilterBilateralGauss, kernel, (Ipp32f)sigma_color, (Ipp32f)sigma_space, 1, pSpec )) { *ok = false; return; } - if (ippStsNoErr != ippiFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec )) + if (0 > ippiFilterBilateral_8u_C1R( src.ptr(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr(range.start), (int)dst.step[0], roi, kernel, pSpec )) *ok = false; } private: diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp index 649eeb6074..c32813fabd 100644 --- a/modules/imgproc/src/sumpixels.cpp +++ b/modules/imgproc/src/sumpixels.cpp @@ -389,7 +389,7 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output status = ippiIntegral_8u32s_C1R( (const Ipp8u*)src.data, (int)src.step, (Ipp32s*)sum.data, (int)sum.step, srcRoiSize, 0 ); } } - if (ippStsNoErr == status) + if (0 <= status) return; } #endif From dbdc476b797a86897d09c72dffe74ecf81bead6c Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 14:17:22 +0400 Subject: [PATCH 43/52] Check results of ipp function --- modules/core/src/matmul.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp index b3004707e6..8891bb05f8 100644 --- a/modules/core/src/matmul.cpp +++ b/modules/core/src/matmul.cpp @@ -2799,11 +2799,11 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len) { double r = 0; #if ARITHM_USE_IPP - ippiDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), - src2, (int)(len*sizeof(src2[0])), - ippiSize(len, 1), &r); - return r; -#else + if (0 <= ippiDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])), + src2, (int)(len*sizeof(src2[0])), + ippiSize(len, 1), &r)) + return r; +#endif int i = 0; #if CV_SSE2 @@ -2849,7 +2849,6 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len) } #endif return r + dotProd_(src1, src2, len - i); -#endif } From e8f79d6e1fd7698600882dadf57fb6cce442d299 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 14:43:09 +0400 Subject: [PATCH 44/52] Fix rebase errors --- CMakeLists.txt | 7 +- cmake/OpenCVFindIPP.cmake | 397 +------------------------------------- 2 files changed, 5 insertions(+), 399 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e7ceb6281e..166d8b6d71 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -# ---------------------------------------------------------------------------- +# ---------------------------------------------------------------------------- # Root CMake file for OpenCV # # From the off-tree build directory, invoke: @@ -917,14 +917,9 @@ endif(DEFINED WITH_INTELPERC) status("") status(" Other third-party libraries:") -<<<<<<< HEAD if((WITH_IPP OR WITH_ICV) AND HAVE_IPP) status(" Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]") status(" at:" "${IPP_ROOT_DIR}") -======= -if(WITH_IPP AND IPP_FOUND) - status(" Use IPP:" "${IPP_VERSION_STR} [${IPP_VERSION_MAJOR}.${IPP_VERSION_MINOR}.${IPP_VERSION_BUILD}]") ->>>>>>> Prepare codes for ippicv library else() status(" Use IPP:" (WITH_IPP OR WITH_ICV) AND NOT HAVE_IPP THEN "IPP not found" ELSE NO) endif() diff --git a/cmake/OpenCVFindIPP.cmake b/cmake/OpenCVFindIPP.cmake index d42a371a3f..780ee51b87 100644 --- a/cmake/OpenCVFindIPP.cmake +++ b/cmake/OpenCVFindIPP.cmake @@ -2,7 +2,6 @@ # The script to detect Intel(R) Integrated Performance Primitives (IPP) # installation/package # -<<<<<<< HEAD # Windows host: # Run script like this before cmake: # call "\bin\ippvars.bat" intel64 @@ -20,11 +19,10 @@ # IPP_ROOT_DIR - root of IPP installation # IPP_INCLUDE_DIRS - IPP include folder # IPP_LIBRARIES - IPP libraries that are used by OpenCV -# IPP_FOUND - True if Intel IPP found -# IPP_ROOT_DIR - root of IPP installation -# IPP_INCLUDE_DIRS - IPP include folder -# IPP_LIBRARY_DIRS - IPP libraries folder -# IPP_LIBRARIES - IPP libraries names that are used by OpenCV +# IPP_VERSION_STR - string with the newest detected IPP version +# IPP_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) +# IPP_VERSION_MINOR +# IPP_VERSION_BUILD # # Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) # @@ -224,304 +222,9 @@ if(IPP_H_PATH) ipp_get_version(${IPP_ROOT_DIR}) ipp_set_variables(${IPP_VERSION_STR}) -======= -======= -# IPP_LATEST_VERSION_STR - string with the newest detected IPP version -# IPP_LATEST_VERSION_MAJOR - numbers of IPP version (MAJOR.MINOR.BUILD) -# IPP_LATEST_VERSION_MINOR -# IPP_LATEST_VERSION_BUILD -# -# Created: 30 Dec 2010 by Vladimir Dudnik (vladimir.dudnik@intel.com) -# ->>>>>>> Undo changes ipp to ippicv prefix of function names - -set(IPP_FOUND) -set(IPP_VERSION_STR "5.3.0.0") # will not detect earlier versions -set(IPP_VERSION_MAJOR 0) -set(IPP_VERSION_MINOR 0) -set(IPP_VERSION_BUILD 0) -set(IPP_ROOT_DIR) -set(IPP_INCLUDE_DIRS) -set(IPP_LIBRARY_DIRS) -set(IPP_LIBRARIES) -set(IPP_LIB_PREFIX ${CMAKE_STATIC_LIBRARY_PREFIX}) -set(IPP_LIB_SUFFIX ${CMAKE_STATIC_LIBRARY_SUFFIX}) -set(IPP_PREFIX "ipp") -set(IPP_SUFFIX "_l") -set(IPPCORE "core") # core functionality -set(IPPS "s") # signal processing -set(IPPI "i") # image processing -set(IPPCC "cc") # color conversion -set(IPPCV "cv") # computer vision -set(IPPVM "vm") # vector math - - -set(IPP_X64 0) -if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8) - set(IPP_X64 1) -endif() -if (CMAKE_CL_64) - set(IPP_X64 1) -endif() - -# ------------------------------------------------------------------------ -# This function detect IPP version by analyzing ippversion.h file -# Note, ippversion.h file was inroduced since IPP 5.3 -# ------------------------------------------------------------------------ -function(get_ipp_version _ROOT_DIR) - set(_VERSION_STR) - set(_MAJOR) - set(_MINOR) - set(_BUILD) - - # read IPP version info from file - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") - if("${STR3}" STREQUAL "") - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") - endif() - file(STRINGS ${_ROOT_DIR}/include/ippversion.h STR4 REGEX "IPP_VERSION_STR") - - # extract info and assign to variables - string(REGEX MATCHALL "[0-9]+" _MAJOR ${STR1}) - string(REGEX MATCHALL "[0-9]+" _MINOR ${STR2}) - string(REGEX MATCHALL "[0-9]+" _BUILD ${STR3}) - string(REGEX MATCHALL "[0-9]+[.]+[0-9]+[^\"]+|[0-9]+[.]+[0-9]+" _VERSION_STR ${STR4}) - - # export info to parent scope - set(IPP_VERSION_STR ${_VERSION_STR} PARENT_SCOPE) - set(IPP_VERSION_MAJOR ${_MAJOR} PARENT_SCOPE) - set(IPP_VERSION_MINOR ${_MINOR} PARENT_SCOPE) - set(IPP_VERSION_BUILD ${_BUILD} PARENT_SCOPE) - - message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") - message(STATUS "at: ${_ROOT_DIR}") - - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This is auxiliary function called from set_ipp_variables() -# to set IPP_LIBRARIES variable in IPP 6.x style (IPP 5.3 should also work) -# ------------------------------------------------------------------------ -function(set_ipp_old_libraries) - set(IPP_PREFIX "ipp") - set(IPP_SUFFIX) # old style static core libs suffix - set(IPP_ARCH) # architecture suffix - set(IPP_DISP "emerged") # old style dipatcher and cpu-specific - set(IPP_MRGD "merged") # static libraries - set(IPPCORE "core") # core functionality - set(IPPSP "s") # signal processing - set(IPPIP "i") # image processing - set(IPPCC "cc") # color conversion - set(IPPCV "cv") # computer vision - set(IPPVM "vm") # vector math - - if (IPP_X64) - set(IPP_ARCH "em64t") - endif() - - if(WIN32) - set(IPP_SUFFIX "l") - endif() - - set(IPP_LIBRARIES - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPIP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_MRGD}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPSP}${IPP_DISP}${IPP_ARCH}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_ARCH}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - PARENT_SCOPE) - - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This is auxiliary function called from set_ipp_variables() -# to set IPP_LIBRARIES variable in IPP 7.x and 8.x style -# ------------------------------------------------------------------------ -function(set_ipp_new_libraries _LATEST_VERSION) - set(IPP_PREFIX "ipp") - - if(${_LATEST_VERSION} VERSION_LESS "8.0") - set(IPP_SUFFIX "_l") # static not threaded libs suffix IPP 7.x - else() - if(WIN32) - set(IPP_SUFFIX "mt") # static not threaded libs suffix IPP 8.x for Windows - else() - set(IPP_SUFFIX "") # static not threaded libs suffix IPP 8.x for Linux/OS X - endif() - endif() - set(IPPCORE "core") # core functionality - set(IPPSP "s") # signal processing - set(IPPIP "i") # image processing - set(IPPCC "cc") # color conversion - set(IPPCV "cv") # computer vision - set(IPPVM "vm") # vector math - - set(IPP_LIBRARIES - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPVM}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCC}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCV}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPI}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPS}${IPP_SUFFIX}${IPP_LIB_SUFFIX} - ${IPP_LIB_PREFIX}${IPP_PREFIX}${IPPCORE}${IPP_SUFFIX}${IPP_LIB_SUFFIX}) - - if (UNIX) - set(IPP_LIBRARIES - ${IPP_LIBRARIES} - ${IPP_LIB_PREFIX}irc${CMAKE_SHARED_LIBRARY_SUFFIX} - ${IPP_LIB_PREFIX}imf${CMAKE_SHARED_LIBRARY_SUFFIX} - ${IPP_LIB_PREFIX}svml${CMAKE_SHARED_LIBRARY_SUFFIX}) - endif() - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This function will set -# IPP_INCLUDE_DIRS, IPP_LIBRARY_DIRS and IPP_LIBRARIES variables depending -# on IPP version parameter. -# Since IPP 7.0 version library names and install folder structure -# was changed -# ------------------------------------------------------------------------ -function(set_ipp_variables _LATEST_VERSION) - if(${_LATEST_VERSION} VERSION_LESS "7.0") -# message(STATUS "old") - - # set INCLUDE and LIB folders - set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib PARENT_SCOPE) - - if (IPP_X64) - if(NOT EXISTS ${IPP_ROOT_DIR}/../em64t) - message(SEND_ERROR "IPP EM64T libraries not found") - endif() - else() - if(NOT EXISTS ${IPP_ROOT_DIR}/../ia32) - message(SEND_ERROR "IPP IA32 libraries not found") - endif() - endif() - -<<<<<<< HEAD -# read IPP version info from file -set(_VERSION_STR) -set(_MAJOR) -set(_MINOR) -set(_BUILD) -file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR1 REGEX "IPP_VERSION_MAJOR") -file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR2 REGEX "IPP_VERSION_MINOR") -file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_BUILD") -if("${STR3}" STREQUAL "") - file(STRINGS ${IPP_INCLUDE_DIR}/ippversion.h STR3 REGEX "IPP_VERSION_UPDATE") ->>>>>>> Prepare codes for ippicv library -======= - # set IPP_LIBRARIES variable (6.x lib names) - set_ipp_old_libraries() - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - message(STATUS "IPP libs: ${IPP_LIBRARIES}") - - else() -# message(STATUS "new") - - # set INCLUDE and LIB folders - set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE) - - if (APPLE) - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib) - elseif (IPP_X64) - if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64) - message(SEND_ERROR "IPP EM64T libraries not found") - endif() - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/intel64) - else() - if(NOT EXISTS ${IPP_ROOT_DIR}/lib/ia32) - message(SEND_ERROR "IPP IA32 libraries not found") - endif() - set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib/ia32) - endif() - - if (UNIX) - get_filename_component(INTEL_COMPILER_LIBRARY_DIR ${IPP_ROOT_DIR}/../lib REALPATH) - if (IPP_X64) - if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/intel64) - message(SEND_ERROR "Intel compiler EM64T libraries not found") - endif() - set(IPP_LIBRARY_DIRS - ${IPP_LIBRARY_DIRS} - ${INTEL_COMPILER_LIBRARY_DIR}/intel64) - else() - if(NOT EXISTS ${INTEL_COMPILER_LIBRARY_DIR}/ia32) - message(SEND_ERROR "Intel compiler IA32 libraries not found") - endif() - set(IPP_LIBRARY_DIRS - ${IPP_LIBRARY_DIRS} - ${INTEL_COMPILER_LIBRARY_DIR}/ia32) - endif() - endif() - set(IPP_LIBRARY_DIRS ${IPP_LIBRARY_DIRS} PARENT_SCOPE) - - # set IPP_LIBRARIES variable (7.x or 8.x lib names) - set_ipp_new_libraries(${_LATEST_VERSION}) - set(IPP_LIBRARIES ${IPP_LIBRARIES} PARENT_SCOPE) - message(STATUS "IPP libs: ${IPP_LIBRARIES}") - - endif() - - return() - -endfunction() - - -# ------------------------------------------------------------------------ -# This section will look for IPP through IPPROOT env variable -# Note, IPPROOT is not set by IPP installer, you may need to set it manually -# ------------------------------------------------------------------------ -find_path( - IPP_H_PATH - NAMES ippversion.h - PATHS $ENV{IPPROOT} - PATH_SUFFIXES include - DOC "The path to Intel(R) IPP header files" - NO_DEFAULT_PATH - NO_CMAKE_PATH) - -if(IPP_H_PATH) - set(IPP_FOUND 1) - - # traverse up to IPPROOT level - get_filename_component(IPP_ROOT_DIR ${IPP_H_PATH} PATH) - - # extract IPP version info - get_ipp_version(${IPP_ROOT_DIR}) - - # keep info in the same vars for auto search and search by IPPROOT - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) - set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) - set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) - - # set IPP INCLUDE, LIB dirs and library names - set_ipp_variables(${IPP_LATEST_VERSION_STR}) ->>>>>>> Undo changes ipp to ippicv prefix of function names endif() -<<<<<<< HEAD -<<<<<<< HEAD if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) # Since IPP built with Microsoft compiler and /GS option # ====================================================== @@ -539,95 +242,3 @@ if(WIN32 AND MINGW AND NOT IPP_VERSION_MAJOR LESS 7) set(MSV_NTDLL "ntdll") set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_NTDLL}${IPP_LIB_SUFFIX}) endif() -======= -# export info to parent scope -set(IPP_VERSION_STR ${_VERSION_STR}) -set(IPP_VERSION_MAJOR ${_MAJOR}) -set(IPP_VERSION_MINOR ${_MINOR}) -set(IPP_VERSION_BUILD ${_BUILD}) - -message(STATUS "found IPP: ${_MAJOR}.${_MINOR}.${_BUILD} [${_VERSION_STR}]") ->>>>>>> Prepare codes for ippicv library -======= -if(NOT IPP_FOUND) - # reset var from previous search - set(IPP_H_PATH) - - - # ------------------------------------------------------------------------ - # This section will look for IPP through system program folders - # Note, if several IPP installations found the newest version will be - # selected - # ------------------------------------------------------------------------ - foreach(curdir ${CMAKE_SYSTEM_PREFIX_PATH}) - set(curdir ${curdir}/intel) - file(TO_CMAKE_PATH ${curdir} CURDIR) - - if(EXISTS ${curdir}) - file(GLOB_RECURSE IPP_H_DIR ${curdir}/ippversion.h) - - if(IPP_H_DIR) - set(IPP_FOUND 1) - endif() - - # init IPP_LATEST_VERSION version with oldest detectable version (5.3.0.0) - # IPP prior 5.3 did not have ippversion.h file - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - - # look through all dirs where ippversion.h was found - foreach(item ${IPP_H_DIR}) - - # traverse up to IPPROOT level - get_filename_component(_FILE_PATH ${item} PATH) - get_filename_component(_ROOT_DIR ${_FILE_PATH} PATH) - - # extract IPP version info - get_ipp_version(${_ROOT_DIR}) - - # remember the latest version (if many found) - if(${IPP_LATEST_VERSION_STR} VERSION_LESS ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_STR ${IPP_VERSION_STR}) - set(IPP_LATEST_VERSION_MAJOR ${IPP_VERSION_MAJOR}) - set(IPP_LATEST_VERSION_MINOR ${IPP_VERSION_MINOR}) - set(IPP_LATEST_VERSION_BUILD ${IPP_VERSION_BUILD}) - set(IPP_ROOT_DIR ${_ROOT_DIR}) - endif() - endforeach() - endif() - endforeach() -endif() - -if(IPP_FOUND) - # set IPP INCLUDE, LIB dirs and library names - set_ipp_variables(${IPP_LATEST_VERSION_STR}) - - # set CACHE variable IPP_H_PATH, - # path to IPP header files for the latest version - find_path( - IPP_H_PATH - NAMES ippversion.h - PATHS ${IPP_ROOT_DIR} - PATH_SUFFIXES include - DOC "The path to Intel(R) IPP header files" - NO_DEFAULT_PATH - NO_CMAKE_PATH) -endif() - -if(WIN32 AND MINGW AND NOT IPP_LATEST_VERSION_MAJOR LESS 7) - # Since IPP built with Microsoft compiler and /GS option - # ====================================================== - # From Windows SDK 7.1 - # (usually in "C:\Program Files\Microsoft Visual Studio 10.0\VC\lib"), - # to avoid undefined reference to __security_cookie and _chkstk: - set(MSV_RUNTMCHK "RunTmChk") - set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_RUNTMCHK}${IPP_LIB_SUFFIX}) - - # To avoid undefined reference to _alldiv and _chkstk - # =================================================== - # NB: it may require a recompilation of w32api (after having modified - # the file ntdll.def) to export the required functions - # See http://code.opencv.org/issues/1906 for additional details - set(MSV_NTDLL "ntdll") - set(IPP_LIBRARIES ${IPP_LIBRARIES} ${MSV_NTDLL}${IPP_LIB_SUFFIX}) -endif() ->>>>>>> Undo changes ipp to ippicv prefix of function names From 268c0caa7aa3256460a13f1a70c949dea9b16404 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 14:53:30 +0400 Subject: [PATCH 45/52] Fix problems in CMakeLists.txt --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 166d8b6d71..20522e0496 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -# ---------------------------------------------------------------------------- +# ---------------------------------------------------------------------------- # Root CMake file for OpenCV # # From the off-tree build directory, invoke: From 2d545819711f87204a057465966d85b6e5c9d291 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 16:45:35 +0400 Subject: [PATCH 46/52] Fix ifdef for IPP version greater 8.1 --- modules/core/src/stat.cpp | 7 ++++--- modules/imgproc/src/color.cpp | 4 ++-- modules/imgproc/src/morph.cpp | 4 ++-- modules/imgproc/src/smooth.cpp | 2 +- 4 files changed, 9 insertions(+), 8 deletions(-) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index b7e5d34224..8015c3c583 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -43,6 +43,7 @@ #include "precomp.hpp" #include "opencl_kernels.hpp" #include +#include namespace cv { @@ -971,7 +972,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input ippiMeanStdDevFuncC1 ippFuncC1 = type == CV_8UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_8u_C1R : type == CV_16UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_16u_C1R : -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) type == CV_32FC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 #endif 0; @@ -2112,7 +2113,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R : -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif @@ -2544,7 +2545,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R : -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 30b04c2381..3a0972b04a 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -298,7 +298,7 @@ static ippiReorderFunc ippiSwapChannelsC3RTab[] = 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) static ippiReorderFunc ippiSwapChannelsC4RTab[] = { (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, @@ -3254,7 +3254,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } -#if (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) else if( code == CV_RGBA2BGRA ) { if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index b3433549d0..df055c83b2 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1136,7 +1136,7 @@ private: Scalar borderValue; }; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { @@ -1459,7 +1459,7 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, Size ksize = kernel.data ? kernel.size() : Size(3,3); anchor = normalizeAnchor(anchor, ksize); -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) ) return; #endif diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 7499e24687..65d2dce4f7 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1109,7 +1109,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, return; #endif -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1) +#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) if( type == CV_32FC1 && sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 ) { Mat src = _src.getMat(), dst = _dst.getMat(); From 7badc85b60e7d1c655f4cfc99d4a3955009f40e0 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Mon, 7 Apr 2014 17:06:02 +0400 Subject: [PATCH 47/52] Fix for pullrequest comment --- modules/core/src/stat.cpp | 6 +++--- modules/imgproc/src/color.cpp | 4 ++-- modules/imgproc/src/morph.cpp | 4 ++-- modules/imgproc/src/smooth.cpp | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 8015c3c583..01211f0d80 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -972,7 +972,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input ippiMeanStdDevFuncC1 ippFuncC1 = type == CV_8UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_8u_C1R : type == CV_16UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_16u_C1R : -#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) +#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) type == CV_32FC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 #endif 0; @@ -2113,7 +2113,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R : -#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) +#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif @@ -2545,7 +2545,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R : -#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) +#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 3a0972b04a..95f4eb4459 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -298,7 +298,7 @@ static ippiReorderFunc ippiSwapChannelsC3RTab[] = 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; -#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) +#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) static ippiReorderFunc ippiSwapChannelsC4RTab[] = { (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, @@ -3254,7 +3254,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } -#if ((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8) +#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) else if( code == CV_RGBA2BGRA ) { if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index df055c83b2..1fd93f862d 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1136,7 +1136,7 @@ private: Scalar borderValue; }; -#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { @@ -1459,7 +1459,7 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, Size ksize = kernel.data ? kernel.size() : Size(3,3); anchor = normalizeAnchor(anchor, ksize); -#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) ) return; #endif diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 65d2dce4f7..629d668258 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1109,7 +1109,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, return; #endif -#if defined (HAVE_IPP) && (((IPP_VERSION_MAJOR >= 8) && (IPP_VERSION_MINOR >= 1)) || (IPP_VERSION_MAJOR > 8)) +#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) if( type == CV_32FC1 && sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 ) { Mat src = _src.getMat(), dst = _dst.getMat(); From 616ec74beb74a7f26df87f51e3c8c3f798da7bb8 Mon Sep 17 00:00:00 2001 From: krodyush Date: Mon, 7 Apr 2014 17:32:39 +0400 Subject: [PATCH 48/52] fix previous merge error --- modules/video/src/opencl/pyrlk.cl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/video/src/opencl/pyrlk.cl b/modules/video/src/opencl/pyrlk.cl index 1e27c8af56..cf401057d4 100644 --- a/modules/video/src/opencl/pyrlk.cl +++ b/modules/video/src/opencl/pyrlk.cl @@ -297,7 +297,7 @@ void ReadPatchIToLocalMem(image2d_t I, float2 Point, local float IPatchLocal[LSy __attribute__((reqd_work_group_size(LSx, LSy, 1))) __kernel void lkSparse(image2d_t I, image2d_t J, - __global const float2* prevPts, int prevPtsStep, __global float2* nextPts, int nextPtsStep, __global uchar* status, __global float* err, + __global const float2* prevPts, __global float2* nextPts, __global uchar* status, __global float* err, const int level, const int rows, const int cols, int PATCH_X, int PATCH_Y, int c_winSize_x, int c_winSize_y, int c_iters, char calcErr) { __local float smem1[BUFFER]; From f9c52894833cb4da02bb6f245409c3e20b4a67fd Mon Sep 17 00:00:00 2001 From: Elena Gvozdeva Date: Fri, 4 Apr 2014 12:08:22 +0400 Subject: [PATCH 49/52] fixed --- modules/core/test/test_ippasync.cpp | 4 ++-- samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp | 5 ++--- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/modules/core/test/test_ippasync.cpp b/modules/core/test/test_ippasync.cpp index 2d30e7aa57..bd37ffa63b 100644 --- a/modules/core/test/test_ippasync.cpp +++ b/modules/core/test/test_ippasync.cpp @@ -49,7 +49,7 @@ PARAM_TEST_CASE(IPPAsync, MatDepth, Channels, hppAccelType) TEST_P(IPPAsync, accuracy) { sts = hppCreateInstance(accelType, 0, &accel); - if (sts!=HPP_STATUS_NO_ERROR) printf("hppStatus= %d\n",sts); + if (sts!=HPP_STATUS_NO_ERROR) printf("hppStatus = %d\n",sts); CV_Assert(sts==HPP_STATUS_NO_ERROR); virtMatrix = hppiCreateVirtualMatrices(accel, 2); @@ -133,7 +133,7 @@ PARAM_TEST_CASE(IPPAsyncShared, Channels, hppAccelType) TEST_P(IPPAsyncShared, accuracy) { sts = hppCreateInstance(accelType, 0, &accel); - if (sts!=HPP_STATUS_NO_ERROR) printf("hppStatus= %d\n",sts); + if (sts!=HPP_STATUS_NO_ERROR) printf("hppStatus = %d\n",sts); CV_Assert(sts==HPP_STATUS_NO_ERROR); virtMatrix = hppiCreateVirtualMatrices(accel, 2); diff --git a/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp index 3c5e8d3029..0cfc5e6932 100644 --- a/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp +++ b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp @@ -37,7 +37,7 @@ const char* keys = { "{c camera | | use camera or not}" "{fn file_name|baboon.jpg | image file }" - "{a accel |cpu | accelerator type: auto (default), cpu, gpu}" + "{a accel |auto | accelerator type: auto (default), cpu, gpu}" }; //this is a sample for hppiSobel functions @@ -92,8 +92,7 @@ int main(int argc, const char** argv) sAccel = accelType == HPP_ACCEL_TYPE_CPU ? "cpu": accelType == HPP_ACCEL_TYPE_GPU ? "gpu": - accelType == HPP_ACCEL_TYPE_GPU_VIA_DX9 ? "gpu": - accelType == HPP_ACCEL_TYPE_OCL ? "ocl": "?"; + accelType == HPP_ACCEL_TYPE_GPU_VIA_DX9 ? "gpu dx9": "?"; printf("accelType %s\n", sAccel.c_str()); From f23134ce01cb9c38e9ac13f3d5c0afcbc1502bc2 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Tue, 8 Apr 2014 12:43:57 +0400 Subject: [PATCH 50/52] Add IPP_VERSION_X100 define --- modules/core/include/opencv2/core/private.hpp | 3 +++ modules/core/src/dxt.cpp | 2 +- modules/core/src/stat.cpp | 6 +++--- modules/imgproc/src/color.cpp | 4 ++-- modules/imgproc/src/filter.cpp | 2 +- modules/imgproc/src/imgwarp.cpp | 6 +++--- modules/imgproc/src/morph.cpp | 4 ++-- modules/imgproc/src/smooth.cpp | 2 +- 8 files changed, 16 insertions(+), 13 deletions(-) diff --git a/modules/core/include/opencv2/core/private.hpp b/modules/core/include/opencv2/core/private.hpp index 561499219f..45351d1a86 100644 --- a/modules/core/include/opencv2/core/private.hpp +++ b/modules/core/include/opencv2/core/private.hpp @@ -216,12 +216,15 @@ CV_EXPORTS void scalarToRawData(const cv::Scalar& s, void* buf, int type, int un # else # include "ipp.h" # endif +# define IPP_VERSION_X100 (IPP_VERSION_MAJOR * 100 + IPP_VERSION_MINOR) static inline IppiSize ippiSize(int width, int height) { IppiSize size = { width, height }; return size; } +#else +# define IPP_VERSION_X100 0 #endif #ifndef IPPI_CALL diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 4cdb6a16d2..0f2cbd98b2 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -53,7 +53,7 @@ namespace cv # pragma warning(disable: 4748) #endif -#if defined HAVE_IPP && IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701 +#if defined HAVE_IPP && IPP_VERSION_X100 >= 701 #define USE_IPP_DFT 1 #else #undef USE_IPP_DFT diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 01211f0d80..adc24119ec 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -972,7 +972,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input ippiMeanStdDevFuncC1 ippFuncC1 = type == CV_8UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_8u_C1R : type == CV_16UC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_16u_C1R : -#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if (IPP_VERSION_X100 >= 801) type == CV_32FC1 ? (ippiMeanStdDevFuncC1)ippiMean_StdDev_32f_C1R ://Aug 2013: bug in IPP 7.1, 8.0 #endif 0; @@ -2113,7 +2113,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask ) type == CV_16UC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C1R : -#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if (IPP_VERSION_X100 >= 801) type == CV_16SC3 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormFuncNoHint)ippiNorm_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif @@ -2545,7 +2545,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C3R : type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16u_C4R : type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C1R : -#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if (IPP_VERSION_X100 >= 801) type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C3R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_Inf_16s_C4R : //Aug 2013: problem in IPP 7.1, 8.0 : -32768 #endif diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp index 95f4eb4459..8ab7e4929f 100644 --- a/modules/imgproc/src/color.cpp +++ b/modules/imgproc/src/color.cpp @@ -298,7 +298,7 @@ static ippiReorderFunc ippiSwapChannelsC3RTab[] = 0, (ippiReorderFunc)ippiSwapChannels_32f_C3R, 0, 0 }; -#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if (IPP_VERSION_X100 >= 801) static ippiReorderFunc ippiSwapChannelsC4RTab[] = { (ippiReorderFunc)ippiSwapChannels_8u_C4R, 0, (ippiReorderFunc)ippiSwapChannels_16u_C4R, 0, @@ -3254,7 +3254,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn ) if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) ) return; } -#if (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if (IPP_VERSION_X100 >= 801) else if( code == CV_RGBA2BGRA ) { if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) ) diff --git a/modules/imgproc/src/filter.cpp b/modules/imgproc/src/filter.cpp index d23f87ef47..921df18743 100644 --- a/modules/imgproc/src/filter.cpp +++ b/modules/imgproc/src/filter.cpp @@ -47,7 +47,7 @@ Base Image Filter \****************************************************************************************/ -#if defined HAVE_IPP && IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701 +#if defined HAVE_IPP && IPP_VERSION_X100 >= 701 #define USE_IPP_SEP_FILTERS 1 #else #undef USE_IPP_SEP_FILTERS diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 9e5540a7b5..7dcd44229f 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -55,7 +55,7 @@ static IppStatus sts = ippInit(); namespace cv { -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) typedef IppStatus (CV_STDCALL* ippiResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); typedef IppStatus (CV_STDCALL* ippiResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); typedef IppStatus (CV_STDCALL* ippiResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); @@ -1912,7 +1912,7 @@ static int computeResizeAreaTab( int ssize, int dsize, int cn, double scale, Dec getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ getSrcOffsetFunc = (ippiResizeGetSrcOffset)ippiResizeGetSrcOffset_##TYPE; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) class IPPresizeInvoker : public ParallelLoopBody { @@ -2384,7 +2384,7 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize, double scale_x = 1./inv_scale_x, scale_y = 1./inv_scale_y; int k, sx, sy, dx, dy; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR*100 + IPP_VERSION_MINOR >= 701) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) #define IPP_RESIZE_EPS 1.e-10 double ex = fabs((double)dsize.width/src.cols - inv_scale_x)/inv_scale_x; diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index 1fd93f862d..efac0182b4 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1136,7 +1136,7 @@ private: Scalar borderValue; }; -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { @@ -1459,7 +1459,7 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, Size ksize = kernel.data ? kernel.size() : Size(3,3); anchor = normalizeAnchor(anchor, ksize); -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) ) return; #endif diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 629d668258..7e61dc7b03 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1109,7 +1109,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, return; #endif -#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR * 10 + IPP_VERSION_MINOR >= 81) +#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) if( type == CV_32FC1 && sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 ) { Mat src = _src.getMat(), dst = _dst.getMat(); From 9828cd6086c5492794e46d65f68d701fdf86bcc9 Mon Sep 17 00:00:00 2001 From: vbystricky Date: Tue, 8 Apr 2014 13:05:23 +0400 Subject: [PATCH 51/52] Remove defined(HAVE_IPP) --- modules/core/src/dxt.cpp | 2 +- modules/imgproc/src/filter.cpp | 2 +- modules/imgproc/src/imgwarp.cpp | 6 +++--- modules/imgproc/src/morph.cpp | 4 ++-- modules/imgproc/src/smooth.cpp | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/modules/core/src/dxt.cpp b/modules/core/src/dxt.cpp index 0f2cbd98b2..c5a44e7ef6 100644 --- a/modules/core/src/dxt.cpp +++ b/modules/core/src/dxt.cpp @@ -53,7 +53,7 @@ namespace cv # pragma warning(disable: 4748) #endif -#if defined HAVE_IPP && IPP_VERSION_X100 >= 701 +#if IPP_VERSION_X100 >= 701 #define USE_IPP_DFT 1 #else #undef USE_IPP_DFT diff --git a/modules/imgproc/src/filter.cpp b/modules/imgproc/src/filter.cpp index 921df18743..8b337f645b 100644 --- a/modules/imgproc/src/filter.cpp +++ b/modules/imgproc/src/filter.cpp @@ -47,7 +47,7 @@ Base Image Filter \****************************************************************************************/ -#if defined HAVE_IPP && IPP_VERSION_X100 >= 701 +#if IPP_VERSION_X100 >= 701 #define USE_IPP_SEP_FILTERS 1 #else #undef USE_IPP_SEP_FILTERS diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 7dcd44229f..0c7aafc7b9 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -55,7 +55,7 @@ static IppStatus sts = ippInit(); namespace cv { -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) +#if IPP_VERSION_X100 >= 701 typedef IppStatus (CV_STDCALL* ippiResizeFunc)(const void*, int, const void*, int, IppiPoint, IppiSize, IppiBorderType, void*, void*, Ipp8u*); typedef IppStatus (CV_STDCALL* ippiResizeGetBufferSize)(void*, IppiSize, Ipp32u, int*); typedef IppStatus (CV_STDCALL* ippiResizeGetSrcOffset)(void*, IppiPoint, IppiPoint*); @@ -1912,7 +1912,7 @@ static int computeResizeAreaTab( int ssize, int dsize, int cn, double scale, Dec getBufferSizeFunc = (ippiResizeGetBufferSize)ippiResizeGetBufferSize_##TYPE;\ getSrcOffsetFunc = (ippiResizeGetSrcOffset)ippiResizeGetSrcOffset_##TYPE; -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) +#if IPP_VERSION_X100 >= 701 class IPPresizeInvoker : public ParallelLoopBody { @@ -2384,7 +2384,7 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize, double scale_x = 1./inv_scale_x, scale_y = 1./inv_scale_y; int k, sx, sy, dx, dy; -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 701) +#if IPP_VERSION_X100 >= 701 #define IPP_RESIZE_EPS 1.e-10 double ex = fabs((double)dsize.width/src.cols - inv_scale_x)/inv_scale_x; diff --git a/modules/imgproc/src/morph.cpp b/modules/imgproc/src/morph.cpp index efac0182b4..07aa4c5dd3 100644 --- a/modules/imgproc/src/morph.cpp +++ b/modules/imgproc/src/morph.cpp @@ -1136,7 +1136,7 @@ private: Scalar borderValue; }; -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) +#if IPP_VERSION_X100 >= 801 static bool IPPMorphReplicate(int op, const Mat &src, Mat &dst, const Mat &kernel, const Size& ksize, const Point &anchor, bool rectKernel) { @@ -1459,7 +1459,7 @@ static void morphOp( int op, InputArray _src, OutputArray _dst, Size ksize = kernel.data ? kernel.size() : Size(3,3); anchor = normalizeAnchor(anchor, ksize); -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) +#if IPP_VERSION_X100 >= 801 if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) ) return; #endif diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 7e61dc7b03..84570bd2c2 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1109,7 +1109,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, return; #endif -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 801) +#if IPP_VERSION_X100 >= 801 if( type == CV_32FC1 && sigma1 == sigma2 && ksize.width == ksize.height && sigma1 != 0.0 ) { Mat src = _src.getMat(), dst = _dst.getMat(); From aa5326c2314b3cadd68146d379e037ba2abe7406 Mon Sep 17 00:00:00 2001 From: Ilya Lavrenov Date: Tue, 8 Apr 2014 01:11:58 +0400 Subject: [PATCH 52/52] cv::norm -> cvtest::norm in tests Conflicts: modules/core/src/stat.cpp --- modules/calib3d/test/test_affine3.cpp | 8 ++-- .../calib3d/test/test_affine3d_estimator.cpp | 6 +-- .../calib3d/test/test_cameracalibration.cpp | 24 +++++------ .../test_cameracalibration_artificial.cpp | 5 ++- modules/calib3d/test/test_fundam.cpp | 6 +-- modules/calib3d/test/test_homography.cpp | 2 +- modules/calib3d/test/test_solvepnp_ransac.cpp | 4 +- modules/calib3d/test/test_stereomatching.cpp | 2 +- .../calib3d/test/test_undistort_points.cpp | 2 +- modules/core/src/stat.cpp | 2 +- modules/core/test/test_arithm.cpp | 7 ++-- modules/core/test/test_dxt.cpp | 2 +- modules/core/test/test_eigen.cpp | 39 +++++++++-------- modules/core/test/test_io.cpp | 4 +- modules/core/test/test_mat.cpp | 42 +++++++++---------- modules/core/test/test_math.cpp | 10 ++--- modules/core/test/test_operations.cpp | 30 ++++++------- modules/core/test/test_rand.cpp | 2 +- modules/core/test/test_umat.cpp | 8 ++-- modules/features2d/test/test_fast.cpp | 4 +- .../features2d/test/test_nearestneighbors.cpp | 10 ++--- modules/highgui/test/test_drawing.cpp | 6 +-- modules/highgui/test/test_ffmpeg.cpp | 2 +- modules/highgui/test/test_grfmt.cpp | 16 +++---- .../imgproc/test/test_bilateral_filter.cpp | 2 +- .../imgproc/test/test_connectedcomponents.cpp | 4 +- modules/imgproc/test/test_convhull.cpp | 4 +- modules/imgproc/test/test_houghLines.cpp | 2 +- modules/imgproc/test/test_imgwarp.cpp | 2 +- modules/imgproc/test/test_imgwarp_strict.cpp | 2 +- modules/ml/test/test_mltests2.cpp | 4 +- modules/ml/test/test_save_load.cpp | 4 +- modules/objdetect/test/test_cascadeandhog.cpp | 6 +-- modules/ts/include/opencv2/ts.hpp | 6 ++- modules/ts/include/opencv2/ts/ocl_test.hpp | 4 +- modules/ts/src/ocl_test.cpp | 4 +- modules/ts/src/ts_func.cpp | 13 ++++-- 37 files changed, 158 insertions(+), 142 deletions(-) diff --git a/modules/calib3d/test/test_affine3.cpp b/modules/calib3d/test/test_affine3.cpp index cc94d99c19..03fe869c63 100644 --- a/modules/calib3d/test/test_affine3.cpp +++ b/modules/calib3d/test/test_affine3.cpp @@ -54,8 +54,8 @@ TEST(Calib3d_Affine3f, accuracy) cv::Rodrigues(rvec, expected); - ASSERT_EQ(0, norm(cv::Mat(affine.matrix, false).colRange(0, 3).rowRange(0, 3) != expected)); - ASSERT_EQ(0, norm(cv::Mat(affine.linear()) != expected)); + ASSERT_EQ(0, cvtest::norm(cv::Mat(affine.matrix, false).colRange(0, 3).rowRange(0, 3) != expected, cv::NORM_L2)); + ASSERT_EQ(0, cvtest::norm(cv::Mat(affine.linear()) != expected, cv::NORM_L2)); cv::Matx33d R = cv::Matx33d::eye(); @@ -77,7 +77,7 @@ TEST(Calib3d_Affine3f, accuracy) cv::Mat diff; cv::absdiff(expected, result.matrix, diff); - ASSERT_LT(cv::norm(diff, cv::NORM_INF), 1e-15); + ASSERT_LT(cvtest::norm(diff, cv::NORM_INF), 1e-15); } TEST(Calib3d_Affine3f, accuracy_rvec) @@ -103,6 +103,6 @@ TEST(Calib3d_Affine3f, accuracy_rvec) cv::Rodrigues(R, vo); //std::cout << "O:" <<(cv::getTickCount() - s)*1000/cv::getTickFrequency() << std::endl; - ASSERT_LT(cv::norm(va - vo), 1e-9); + ASSERT_LT(cvtest::norm(va, vo, cv::NORM_L2), 1e-9); } } diff --git a/modules/calib3d/test/test_affine3d_estimator.cpp b/modules/calib3d/test/test_affine3d_estimator.cpp index f31e2e7324..c677275c95 100644 --- a/modules/calib3d/test/test_affine3d_estimator.cpp +++ b/modules/calib3d/test/test_affine3d_estimator.cpp @@ -108,9 +108,9 @@ bool CV_Affine3D_EstTest::test4Points() estimateAffine3D(fpts, tpts, aff_est, outliers); const double thres = 1e-3; - if (norm(aff_est, aff, NORM_INF) > thres) + if (cvtest::norm(aff_est, aff, NORM_INF) > thres) { - //cout << norm(aff_est, aff, NORM_INF) << endl; + //cout << cvtest::norm(aff_est, aff, NORM_INF) << endl; ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); return false; } @@ -161,7 +161,7 @@ bool CV_Affine3D_EstTest::testNPoints() } const double thres = 1e-4; - if (norm(aff_est, aff, NORM_INF) > thres) + if (cvtest::norm(aff_est, aff, NORM_INF) > thres) { cout << "aff est: " << aff_est << endl; cout << "aff ref: " << aff << endl; diff --git a/modules/calib3d/test/test_cameracalibration.cpp b/modules/calib3d/test/test_cameracalibration.cpp index 7d0bdaeb10..da9b931f53 100644 --- a/modules/calib3d/test/test_cameracalibration.cpp +++ b/modules/calib3d/test/test_cameracalibration.cpp @@ -215,7 +215,7 @@ void CV_ProjectPointsTest::prepare_to_validation( int /*test_case_idx*/ ) cvTsProjectPoints( m, vec2, m2v_jac ); cvTsCopy( vec, vec2 ); - theta0 = cvNorm( vec2, 0, CV_L2 ); + theta0 = cvtest::norm( cvarrtomat(vec2), 0, CV_L2 ); theta1 = fmod( theta0, CV_PI*2 ); if( theta1 > CV_PI ) @@ -225,7 +225,7 @@ void CV_ProjectPointsTest::prepare_to_validation( int /*test_case_idx*/ ) if( calc_jacobians ) { //cvInvert( v2m_jac, m2v_jac, CV_SVD ); - if( cvNorm(&test_mat[OUTPUT][3],0,CV_C) < 1000 ) + if( cvtest::norm(cvarrtomat(&test_mat[OUTPUT][3]), 0, CV_C) < 1000 ) { cvTsGEMM( &test_mat[OUTPUT][1], &test_mat[OUTPUT][3], 1, 0, 0, &test_mat[OUTPUT][4], @@ -1112,7 +1112,7 @@ void CV_ProjectPointsTest::run(int) rightImgPoints[i], valDpdrot, valDpdt, valDpdf, valDpdc, valDpddist, 0 ); } calcdfdx( leftImgPoints, rightImgPoints, dEps, valDpdrot ); - err = norm( dpdrot, valDpdrot, NORM_INF ); + err = cvtest::norm( dpdrot, valDpdrot, NORM_INF ); if( err > 3 ) { ts->printf( cvtest::TS::LOG, "bad dpdrot: too big difference = %g\n", err ); @@ -1130,7 +1130,7 @@ void CV_ProjectPointsTest::run(int) rightImgPoints[i], valDpdrot, valDpdt, valDpdf, valDpdc, valDpddist, 0 ); } calcdfdx( leftImgPoints, rightImgPoints, dEps, valDpdt ); - if( norm( dpdt, valDpdt, NORM_INF ) > 0.2 ) + if( cvtest::norm( dpdt, valDpdt, NORM_INF ) > 0.2 ) { ts->printf( cvtest::TS::LOG, "bad dpdtvec\n" ); code = cvtest::TS::FAIL_BAD_ACCURACY; @@ -1153,7 +1153,7 @@ void CV_ProjectPointsTest::run(int) project( objPoints, rvec, tvec, rightCameraMatrix, distCoeffs, rightImgPoints[1], valDpdrot, valDpdt, valDpdf, valDpdc, valDpddist, 0 ); calcdfdx( leftImgPoints, rightImgPoints, dEps, valDpdf ); - if ( norm( dpdf, valDpdf ) > 0.2 ) + if ( cvtest::norm( dpdf, valDpdf, NORM_L2 ) > 0.2 ) { ts->printf( cvtest::TS::LOG, "bad dpdf\n" ); code = cvtest::TS::FAIL_BAD_ACCURACY; @@ -1174,7 +1174,7 @@ void CV_ProjectPointsTest::run(int) project( objPoints, rvec, tvec, rightCameraMatrix, distCoeffs, rightImgPoints[1], valDpdrot, valDpdt, valDpdf, valDpdc, valDpddist, 0 ); calcdfdx( leftImgPoints, rightImgPoints, dEps, valDpdc ); - if ( norm( dpdc, valDpdc ) > 0.2 ) + if ( cvtest::norm( dpdc, valDpdc, NORM_L2 ) > 0.2 ) { ts->printf( cvtest::TS::LOG, "bad dpdc\n" ); code = cvtest::TS::FAIL_BAD_ACCURACY; @@ -1193,7 +1193,7 @@ void CV_ProjectPointsTest::run(int) rightImgPoints[i], valDpdrot, valDpdt, valDpdf, valDpdc, valDpddist, 0 ); } calcdfdx( leftImgPoints, rightImgPoints, dEps, valDpddist ); - if( norm( dpddist, valDpddist ) > 0.3 ) + if( cvtest::norm( dpddist, valDpddist, NORM_L2 ) > 0.3 ) { ts->printf( cvtest::TS::LOG, "bad dpddist\n" ); code = cvtest::TS::FAIL_BAD_ACCURACY; @@ -1481,8 +1481,8 @@ void CV_StereoCalibrationTest::run( int ) Mat eye33 = Mat::eye(3,3,CV_64F); Mat R1t = R1.t(), R2t = R2.t(); - if( norm(R1t*R1 - eye33) > 0.01 || - norm(R2t*R2 - eye33) > 0.01 || + if( cvtest::norm(R1t*R1 - eye33, NORM_L2) > 0.01 || + cvtest::norm(R2t*R2 - eye33, NORM_L2) > 0.01 || abs(determinant(F)) > 0.01) { ts->printf( cvtest::TS::LOG, "The computed (by rectify) R1 and R2 are not orthogonal," @@ -1505,7 +1505,7 @@ void CV_StereoCalibrationTest::run( int ) //check that Tx after rectification is equal to distance between cameras double tx = fabs(P2.at(0, 3) / P2.at(0, 0)); - if (fabs(tx - norm(T)) > 1e-5) + if (fabs(tx - cvtest::norm(T, NORM_L2)) > 1e-5) { ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); return; @@ -1556,7 +1556,7 @@ void CV_StereoCalibrationTest::run( int ) Mat reprojectedPoints; perspectiveTransform(sparsePoints, reprojectedPoints, Q); - if (norm(triangulatedPoints - reprojectedPoints) / sqrt((double)pointsCount) > requiredAccuracy) + if (cvtest::norm(triangulatedPoints, reprojectedPoints, NORM_L2) / sqrt((double)pointsCount) > requiredAccuracy) { ts->printf( cvtest::TS::LOG, "Points reprojected with a matrix Q and points reconstructed by triangulation are different, testcase %d\n", testcase); ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT ); @@ -1581,7 +1581,7 @@ void CV_StereoCalibrationTest::run( int ) { Mat error = newHomogeneousPoints2.row(i) * typedF * newHomogeneousPoints1.row(i).t(); CV_Assert(error.rows == 1 && error.cols == 1); - if (norm(error) > constraintAccuracy) + if (cvtest::norm(error, NORM_L2) > constraintAccuracy) { ts->printf( cvtest::TS::LOG, "Epipolar constraint is violated after correctMatches, testcase %d\n", testcase); ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT ); diff --git a/modules/calib3d/test/test_cameracalibration_artificial.cpp b/modules/calib3d/test/test_cameracalibration_artificial.cpp index 07e5894b96..94f70e7ccf 100644 --- a/modules/calib3d/test/test_cameracalibration_artificial.cpp +++ b/modules/calib3d/test/test_cameracalibration_artificial.cpp @@ -204,7 +204,7 @@ protected: Rodrigues(rvecs[i], rmat); Rodrigues(rvecs_est[i], rmat_est); - if (norm(rmat_est, rmat) > eps* (norm(rmat) + dlt)) + if (cvtest::norm(rmat_est, rmat, NORM_L2) > eps* (cvtest::norm(rmat, NORM_L2) + dlt)) { if (err_count++ < errMsgNum) { @@ -213,7 +213,8 @@ protected: else { ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned rvecs (rotation matrs). Index = %d\n", r, i); - ts->printf( cvtest::TS::LOG, "%d) norm(rot_mat_est - rot_mat_exp) = %f, norm(rot_mat_exp) = %f \n", r, norm(rmat_est, rmat), norm(rmat)); + ts->printf( cvtest::TS::LOG, "%d) norm(rot_mat_est - rot_mat_exp) = %f, norm(rot_mat_exp) = %f \n", r, + cvtest::norm(rmat_est, rmat, NORM_L2), cvtest::norm(rmat, NORM_L2)); } } diff --git a/modules/calib3d/test/test_fundam.cpp b/modules/calib3d/test/test_fundam.cpp index 749faf1257..e2245c12b0 100644 --- a/modules/calib3d/test/test_fundam.cpp +++ b/modules/calib3d/test/test_fundam.cpp @@ -738,7 +738,7 @@ void CV_RodriguesTest::prepare_to_validation( int /*test_case_idx*/ ) if( calc_jacobians ) { //cvInvert( v2m_jac, m2v_jac, CV_SVD ); - double nrm = norm(test_mat[REF_OUTPUT][3],CV_C); + double nrm = cvtest::norm(test_mat[REF_OUTPUT][3], CV_C); if( FLT_EPSILON < nrm && nrm < 1000 ) { gemm( test_mat[OUTPUT][1], test_mat[OUTPUT][3], @@ -1409,8 +1409,8 @@ void CV_EssentialMatTest::prepare_to_validation( int test_case_idx ) double* pose_prop1 = (double*)test_mat[REF_OUTPUT][2].data; double* pose_prop2 = (double*)test_mat[OUTPUT][2].data; - double terr1 = norm(Rt0.col(3) / norm(Rt0.col(3)) + test_mat[TEMP][3]); - double terr2 = norm(Rt0.col(3) / norm(Rt0.col(3)) - test_mat[TEMP][3]); + double terr1 = cvtest::norm(Rt0.col(3) / norm(Rt0.col(3)) + test_mat[TEMP][3], NORM_L2); + double terr2 = cvtest::norm(Rt0.col(3) / norm(Rt0.col(3)) - test_mat[TEMP][3], NORM_L2); Mat rvec; Rodrigues(Rt0.colRange(0, 3), rvec); pose_prop1[0] = 0; diff --git a/modules/calib3d/test/test_homography.cpp b/modules/calib3d/test/test_homography.cpp index 5bb50bb265..59d92905a4 100644 --- a/modules/calib3d/test/test_homography.cpp +++ b/modules/calib3d/test/test_homography.cpp @@ -119,7 +119,7 @@ bool CV_HomographyTest::check_matrix_size(const cv::Mat& H) bool CV_HomographyTest::check_matrix_diff(const cv::Mat& original, const cv::Mat& found, const int norm_type, double &diff) { - diff = cv::norm(original, found, norm_type); + diff = cvtest::norm(original, found, norm_type); return diff <= max_diff; } diff --git a/modules/calib3d/test/test_solvepnp_ransac.cpp b/modules/calib3d/test/test_solvepnp_ransac.cpp index e6f25466d8..37e0959d16 100644 --- a/modules/calib3d/test/test_solvepnp_ransac.cpp +++ b/modules/calib3d/test/test_solvepnp_ransac.cpp @@ -299,8 +299,8 @@ TEST(DISABLED_Calib3d_SolvePnPRansac, concurrency) solvePnPRansac(object, image, camera_mat, dist_coef, rvec2, tvec2); } - double rnorm = cv::norm(rvec1, rvec2, NORM_INF); - double tnorm = cv::norm(tvec1, tvec2, NORM_INF); + double rnorm = cvtest::norm(rvec1, rvec2, NORM_INF); + double tnorm = cvtest::norm(tvec1, tvec2, NORM_INF); EXPECT_LT(rnorm, 1e-6); EXPECT_LT(tnorm, 1e-6); diff --git a/modules/calib3d/test/test_stereomatching.cpp b/modules/calib3d/test/test_stereomatching.cpp index 8beb9f905e..8c377de0c1 100644 --- a/modules/calib3d/test/test_stereomatching.cpp +++ b/modules/calib3d/test/test_stereomatching.cpp @@ -279,7 +279,7 @@ float dispRMS( const Mat& computedDisp, const Mat& groundTruthDisp, const Mat& m checkTypeAndSizeOfMask( mask, sz ); pointsCount = countNonZero(mask); } - return 1.f/sqrt((float)pointsCount) * (float)norm(computedDisp, groundTruthDisp, NORM_L2, mask); + return 1.f/sqrt((float)pointsCount) * (float)cvtest::norm(computedDisp, groundTruthDisp, NORM_L2, mask); } /* diff --git a/modules/calib3d/test/test_undistort_points.cpp b/modules/calib3d/test/test_undistort_points.cpp index 5dabd213db..0eb3552272 100644 --- a/modules/calib3d/test/test_undistort_points.cpp +++ b/modules/calib3d/test/test_undistort_points.cpp @@ -84,7 +84,7 @@ void CV_UndistortTest::run(int /* start_from */) Mat p; perspectiveTransform(undistortedPoints, p, intrinsics); undistortedPoints = p; - double diff = norm(Mat(realUndistortedPoints), undistortedPoints); + double diff = cvtest::norm(Mat(realUndistortedPoints), undistortedPoints, NORM_L2); if (diff > thresh) { ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index adc24119ec..0e3d44ed6b 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -2364,7 +2364,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m #if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7) Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat(); - normType &= 7; + normType &= NORM_TYPE_MASK; CV_Assert( normType == NORM_INF || normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR || ((normType == NORM_HAMMING || normType == NORM_HAMMING2) && src1.type() == CV_8U) ); size_t total_size = src1.total(); diff --git a/modules/core/test/test_arithm.cpp b/modules/core/test/test_arithm.cpp index 626b44cbc5..2527e5397a 100644 --- a/modules/core/test/test_arithm.cpp +++ b/modules/core/test/test_arithm.cpp @@ -1362,7 +1362,8 @@ TEST_P(ElemWiseTest, accuracy) double maxErr = op->getMaxErr(depth); vector pos; - ASSERT_PRED_FORMAT2(cvtest::MatComparator(maxErr, op->context), dst0, dst) << "\nsrc[0] ~ " << cvtest::MatInfo(!src.empty() ? src[0] : Mat()) << "\ntestCase #" << testIdx << "\n"; + ASSERT_PRED_FORMAT2(cvtest::MatComparator(maxErr, op->context), dst0, dst) << "\nsrc[0] ~ " << + cvtest::MatInfo(!src.empty() ? src[0] : Mat()) << "\ntestCase #" << testIdx << "\n"; } } @@ -1500,7 +1501,7 @@ protected: } Mat d1; d.convertTo(d1, depth); - CV_Assert( norm(c, d1, CV_C) <= DBL_EPSILON ); + CV_Assert( cvtest::norm(c, d1, CV_C) <= DBL_EPSILON ); } Mat_ tmpSrc(100,100); @@ -1574,7 +1575,7 @@ TEST_P(Mul1, One) cv::multiply(3, src, dst); - ASSERT_EQ(0, cv::norm(dst, ref_dst, cv::NORM_INF)); + ASSERT_EQ(0, cvtest::norm(dst, ref_dst, cv::NORM_INF)); } INSTANTIATE_TEST_CASE_P(Arithm, Mul1, testing::Values(Size(2, 2), Size(1, 1))); diff --git a/modules/core/test/test_dxt.cpp b/modules/core/test/test_dxt.cpp index 1c0c7b00bf..9fc12c183d 100644 --- a/modules/core/test/test_dxt.cpp +++ b/modules/core/test/test_dxt.cpp @@ -855,7 +855,7 @@ protected: merge(mv, 2, srcz); dft(srcz, dstz); dft(src, dst, DFT_COMPLEX_OUTPUT); - if(norm(dst, dstz, NORM_INF) > 1e-3) + if (cvtest::norm(dst, dstz, NORM_INF) > 1e-3) { cout << "actual:\n" << dst << endl << endl; cout << "reference:\n" << dstz << endl << endl; diff --git a/modules/core/test/test_eigen.cpp b/modules/core/test/test_eigen.cpp index 21859e59b8..671378443e 100644 --- a/modules/core/test/test_eigen.cpp +++ b/modules/core/test/test_eigen.cpp @@ -175,7 +175,7 @@ bool Core_EigenTest::check_pair_count(const cv::Mat& src, const cv::Mat& evalues { std::cout << endl; std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl; std::cout << "Number of rows: " << evalues.rows << " Number of cols: " << evalues.cols << endl; - std:: cout << "Size of src symmetric matrix: " << src.rows << " * " << src.cols << endl; std::cout << endl; + std::cout << "Size of src symmetric matrix: " << src.rows << " * " << src.cols << endl; std::cout << endl; CV_Error(CORE_EIGEN_ERROR_COUNT, MESSAGE_ERROR_COUNT); return false; } @@ -187,7 +187,7 @@ bool Core_EigenTest::check_pair_count(const cv::Mat& src, const cv::Mat& evalues int n = src.rows, s = sign(high_index); int right_eigen_pair_count = n - max(0, low_index) - ((int)((n/2.0)*(s*s-s)) + (1+s-s*s)*(n - (high_index+1))); - if (!((evectors.rows == right_eigen_pair_count) && (evectors.cols == right_eigen_pair_count))) + if (!(evectors.rows == right_eigen_pair_count && evectors.cols == right_eigen_pair_count)) { std::cout << endl; std::cout << "Checking sizes of eigen vectors matrix " << evectors << "..." << endl; std::cout << "Number of rows: " << evectors.rows << " Number of cols: " << evectors.cols << endl; @@ -196,7 +196,7 @@ bool Core_EigenTest::check_pair_count(const cv::Mat& src, const cv::Mat& evalues return false; } - if (!((evalues.rows == right_eigen_pair_count) && (evalues.cols == 1))) + if (!(evalues.rows == right_eigen_pair_count && evalues.cols == 1)) { std::cout << endl; std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl; std::cout << "Number of rows: " << evalues.rows << " Number of cols: " << evalues.cols << endl; @@ -212,9 +212,9 @@ void Core_EigenTest::print_information(const size_t norm_idx, const cv::Mat& src { switch (NORM_TYPE[norm_idx]) { - case cv::NORM_L1: {std::cout << "L1"; break;} - case cv::NORM_L2: {std::cout << "L2"; break;} - case cv::NORM_INF: {std::cout << "INF"; break;} + case cv::NORM_L1: std::cout << "L1"; break; + case cv::NORM_L2: std::cout << "L2"; break; + case cv::NORM_INF: std::cout << "INF"; break; default: break; } @@ -234,7 +234,7 @@ bool Core_EigenTest::check_orthogonality(const cv::Mat& U) for (int i = 0; i < COUNT_NORM_TYPES; ++i) { - double diff = cv::norm(UUt, E, NORM_TYPE[i]); + double diff = cvtest::norm(UUt, E, NORM_TYPE[i]); if (diff > eps_vec) { std::cout << endl; std::cout << "Checking orthogonality of matrix " << U << ": "; @@ -271,12 +271,12 @@ bool Core_EigenTest::check_pairs_order(const cv::Mat& eigen_values) for (int i = 0; i < (int)(eigen_values.total() - 1); ++i) if (!(eigen_values.at(i, 0) > eigen_values.at(i+1, 0))) { - std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl; - std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl; - std::cout << endl; - CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order."); - return false; - } + std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl; + std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl; + std::cout << endl; + CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order."); + return false; + } break; } @@ -296,11 +296,14 @@ bool Core_EigenTest::test_pairs(const cv::Mat& src) cv::eigen(src, eigen_values, eigen_vectors); - if (!check_pair_count(src, eigen_values, eigen_vectors)) return false; + if (!check_pair_count(src, eigen_values, eigen_vectors)) + return false; - if (!check_orthogonality (eigen_vectors)) return false; + if (!check_orthogonality (eigen_vectors)) + return false; - if (!check_pairs_order(eigen_values)) return false; + if (!check_pairs_order(eigen_values)) + return false; cv::Mat eigen_vectors_t; cv::transpose(eigen_vectors, eigen_vectors_t); @@ -340,7 +343,7 @@ bool Core_EigenTest::test_pairs(const cv::Mat& src) for (int i = 0; i < COUNT_NORM_TYPES; ++i) { - double diff = cv::norm(disparity, NORM_TYPE[i]); + double diff = cvtest::norm(disparity, NORM_TYPE[i]); if (diff > eps_vec) { std::cout << endl; std::cout << "Checking accuracy of eigen vectors computing for matrix " << src << ": "; @@ -369,7 +372,7 @@ bool Core_EigenTest::test_values(const cv::Mat& src) for (int i = 0; i < COUNT_NORM_TYPES; ++i) { - double diff = cv::norm(eigen_values_1, eigen_values_2, NORM_TYPE[i]); + double diff = cvtest::norm(eigen_values_1, eigen_values_2, NORM_TYPE[i]); if (diff > eps_val) { std::cout << endl; std::cout << "Checking accuracy of eigen values computing for matrix " << src << ": "; diff --git a/modules/core/test/test_io.cpp b/modules/core/test/test_io.cpp index e6c412f869..ba56f76a6f 100644 --- a/modules/core/test/test_io.cpp +++ b/modules/core/test/test_io.cpp @@ -480,9 +480,9 @@ protected: fs["g1"] >> og1; CV_Assert( mi2.empty() ); CV_Assert( mv2.empty() ); - CV_Assert( norm(mi3, mi4, CV_C) == 0 ); + CV_Assert( cvtest::norm(Mat(mi3), Mat(mi4), CV_C) == 0 ); CV_Assert( mv4.size() == 1 ); - double n = norm(mv3[0], mv4[0], CV_C); + double n = cvtest::norm(mv3[0], mv4[0], CV_C); CV_Assert( vudt2.empty() ); CV_Assert( vudt3 == vudt4 ); CV_Assert( n == 0 ); diff --git a/modules/core/test/test_mat.cpp b/modules/core/test/test_mat.cpp index 86aca01608..ac27bd7b53 100644 --- a/modules/core/test/test_mat.cpp +++ b/modules/core/test/test_mat.cpp @@ -340,7 +340,7 @@ protected: Mat Qv = Q * v; Mat lv = eval.at(i,0) * v; - err = norm( Qv, lv ); + err = cvtest::norm( Qv, lv, NORM_L2 ); if( err > eigenEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of eigen(); err = %f\n", err ); @@ -350,7 +350,7 @@ protected: } // check pca eigenvalues evalEps = 1e-6, evecEps = 1e-3; - err = norm( rPCA.eigenvalues, subEval ); + err = cvtest::norm( rPCA.eigenvalues, subEval, NORM_L2 ); if( err > evalEps ) { ts->printf( cvtest::TS::LOG, "pca.eigenvalues is incorrect (CV_PCA_DATA_AS_ROW); err = %f\n", err ); @@ -362,11 +362,11 @@ protected: { Mat r0 = rPCA.eigenvectors.row(i); Mat r1 = subEvec.row(i); - err = norm( r0, r1, CV_L2 ); + err = cvtest::norm( r0, r1, CV_L2 ); if( err > evecEps ) { r1 *= -1; - double err2 = norm(r0, r1, CV_L2); + double err2 = cvtest::norm(r0, r1, CV_L2); if( err2 > evecEps ) { Mat tmp; @@ -390,7 +390,7 @@ protected: // check pca project Mat subEvec_t = subEvec.t(); Mat prj = rTestPoints.row(i) - avg; prj *= subEvec_t; - err = norm(rPrjTestPoints.row(i), prj, CV_RELATIVE_L2); + err = cvtest::norm(rPrjTestPoints.row(i), prj, CV_RELATIVE_L2); if( err > prjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of project() (CV_PCA_DATA_AS_ROW); err = %f\n", err ); @@ -399,7 +399,7 @@ protected: } // check pca backProject Mat backPrj = rPrjTestPoints.row(i) * subEvec + avg; - err = norm( rBackPrjTestPoints.row(i), backPrj, CV_RELATIVE_L2 ); + err = cvtest::norm( rBackPrjTestPoints.row(i), backPrj, CV_RELATIVE_L2 ); if( err > backPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_ROW); err = %f\n", err ); @@ -412,14 +412,14 @@ protected: cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, maxComponents ); diffPrjEps = 1, diffBackPrjEps = 1; Mat ocvPrjTestPoints = cPCA.project(rTestPoints.t()); - err = norm(cv::abs(ocvPrjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); + err = cvtest::norm(cv::abs(ocvPrjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); if( err > diffPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of project() (CV_PCA_DATA_AS_COL); err = %f\n", err ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); return; } - err = norm(cPCA.backProject(ocvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 ); + err = cvtest::norm(cPCA.backProject(ocvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 ); if( err > diffBackPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_COL); err = %f\n", err ); @@ -433,9 +433,9 @@ protected: Mat rvPrjTestPoints = cPCA.project(rTestPoints.t()); if( cPCA.eigenvectors.rows > maxComponents) - err = norm(cv::abs(rvPrjTestPoints.rowRange(0,maxComponents)), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); + err = cvtest::norm(cv::abs(rvPrjTestPoints.rowRange(0,maxComponents)), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); else - err = norm(cv::abs(rvPrjTestPoints), cv::abs(rPrjTestPoints.colRange(0,cPCA.eigenvectors.rows).t()), CV_RELATIVE_L2 ); + err = cvtest::norm(cv::abs(rvPrjTestPoints), cv::abs(rPrjTestPoints.colRange(0,cPCA.eigenvectors.rows).t()), CV_RELATIVE_L2 ); if( err > diffPrjEps ) { @@ -443,7 +443,7 @@ protected: ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); return; } - err = norm(cPCA.backProject(rvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 ); + err = cvtest::norm(cPCA.backProject(rvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 ); if( err > diffBackPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_COL); retainedVariance=0.95; err = %f\n", err ); @@ -467,14 +467,14 @@ protected: cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints ); cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints ); - err = norm(prjTestPoints, rPrjTestPoints, CV_RELATIVE_L2); + err = cvtest::norm(prjTestPoints, rPrjTestPoints, CV_RELATIVE_L2); if( err > diffPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of cvProjectPCA() (CV_PCA_DATA_AS_ROW); err = %f\n", err ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); return; } - err = norm(backPrjTestPoints, rBackPrjTestPoints, CV_RELATIVE_L2); + err = cvtest::norm(backPrjTestPoints, rBackPrjTestPoints, CV_RELATIVE_L2); if( err > diffBackPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of cvBackProjectPCA() (CV_PCA_DATA_AS_ROW); err = %f\n", err ); @@ -495,14 +495,14 @@ protected: cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints ); cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints ); - err = norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); + err = cvtest::norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); if( err > diffPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of cvProjectPCA() (CV_PCA_DATA_AS_COL); err = %f\n", err ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); return; } - err = norm(backPrjTestPoints, rBackPrjTestPoints.t(), CV_RELATIVE_L2); + err = cvtest::norm(backPrjTestPoints, rBackPrjTestPoints.t(), CV_RELATIVE_L2); if( err > diffBackPrjEps ) { ts->printf( cvtest::TS::LOG, "bad accuracy of cvBackProjectPCA() (CV_PCA_DATA_AS_COL); err = %f\n", err ); @@ -518,19 +518,19 @@ protected: PCA lPCA; fs.open( "PCA_store.yml", FileStorage::READ ); lPCA.read( fs.root() ); - err = norm( rPCA.eigenvectors, lPCA.eigenvectors, CV_RELATIVE_L2 ); + err = cvtest::norm( rPCA.eigenvectors, lPCA.eigenvectors, CV_RELATIVE_L2 ); if( err > 0 ) { ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); } - err = norm( rPCA.eigenvalues, lPCA.eigenvalues, CV_RELATIVE_L2 ); + err = cvtest::norm( rPCA.eigenvalues, lPCA.eigenvalues, CV_RELATIVE_L2 ); if( err > 0 ) { ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); } - err = norm( rPCA.mean, lPCA.mean, CV_RELATIVE_L2 ); + err = cvtest::norm( rPCA.mean, lPCA.mean, CV_RELATIVE_L2 ); if( err > 0 ) { ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err ); @@ -731,9 +731,9 @@ void Core_ArrayOpTest::run( int /* start_from */) } minMaxLoc(_all_vals, &min_val, &max_val); - double _norm0 = norm(_all_vals, CV_C); - double _norm1 = norm(_all_vals, CV_L1); - double _norm2 = norm(_all_vals, CV_L2); + double _norm0 = cvtest::norm(_all_vals, CV_C); + double _norm1 = cvtest::norm(_all_vals, CV_L1); + double _norm2 = cvtest::norm(_all_vals, CV_L2); for( i = 0; i < nz0; i++ ) { diff --git a/modules/core/test/test_math.cpp b/modules/core/test/test_math.cpp index 859ebe60ea..0d64fe8c02 100644 --- a/modules/core/test/test_math.cpp +++ b/modules/core/test/test_math.cpp @@ -2433,7 +2433,7 @@ protected: } Mat convertedRes = resInRad * 180. / CV_PI; - double normDiff = norm(convertedRes - resInDeg, NORM_INF); + double normDiff = cvtest::norm(convertedRes - resInDeg, NORM_INF); if(normDiff > FLT_EPSILON * 180.) { ts->printf(cvtest::TS::LOG, "There are incorrect result angles (in radians)\n"); @@ -2569,11 +2569,11 @@ TEST(Core_Invert, small) cv::Mat b = a.t()*a; cv::Mat c, i = Mat_::eye(3, 3); cv::invert(b, c, cv::DECOMP_LU); //std::cout << b*c << std::endl; - ASSERT_LT( cv::norm(b*c, i, CV_C), 0.1 ); + ASSERT_LT( cvtest::norm(b*c, i, CV_C), 0.1 ); cv::invert(b, c, cv::DECOMP_SVD); //std::cout << b*c << std::endl; - ASSERT_LT( cv::norm(b*c, i, CV_C), 0.1 ); + ASSERT_LT( cvtest::norm(b*c, i, CV_C), 0.1 ); cv::invert(b, c, cv::DECOMP_CHOLESKY); //std::cout << b*c << std::endl; - ASSERT_LT( cv::norm(b*c, i, CV_C), 0.1 ); + ASSERT_LT( cvtest::norm(b*c, i, CV_C), 0.1 ); } ///////////////////////////////////////////////////////////////////////////////////////////////////// @@ -2621,7 +2621,7 @@ TEST(Core_SVD, flt) Mat X, B1; solve(A, B, X, DECOMP_SVD); B1 = A*X; - EXPECT_LE(norm(B1, B, NORM_L2 + NORM_RELATIVE), FLT_EPSILON*10); + EXPECT_LE(cvtest::norm(B1, B, NORM_L2 + NORM_RELATIVE), FLT_EPSILON*10); } diff --git a/modules/core/test/test_operations.cpp b/modules/core/test/test_operations.cpp index 8215ea93f5..543fb31ac7 100644 --- a/modules/core/test/test_operations.cpp +++ b/modules/core/test/test_operations.cpp @@ -83,11 +83,11 @@ protected: void checkDiff(const Mat& m1, const Mat& m2, const string& s) { - if (norm(m1, m2, NORM_INF) != 0) throw test_excep(s); + if (cvtest::norm(m1, m2, NORM_INF) != 0) throw test_excep(s); } void checkDiffF(const Mat& m1, const Mat& m2, const string& s) { - if (norm(m1, m2, NORM_INF) > 1e-5) throw test_excep(s); + if (cvtest::norm(m1, m2, NORM_INF) > 1e-5) throw test_excep(s); } }; @@ -488,7 +488,7 @@ bool CV_OperationsTest::TestSubMatAccess() coords.push_back(T_bs(i)); //std::cout << T_bs1(i) << std::endl; } - CV_Assert( norm(coords, T_bs.reshape(1,1), NORM_INF) == 0 ); + CV_Assert( cvtest::norm(coords, T_bs.reshape(1,1), NORM_INF) == 0 ); } catch (const test_excep& e) { @@ -776,14 +776,14 @@ bool CV_OperationsTest::TestTemplateMat() mvf.push_back(Mat_::zeros(4, 3)); merge(mvf, mf2); split(mf2, mvf2); - CV_Assert( norm(mvf2[0], mvf[0], CV_C) == 0 && - norm(mvf2[1], mvf[1], CV_C) == 0 ); + CV_Assert( cvtest::norm(mvf2[0], mvf[0], CV_C) == 0 && + cvtest::norm(mvf2[1], mvf[1], CV_C) == 0 ); { Mat a(2,2,CV_32F,1.f); Mat b(1,2,CV_32F,1.f); Mat c = (a*b.t()).t(); - CV_Assert( norm(c, CV_L1) == 4. ); + CV_Assert( cvtest::norm(c, CV_L1) == 4. ); } bool badarg_catched = false; @@ -988,7 +988,7 @@ bool CV_OperationsTest::operations1() Vec v10dzero; for (int ii = 0; ii < 10; ++ii) { - if (!v10dzero[ii] == 0.0) + if (v10dzero[ii] != 0.0) throw test_excep(); } @@ -1014,13 +1014,13 @@ bool CV_OperationsTest::operations1() Matx33f b(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f); Mat c; add(Mat::zeros(3, 3, CV_32F), b, c); - CV_Assert( norm(b, c, CV_C) == 0 ); + CV_Assert( cvtest::norm(b, c, CV_C) == 0 ); add(Mat::zeros(3, 3, CV_64F), b, c, noArray(), c.type()); - CV_Assert( norm(b, c, CV_C) == 0 ); + CV_Assert( cvtest::norm(b, c, CV_C) == 0 ); add(Mat::zeros(6, 1, CV_64F), 1, c, noArray(), c.type()); - CV_Assert( norm(Matx61f(1.f, 1.f, 1.f, 1.f, 1.f, 1.f), c, CV_C) == 0 ); + CV_Assert( cvtest::norm(Matx61f(1.f, 1.f, 1.f, 1.f, 1.f, 1.f), c, CV_C) == 0 ); vector pt2d(3); vector pt3d(2); @@ -1066,11 +1066,11 @@ bool CV_OperationsTest::TestSVD() Mat A = (Mat_(3,4) << 1, 2, -1, 4, 2, 4, 3, 5, -1, -2, 6, 7); Mat x; SVD::solveZ(A,x); - if( norm(A*x, CV_C) > FLT_EPSILON ) + if( cvtest::norm(A*x, CV_C) > FLT_EPSILON ) throw test_excep(); SVD svd(A, SVD::FULL_UV); - if( norm(A*svd.vt.row(3).t(), CV_C) > FLT_EPSILON ) + if( cvtest::norm(A*svd.vt.row(3).t(), CV_C) > FLT_EPSILON ) throw test_excep(); Mat Dp(3,3,CV_32FC1); @@ -1094,11 +1094,11 @@ bool CV_OperationsTest::TestSVD() W=decomp.w; Mat I = Mat::eye(3, 3, CV_32F); - if( norm(U*U.t(), I, CV_C) > FLT_EPSILON || - norm(Vt*Vt.t(), I, CV_C) > FLT_EPSILON || + if( cvtest::norm(U*U.t(), I, CV_C) > FLT_EPSILON || + cvtest::norm(Vt*Vt.t(), I, CV_C) > FLT_EPSILON || W.at(2) < 0 || W.at(1) < W.at(2) || W.at(0) < W.at(1) || - norm(U*Mat::diag(W)*Vt, Q, CV_C) > FLT_EPSILON ) + cvtest::norm(U*Mat::diag(W)*Vt, Q, CV_C) > FLT_EPSILON ) throw test_excep(); } catch(const test_excep&) diff --git a/modules/core/test/test_rand.cpp b/modules/core/test/test_rand.cpp index 1d9b3dd0d1..a94624b89a 100644 --- a/modules/core/test/test_rand.cpp +++ b/modules/core/test/test_rand.cpp @@ -174,7 +174,7 @@ void Core_RandTest::run( int ) } } - if( maxk >= 1 && norm(arr[0], arr[1], NORM_INF) > eps) + if( maxk >= 1 && cvtest::norm(arr[0], arr[1], NORM_INF) > eps) { ts->printf( cvtest::TS::LOG, "RNG output depends on the array lengths (some generated numbers get lost?)" ); ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT ); diff --git a/modules/core/test/test_umat.cpp b/modules/core/test/test_umat.cpp index b7deb48955..d7ae7a9385 100644 --- a/modules/core/test/test_umat.cpp +++ b/modules/core/test/test_umat.cpp @@ -563,12 +563,12 @@ protected: void checkDiff(const Mat& m1, const Mat& m2, const string& s) { - if (norm(m1, m2, NORM_INF) != 0) + if (cvtest::norm(m1, m2, NORM_INF) != 0) throw test_excep(s); } void checkDiffF(const Mat& m1, const Mat& m2, const string& s) { - if (norm(m1, m2, NORM_INF) > 1e-5) + if (cvtest::norm(m1, m2, NORM_INF) > 1e-5) throw test_excep(s); } }; @@ -721,7 +721,7 @@ TEST(Core_UMat, getUMat) um.setTo(17); } - double err = norm(m, ref, NORM_INF); + double err = cvtest::norm(m, ref, NORM_INF); if (err > 0) { std::cout << "m: " << std::endl << m << std::endl; @@ -742,7 +742,7 @@ TEST(UMat, Sync) um.setTo(cv::Scalar::all(19)); - EXPECT_EQ(0, cv::norm(um.getMat(ACCESS_READ), cv::Mat(um.size(), um.type(), 19), NORM_INF)); + EXPECT_EQ(0, cvtest::norm(um.getMat(ACCESS_READ), cv::Mat(um.size(), um.type(), 19), NORM_INF)); } TEST(UMat, setOpenCL) diff --git a/modules/features2d/test/test_fast.cpp b/modules/features2d/test/test_fast.cpp index d500ce549c..0bca41b541 100644 --- a/modules/features2d/test/test_fast.cpp +++ b/modules/features2d/test/test_fast.cpp @@ -119,8 +119,8 @@ void CV_FastTest::run( int ) read( fs["exp_kps2"], exp_kps2, Mat() ); fs.release(); - if ( exp_kps1.size != kps1.size || 0 != norm(exp_kps1, kps1, NORM_L2) || - exp_kps2.size != kps2.size || 0 != norm(exp_kps2, kps2, NORM_L2)) + if ( exp_kps1.size != kps1.size || 0 != cvtest::norm(exp_kps1, kps1, NORM_L2) || + exp_kps2.size != kps2.size || 0 != cvtest::norm(exp_kps2, kps2, NORM_L2)) { ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); return; diff --git a/modules/features2d/test/test_nearestneighbors.cpp b/modules/features2d/test/test_nearestneighbors.cpp index e61dfce6bb..3d80b0db17 100644 --- a/modules/features2d/test/test_nearestneighbors.cpp +++ b/modules/features2d/test/test_nearestneighbors.cpp @@ -193,8 +193,8 @@ int CV_KDTreeTest_CPP::checkGetPoins( const Mat& data ) // 3d way tr->getPoints( idxs, res3 ); - if( norm( res1, data, NORM_L1) != 0 || - norm( res3, data, NORM_L1) != 0) + if( cvtest::norm( res1, data, NORM_L1) != 0 || + cvtest::norm( res3, data, NORM_L1) != 0) return cvtest::TS::FAIL_BAD_ACCURACY; return cvtest::TS::OK; } @@ -232,7 +232,7 @@ int CV_KDTreeTest_CPP::findNeighbors( Mat& points, Mat& neighbors ) } // compare results - if( norm( neighbors, neighbors2, NORM_L1 ) != 0 ) + if( cvtest::norm( neighbors, neighbors2, NORM_L1 ) != 0 ) return cvtest::TS::FAIL_BAD_ACCURACY; return cvtest::TS::OK; @@ -284,7 +284,7 @@ int CV_FlannTest::knnSearch( Mat& points, Mat& neighbors ) } // compare results - if( norm( neighbors, neighbors1, NORM_L1 ) != 0 ) + if( cvtest::norm( neighbors, neighbors1, NORM_L1 ) != 0 ) return cvtest::TS::FAIL_BAD_ACCURACY; return cvtest::TS::OK; @@ -316,7 +316,7 @@ int CV_FlannTest::radiusSearch( Mat& points, Mat& neighbors ) neighbors1.at(i,j) = *it; } // compare results - if( norm( neighbors, neighbors1, NORM_L1 ) != 0 ) + if( cvtest::norm( neighbors, neighbors1, NORM_L1 ) != 0 ) return cvtest::TS::FAIL_BAD_ACCURACY; return cvtest::TS::OK; diff --git a/modules/highgui/test/test_drawing.cpp b/modules/highgui/test/test_drawing.cpp index 0769f0ce7f..9d9e17dde2 100644 --- a/modules/highgui/test/test_drawing.cpp +++ b/modules/highgui/test/test_drawing.cpp @@ -76,7 +76,7 @@ void CV_DrawingTest::run( int ) } else { - float err = (float)norm( testImg, valImg, CV_RELATIVE_L1 ); + float err = (float)cvtest::norm( testImg, valImg, CV_RELATIVE_L1 ); float Eps = 0.9f; if( err > Eps) { @@ -229,7 +229,7 @@ int CV_DrawingTest_CPP::checkLineIterator( Mat& img ) for(int i = 0; i < it.count; ++it, i++ ) { Vec3b v = (Vec3b)(*(*it)) - img.at(300,i); - float err = (float)norm( v ); + float err = (float)cvtest::norm( v, NORM_L2 ); if( err != 0 ) { ts->printf( ts->LOG, "LineIterator works incorrect" ); @@ -395,7 +395,7 @@ int CV_DrawingTest_C::checkLineIterator( Mat& _img ) for(int i = 0; i < count; i++ ) { Vec3b v = (Vec3b)(*(it.ptr)) - _img.at(300,i); - float err = (float)norm( v ); + float err = (float)cvtest::norm( v, NORM_L2 ); if( err != 0 ) { ts->printf( ts->LOG, "CvLineIterator works incorrect" ); diff --git a/modules/highgui/test/test_ffmpeg.cpp b/modules/highgui/test/test_ffmpeg.cpp index 5dcd67be60..f8491d1a69 100644 --- a/modules/highgui/test/test_ffmpeg.cpp +++ b/modules/highgui/test/test_ffmpeg.cpp @@ -163,7 +163,7 @@ public: CV_Assert( !img0.empty() && !img.empty() && img_next.empty() ); - double diff = norm(img0, img, CV_C); + double diff = cvtest::norm(img0, img, CV_C); CV_Assert( diff == 0 ); } catch(...) diff --git a/modules/highgui/test/test_grfmt.cpp b/modules/highgui/test/test_grfmt.cpp index 2f76406296..e4d3e70461 100644 --- a/modules/highgui/test/test_grfmt.cpp +++ b/modules/highgui/test/test_grfmt.cpp @@ -121,7 +121,7 @@ public: CV_Assert(img.type() == img_test.type()); CV_Assert(num_channels == img_test.channels()); - double n = norm(img, img_test); + double n = cvtest::norm(img, img_test, NORM_L2); if ( n > 1.0) { ts->printf(ts->LOG, "norm = %f \n", n); @@ -151,7 +151,7 @@ public: CV_Assert(img.size() == img_test.size()); CV_Assert(img.type() == img_test.type()); - double n = norm(img, img_test); + double n = cvtest::norm(img, img_test, NORM_L2); if ( n > 1.0) { ts->printf(ts->LOG, "norm = %f \n", n); @@ -183,7 +183,7 @@ public: CV_Assert(img.type() == img_test.type()); - double n = norm(img, img_test); + double n = cvtest::norm(img, img_test, NORM_L2); if ( n > 1.0) { ts->printf(ts->LOG, "norm = %f \n", n); @@ -210,7 +210,7 @@ public: { Mat rle = imread(string(ts->get_data_path()) + "readwrite/rle8.bmp"); Mat bmp = imread(string(ts->get_data_path()) + "readwrite/ordinary.bmp"); - if (norm(rle-bmp)>1.e-10) + if (cvtest::norm(rle-bmp, NORM_L2)>1.e-10) ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); } catch(...) @@ -406,7 +406,7 @@ TEST(Highgui_Jpeg, encode_decode_progressive_jpeg) EXPECT_NO_THROW(cv::imwrite(output_normal, img)); cv::Mat img_jpg_normal = cv::imread(output_normal); - EXPECT_EQ(0, cv::norm(img_jpg_progressive, img_jpg_normal, NORM_INF)); + EXPECT_EQ(0, cvtest::norm(img_jpg_progressive, img_jpg_normal, NORM_INF)); remove(output_progressive.c_str()); } @@ -430,7 +430,7 @@ TEST(Highgui_Jpeg, encode_decode_optimize_jpeg) EXPECT_NO_THROW(cv::imwrite(output_normal, img)); cv::Mat img_jpg_normal = cv::imread(output_normal); - EXPECT_EQ(0, cv::norm(img_jpg_optimized, img_jpg_normal, NORM_INF)); + EXPECT_EQ(0, cvtest::norm(img_jpg_optimized, img_jpg_normal, NORM_INF)); remove(output_optimized.c_str()); } @@ -612,11 +612,11 @@ TEST(Highgui_WebP, encode_decode_lossless_webp) cv::Mat decode = cv::imdecode(buf, IMREAD_COLOR); ASSERT_FALSE(decode.empty()); - EXPECT_TRUE(cv::norm(decode, img_webp, NORM_INF) == 0); + EXPECT_TRUE(cvtest::norm(decode, img_webp, NORM_INF) == 0); ASSERT_FALSE(img_webp.empty()); - EXPECT_TRUE(cv::norm(img, img_webp, NORM_INF) == 0); + EXPECT_TRUE(cvtest::norm(img, img_webp, NORM_INF) == 0); } TEST(Highgui_WebP, encode_decode_lossy_webp) diff --git a/modules/imgproc/test/test_bilateral_filter.cpp b/modules/imgproc/test/test_bilateral_filter.cpp index 0bfc3dc4cc..ba4c9d57b8 100644 --- a/modules/imgproc/test/test_bilateral_filter.cpp +++ b/modules/imgproc/test/test_bilateral_filter.cpp @@ -264,7 +264,7 @@ namespace cvtest reference_dst.convertTo(reference_dst, type); } - double e = norm(reference_dst, _parallel_dst); + double e = cvtest::norm(reference_dst, _parallel_dst, NORM_L2); if (e > eps) { ts->printf(cvtest::TS::CONSOLE, "actual error: %g, expected: %g", e, eps); diff --git a/modules/imgproc/test/test_connectedcomponents.cpp b/modules/imgproc/test/test_connectedcomponents.cpp index a9567da970..dd4d8339a0 100644 --- a/modules/imgproc/test/test_connectedcomponents.cpp +++ b/modules/imgproc/test/test_connectedcomponents.cpp @@ -91,12 +91,12 @@ void CV_ConnectedComponentsTest::run( int /* start_from */) exp = labelImage; } - if (0 != norm(labelImage > 0, exp > 0, NORM_INF)) + if (0 != cvtest::norm(labelImage > 0, exp > 0, NORM_INF)) { ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH ); return; } - if (nLabels != norm(labelImage, NORM_INF)+1) + if (nLabels != cvtest::norm(labelImage, NORM_INF)+1) { ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH ); return; diff --git a/modules/imgproc/test/test_convhull.cpp b/modules/imgproc/test/test_convhull.cpp index 2b6169cf5b..6b5144f924 100644 --- a/modules/imgproc/test/test_convhull.cpp +++ b/modules/imgproc/test/test_convhull.cpp @@ -566,6 +566,8 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx ) hull = cvCreateMat( 1, hull_count, CV_32FC2 ); mask = cvCreateMat( 1, hull_count, CV_8UC1 ); cvZero( mask ); + Mat _mask = cvarrToMat(mask); + h = (CvPoint2D32f*)(hull->data.ptr); // extract convex hull points @@ -643,7 +645,7 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx ) mask->data.ptr[idx] = (uchar)1; } - if( cvNorm( mask, 0, CV_L1 ) != hull_count ) + if( cvtest::norm( _mask, Mat::zeros(_mask.dims, _mask.size, _mask.type()), NORM_L1 ) != hull_count ) { ts->printf( cvtest::TS::LOG, "Not every convex hull vertex coincides with some input point\n" ); code = cvtest::TS::FAIL_BAD_ACCURACY; diff --git a/modules/imgproc/test/test_houghLines.cpp b/modules/imgproc/test/test_houghLines.cpp index fa9ecafef0..660b3dd583 100644 --- a/modules/imgproc/test/test_houghLines.cpp +++ b/modules/imgproc/test/test_houghLines.cpp @@ -137,7 +137,7 @@ void CV_HoughLinesTest::run_test(int type) if( exp_lines.size != lines.size ) transpose(lines, lines); - if ( exp_lines.size != lines.size || norm(exp_lines, lines, NORM_INF) > 1e-4 ) + if ( exp_lines.size != lines.size || cvtest::norm(exp_lines, lines, NORM_INF) > 1e-4 ) { ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); return; diff --git a/modules/imgproc/test/test_imgwarp.cpp b/modules/imgproc/test/test_imgwarp.cpp index 53f7d5c2fc..b0897483a2 100644 --- a/modules/imgproc/test/test_imgwarp.cpp +++ b/modules/imgproc/test/test_imgwarp.cpp @@ -1530,7 +1530,7 @@ TEST(Imgproc_resize_area, regression) } } - ASSERT_EQ(norm(one_channel_diff, cv::NORM_INF), 0); + ASSERT_EQ(cvtest::norm(one_channel_diff, cv::NORM_INF), 0); } diff --git a/modules/imgproc/test/test_imgwarp_strict.cpp b/modules/imgproc/test/test_imgwarp_strict.cpp index 76d65b198b..07c5e0cc85 100644 --- a/modules/imgproc/test/test_imgwarp_strict.cpp +++ b/modules/imgproc/test/test_imgwarp_strict.cpp @@ -254,7 +254,7 @@ void CV_ImageWarpBaseTest::validate_results() const // fabs(rD[dx] - D[dx]) < 250.0f && rD[dx] <= 255.0f && D[dx] <= 255.0f && rD[dx] >= 0.0f && D[dx] >= 0.0f) { - PRINT_TO_LOG("\nNorm of the difference: %lf\n", norm(reference_dst, _dst, NORM_INF)); + PRINT_TO_LOG("\nNorm of the difference: %lf\n", cvtest::norm(reference_dst, _dst, NORM_INF)); PRINT_TO_LOG("Error in (dx, dy): (%d, %d)\n", dx / cn + 1, dy + 1); PRINT_TO_LOG("Tuple (rD, D): (%f, %f)\n", rD[dx], D[dx]); PRINT_TO_LOG("Dsize: (%d, %d)\n", dsize.width / cn, dsize.height); diff --git a/modules/ml/test/test_mltests2.cpp b/modules/ml/test/test_mltests2.cpp index 4f6c95921e..560c449321 100644 --- a/modules/ml/test/test_mltests2.cpp +++ b/modules/ml/test/test_mltests2.cpp @@ -52,7 +52,9 @@ void nbayes_check_data( CvMLData* _data ) CV_Error( CV_StsBadArg, "missing values are not supported" ); const CvMat* var_types = _data->get_var_types(); bool is_classifier = var_types->data.ptr[var_types->cols-1] == CV_VAR_CATEGORICAL; - if( ( fabs( cvNorm( var_types, 0, CV_L1 ) - + + Mat _var_types = cvarrToMat(var_types); + if( ( fabs( cvtest::norm( _var_types, Mat::zeros(_var_types.dims, _var_types.size, _var_types.type()), CV_L1 ) - (var_types->rows + var_types->cols - 2)*CV_VAR_ORDERED - CV_VAR_CATEGORICAL ) > FLT_EPSILON ) || !is_classifier ) CV_Error( CV_StsBadArg, "incorrect types of predictors or responses" ); diff --git a/modules/ml/test/test_save_load.cpp b/modules/ml/test/test_save_load.cpp index 7300185b4d..8b58ce534a 100644 --- a/modules/ml/test/test_save_load.cpp +++ b/modules/ml/test/test_save_load.cpp @@ -184,8 +184,8 @@ TEST(DISABLED_ML_SVM, linear_save_load) svm3.predict(samples, r3); double eps = 1e-4; - EXPECT_LE(norm(r1, r2, NORM_INF), eps); - EXPECT_LE(norm(r1, r3, NORM_INF), eps); + EXPECT_LE(cvtest::norm(r1, r2, NORM_INF), eps); + EXPECT_LE(cvtest::norm(r1, r3, NORM_INF), eps); remove(tname.c_str()); } diff --git a/modules/objdetect/test/test_cascadeandhog.cpp b/modules/objdetect/test/test_cascadeandhog.cpp index 746a48ca97..4a311e49e9 100644 --- a/modules/objdetect/test/test_cascadeandhog.cpp +++ b/modules/objdetect/test/test_cascadeandhog.cpp @@ -1087,7 +1087,7 @@ void HOGDescriptorTester::detect(const Mat& img, } const double eps = 0.0; - double diff_norm = norm(Mat(actual_weights) - Mat(weights), NORM_L2); + double diff_norm = cvtest::norm(actual_weights, weights, NORM_L2); if (diff_norm > eps) { ts->printf(cvtest::TS::SUMMARY, "Weights for found locations aren't equal.\n" @@ -1168,7 +1168,7 @@ void HOGDescriptorTester::compute(InputArray _img, vector& descriptors, std::vector actual_descriptors; actual_hog->compute(img, actual_descriptors, winStride, padding, locations); - double diff_norm = cv::norm(Mat(actual_descriptors) - Mat(descriptors), NORM_L2); + double diff_norm = cvtest::norm(actual_descriptors, descriptors, NORM_L2); const double eps = 0.0; if (diff_norm > eps) { @@ -1318,7 +1318,7 @@ void HOGDescriptorTester::computeGradient(const Mat& img, Mat& grad, Mat& qangle const double eps = 0.0; for (i = 0; i < 2; ++i) { - double diff_norm = norm(reference_mats[i] - actual_mats[i], NORM_L2); + double diff_norm = cvtest::norm(reference_mats[i], actual_mats[i], NORM_L2); if (diff_norm > eps) { ts->printf(cvtest::TS::LOG, "%s matrices are not equal\n" diff --git a/modules/ts/include/opencv2/ts.hpp b/modules/ts/include/opencv2/ts.hpp index 8febfca9c8..457f00b3e2 100644 --- a/modules/ts/include/opencv2/ts.hpp +++ b/modules/ts/include/opencv2/ts.hpp @@ -47,6 +47,8 @@ using cv::Scalar; using cv::Size; using cv::Point; using cv::Rect; +using cv::InputArray; +using cv::noArray; class CV_EXPORTS TS; @@ -124,8 +126,8 @@ CV_EXPORTS void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx CV_EXPORTS void minMaxLoc(const Mat& src, double* minval, double* maxval, vector* minloc, vector* maxloc, const Mat& mask=Mat()); -CV_EXPORTS double norm(const Mat& src, int normType, const Mat& mask=Mat()); -CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask=Mat()); +CV_EXPORTS double norm(InputArray src, int normType, InputArray mask=noArray()); +CV_EXPORTS double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray()); CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask=Mat()); CV_EXPORTS bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector* idx); diff --git a/modules/ts/include/opencv2/ts/ocl_test.hpp b/modules/ts/include/opencv2/ts/ocl_test.hpp index 28ff674911..5dd25dba4f 100644 --- a/modules/ts/include/opencv2/ts/ocl_test.hpp +++ b/modules/ts/include/opencv2/ts/ocl_test.hpp @@ -243,9 +243,9 @@ struct CV_EXPORTS TestUtils static inline double checkNormRelative(InputArray m1, InputArray m2, InputArray mask = noArray()) { - return cv::norm(m1.getMat(), m2.getMat(), cv::NORM_INF, mask) / + return cvtest::norm(m1.getMat(), m2.getMat(), cv::NORM_INF, mask) / std::max((double)std::numeric_limits::epsilon(), - (double)std::max(cv::norm(m1.getMat(), cv::NORM_INF), norm(m2.getMat(), cv::NORM_INF))); + (double)std::max(cvtest::norm(m1.getMat(), cv::NORM_INF), cvtest::norm(m2.getMat(), cv::NORM_INF))); } }; diff --git a/modules/ts/src/ocl_test.cpp b/modules/ts/src/ocl_test.cpp index 0291cadbed..a2a75cf888 100644 --- a/modules/ts/src/ocl_test.cpp +++ b/modules/ts/src/ocl_test.cpp @@ -225,12 +225,12 @@ Mat TestUtils::readImageType(const String &fname, int type) double TestUtils::checkNorm1(InputArray m, InputArray mask) { - return norm(m.getMat(), NORM_INF, mask); + return cvtest::norm(m.getMat(), NORM_INF, mask.getMat()); } double TestUtils::checkNorm2(InputArray m1, InputArray m2, InputArray mask) { - return norm(m1.getMat(), m2.getMat(), NORM_INF, mask); + return cvtest::norm(m1.getMat(), m2.getMat(), NORM_INF, mask.getMat()); } double TestUtils::checkSimilarity(InputArray m1, InputArray m2) diff --git a/modules/ts/src/ts_func.cpp b/modules/ts/src/ts_func.cpp index 89c91b98f1..e3563caa4f 100644 --- a/modules/ts/src/ts_func.cpp +++ b/modules/ts/src/ts_func.cpp @@ -1238,15 +1238,16 @@ norm_(const _Tp* src1, const _Tp* src2, size_t total, int cn, int normType, doub } -double norm(const Mat& src, int normType, const Mat& mask) +double norm(InputArray _src, int normType, InputArray _mask) { + Mat src = _src.getMat(), mask = _mask.getMat(); if( normType == NORM_HAMMING || normType == NORM_HAMMING2 ) { if( !mask.empty() ) { Mat temp; bitwise_and(src, mask, temp); - return norm(temp, normType, Mat()); + return cvtest::norm(temp, normType, Mat()); } CV_Assert( src.depth() == CV_8U ); @@ -1317,8 +1318,12 @@ double norm(const Mat& src, int normType, const Mat& mask) } -double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask) +double norm(InputArray _src1, InputArray _src2, int normType, InputArray _mask) { + Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat(); + bool isRelative = (normType & NORM_RELATIVE) != 0; + normType &= ~NORM_RELATIVE; + if( normType == NORM_HAMMING || normType == NORM_HAMMING2 ) { Mat temp; @@ -1391,7 +1396,7 @@ double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask) } if( normType0 == NORM_L2 ) result = sqrt(result); - return result; + return isRelative ? result / (cvtest::norm(src2, normType) + DBL_EPSILON) : result; }