Added license header, using cv::Ptr, small fixes.

modules/core/include/opencv2/core/cvdef.h

@@ -244,7 +244,7 @@ typedef signed char schar;
 
 /* fundamental constants */
 #define CV_PI   3.1415926535897932384626433832795
-#define CV_TWO_PI 6.283185307179586476925286766559
+#define CV_2PI 6.283185307179586476925286766559
 #define CV_LOG2 0.69314718055994530941723212145818
 
 /****************************************************************************************\

modules/core/src/dxt.cpp

@@ -1788,89 +1788,23 @@ namespace cv
 
 enum FftType
 {
-    R2R = 0,
-    C2R = 1,
-    R2C = 2,
-    C2C = 3
+    R2R = 0, // real to CCS in case forward transform, CCS to real otherwise
+    C2R = 1, // complex to real in case inverse transform
+    R2C = 2, // real to complex in case forward transform
+    C2C = 3  // complex to complex
 };
 
-static void ocl_getRadixes(int cols, std::vector<int>& radixes, std::vector<int>& blocks, int& min_radix)
-{
-    int factors[34];
-    int nf = DFTFactorize(cols, factors);
-
-    int n = 1;
-    int factor_index = 0;
-    min_radix = INT_MAX;
-
-    // 2^n transforms
-    if ((factors[factor_index] & 1) == 0)
-    {
-        for( ; n < factors[factor_index];)
-        {
-            int radix = 2, block = 1;
-            if (8*n <= factors[0])
-                radix = 8;
-            else if (4*n <= factors[0])
-            {
-                radix = 4;
-                if (cols % 12 == 0)
-                    block = 3;
-                else if (cols % 8 == 0)
-                    block = 2;
-            }
-            else
-            {
-                if (cols % 10 == 0)
-                    block = 5;
-                else if (cols % 8 == 0)
-                    block = 4;
-                else if (cols % 6 == 0)
-                    block = 3;
-                else if (cols % 4 == 0)
-                    block = 2;
-            }
-
-            radixes.push_back(radix);
-            blocks.push_back(block);
-            min_radix = min(min_radix, block*radix);
-            n *= radix;
-        }
-        factor_index++;
-    }
-
-    // all the other transforms
-    for( ; factor_index < nf; factor_index++)
-    {
-        int radix = factors[factor_index], block = 1;
-        if (radix == 3)
-        {
-            if (cols % 12 == 0)
-                block = 4;
-            else if (cols % 9 == 0)
-                block = 3;
-            else if (cols % 6 == 0)
-                block = 2;
-        }
-        else if (radix == 5)
-        {
-            if (cols % 10 == 0)
-                block = 2;
-        }
-        radixes.push_back(radix);
-        blocks.push_back(block);
-        min_radix = min(min_radix, block*radix);
-    }
-}
-
 struct OCL_FftPlan
 {
+private:
     UMat twiddles;
     String buildOptions;
     int thread_count;
+    bool status;
 
+public:
     int dft_size;
-    bool status;
+
     OCL_FftPlan(int _size): dft_size(_size), status(true)
     {
         int min_radix;
@@ -1910,7 +1844,7 @@ struct OCL_FftPlan
 
             for (int j=1; j<radix; j++)
             {
-                double theta = -CV_TWO_PI*j/n;
+                double theta = -CV_2PI*j/n;
 
                 for (int k=0; k<(n/radix); k++)
                 {
@@ -1922,7 +1856,7 @@ struct OCL_FftPlan
         twiddles = tw.getUMat(ACCESS_READ);
 
         buildOptions = format("-D LOCAL_SIZE=%d -D kercn=%d -D RADIX_PROCESS=%s",
-                              dft_size, dft_size/thread_count, radix_processing.c_str());
+                              dft_size, min_radix, radix_processing.c_str());
     }
 
     bool enqueueTransform(InputArray _src, OutputArray _dst, int num_dfts, int flags, int fftType, bool rows = true) const
@@ -1982,6 +1916,76 @@ struct OCL_FftPlan
         k.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnly(dst), ocl::KernelArg::PtrReadOnly(twiddles), thread_count, num_dfts);
         return k.run(2, globalsize, localsize, false);
     }
+
+private:
+    static void ocl_getRadixes(int cols, std::vector<int>& radixes, std::vector<int>& blocks, int& min_radix)
+    {
+        int factors[34];
+        int nf = DFTFactorize(cols, factors);
+
+        int n = 1;
+        int factor_index = 0;
+        min_radix = INT_MAX;
+
+        // 2^n transforms
+        if ((factors[factor_index] & 1) == 0)
+        {
+            for( ; n < factors[factor_index];)
+            {
+                int radix = 2, block = 1;
+                if (8*n <= factors[0])
+                    radix = 8;
+                else if (4*n <= factors[0])
+                {
+                    radix = 4;
+                    if (cols % 12 == 0)
+                        block = 3;
+                    else if (cols % 8 == 0)
+                        block = 2;
+                }
+                else
+                {
+                    if (cols % 10 == 0)
+                        block = 5;
+                    else if (cols % 8 == 0)
+                        block = 4;
+                    else if (cols % 6 == 0)
+                        block = 3;
+                    else if (cols % 4 == 0)
+                        block = 2;
+                }
+
+                radixes.push_back(radix);
+                blocks.push_back(block);
+                min_radix = min(min_radix, block*radix);
+                n *= radix;
+            }
+            factor_index++;
+        }
+
+        // all the other transforms
+        for( ; factor_index < nf; factor_index++)
+        {
+            int radix = factors[factor_index], block = 1;
+            if (radix == 3)
+            {
+                if (cols % 12 == 0)
+                    block = 4;
+                else if (cols % 9 == 0)
+                    block = 3;
+                else if (cols % 6 == 0)
+                    block = 2;
+            }
+            else if (radix == 5)
+            {
+                if (cols % 10 == 0)
+                    block = 2;
+            }
+            radixes.push_back(radix);
+            blocks.push_back(block);
+            min_radix = min(min_radix, block*radix);
+        }
+    }
 };
 
 class OCL_FftPlanCache
@@ -1993,27 +1997,24 @@ public:
         return planCache;
     }
 
-    OCL_FftPlan* getFftPlan(int dft_size)
+    Ptr<OCL_FftPlan> getFftPlan(int dft_size)
     {
         for (size_t i = 0, size = planStorage.size(); i < size; ++i)
         {
-            OCL_FftPlan * const plan = planStorage[i];
-
+            Ptr<OCL_FftPlan> plan = planStorage[i];
             if (plan->dft_size == dft_size)
             {
                 return plan;
             }
         }
 
-        OCL_FftPlan * newPlan = new OCL_FftPlan(dft_size);
+        Ptr<OCL_FftPlan> newPlan = Ptr<OCL_FftPlan>(new OCL_FftPlan(dft_size));
         planStorage.push_back(newPlan);
         return newPlan;
     }
 
     ~OCL_FftPlanCache()
     {
-        for (std::vector<OCL_FftPlan *>::iterator i = planStorage.begin(), end = planStorage.end(); i != end; ++i)
-            delete (*i);
         planStorage.clear();
     }
 
@@ -2023,18 +2024,18 @@ protected:
     {
     }
 
-    std::vector<OCL_FftPlan*> planStorage;
+    std::vector<Ptr<OCL_FftPlan> > planStorage;
 };
 
-static bool ocl_dft_C2C_rows(InputArray _src, OutputArray _dst, int nonzero_rows, int flags, int fftType)
+static bool ocl_dft_rows(InputArray _src, OutputArray _dst, int nonzero_rows, int flags, int fftType)
 {
-    const OCL_FftPlan* plan = OCL_FftPlanCache::getInstance().getFftPlan(_src.cols());
+    Ptr<OCL_FftPlan> plan = OCL_FftPlanCache::getInstance().getFftPlan(_src.cols());
     return plan->enqueueTransform(_src, _dst, nonzero_rows, flags, fftType, true);
 }
 
-static bool ocl_dft_C2C_cols(InputArray _src, OutputArray _dst, int nonzero_cols, int flags, int fftType)
+static bool ocl_dft_cols(InputArray _src, OutputArray _dst, int nonzero_cols, int flags, int fftType)
 {
-    const OCL_FftPlan* plan = OCL_FftPlanCache::getInstance().getFftPlan(_src.rows());
+    Ptr<OCL_FftPlan> plan = OCL_FftPlanCache::getInstance().getFftPlan(_src.rows());
     return plan->enqueueTransform(_src, _dst, nonzero_cols, flags, fftType, false);
 }
 
@@ -2103,13 +2104,13 @@ static bool ocl_dft(InputArray _src, OutputArray _dst, int flags, int nonzero_ro
 
     if (!inv)
     {
-        if (!ocl_dft_C2C_rows(src, output, nonzero_rows, flags, fftType))
+        if (!ocl_dft_rows(src, output, nonzero_rows, flags, fftType))
             return false;
 
         if (!is1d)
         {
             int nonzero_cols = fftType == R2R ? output.cols/2 + 1 : output.cols;
-            if (!ocl_dft_C2C_cols(output, _dst, nonzero_cols, flags, fftType))
+            if (!ocl_dft_cols(output, _dst, nonzero_cols, flags, fftType))
                 return false;
         }
     }
@@ -2118,12 +2119,12 @@ static bool ocl_dft(InputArray _src, OutputArray _dst, int flags, int nonzero_ro
         if (fftType == C2C)
         {
             // complex output
-            if (!ocl_dft_C2C_rows(src, output, nonzero_rows, flags, fftType))
+            if (!ocl_dft_rows(src, output, nonzero_rows, flags, fftType))
                 return false;
 
             if (!is1d)
             {
-                if (!ocl_dft_C2C_cols(output, output, output.cols, flags, fftType))
+                if (!ocl_dft_cols(output, output, output.cols, flags, fftType))
                     return false;
             }
         }
@@ -2131,16 +2132,16 @@ static bool ocl_dft(InputArray _src, OutputArray _dst, int flags, int nonzero_ro
         {
             if (is1d)
             {
-                if (!ocl_dft_C2C_rows(src, output, nonzero_rows, flags, fftType))
+                if (!ocl_dft_rows(src, output, nonzero_rows, flags, fftType))
                     return false;
             }
             else
             {
                 int nonzero_cols = src.cols/2 + 1;
-                if (!ocl_dft_C2C_cols(src, output, nonzero_cols, flags, fftType))
+                if (!ocl_dft_cols(src, output, nonzero_cols, flags, fftType))
                     return false;
 
-                if (!ocl_dft_C2C_rows(output, _dst, nonzero_rows, flags, fftType))
+                if (!ocl_dft_rows(output, _dst, nonzero_rows, flags, fftType))
                     return false;
             }
         }
@@ -2286,7 +2287,7 @@ public:
         }
 
         // no baked plan is found, so let's create a new one
-        FftPlan * newPlan = new FftPlan(dft_size, src_step, dst_step, doubleFP, inplace, flags, fftType);
+        Ptr<FftPlan> newPlan = Ptr<FftPlan>(new FftPlan(dft_size, src_step, dst_step, doubleFP, inplace, flags, fftType));
         planStorage.push_back(newPlan);
 
         return newPlan->plHandle;
@@ -2294,8 +2295,6 @@ public:
 
     ~PlanCache()
     {
-        for (std::vector<FftPlan *>::iterator i = planStorage.begin(), end = planStorage.end(); i != end; ++i)
-            delete (*i);
         planStorage.clear();
     }
 
@@ -2305,7 +2304,7 @@ protected:
     {
     }
 
-    std::vector<FftPlan *> planStorage;
+    std::vector<Ptr<FftPlan> > planStorage;
 };
 
 extern "C" {

modules/core/src/opencl/fft.cl

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Copyright (C) 2014, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
 #define SQRT_2 0.707106781188f
 #define sin_120 0.866025403784f
 #define fft5_2  0.559016994374f
@@ -509,9 +516,9 @@ void fft_radix5_B2(__local float2* smem, __global const float2* twiddles, const
 }
 
 #ifdef DFT_SCALE
-#define VAL(x, scale) x*scale
+#define SCALE_VAL(x, scale) x*scale
 #else
-#define VAL(x, scale) x
+#define SCALE_VAL(x, scale) x
 #endif
 
 __kernel void fft_multi_radix_rows(__global const uchar* src_ptr, int src_step, int src_offset, int src_rows, int src_cols,
@@ -558,15 +565,15 @@ __kernel void fft_multi_radix_rows(__global const uchar* src_ptr, int src_step,
         __global float2* dst = (__global float2*)(dst_ptr + mad24(y, dst_step, dst_offset));
         #pragma unroll
         for (int i=x; i<cols; i+=block_size)
-            dst[i] = VAL(smem[i], scale);
+            dst[i] = SCALE_VAL(smem[i], scale);
 #else
         // pack row to CCS
         __local float* smem_1cn = (__local float*) smem;
         __global float* dst = (__global float*)(dst_ptr + mad24(y, dst_step, dst_offset));
         for (int i=x; i<dst_cols-1; i+=block_size)
-            dst[i+1] = VAL(smem_1cn[i+2], scale);
+            dst[i+1] = SCALE_VAL(smem_1cn[i+2], scale);
         if (x == 0)
-            dst[0] = VAL(smem_1cn[0], scale);
+            dst[0] = SCALE_VAL(smem_1cn[0], scale);
 #endif
     }
     else
@@ -611,7 +618,7 @@ __kernel void fft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
         __global uchar* dst = dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(float)*2), dst_offset));
         #pragma unroll
         for (int i=0; i<kercn; i++)
-            *((__global float2*)(dst + i*block_size*dst_step)) = VAL(smem[y + i*block_size], scale);
+            *((__global float2*)(dst + i*block_size*dst_step)) = SCALE_VAL(smem[y + i*block_size], scale);
 #else
         if (x == 0)
         {
@@ -619,9 +626,9 @@ __kernel void fft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
             __local float* smem_1cn = (__local float*) smem;
             __global uchar* dst = dst_ptr + mad24(y+1, dst_step, dst_offset);
             for (int i=y; i<dst_rows-1; i+=block_size, dst+=dst_step*block_size)
-                *((__global float*) dst) = VAL(smem_1cn[i+2], scale);
+                *((__global float*) dst) = SCALE_VAL(smem_1cn[i+2], scale);
             if (y == 0)
-                *((__global float*) (dst_ptr + dst_offset)) = VAL(smem_1cn[0], scale);
+                *((__global float*) (dst_ptr + dst_offset)) = SCALE_VAL(smem_1cn[0], scale);
         }
         else if (x == (dst_cols+1)/2)
         {
@@ -629,16 +636,16 @@ __kernel void fft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
             __local float* smem_1cn = (__local float*) smem;
             __global uchar* dst = dst_ptr + mad24(dst_cols-1, (int)sizeof(float), mad24(y+1, dst_step, dst_offset));
             for (int i=y; i<dst_rows-1; i+=block_size, dst+=dst_step*block_size)
-                *((__global float*) dst) = VAL(smem_1cn[i+2], scale);
+                *((__global float*) dst) = SCALE_VAL(smem_1cn[i+2], scale);
             if (y == 0)
-                *((__global float*) (dst_ptr + mad24(dst_cols-1, (int)sizeof(float), dst_offset))) = VAL(smem_1cn[0], scale);
+                *((__global float*) (dst_ptr + mad24(dst_cols-1, (int)sizeof(float), dst_offset))) = SCALE_VAL(smem_1cn[0], scale);
         }
         else
         {
             __global uchar* dst = dst_ptr + mad24(x, (int)sizeof(float)*2, mad24(y, dst_step, dst_offset - (int)sizeof(float)));
             #pragma unroll
             for (int i=y; i<dst_rows; i+=block_size, dst+=block_size*dst_step)
-                vstore2(VAL(smem[i], scale), 0, (__global float*) dst);
+                vstore2(SCALE_VAL(smem[i], scale), 0, (__global float*) dst);
         }
 #endif
     }
@@ -724,15 +731,15 @@ __kernel void ifft_multi_radix_rows(__global const uchar* src_ptr, int src_step,
         #pragma unroll
         for (int i=0; i<kercn; i++)
         {
-            dst[i*block_size].x = VAL(smem[x + i*block_size].x, scale);
-            dst[i*block_size].y = VAL(-smem[x + i*block_size].y, scale);
+            dst[i*block_size].x = SCALE_VAL(smem[x + i*block_size].x, scale);
+            dst[i*block_size].y = SCALE_VAL(-smem[x + i*block_size].y, scale);
         }
 #else
         __global float* dst = (__global float*)(dst_ptr + mad24(y, dst_step, mad24(x, (int)(sizeof(float)), dst_offset)));
         #pragma unroll
         for (int i=0; i<kercn; i++)
         {
-            dst[i*block_size] = VAL(smem[x + i*block_size].x, scale);
+            dst[i*block_size] = SCALE_VAL(smem[x + i*block_size].x, scale);
         }
 #endif
     }
@@ -783,9 +790,9 @@ __kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
         #pragma unroll
         for (int i=0; i<kercn; i++)
         {
-           __global float2* rez = (__global float2*)(dst + i*block_size*dst_step);
-            rez[0].x = smem[y + i*block_size].x;
-            rez[0].y = -smem[y + i*block_size].y;
+           __global float2* res = (__global float2*)(dst + i*block_size*dst_step);
+            res[0].x = smem[y + i*block_size].x;
+            res[0].y = -smem[y + i*block_size].y;
         }
     }
 #else
@@ -848,9 +855,9 @@ __kernel void ifft_multi_radix_cols(__global const uchar* src_ptr, int src_step,
         #pragma unroll
         for (int i=0; i<kercn; i++)
         {
-            __global float2* rez = (__global float2*)(dst + i*block_size*dst_step);
-            rez[0].x =  smem[y + i*block_size].x;
-            rez[0].y = -smem[y + i*block_size].y;
+            __global float2* res = (__global float2*)(dst + i*block_size*dst_step);
+            res[0].x =  smem[y + i*block_size].x;
+            res[0].y = -smem[y + i*block_size].y;
         }
     }
 #endif