--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////\r
+//\r
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
+//\r
+// By downloading, copying, installing or using the software you agree to this license.\r
+// If you do not agree to this license, do not download, install,\r
+// copy or use the software.\r
+//\r
+//\r
+// License Agreement\r
+// For Open Source Computer Vision Library\r
+//\r
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.\r
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.\r
+// Third party copyrights are property of their respective owners.\r
+//\r
+// Redistribution and use in source and binary forms, with or without modification,\r
+// are permitted provided that the following conditions are met:\r
+//\r
+// * Redistribution's of source code must retain the above copyright notice,\r
+// this list of conditions and the following disclaimer.\r
+//\r
+// * Redistribution's in binary form must reproduce the above copyright notice,\r
+// this list of conditions and the following disclaimer in the documentation\r
+// and/or other materials provided with the distribution.\r
+//\r
+// * The name of the copyright holders may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// This software is provided by the copyright holders and contributors "as is" and\r
+// any express or implied warranties, including, but not limited to, the implied\r
+// warranties of merchantability and fitness for a particular purpose are disclaimed.\r
+// In no event shall the Intel Corporation or contributors be liable for any direct,\r
+// indirect, incidental, special, exemplary, or consequential damages\r
+// (including, but not limited to, procurement of substitute goods or services;\r
+// loss of use, data, or profits; or business interruption) however caused\r
+// and on any theory of liability, whether in contract, strict liability,\r
+// or tort (including negligence or otherwise) arising in any way out of\r
+// the use of this software, even if advised of the possibility of such damage.\r
+//\r
+//M*/\r
+\r
+#include "_cv.h"\r
+\r
+/*\r
+ * This file includes the code, contributed by Simon Perreault\r
+ * (the function icvMedianBlur_8u_O1)\r
+ *\r
+ * Constant-time median filtering -- http://nomis80.org/ctmf.html\r
+ * Copyright (C) 2006 Simon Perreault\r
+ *\r
+ * Contact:\r
+ * Laboratoire de vision et systemes numeriques\r
+ * Pavillon Adrien-Pouliot\r
+ * Universite Laval\r
+ * Sainte-Foy, Quebec, Canada\r
+ * G1K 7P4\r
+ *\r
+ * perreaul@gel.ulaval.ca\r
+ */\r
+\r
+namespace cv\r
+{\r
+\r
+/****************************************************************************************\\r
+ Box Filter\r
+\****************************************************************************************/\r
+\r
+template<typename T, typename ST> struct RowSum : public BaseRowFilter\r
+{\r
+ RowSum( int _ksize, int _anchor )\r
+ {\r
+ ksize = _ksize;\r
+ anchor = _anchor;\r
+ }\r
+ \r
+ void operator()(const uchar* src, uchar* dst, int width, int cn)\r
+ {\r
+ const T* S = (const T*)src;\r
+ ST* D = (ST*)dst;\r
+ int i = 0, k, ksz_cn = ksize*cn;\r
+ \r
+ width = (width - 1)*cn;\r
+ for( k = 0; k < cn; k++, S++, D++ )\r
+ {\r
+ ST s = 0;\r
+ for( i = 0; i < ksz_cn; i += cn )\r
+ s += S[i];\r
+ D[0] = s;\r
+ for( i = 0; i < width; i += cn )\r
+ {\r
+ s += S[i + ksz_cn] - S[i];\r
+ D[i+cn] = s;\r
+ }\r
+ }\r
+ }\r
+};\r
+\r
+\r
+template<typename ST, typename T> struct ColumnSum : public BaseColumnFilter\r
+{\r
+ ColumnSum( int _ksize, int _anchor, double _scale )\r
+ {\r
+ ksize = _ksize;\r
+ anchor = _anchor;\r
+ scale = _scale;\r
+ sumCount = 0;\r
+ }\r
+\r
+ void reset() { sumCount = 0; }\r
+ \r
+ void operator()(const uchar** src, uchar* dst, int dststep, int count, int width)\r
+ {\r
+ int i;\r
+ ST* SUM;\r
+ bool haveScale = scale != 1;\r
+ double _scale = scale;\r
+\r
+ if( width != (int)sum.size() )\r
+ {\r
+ sum.resize(width);\r
+ sumCount = 0;\r
+ }\r
+\r
+ SUM = &sum[0];\r
+ if( sumCount == 0 )\r
+ {\r
+ for( i = 0; i < width; i++ )\r
+ SUM[i] = 0;\r
+ for( ; sumCount < ksize - 1; sumCount++, src++ )\r
+ {\r
+ const ST* Sp = (const ST*)src[0];\r
+ for( i = 0; i <= width - 2; i += 2 )\r
+ {\r
+ ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];\r
+ SUM[i] = s0; SUM[i+1] = s1;\r
+ }\r
+\r
+ for( ; i < width; i++ )\r
+ SUM[i] += Sp[i];\r
+ }\r
+ }\r
+ else\r
+ {\r
+ CV_Assert( sumCount == ksize-1 );\r
+ src += ksize-1;\r
+ }\r
+\r
+ for( ; count--; src++ )\r
+ {\r
+ const ST* Sp = (const ST*)src[0];\r
+ const ST* Sm = (const ST*)src[1-ksize];\r
+ T* D = (T*)dst;\r
+ if( haveScale )\r
+ {\r
+ for( i = 0; i <= width - 2; i += 2 )\r
+ {\r
+ ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];\r
+ D[i] = saturate_cast<T>(s0*_scale);\r
+ D[i+1] = saturate_cast<T>(s1*_scale);\r
+ s0 -= Sm[i]; s1 -= Sm[i+1];\r
+ SUM[i] = s0; SUM[i+1] = s1;\r
+ }\r
+\r
+ for( ; i < width; i++ )\r
+ {\r
+ ST s0 = SUM[i] + Sp[i];\r
+ D[i] = saturate_cast<T>(s0*_scale);\r
+ SUM[i] = s0 - Sm[i];\r
+ }\r
+ }\r
+ else\r
+ {\r
+ for( i = 0; i <= width - 2; i += 2 )\r
+ {\r
+ ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];\r
+ D[i] = saturate_cast<T>(s0);\r
+ D[i+1] = saturate_cast<T>(s1);\r
+ s0 -= Sm[i]; s1 -= Sm[i+1];\r
+ SUM[i] = s0; SUM[i+1] = s1;\r
+ }\r
+\r
+ for( ; i < width; i++ )\r
+ {\r
+ ST s0 = SUM[i] + Sp[i];\r
+ D[i] = saturate_cast<T>(s0);\r
+ SUM[i] = s0 - Sm[i];\r
+ }\r
+ }\r
+ dst += dststep;\r
+ }\r
+ }\r
+\r
+ double scale;\r
+ int sumCount;\r
+ vector<ST> sum;\r
+};\r
+\r
+\r
+Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType, int ksize, int anchor)\r
+{\r
+ int sdepth = CV_MAT_DEPTH(srcType), ddepth = CV_MAT_DEPTH(sumType);\r
+ CV_Assert( CV_MAT_CN(sumType) == CV_MAT_CN(srcType) );\r
+\r
+ if( anchor < 0 )\r
+ anchor = ksize/2;\r
+\r
+ if( sdepth == CV_8U && ddepth == CV_32S )\r
+ return Ptr<BaseRowFilter>(new RowSum<uchar, int>(ksize, anchor));\r
+ if( sdepth == CV_8U && ddepth == CV_64F )\r
+ return Ptr<BaseRowFilter>(new RowSum<uchar, double>(ksize, anchor));\r
+ if( sdepth == CV_16U && ddepth == CV_32S )\r
+ return Ptr<BaseRowFilter>(new RowSum<ushort, int>(ksize, anchor));\r
+ if( sdepth == CV_16U && ddepth == CV_64F )\r
+ return Ptr<BaseRowFilter>(new RowSum<ushort, double>(ksize, anchor));\r
+ if( sdepth == CV_16S && ddepth == CV_32S )\r
+ return Ptr<BaseRowFilter>(new RowSum<short, int>(ksize, anchor));\r
+ if( sdepth == CV_32S && ddepth == CV_32S )\r
+ return Ptr<BaseRowFilter>(new RowSum<int, int>(ksize, anchor));\r
+ if( sdepth == CV_16S && ddepth == CV_64F )\r
+ return Ptr<BaseRowFilter>(new RowSum<short, double>(ksize, anchor));\r
+ if( sdepth == CV_32F && ddepth == CV_64F )\r
+ return Ptr<BaseRowFilter>(new RowSum<float, double>(ksize, anchor));\r
+ if( sdepth == CV_64F && ddepth == CV_64F )\r
+ return Ptr<BaseRowFilter>(new RowSum<double, double>(ksize, anchor));\r
+\r
+ CV_Error_( CV_StsNotImplemented,\r
+ ("Unsupported combination of source format (=%d), and buffer format (=%d)",\r
+ srcType, sumType));\r
+\r
+ return Ptr<BaseRowFilter>(0);\r
+}\r
+\r
+\r
+Ptr<BaseColumnFilter> getColumnSumFilter(int sumType, int dstType, int ksize,\r
+ int anchor, double scale)\r
+{\r
+ int sdepth = CV_MAT_DEPTH(sumType), ddepth = CV_MAT_DEPTH(dstType);\r
+ CV_Assert( CV_MAT_CN(sumType) == CV_MAT_CN(dstType) );\r
+\r
+ if( anchor < 0 )\r
+ anchor = ksize/2;\r
+\r
+ if( ddepth == CV_8U && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, uchar>(ksize, anchor, scale));\r
+ if( ddepth == CV_8U && sdepth == CV_64F )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<double, uchar>(ksize, anchor, scale));\r
+ if( ddepth == CV_16U && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, ushort>(ksize, anchor, scale));\r
+ if( ddepth == CV_16U && sdepth == CV_64F )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<double, ushort>(ksize, anchor, scale));\r
+ if( ddepth == CV_16S && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, short>(ksize, anchor, scale));\r
+ if( ddepth == CV_16S && sdepth == CV_64F )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<double, short>(ksize, anchor, scale));\r
+ if( ddepth == CV_32S && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, int>(ksize, anchor, scale));\r
+ if( ddepth == CV_32F && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, float>(ksize, anchor, scale));\r
+ if( ddepth == CV_32F && sdepth == CV_64F )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<double, float>(ksize, anchor, scale));\r
+ if( ddepth == CV_64F && sdepth == CV_32S )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<int, double>(ksize, anchor, scale));\r
+ if( ddepth == CV_64F && sdepth == CV_64F )\r
+ return Ptr<BaseColumnFilter>(new ColumnSum<double, double>(ksize, anchor, scale));\r
+\r
+ CV_Error_( CV_StsNotImplemented,\r
+ ("Unsupported combination of sum format (=%d), and destination format (=%d)",\r
+ sumType, dstType));\r
+\r
+ return Ptr<BaseColumnFilter>(0);\r
+}\r
+\r
+\r
+Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,\r
+ Point anchor, bool normalize, int borderType )\r
+{\r
+ int sdepth = CV_MAT_DEPTH(srcType);\r
+ int cn = CV_MAT_CN(srcType), sumType = CV_64F;\r
+ if( sdepth < CV_32S && (!normalize ||\r
+ ksize.width*ksize.height <= (sdepth == CV_8U ? (1<<23) :\r
+ sdepth == CV_16U ? (1 << 15) : (1 << 16))) )\r
+ sumType = CV_32S;\r
+ sumType = CV_MAKETYPE( sumType, cn );\r
+\r
+ Ptr<BaseRowFilter> rowFilter = getRowSumFilter(srcType, sumType, ksize.width, anchor.x );\r
+ Ptr<BaseColumnFilter> columnFilter = getColumnSumFilter(sumType,\r
+ dstType, ksize.height, anchor.y, normalize ? 1./(ksize.width*ksize.height) : 1);\r
+\r
+ return Ptr<FilterEngine>(new FilterEngine(Ptr<BaseFilter>(0), rowFilter, columnFilter,\r
+ srcType, dstType, sumType, borderType ));\r
+}\r
+\r
+\r
+void boxFilter( const Mat& src, Mat& dst, int ddepth,\r
+ Size ksize, Point anchor,\r
+ bool normalize, int borderType )\r
+{\r
+ int sdepth = src.depth(), cn = src.channels();\r
+ if( ddepth < 0 )\r
+ ddepth = sdepth;\r
+ dst.create( src.size(), CV_MAKETYPE(ddepth, cn) );\r
+ if( borderType != BORDER_CONSTANT && normalize )\r
+ {\r
+ if( src.rows == 1 )\r
+ ksize.height = 1;\r
+ if( src.cols == 1 )\r
+ ksize.width = 1;\r
+ }\r
+ Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(),\r
+ ksize, anchor, normalize, borderType );\r
+ f->apply( src, dst );\r
+}\r
+\r
+/****************************************************************************************\\r
+ Gaussian Blur\r
+\****************************************************************************************/\r
+\r
+Mat getGaussianKernel( int n, double sigma, int ktype )\r
+{\r
+ const int SMALL_GAUSSIAN_SIZE = 7;\r
+ static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =\r
+ {\r
+ {1.f},\r
+ {0.25f, 0.5f, 0.25f},\r
+ {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},\r
+ {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}\r
+ };\r
+\r
+ const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?\r
+ small_gaussian_tab[n>>1] : 0;\r
+\r
+ CV_Assert( ktype == CV_32F || ktype == CV_64F );\r
+ Mat kernel(n, 1, ktype);\r
+ float* cf = (float*)kernel.data;\r
+ double* cd = (double*)kernel.data;\r
+\r
+ double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;\r
+ double scale2X = -0.5/(sigmaX*sigmaX);\r
+ double sum = 0;\r
+\r
+ int i;\r
+ for( i = 0; i < n; i++ )\r
+ {\r
+ double x = i - (n-1)*0.5;\r
+ double t = fixed_kernel ? (double)fixed_kernel[i] : std::exp(scale2X*x*x);\r
+ if( ktype == CV_32F )\r
+ {\r
+ cf[i] = (float)t;\r
+ sum += cf[i];\r
+ }\r
+ else\r
+ {\r
+ cd[i] = t;\r
+ sum += cd[i];\r
+ }\r
+ }\r
+\r
+ sum = 1./sum;\r
+ for( i = 0; i < n; i++ )\r
+ {\r
+ if( ktype == CV_32F )\r
+ cf[i] = (float)(cf[i]*sum);\r
+ else\r
+ cd[i] *= sum;\r
+ }\r
+\r
+ return kernel;\r
+}\r
+\r
+\r
+Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,\r
+ double sigma1, double sigma2,\r
+ int borderType )\r
+{\r
+ int depth = CV_MAT_DEPTH(type);\r
+ if( sigma2 <= 0 )\r
+ sigma2 = sigma1;\r
+\r
+ // automatic detection of kernel size from sigma\r
+ if( ksize.width <= 0 && sigma1 > 0 )\r
+ ksize.width = cvRound(sigma1*(depth == CV_8U ? 3 : 4)*2 + 1)|1;\r
+ if( ksize.height <= 0 && sigma2 > 0 )\r
+ ksize.height = cvRound(sigma2*(depth == CV_8U ? 3 : 4)*2 + 1)|1;\r
+\r
+ CV_Assert( ksize.width > 0 && ksize.width % 2 == 1 &&\r
+ ksize.height > 0 && ksize.height % 2 == 1 );\r
+\r
+ sigma1 = std::max( sigma1, 0. );\r
+ sigma2 = std::max( sigma2, 0. );\r
+\r
+ Mat kx = getGaussianKernel( ksize.width, sigma1, std::max(depth, CV_32F) );\r
+ Mat ky;\r
+ if( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL_EPSILON )\r
+ ky = kx;\r
+ else\r
+ ky = getGaussianKernel( ksize.height, sigma2, std::max(depth, CV_32F) );\r
+\r
+ return createSeparableLinearFilter( type, type, kx, ky, Point(-1,-1), 0, borderType );\r
+}\r
+\r
+\r
+void GaussianBlur( const Mat& src, Mat& dst, Size ksize,\r
+ double sigma1, double sigma2,\r
+ int borderType )\r
+{\r
+ if( ksize.width == 1 && ksize.height == 1 )\r
+ {\r
+ src.copyTo(dst);\r
+ return;\r
+ }\r
+\r
+ dst.create( src.size(), src.type() );\r
+ if( borderType != BORDER_CONSTANT )\r
+ {\r
+ if( src.rows == 1 )\r
+ ksize.height = 1;\r
+ if( src.cols == 1 )\r
+ ksize.width = 1;\r
+ }\r
+ Ptr<FilterEngine> f = createGaussianFilter( src.type(), ksize, sigma1, sigma2, borderType );\r
+ f->apply( src, dst );\r
+}\r
+\r
+\r
+/****************************************************************************************\\r
+ Median Filter\r
+\****************************************************************************************/\r
+\r
+//#undef CV_SSE2\r
+\r
+//#if defined __VEC__ || defined __ALTIVEC__\r
+//#define CV_ALTIVEC 1\r
+//#endif\r
+\r
+#undef CV_ALTIVEC\r
+\r
+#if CV_ALTIVEC\r
+#include <altivec.h>\r
+#undef bool\r
+#endif\r
+\r
+#if _MSC_VER >= 1200\r
+#pragma warning( disable: 4244 )\r
+#endif\r
+\r
+typedef ushort HT;\r
+\r
+/**\r
+ * This structure represents a two-tier histogram. The first tier (known as the\r
+ * "coarse" level) is 4 bit wide and the second tier (known as the "fine" level)\r
+ * is 8 bit wide. Pixels inserted in the fine level also get inserted into the\r
+ * coarse bucket designated by the 4 MSBs of the fine bucket value.\r
+ *\r
+ * The structure is aligned on 16 bits, which is a prerequisite for SIMD\r
+ * instructions. Each bucket is 16 bit wide, which means that extra care must be\r
+ * taken to prevent overflow.\r
+ */\r
+typedef struct\r
+{\r
+ HT coarse[16];\r
+ HT fine[16][16];\r
+} Histogram;\r
+\r
+\r
+#if CV_SSE2 || defined __MMX__ || CV_ALTIVEC\r
+#define MEDIAN_HAVE_SIMD 1\r
+#else\r
+#define MEDIAN_HAVE_SIMD 0\r
+#endif\r
+\r
+/**\r
+ * histogram_add - adds histograms x and y.\r
+ * histogram_sub - subtracts histogram x from y.\r
+ */\r
+#if CV_SSE2\r
+static inline void histogram_add( const HT x[16], HT y[16] )\r
+{\r
+ const __m128i* rx = (const __m128i*)x;\r
+ __m128i* ry = (__m128i*)y;\r
+ __m128i r0 = _mm_add_epi16(_mm_load_si128(ry+0),_mm_load_si128(rx+0));\r
+ __m128i r1 = _mm_add_epi16(_mm_load_si128(ry+1),_mm_load_si128(rx+1));\r
+ _mm_store_si128(ry+0, r0);\r
+ _mm_store_si128(ry+1, r1);\r
+}\r
+\r
+static inline void histogram_sub( const HT x[16], HT y[16] )\r
+{\r
+ const __m128i* rx = (const __m128i*)x;\r
+ __m128i* ry = (__m128i*)y;\r
+ __m128i r0 = _mm_sub_epi16(_mm_load_si128(ry+0),_mm_load_si128(rx+0));\r
+ __m128i r1 = _mm_sub_epi16(_mm_load_si128(ry+1),_mm_load_si128(rx+1));\r
+ _mm_store_si128(ry+0, r0);\r
+ _mm_store_si128(ry+1, r1);\r
+}\r
+#elif defined(__MMX__)\r
+static inline void histogram_add( const HT x[16], HT y[16] )\r
+{\r
+ *(__m64*) &y[0] = _mm_add_pi16( *(__m64*) &y[0], *(__m64*) &x[0] );\r
+ *(__m64*) &y[4] = _mm_add_pi16( *(__m64*) &y[4], *(__m64*) &x[4] );\r
+ *(__m64*) &y[8] = _mm_add_pi16( *(__m64*) &y[8], *(__m64*) &x[8] );\r
+ *(__m64*) &y[12] = _mm_add_pi16( *(__m64*) &y[12], *(__m64*) &x[12] );\r
+}\r
+\r
+static inline void histogram_sub( const HT x[16], HT y[16] )\r
+{\r
+ *(__m64*) &y[0] = _mm_sub_pi16( *(__m64*) &y[0], *(__m64*) &x[0] );\r
+ *(__m64*) &y[4] = _mm_sub_pi16( *(__m64*) &y[4], *(__m64*) &x[4] );\r
+ *(__m64*) &y[8] = _mm_sub_pi16( *(__m64*) &y[8], *(__m64*) &x[8] );\r
+ *(__m64*) &y[12] = _mm_sub_pi16( *(__m64*) &y[12], *(__m64*) &x[12] );\r
+}\r
+#elif CV_ALTIVEC\r
+static inline void histogram_add( const HT x[16], HT y[16] )\r
+{\r
+ *(vector HT*) &y[0] = vec_add( *(vector HT*) &y[0], *(vector HT*) &x[0] );\r
+ *(vector HT*) &y[8] = vec_add( *(vector HT*) &y[8], *(vector HT*) &x[8] );\r
+}\r
+\r
+static inline void histogram_sub( const HT x[16], HT y[16] )\r
+{\r
+ *(vector HT*) &y[0] = vec_sub( *(vector HT*) &y[0], *(vector HT*) &x[0] );\r
+ *(vector HT*) &y[8] = vec_sub( *(vector HT*) &y[8], *(vector HT*) &x[8] );\r
+}\r
+#else\r
+static inline void histogram_add( const HT x[16], HT y[16] )\r
+{\r
+ int i;\r
+ for( i = 0; i < 16; ++i )\r
+ y[i] = (HT)(y[i] + x[i]);\r
+}\r
+\r
+static inline void histogram_sub( const HT x[16], HT y[16] )\r
+{\r
+ int i;\r
+ for( i = 0; i < 16; ++i )\r
+ y[i] = (HT)(y[i] - x[i]);\r
+}\r
+#endif\r
+\r
+static inline void histogram_muladd( int a, const HT x[16],\r
+ HT y[16] )\r
+{\r
+ for( int i = 0; i < 16; ++i )\r
+ y[i] = (HT)(y[i] + a * x[i]);\r
+}\r
+\r
+static void\r
+medianBlur_8u_O1( const Mat& _src, Mat& _dst, int ksize )\r
+{\r
+/**\r
+ * HOP is short for Histogram OPeration. This macro makes an operation \a op on\r
+ * histogram \a h for pixel value \a x. It takes care of handling both levels.\r
+ */\r
+#define HOP(h,x,op) \\r
+ h.coarse[x>>4] op, \\r
+ *((HT*)h.fine + x) op\r
+\r
+#define COP(c,j,x,op) \\r
+ h_coarse[ 16*(n*c+j) + (x>>4) ] op, \\r
+ h_fine[ 16 * (n*(16*c+(x>>4)) + j) + (x & 0xF) ] op\r
+\r
+ int cn = _dst.channels(), m = _dst.rows, r = (ksize-1)/2;\r
+ size_t sstep = _src.step, dstep = _dst.step;\r
+ Histogram CV_DECL_ALIGNED(16) H[4];\r
+ HT luc[4][16];\r
+\r
+ int STRIPE_SIZE = std::min( _dst.cols, 512/cn );\r
+\r
+ vector<HT> _h_coarse(1 * 16 * (STRIPE_SIZE + 2*r) * cn);\r
+ vector<HT> _h_fine(16 * 16 * (STRIPE_SIZE + 2*r) * cn);\r
+ HT* h_coarse = &_h_coarse[0];\r
+ HT* h_fine = &_h_fine[0];\r
+\r
+ for( int x = 0; x < _dst.cols; x += STRIPE_SIZE )\r
+ {\r
+ int i, j, k, c, n = std::min(_dst.cols - x, STRIPE_SIZE) + r*2;\r
+ const uchar* src = _src.data + x*cn;\r
+ uchar* dst = _dst.data + (x - r)*cn;\r
+\r
+ memset( h_coarse, 0, 16*n*cn*sizeof(h_coarse[0]) );\r
+ memset( h_fine, 0, 16*16*n*cn*sizeof(h_fine[0]) );\r
+\r
+ // First row initialization\r
+ for( c = 0; c < cn; c++ )\r
+ {\r
+ for( j = 0; j < n; j++ )\r
+ COP( c, j, src[cn*j+c], += r+2 );\r
+\r
+ for( i = 1; i < r; i++ )\r
+ {\r
+ const uchar* p = src + sstep*std::min(i, m-1);\r
+ for ( j = 0; j < n; j++ )\r
+ COP( c, j, p[cn*j+c], ++ );\r
+ }\r
+ }\r
+\r
+ for( i = 0; i < m; i++ )\r
+ {\r
+ const uchar* p0 = src + sstep * std::max( 0, i-r-1 );\r
+ const uchar* p1 = src + sstep * std::min( m-1, i+r );\r
+\r
+ memset( H, 0, cn*sizeof(H[0]) );\r
+ memset( luc, 0, cn*sizeof(luc[0]) );\r
+ for( c = 0; c < cn; c++ )\r
+ {\r
+ // Update column histograms for the entire row.\r
+ for( j = 0; j < n; j++ )\r
+ {\r
+ COP( c, j, p0[j*cn + c], -- );\r
+ COP( c, j, p1[j*cn + c], ++ );\r
+ }\r
+\r
+ // First column initialization\r
+ for( j = 0; j < 2*r; ++j )\r
+ histogram_add( &h_coarse[16*(n*c+j)], H[c].coarse );\r
+ for( k = 0; k < 16; ++k )\r
+ histogram_muladd( 2*r+1, &h_fine[16*n*(16*c+k)], &H[c].fine[k][0] );\r
+\r
+ for( j = r; j < n-r; j++ )\r
+ {\r
+ int t = 2*r*r + 2*r, b, sum = 0;\r
+ HT* segment;\r
+\r
+ histogram_add( &h_coarse[16*(n*c + std::min(j+r,n-1))], H[c].coarse );\r
+\r
+ // Find median at coarse level\r
+ for ( k = 0; k < 16 ; ++k )\r
+ {\r
+ sum += H[c].coarse[k];\r
+ if ( sum > t )\r
+ {\r
+ sum -= H[c].coarse[k];\r
+ break;\r
+ }\r
+ }\r
+ assert( k < 16 );\r
+\r
+ /* Update corresponding histogram segment */\r
+ if ( luc[c][k] <= j-r )\r
+ {\r
+ memset( &H[c].fine[k], 0, 16 * sizeof(HT) );\r
+ for ( luc[c][k] = j-r; luc[c][k] < MIN(j+r+1,n); ++luc[c][k] )\r
+ histogram_add( &h_fine[16*(n*(16*c+k)+luc[c][k])], H[c].fine[k] );\r
+\r
+ if ( luc[c][k] < j+r+1 )\r
+ {\r
+ histogram_muladd( j+r+1 - n, &h_fine[16*(n*(16*c+k)+(n-1))], &H[c].fine[k][0] );\r
+ luc[c][k] = (HT)(j+r+1);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ for ( ; luc[c][k] < j+r+1; ++luc[c][k] )\r
+ {\r
+ histogram_sub( &h_fine[16*(n*(16*c+k)+MAX(luc[c][k]-2*r-1,0))], H[c].fine[k] );\r
+ histogram_add( &h_fine[16*(n*(16*c+k)+MIN(luc[c][k],n-1))], H[c].fine[k] );\r
+ }\r
+ }\r
+\r
+ histogram_sub( &h_coarse[16*(n*c+MAX(j-r,0))], H[c].coarse );\r
+\r
+ /* Find median in segment */\r
+ segment = H[c].fine[k];\r
+ for ( b = 0; b < 16 ; b++ )\r
+ {\r
+ sum += segment[b];\r
+ if ( sum > t )\r
+ {\r
+ dst[dstep*i+cn*j+c] = (uchar)(16*k + b);\r
+ break;\r
+ }\r
+ }\r
+ assert( b < 16 );\r
+ }\r
+ }\r
+ }\r
+ }\r
+ #if defined(__MMX__)\r
+ _mm_empty();\r
+ #endif\r
+\r
+#undef HOP\r
+#undef COP\r
+}\r
+\r
+\r
+#if _MSC_VER >= 1200\r
+#pragma warning( default: 4244 )\r
+#endif\r
+\r
+static void\r
+medianBlur_8u_Om( const Mat& _src, Mat& _dst, int m )\r
+{\r
+ #define N 16\r
+ int zone0[4][N];\r
+ int zone1[4][N*N];\r
+ int x, y;\r
+ int n2 = m*m/2;\r
+ Size size = _dst.size();\r
+ const uchar* src = _src.data;\r
+ uchar* dst = _dst.data;\r
+ int src_step = (int)_src.step, dst_step = (int)_dst.step;\r
+ int cn = _src.channels();\r
+ const uchar* src_max = src + size.height*src_step;\r
+\r
+ #define UPDATE_ACC01( pix, cn, op ) \\r
+ { \\r
+ int p = (pix); \\r
+ zone1[cn][p] op; \\r
+ zone0[cn][p >> 4] op; \\r
+ }\r
+\r
+ //CV_Assert( size.height >= nx && size.width >= nx );\r
+ for( x = 0; x < size.width; x++, src += cn, dst += cn )\r
+ {\r
+ uchar* dst_cur = dst;\r
+ const uchar* src_top = src;\r
+ const uchar* src_bottom = src;\r
+ int k, c;\r
+ int src_step1 = src_step, dst_step1 = dst_step;\r
+\r
+ if( x % 2 != 0 )\r
+ {\r
+ src_bottom = src_top += src_step*(size.height-1);\r
+ dst_cur += dst_step*(size.height-1);\r
+ src_step1 = -src_step1;\r
+ dst_step1 = -dst_step1;\r
+ }\r
+\r
+ // init accumulator\r
+ memset( zone0, 0, sizeof(zone0[0])*cn );\r
+ memset( zone1, 0, sizeof(zone1[0])*cn );\r
+\r
+ for( y = 0; y <= m/2; y++ )\r
+ {\r
+ for( c = 0; c < cn; c++ )\r
+ {\r
+ if( y > 0 )\r
+ {\r
+ for( k = 0; k < m*cn; k += cn )\r
+ UPDATE_ACC01( src_bottom[k+c], c, ++ );\r
+ }\r
+ else\r
+ {\r
+ for( k = 0; k < m*cn; k += cn )\r
+ UPDATE_ACC01( src_bottom[k+c], c, += m/2+1 );\r
+ }\r
+ }\r
+\r
+ if( (src_step1 > 0 && y < size.height-1) ||\r
+ (src_step1 < 0 && size.height-y-1 > 0) )\r
+ src_bottom += src_step1;\r
+ }\r
+\r
+ for( y = 0; y < size.height; y++, dst_cur += dst_step1 )\r
+ {\r
+ // find median\r
+ for( c = 0; c < cn; c++ )\r
+ {\r
+ int s = 0;\r
+ for( k = 0; ; k++ )\r
+ {\r
+ int t = s + zone0[c][k];\r
+ if( t > n2 ) break;\r
+ s = t;\r
+ }\r
+\r
+ for( k *= N; ;k++ )\r
+ {\r
+ s += zone1[c][k];\r
+ if( s > n2 ) break;\r
+ }\r
+\r
+ dst_cur[c] = (uchar)k;\r
+ }\r
+\r
+ if( y+1 == size.height )\r
+ break;\r
+\r
+ if( cn == 1 )\r
+ {\r
+ for( k = 0; k < m; k++ )\r
+ {\r
+ int p = src_top[k];\r
+ int q = src_bottom[k];\r
+ zone1[0][p]--;\r
+ zone0[0][p>>4]--;\r
+ zone1[0][q]++;\r
+ zone0[0][q>>4]++;\r
+ }\r
+ }\r
+ else if( cn == 3 )\r
+ {\r
+ for( k = 0; k < m*3; k += 3 )\r
+ {\r
+ UPDATE_ACC01( src_top[k], 0, -- );\r
+ UPDATE_ACC01( src_top[k+1], 1, -- );\r
+ UPDATE_ACC01( src_top[k+2], 2, -- );\r
+\r
+ UPDATE_ACC01( src_bottom[k], 0, ++ );\r
+ UPDATE_ACC01( src_bottom[k+1], 1, ++ );\r
+ UPDATE_ACC01( src_bottom[k+2], 2, ++ );\r
+ }\r
+ }\r
+ else\r
+ {\r
+ assert( cn == 4 );\r
+ for( k = 0; k < m*4; k += 4 )\r
+ {\r
+ UPDATE_ACC01( src_top[k], 0, -- );\r
+ UPDATE_ACC01( src_top[k+1], 1, -- );\r
+ UPDATE_ACC01( src_top[k+2], 2, -- );\r
+ UPDATE_ACC01( src_top[k+3], 3, -- );\r
+\r
+ UPDATE_ACC01( src_bottom[k], 0, ++ );\r
+ UPDATE_ACC01( src_bottom[k+1], 1, ++ );\r
+ UPDATE_ACC01( src_bottom[k+2], 2, ++ );\r
+ UPDATE_ACC01( src_bottom[k+3], 3, ++ );\r
+ }\r
+ }\r
+\r
+ if( (src_step1 > 0 && src_bottom + src_step1 < src_max) ||\r
+ (src_step1 < 0 && src_bottom + src_step1 >= src) )\r
+ src_bottom += src_step1;\r
+\r
+ if( y >= m/2 )\r
+ src_top += src_step1;\r
+ }\r
+ }\r
+#undef N\r
+#undef UPDATE_ACC\r
+}\r
+\r
+\r
+struct MinMax8u\r
+{\r
+ typedef uchar value_type;\r
+ typedef int arg_type;\r
+ enum { SIZE = 1 };\r
+ arg_type load(const uchar* ptr) { return *ptr; }\r
+ void store(uchar* ptr, arg_type val) { *ptr = (uchar)val; }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ int t = CV_FAST_CAST_8U(a - b);\r
+ b += t; a -= t;\r
+ }\r
+};\r
+\r
+struct MinMax16u\r
+{\r
+ typedef ushort value_type;\r
+ typedef int arg_type;\r
+ enum { SIZE = 1 };\r
+ arg_type load(const ushort* ptr) { return *ptr; }\r
+ void store(ushort* ptr, arg_type val) { *ptr = (ushort)val; }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ arg_type t = a;\r
+ a = std::min(a, b);\r
+ b = std::max(b, t);\r
+ }\r
+};\r
+\r
+struct MinMax32f\r
+{\r
+ typedef float value_type;\r
+ typedef float arg_type;\r
+ enum { SIZE = 1 };\r
+ arg_type load(const float* ptr) { return *ptr; }\r
+ void store(float* ptr, arg_type val) { *ptr = val; }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ arg_type t = a;\r
+ a = std::min(a, b);\r
+ b = std::max(b, t);\r
+ }\r
+};\r
+\r
+#if CV_SSE2\r
+\r
+struct MinMaxVec8u\r
+{\r
+ typedef uchar value_type;\r
+ typedef __m128i arg_type;\r
+ enum { SIZE = 16 };\r
+ arg_type load(const uchar* ptr) { return _mm_loadu_si128((const __m128i*)ptr); }\r
+ void store(uchar* ptr, arg_type val) { _mm_storeu_si128((__m128i*)ptr, val); }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ arg_type t = a;\r
+ a = _mm_min_epu8(a, b);\r
+ b = _mm_max_epu8(b, t);\r
+ }\r
+};\r
+\r
+\r
+struct MinMaxVec16u\r
+{\r
+ typedef ushort value_type;\r
+ typedef __m128i arg_type;\r
+ enum { SIZE = 8 };\r
+ arg_type load(const ushort* ptr) { return _mm_loadu_si128((const __m128i*)ptr); }\r
+ void store(ushort* ptr, arg_type val) { _mm_storeu_si128((__m128i*)ptr, val); }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ arg_type t = _mm_subs_epu16(a, b);\r
+ a = _mm_subs_epu16(a, t);\r
+ b = _mm_adds_epu16(b, t);\r
+ }\r
+};\r
+\r
+\r
+struct MinMaxVec32f\r
+{\r
+ typedef float value_type;\r
+ typedef __m128 arg_type;\r
+ enum { SIZE = 4 };\r
+ arg_type load(const float* ptr) { return _mm_loadu_ps(ptr); }\r
+ void store(float* ptr, arg_type val) { _mm_storeu_ps(ptr, val); }\r
+ void operator()(arg_type& a, arg_type& b) const\r
+ {\r
+ arg_type t = a;\r
+ a = _mm_min_ps(a, b);\r
+ b = _mm_max_ps(b, t);\r
+ }\r
+};\r
+\r
+\r
+#else\r
+\r
+typedef MinMax8u MinMaxVec8u;\r
+typedef MinMax16u MinMaxVec16u;\r
+typedef MinMax32f MinMaxVec32f;\r
+\r
+#endif\r
+\r
+template<class Op, class VecOp>\r
+static void\r
+medianBlur_SortNet( const Mat& _src, Mat& _dst, int m )\r
+{\r
+ typedef typename Op::value_type T;\r
+ typedef typename Op::arg_type WT;\r
+ typedef typename VecOp::arg_type VT;\r
+\r
+ const T* src = (const T*)_src.data;\r
+ T* dst = (T*)_dst.data;\r
+ int sstep = (int)(_src.step/sizeof(T));\r
+ int dstep = (int)(_dst.step/sizeof(T));\r
+ Size size = _dst.size();\r
+ int i, j, k, cn = _src.channels();\r
+ Op op;\r
+ VecOp vop;\r
+\r
+ if( m == 3 )\r
+ {\r
+ if( size.width == 1 || size.height == 1 )\r
+ {\r
+ int len = size.width + size.height - 1;\r
+ int sdelta = size.height == 1 ? cn : sstep;\r
+ int sdelta0 = size.height == 1 ? 0 : sstep - cn;\r
+ int ddelta = size.height == 1 ? cn : dstep;\r
+\r
+ for( i = 0; i < len; i++, src += sdelta0, dst += ddelta )\r
+ for( j = 0; j < cn; j++, src++ )\r
+ {\r
+ WT p0 = src[i > 0 ? -sdelta : 0];\r
+ WT p1 = src[0];\r
+ WT p2 = src[i < len - 1 ? sdelta : 0];\r
+\r
+ op(p0, p1); op(p1, p2); op(p0, p1);\r
+ dst[j] = (T)p1;\r
+ }\r
+ return;\r
+ }\r
+ \r
+ size.width *= cn;\r
+ for( i = 0; i < size.height; i++, dst += dstep )\r
+ {\r
+ const T* row0 = src + std::max(i - 1, 0)*sstep;\r
+ const T* row1 = src + i*sstep;\r
+ const T* row2 = src + std::min(i + 1, size.height-1)*sstep;\r
+ int limit = cn;\r
+\r
+ for(j = 0;; )\r
+ {\r
+ for( ; j < limit; j++ )\r
+ {\r
+ int j0 = j >= cn ? j - cn : j;\r
+ int j2 = j < size.width - cn ? j + cn : j;\r
+ WT p0 = row0[j0], p1 = row0[j], p2 = row0[j2];\r
+ WT p3 = row1[j0], p4 = row1[j], p5 = row1[j2];\r
+ WT p6 = row2[j0], p7 = row2[j], p8 = row2[j2];\r
+\r
+ op(p1, p2); op(p4, p5); op(p7, p8); op(p0, p1);\r
+ op(p3, p4); op(p6, p7); op(p1, p2); op(p4, p5);\r
+ op(p7, p8); op(p0, p3); op(p5, p8); op(p4, p7);\r
+ op(p3, p6); op(p1, p4); op(p2, p5); op(p4, p7);\r
+ op(p4, p2); op(p6, p4); op(p4, p2);\r
+ dst[j] = (T)p4;\r
+ }\r
+\r
+ if( limit == size.width )\r
+ break;\r
+\r
+ for( ; j <= size.width - VecOp::SIZE - cn; j += VecOp::SIZE )\r
+ {\r
+ VT p0 = vop.load(row0+j-cn), p1 = vop.load(row0+j), p2 = vop.load(row0+j+cn);\r
+ VT p3 = vop.load(row1+j-cn), p4 = vop.load(row1+j), p5 = vop.load(row1+j+cn);\r
+ VT p6 = vop.load(row2+j-cn), p7 = vop.load(row2+j), p8 = vop.load(row2+j+cn);\r
+\r
+ vop(p1, p2); vop(p4, p5); vop(p7, p8); vop(p0, p1);\r
+ vop(p3, p4); vop(p6, p7); vop(p1, p2); vop(p4, p5);\r
+ vop(p7, p8); vop(p0, p3); vop(p5, p8); vop(p4, p7);\r
+ vop(p3, p6); vop(p1, p4); vop(p2, p5); vop(p4, p7);\r
+ vop(p4, p2); vop(p6, p4); vop(p4, p2);\r
+ vop.store(dst+j, p4);\r
+ }\r
+\r
+ limit = size.width;\r
+ }\r
+ }\r
+ }\r
+ else if( m == 5 )\r
+ {\r
+ if( size.width == 1 || size.height == 1 )\r
+ {\r
+ int len = size.width + size.height - 1;\r
+ int sdelta = size.height == 1 ? cn : sstep;\r
+ int sdelta0 = size.height == 1 ? 0 : sstep - cn;\r
+ int ddelta = size.height == 1 ? cn : dstep;\r
+\r
+ for( i = 0; i < len; i++, src += sdelta0, dst += ddelta )\r
+ for( j = 0; j < cn; j++, src++ )\r
+ {\r
+ int i1 = i > 0 ? -sdelta : 0;\r
+ int i0 = i > 1 ? -sdelta*2 : i1;\r
+ int i3 = i < len-1 ? sdelta : 0;\r
+ int i4 = i < len-2 ? sdelta*2 : i3;\r
+ WT p0 = src[i0], p1 = src[i1], p2 = src[0], p3 = src[i3], p4 = src[i4];\r
+\r
+ op(p0, p1); op(p3, p4); op(p2, p3); op(p3, p4); op(p0, p2);\r
+ op(p2, p4); op(p1, p3); op(p1, p2);\r
+ dst[j] = (T)p2;\r
+ }\r
+ return;\r
+ }\r
+\r
+ size.width *= cn;\r
+ for( i = 0; i < size.height; i++, dst += dstep )\r
+ {\r
+ const T* row[5];\r
+ row[0] = src + std::max(i - 2, 0)*sstep;\r
+ row[1] = src + std::max(i - 1, 0)*sstep;\r
+ row[2] = src + i*sstep;\r
+ row[3] = src + std::min(i + 1, size.height-1)*sstep;\r
+ row[4] = src + std::min(i + 2, size.height-1)*sstep;\r
+ int limit = cn*2;\r
+\r
+ for(j = 0;; )\r
+ {\r
+ for( ; j < limit; j++ )\r
+ {\r
+ WT p[25];\r
+ int j1 = j >= cn ? j - cn : j;\r
+ int j0 = j >= cn*2 ? j - cn*2 : j1;\r
+ int j3 = j < size.width - cn ? j + cn : j;\r
+ int j4 = j < size.width - cn*2 ? j + cn*2 : j3;\r
+ for( k = 0; k < 5; k++ )\r
+ {\r
+ const T* rowk = row[k];\r
+ p[k*5] = rowk[j0]; p[k*5+1] = rowk[j1];\r
+ p[k*5+2] = rowk[j]; p[k*5+3] = rowk[j3];\r
+ p[k*5+4] = rowk[j4];\r
+ }\r
+ \r
+ op(p[1], p[2]); op(p[0], p[1]); op(p[1], p[2]); op(p[4], p[5]); op(p[3], p[4]);\r
+ op(p[4], p[5]); op(p[0], p[3]); op(p[2], p[5]); op(p[2], p[3]); op(p[1], p[4]);\r
+ op(p[1], p[2]); op(p[3], p[4]); op(p[7], p[8]); op(p[6], p[7]); op(p[7], p[8]);\r
+ op(p[10], p[11]); op(p[9], p[10]); op(p[10], p[11]); op(p[6], p[9]); op(p[8], p[11]);\r
+ op(p[8], p[9]); op(p[7], p[10]); op(p[7], p[8]); op(p[9], p[10]); op(p[0], p[6]);\r
+ op(p[4], p[10]); op(p[4], p[6]); op(p[2], p[8]); op(p[2], p[4]); op(p[6], p[8]);\r
+ op(p[1], p[7]); op(p[5], p[11]); op(p[5], p[7]); op(p[3], p[9]); op(p[3], p[5]);\r
+ op(p[7], p[9]); op(p[1], p[2]); op(p[3], p[4]); op(p[5], p[6]); op(p[7], p[8]);\r
+ op(p[9], p[10]); op(p[13], p[14]); op(p[12], p[13]); op(p[13], p[14]); op(p[16], p[17]);\r
+ op(p[15], p[16]); op(p[16], p[17]); op(p[12], p[15]); op(p[14], p[17]); op(p[14], p[15]);\r
+ op(p[13], p[16]); op(p[13], p[14]); op(p[15], p[16]); op(p[19], p[20]); op(p[18], p[19]);\r
+ op(p[19], p[20]); op(p[21], p[22]); op(p[23], p[24]); op(p[21], p[23]); op(p[22], p[24]);\r
+ op(p[22], p[23]); op(p[18], p[21]); op(p[20], p[23]); op(p[20], p[21]); op(p[19], p[22]);\r
+ op(p[22], p[24]); op(p[19], p[20]); op(p[21], p[22]); op(p[23], p[24]); op(p[12], p[18]);\r
+ op(p[16], p[22]); op(p[16], p[18]); op(p[14], p[20]); op(p[20], p[24]); op(p[14], p[16]);\r
+ op(p[18], p[20]); op(p[22], p[24]); op(p[13], p[19]); op(p[17], p[23]); op(p[17], p[19]);\r
+ op(p[15], p[21]); op(p[15], p[17]); op(p[19], p[21]); op(p[13], p[14]); op(p[15], p[16]);\r
+ op(p[17], p[18]); op(p[19], p[20]); op(p[21], p[22]); op(p[23], p[24]); op(p[0], p[12]);\r
+ op(p[8], p[20]); op(p[8], p[12]); op(p[4], p[16]); op(p[16], p[24]); op(p[12], p[16]);\r
+ op(p[2], p[14]); op(p[10], p[22]); op(p[10], p[14]); op(p[6], p[18]); op(p[6], p[10]);\r
+ op(p[10], p[12]); op(p[1], p[13]); op(p[9], p[21]); op(p[9], p[13]); op(p[5], p[17]);\r
+ op(p[13], p[17]); op(p[3], p[15]); op(p[11], p[23]); op(p[11], p[15]); op(p[7], p[19]);\r
+ op(p[7], p[11]); op(p[11], p[13]); op(p[11], p[12]);\r
+ dst[j] = (T)p[12];\r
+ }\r
+\r
+ if( limit == size.width )\r
+ break;\r
+\r
+ for( ; j <= size.width - VecOp::SIZE - cn*2; j += VecOp::SIZE )\r
+ {\r
+ VT p[25];\r
+ for( k = 0; k < 5; k++ )\r
+ {\r
+ const T* rowk = row[k];\r
+ p[k*5] = vop.load(rowk+j-cn*2); p[k*5+1] = vop.load(rowk+j-cn);\r
+ p[k*5+2] = vop.load(rowk+j); p[k*5+3] = vop.load(rowk+j+cn);\r
+ p[k*5+4] = vop.load(rowk+j+cn*2);\r
+ }\r
+ \r
+ vop(p[1], p[2]); vop(p[0], p[1]); vop(p[1], p[2]); vop(p[4], p[5]); vop(p[3], p[4]);\r
+ vop(p[4], p[5]); vop(p[0], p[3]); vop(p[2], p[5]); vop(p[2], p[3]); vop(p[1], p[4]);\r
+ vop(p[1], p[2]); vop(p[3], p[4]); vop(p[7], p[8]); vop(p[6], p[7]); vop(p[7], p[8]);\r
+ vop(p[10], p[11]); vop(p[9], p[10]); vop(p[10], p[11]); vop(p[6], p[9]); vop(p[8], p[11]);\r
+ vop(p[8], p[9]); vop(p[7], p[10]); vop(p[7], p[8]); vop(p[9], p[10]); vop(p[0], p[6]);\r
+ vop(p[4], p[10]); vop(p[4], p[6]); vop(p[2], p[8]); vop(p[2], p[4]); vop(p[6], p[8]);\r
+ vop(p[1], p[7]); vop(p[5], p[11]); vop(p[5], p[7]); vop(p[3], p[9]); vop(p[3], p[5]);\r
+ vop(p[7], p[9]); vop(p[1], p[2]); vop(p[3], p[4]); vop(p[5], p[6]); vop(p[7], p[8]);\r
+ vop(p[9], p[10]); vop(p[13], p[14]); vop(p[12], p[13]); vop(p[13], p[14]); vop(p[16], p[17]);\r
+ vop(p[15], p[16]); vop(p[16], p[17]); vop(p[12], p[15]); vop(p[14], p[17]); vop(p[14], p[15]);\r
+ vop(p[13], p[16]); vop(p[13], p[14]); vop(p[15], p[16]); vop(p[19], p[20]); vop(p[18], p[19]);\r
+ vop(p[19], p[20]); vop(p[21], p[22]); vop(p[23], p[24]); vop(p[21], p[23]); vop(p[22], p[24]);\r
+ vop(p[22], p[23]); vop(p[18], p[21]); vop(p[20], p[23]); vop(p[20], p[21]); vop(p[19], p[22]);\r
+ vop(p[22], p[24]); vop(p[19], p[20]); vop(p[21], p[22]); vop(p[23], p[24]); vop(p[12], p[18]);\r
+ vop(p[16], p[22]); vop(p[16], p[18]); vop(p[14], p[20]); vop(p[20], p[24]); vop(p[14], p[16]);\r
+ vop(p[18], p[20]); vop(p[22], p[24]); vop(p[13], p[19]); vop(p[17], p[23]); vop(p[17], p[19]);\r
+ vop(p[15], p[21]); vop(p[15], p[17]); vop(p[19], p[21]); vop(p[13], p[14]); vop(p[15], p[16]);\r
+ vop(p[17], p[18]); vop(p[19], p[20]); vop(p[21], p[22]); vop(p[23], p[24]); vop(p[0], p[12]);\r
+ vop(p[8], p[20]); vop(p[8], p[12]); vop(p[4], p[16]); vop(p[16], p[24]); vop(p[12], p[16]);\r
+ vop(p[2], p[14]); vop(p[10], p[22]); vop(p[10], p[14]); vop(p[6], p[18]); vop(p[6], p[10]);\r
+ vop(p[10], p[12]); vop(p[1], p[13]); vop(p[9], p[21]); vop(p[9], p[13]); vop(p[5], p[17]);\r
+ vop(p[13], p[17]); vop(p[3], p[15]); vop(p[11], p[23]); vop(p[11], p[15]); vop(p[7], p[19]);\r
+ vop(p[7], p[11]); vop(p[11], p[13]); vop(p[11], p[12]);\r
+ vop.store(dst+j, p[12]);\r
+ }\r
+\r
+ limit = size.width;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+void medianBlur( const Mat& src0, Mat& dst, int ksize )\r
+{\r
+ if( ksize <= 1 )\r
+ {\r
+ src0.copyTo(dst);\r
+ return;\r
+ }\r
+\r
+ CV_Assert( ksize % 2 == 1 );\r
+ \r
+ Size size = src0.size();\r
+ int cn = src0.channels();\r
+ bool useSortNet = ksize == 3 || (ksize == 5\r
+#if !CV_SSE2\r
+ && src0.depth() > CV_8U\r
+#endif\r
+ );\r
+\r
+ dst.create( src0.size(), src0.type() );\r
+ Mat src;\r
+ if( useSortNet )\r
+ {\r
+ if( dst.data != src0.data )\r
+ src = src0;\r
+ else\r
+ src0.copyTo(src);\r
+ }\r
+ else\r
+ cv::copyMakeBorder( src0, src, 0, 0, ksize/2, ksize/2, BORDER_REPLICATE );\r
+\r
+ if( useSortNet )\r
+ {\r
+ if( src.depth() == CV_8U )\r
+ medianBlur_SortNet<MinMax8u, MinMaxVec8u>( src, dst, ksize );\r
+ else if( src.depth() == CV_16U )\r
+ medianBlur_SortNet<MinMax16u, MinMaxVec16u>( src, dst, ksize );\r
+ else if( src.depth() == CV_32F )\r
+ medianBlur_SortNet<MinMax32f, MinMaxVec32f>( src, dst, ksize );\r
+ return;\r
+ }\r
+\r
+ CV_Assert( src.depth() == CV_8U && (cn == 1 || cn == 3 || cn == 4) );\r
+\r
+ double img_size_mp = (double)(size.width*size.height)/(1 << 20);\r
+ if( ksize <= 3 + (img_size_mp < 1 ? 12 : img_size_mp < 4 ? 6 : 2)*(MEDIAN_HAVE_SIMD ? 1 : 3))\r
+ medianBlur_8u_Om( src, dst, ksize );\r
+ else\r
+ medianBlur_8u_O1( src, dst, ksize );\r
+}\r
+\r
+/****************************************************************************************\\r
+ Bilateral Filtering\r
+\****************************************************************************************/\r
+\r
+static void\r
+bilateralFilter_8u( const Mat& src, Mat& dst, int d,\r
+ double sigma_color, double sigma_space,\r
+ int borderType )\r
+{\r
+ double gauss_color_coeff = -0.5/(sigma_color*sigma_color);\r
+ double gauss_space_coeff = -0.5/(sigma_space*sigma_space);\r
+ int cn = src.channels();\r
+ int i, j, k, maxk, radius;\r
+ Size size = src.size();\r
+\r
+ CV_Assert( (src.type() == CV_8UC1 || src.type() == CV_8UC3) &&\r
+ src.type() == dst.type() && src.size() == dst.size() &&\r
+ src.data != dst.data );\r
+\r
+ if( sigma_color <= 0 )\r
+ sigma_color = 1;\r
+ if( sigma_space <= 0 )\r
+ sigma_space = 1;\r
+\r
+ if( d <= 0 )\r
+ radius = cvRound(sigma_space*1.5);\r
+ else\r
+ radius = d/2;\r
+ radius = MAX(radius, 1);\r
+ d = radius*2 + 1;\r
+\r
+ Mat temp;\r
+ copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );\r
+\r
+ vector<float> _color_weight(cn*256);\r
+ vector<float> _space_weight(d*d);\r
+ vector<int> _space_ofs(d*d);\r
+ float* color_weight = &_color_weight[0];\r
+ float* space_weight = &_space_weight[0];\r
+ int* space_ofs = &_space_ofs[0];\r
+\r
+ // initialize color-related bilateral filter coefficients\r
+ for( i = 0; i < 256*cn; i++ )\r
+ color_weight[i] = (float)std::exp(i*i*gauss_color_coeff);\r
+\r
+ // initialize space-related bilateral filter coefficients\r
+ for( i = -radius, maxk = 0; i <= radius; i++ )\r
+ for( j = -radius; j <= radius; j++ )\r
+ {\r
+ double r = std::sqrt((double)i*i + (double)j*j);\r
+ if( r > radius )\r
+ continue;\r
+ space_weight[maxk] = (float)std::exp(r*r*gauss_space_coeff);\r
+ space_ofs[maxk++] = (int)(i*temp.step + j*cn);\r
+ }\r
+\r
+ for( i = 0; i < size.height; i++ )\r
+ {\r
+ const uchar* sptr = temp.data + (i+radius)*temp.step + radius*cn;\r
+ uchar* dptr = dst.data + i*dst.step;\r
+\r
+ if( cn == 1 )\r
+ {\r
+ for( j = 0; j < size.width; j++ )\r
+ {\r
+ float sum = 0, wsum = 0;\r
+ int val0 = sptr[j];\r
+ for( k = 0; k < maxk; k++ )\r
+ {\r
+ int val = sptr[j + space_ofs[k]];\r
+ float w = space_weight[k]*color_weight[std::abs(val - val0)];\r
+ sum += val*w;\r
+ wsum += w;\r
+ }\r
+ // overflow is not possible here => there is no need to use CV_CAST_8U\r
+ dptr[j] = (uchar)cvRound(sum/wsum);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ assert( cn == 3 );\r
+ for( j = 0; j < size.width*3; j += 3 )\r
+ {\r
+ float sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;\r
+ int b0 = sptr[j], g0 = sptr[j+1], r0 = sptr[j+2];\r
+ for( k = 0; k < maxk; k++ )\r
+ {\r
+ const uchar* sptr_k = sptr + j + space_ofs[k];\r
+ int b = sptr_k[0], g = sptr_k[1], r = sptr_k[2];\r
+ float w = space_weight[k]*color_weight[std::abs(b - b0) +\r
+ std::abs(g - g0) + std::abs(r - r0)];\r
+ sum_b += b*w; sum_g += g*w; sum_r += r*w;\r
+ wsum += w;\r
+ }\r
+ wsum = 1.f/wsum;\r
+ b0 = cvRound(sum_b*wsum);\r
+ g0 = cvRound(sum_g*wsum);\r
+ r0 = cvRound(sum_r*wsum);\r
+ dptr[j] = (uchar)b0; dptr[j+1] = (uchar)g0; dptr[j+2] = (uchar)r0;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+static void\r
+bilateralFilter_32f( const Mat& src, Mat& dst, int d,\r
+ double sigma_color, double sigma_space,\r
+ int borderType )\r
+{\r
+ double gauss_color_coeff = -0.5/(sigma_color*sigma_color);\r
+ double gauss_space_coeff = -0.5/(sigma_space*sigma_space);\r
+ int cn = src.channels();\r
+ int i, j, k, maxk, radius;\r
+ double minValSrc=-1, maxValSrc=1;\r
+ const int kExpNumBinsPerChannel = 1 << 12;\r
+ int kExpNumBins = 0;\r
+ float lastExpVal = 1.f;\r
+ float len, scale_index;\r
+ Size size = src.size();\r
+\r
+ CV_Assert( (src.type() == CV_32FC1 || src.type() == CV_32FC3) &&\r
+ src.type() == dst.type() && src.size() == dst.size() &&\r
+ src.data != dst.data );\r
+\r
+ if( sigma_color <= 0 )\r
+ sigma_color = 1;\r
+ if( sigma_space <= 0 )\r
+ sigma_space = 1;\r
+\r
+ if( d <= 0 )\r
+ radius = cvRound(sigma_space*1.5);\r
+ else\r
+ radius = d/2;\r
+ radius = MAX(radius, 1);\r
+ d = radius*2 + 1;\r
+ // compute the min/max range for the input image (even if multichannel)\r
+ \r
+ minMaxLoc( src.reshape(1), &minValSrc, &maxValSrc );\r
+ \r
+ // temporary copy of the image with borders for easy processing\r
+ Mat temp;\r
+ copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );\r
+\r
+ // allocate lookup tables\r
+ vector<float> _space_weight(d*d);\r
+ vector<int> _space_ofs(d*d);\r
+ float* space_weight = &_space_weight[0];\r
+ int* space_ofs = &_space_ofs[0];\r
+\r
+ // assign a length which is slightly more than needed\r
+ len = (float)(maxValSrc - minValSrc) * cn;\r
+ kExpNumBins = kExpNumBinsPerChannel * cn;\r
+ vector<float> _expLUT(kExpNumBins+2);\r
+ float* expLUT = &_expLUT[0];\r
+\r
+ scale_index = kExpNumBins/len;\r
+ \r
+ // initialize the exp LUT\r
+ for( i = 0; i < kExpNumBins+2; i++ )\r
+ {\r
+ if( lastExpVal > 0.f )\r
+ {\r
+ double val = i / scale_index;\r
+ expLUT[i] = (float)std::exp(val * val * gauss_color_coeff);\r
+ lastExpVal = expLUT[i];\r
+ }\r
+ else\r
+ expLUT[i] = 0.f;\r
+ }\r
+ \r
+ // initialize space-related bilateral filter coefficients\r
+ for( i = -radius, maxk = 0; i <= radius; i++ )\r
+ for( j = -radius; j <= radius; j++ )\r
+ {\r
+ double r = std::sqrt((double)i*i + (double)j*j);\r
+ if( r > radius )\r
+ continue;\r
+ space_weight[maxk] = (float)std::exp(r*r*gauss_space_coeff);\r
+ space_ofs[maxk++] = (int)(i*(temp.step/sizeof(float)) + j*cn);\r
+ }\r
+\r
+ for( i = 0; i < size.height; i++ )\r
+ {\r
+ const float* sptr = (const float*)(temp.data + (i+radius)*temp.step) + radius*cn;\r
+ float* dptr = (float*)(dst.data + i*dst.step);\r
+\r
+ if( cn == 1 )\r
+ {\r
+ for( j = 0; j < size.width; j++ )\r
+ {\r
+ float sum = 0, wsum = 0;\r
+ float val0 = sptr[j];\r
+ for( k = 0; k < maxk; k++ )\r
+ {\r
+ float val = sptr[j + space_ofs[k]];\r
+ float alpha = (float)(std::abs(val - val0)*scale_index);\r
+ int idx = cvFloor(alpha);\r
+ alpha -= idx;\r
+ float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));\r
+ sum += val*w;\r
+ wsum += w;\r
+ }\r
+ dptr[j] = (float)(sum/wsum);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ assert( cn == 3 );\r
+ for( j = 0; j < size.width*3; j += 3 )\r
+ {\r
+ float sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;\r
+ float b0 = sptr[j], g0 = sptr[j+1], r0 = sptr[j+2];\r
+ for( k = 0; k < maxk; k++ )\r
+ {\r
+ const float* sptr_k = sptr + j + space_ofs[k];\r
+ float b = sptr_k[0], g = sptr_k[1], r = sptr_k[2];\r
+ float alpha = (float)((std::abs(b - b0) +\r
+ std::abs(g - g0) + std::abs(r - r0))*scale_index);\r
+ int idx = cvFloor(alpha);\r
+ alpha -= idx;\r
+ float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));\r
+ sum_b += b*w; sum_g += g*w; sum_r += r*w;\r
+ wsum += w;\r
+ }\r
+ wsum = 1.f/wsum;\r
+ b0 = sum_b*wsum;\r
+ g0 = sum_g*wsum;\r
+ r0 = sum_r*wsum;\r
+ dptr[j] = b0; dptr[j+1] = g0; dptr[j+2] = r0;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+\r
+void bilateralFilter( const Mat& src, Mat& dst, int d,\r
+ double sigmaColor, double sigmaSpace,\r
+ int borderType )\r
+{\r
+ dst.create( src.size(), src.type() );\r
+ if( src.depth() == CV_8U )\r
+ bilateralFilter_8u( src, dst, d, sigmaColor, sigmaSpace, borderType );\r
+ else if( src.depth() == CV_32F )\r
+ bilateralFilter_32f( src, dst, d, sigmaColor, sigmaSpace, borderType );\r
+ else\r
+ CV_Error( CV_StsUnsupportedFormat,\r
+ "Bilateral filtering is only implemented for 8u and 32f images" );\r
+}\r
+\r
+}\r
+\r
+//////////////////////////////////////////////////////////////////////////////////////////\r
+\r
+CV_IMPL void\r
+cvSmooth( const void* srcarr, void* dstarr, int smooth_type,\r
+ int param1, int param2, double param3, double param4 )\r
+{\r
+ cv::Mat src = cv::cvarrToMat(srcarr), dst0 = cv::cvarrToMat(dstarr), dst = dst0;\r
+\r
+ CV_Assert( dst.size() == src.size() &&\r
+ (smooth_type == CV_BLUR_NO_SCALE || dst.type() == src.type()) );\r
+\r
+ if( param2 <= 0 )\r
+ param2 = param1;\r
+\r
+ if( smooth_type == CV_BLUR || smooth_type == CV_BLUR_NO_SCALE )\r
+ cv::boxFilter( src, dst, dst.depth(), cv::Size(param1, param2), cv::Point(-1,-1),\r
+ smooth_type == CV_BLUR, cv::BORDER_REPLICATE );\r
+ else if( smooth_type == CV_GAUSSIAN )\r
+ cv::GaussianBlur( src, dst, cv::Size(param1, param2), param3, param4, cv::BORDER_REPLICATE );\r
+ else if( smooth_type == CV_MEDIAN )\r
+ cv::medianBlur( src, dst, param1 );\r
+ else\r
+ cv::bilateralFilter( src, dst, param1, param3, param4, cv::BORDER_REPLICATE );\r
+\r
+ if( dst.data != dst0.data )\r
+ CV_Error( CV_StsUnmatchedFormats, "The destination image does not have the proper type" );\r
+}\r
+\r
+/* End of file. */\r
projects / opencv / blobdiff