modules/imgproc/src/smooth.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                           License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  15 // Third party copyrights are property of their respective owners.
  16 //
  17 // Redistribution and use in source and binary forms, with or without modification,
  18 // are permitted provided that the following conditions are met:
  19 //
  20 //   * Redistribution's of source code must retain the above copyright notice,
  21 //     this list of conditions and the following disclaimer.
  22 //
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,
  24 //     this list of conditions and the following disclaimer in the documentation
  25 //     and/or other materials provided with the distribution.
  26 //
  27 //   * The name of the copyright holders may not be used to endorse or promote products
  28 //     derived from this software without specific prior written permission.
  29 //
  30 // This software is provided by the copyright holders and contributors "as is" and
  31 // any express or implied warranties, including, but not limited to, the implied
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,
  34 // indirect, incidental, special, exemplary, or consequential damages
  35 // (including, but not limited to, procurement of substitute goods or services;
  36 // loss of use, data, or profits; or business interruption) however caused
  37 // and on any theory of liability, whether in contract, strict liability,
  38 // or tort (including negligence or otherwise) arising in any way out of
  39 // the use of this software, even if advised of the possibility of such damage.
  40 //
  41 //M*/
  42
  43 #include "precomp.hpp"
  44
  45 /*
  46  * This file includes the code, contributed by Simon Perreault
  47  * (the function icvMedianBlur_8u_O1)
  48  *
  49  * Constant-time median filtering -- http://nomis80.org/ctmf.html
  50  * Copyright (C) 2006 Simon Perreault
  51  *
  52  * Contact:
  53  *  Laboratoire de vision et systemes numeriques
  54  *  Pavillon Adrien-Pouliot
  55  *  Universite Laval
  56  *  Sainte-Foy, Quebec, Canada
  57  *  G1K 7P4
  58  *
  59  *  perreaul@gel.ulaval.ca
  60  */
  61
  62 namespace cv
  63 {
  64
  65 /****************************************************************************************\
  66                                          Box Filter
  67 \****************************************************************************************/
  68
  69 template<typename T, typename ST> struct RowSum : public BaseRowFilter
  70 {
  71     RowSum( int _ksize, int _anchor )
  72     {
  73         ksize = _ksize;
  74         anchor = _anchor;
  75     }
  76
  77     void operator()(const uchar* src, uchar* dst, int width, int cn)
  78     {
  79         const T* S = (const T*)src;
  80         ST* D = (ST*)dst;
  81         int i = 0, k, ksz_cn = ksize*cn;
  82
  83         width = (width - 1)*cn;
  84         for( k = 0; k < cn; k++, S++, D++ )
  85         {
  86             ST s = 0;
  87             for( i = 0; i < ksz_cn; i += cn )
  88                 s += S[i];
  89             D[0] = s;
  90             for( i = 0; i < width; i += cn )
  91             {
  92                 s += S[i + ksz_cn] - S[i];
  93                 D[i+cn] = s;
  94             }
  95         }
  96     }
  97 };
  98
  99
 100 template<typename ST, typename T> struct ColumnSum : public BaseColumnFilter
 101 {
 102     ColumnSum( int _ksize, int _anchor, double _scale )
 103     {
 104         ksize = _ksize;
 105         anchor = _anchor;
 106         scale = _scale;
 107         sumCount = 0;
 108     }
 109
 110     void reset() { sumCount = 0; }
 111
 112     void operator()(const uchar** src, uchar* dst, int dststep, int count, int width)
 113     {
 114         int i;
 115         ST* SUM;
 116         bool haveScale = scale != 1;
 117         double _scale = scale;
 118
 119         if( width != (int)sum.size() )
 120         {
 121             sum.resize(width);
 122             sumCount = 0;
 123         }
 124
 125         SUM = &sum[0];
 126         if( sumCount == 0 )
 127         {
 128             for( i = 0; i < width; i++ )
 129                 SUM[i] = 0;
 130             for( ; sumCount < ksize - 1; sumCount++, src++ )
 131             {
 132                 const ST* Sp = (const ST*)src[0];
 133                 for( i = 0; i <= width - 2; i += 2 )
 134                 {
 135                     ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];
 136                     SUM[i] = s0; SUM[i+1] = s1;
 137                 }
 138
 139                 for( ; i < width; i++ )
 140                     SUM[i] += Sp[i];
 141             }
 142         }
 143         else
 144         {
 145             CV_Assert( sumCount == ksize-1 );
 146             src += ksize-1;
 147         }
 148
 149         for( ; count--; src++ )
 150         {
 151             const ST* Sp = (const ST*)src[0];
 152             const ST* Sm = (const ST*)src[1-ksize];
 153             T* D = (T*)dst;
 154             if( haveScale )
 155             {
 156                 for( i = 0; i <= width - 2; i += 2 )
 157                 {
 158                     ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];
 159                     D[i] = saturate_cast<T>(s0*_scale);
 160                     D[i+1] = saturate_cast<T>(s1*_scale);
 161                     s0 -= Sm[i]; s1 -= Sm[i+1];
 162                     SUM[i] = s0; SUM[i+1] = s1;
 163                 }
 164
 165                 for( ; i < width; i++ )
 166                 {
 167                     ST s0 = SUM[i] + Sp[i];
 168                     D[i] = saturate_cast<T>(s0*_scale);
 169                     SUM[i] = s0 - Sm[i];
 170                 }
 171             }
 172             else
 173             {
 174                 for( i = 0; i <= width - 2; i += 2 )
 175                 {
 176                     ST s0 = SUM[i] + Sp[i], s1 = SUM[i+1] + Sp[i+1];
 177                     D[i] = saturate_cast<T>(s0);
 178                     D[i+1] = saturate_cast<T>(s1);
 179                     s0 -= Sm[i]; s1 -= Sm[i+1];
 180                     SUM[i] = s0; SUM[i+1] = s1;
 181                 }
 182
 183                 for( ; i < width; i++ )
 184                 {
 185                     ST s0 = SUM[i] + Sp[i];
 186                     D[i] = saturate_cast<T>(s0);
 187                     SUM[i] = s0 - Sm[i];
 188                 }
 189             }
 190             dst += dststep;
 191         }
 192     }
 193
 194     double scale;
 195     int sumCount;
 196     vector<ST> sum;
 197 };
 198
 199
 200 }
 201
 202 cv::Ptr<cv::BaseRowFilter> cv::getRowSumFilter(int srcType, int sumType, int ksize, int anchor)
 203 {
 204     int sdepth = CV_MAT_DEPTH(srcType), ddepth = CV_MAT_DEPTH(sumType);
 205     CV_Assert( CV_MAT_CN(sumType) == CV_MAT_CN(srcType) );
 206
 207     if( anchor < 0 )
 208         anchor = ksize/2;
 209
 210     if( sdepth == CV_8U && ddepth == CV_32S )
 211         return Ptr<BaseRowFilter>(new RowSum<uchar, int>(ksize, anchor));
 212     if( sdepth == CV_8U && ddepth == CV_64F )
 213         return Ptr<BaseRowFilter>(new RowSum<uchar, double>(ksize, anchor));
 214     if( sdepth == CV_16U && ddepth == CV_32S )
 215         return Ptr<BaseRowFilter>(new RowSum<ushort, int>(ksize, anchor));
 216     if( sdepth == CV_16U && ddepth == CV_64F )
 217         return Ptr<BaseRowFilter>(new RowSum<ushort, double>(ksize, anchor));
 218     if( sdepth == CV_16S && ddepth == CV_32S )
 219         return Ptr<BaseRowFilter>(new RowSum<short, int>(ksize, anchor));
 220     if( sdepth == CV_32S && ddepth == CV_32S )
 221         return Ptr<BaseRowFilter>(new RowSum<int, int>(ksize, anchor));
 222     if( sdepth == CV_16S && ddepth == CV_64F )
 223         return Ptr<BaseRowFilter>(new RowSum<short, double>(ksize, anchor));
 224     if( sdepth == CV_32F && ddepth == CV_64F )
 225         return Ptr<BaseRowFilter>(new RowSum<float, double>(ksize, anchor));
 226     if( sdepth == CV_64F && ddepth == CV_64F )
 227         return Ptr<BaseRowFilter>(new RowSum<double, double>(ksize, anchor));
 228
 229     CV_Error_( CV_StsNotImplemented,
 230         ("Unsupported combination of source format (=%d), and buffer format (=%d)",
 231         srcType, sumType));
 232
 233     return Ptr<BaseRowFilter>(0);
 234 }
 235
 236
 237 cv::Ptr<cv::BaseColumnFilter> cv::getColumnSumFilter(int sumType, int dstType, int ksize,
 238                                                      int anchor, double scale)
 239 {
 240     int sdepth = CV_MAT_DEPTH(sumType), ddepth = CV_MAT_DEPTH(dstType);
 241     CV_Assert( CV_MAT_CN(sumType) == CV_MAT_CN(dstType) );
 242
 243     if( anchor < 0 )
 244         anchor = ksize/2;
 245
 246     if( ddepth == CV_8U && sdepth == CV_32S )
 247         return Ptr<BaseColumnFilter>(new ColumnSum<int, uchar>(ksize, anchor, scale));
 248     if( ddepth == CV_8U && sdepth == CV_64F )
 249         return Ptr<BaseColumnFilter>(new ColumnSum<double, uchar>(ksize, anchor, scale));
 250     if( ddepth == CV_16U && sdepth == CV_32S )
 251         return Ptr<BaseColumnFilter>(new ColumnSum<int, ushort>(ksize, anchor, scale));
 252     if( ddepth == CV_16U && sdepth == CV_64F )
 253         return Ptr<BaseColumnFilter>(new ColumnSum<double, ushort>(ksize, anchor, scale));
 254     if( ddepth == CV_16S && sdepth == CV_32S )
 255         return Ptr<BaseColumnFilter>(new ColumnSum<int, short>(ksize, anchor, scale));
 256     if( ddepth == CV_16S && sdepth == CV_64F )
 257         return Ptr<BaseColumnFilter>(new ColumnSum<double, short>(ksize, anchor, scale));
 258     if( ddepth == CV_32S && sdepth == CV_32S )
 259         return Ptr<BaseColumnFilter>(new ColumnSum<int, int>(ksize, anchor, scale));
 260     if( ddepth == CV_32F && sdepth == CV_32S )
 261         return Ptr<BaseColumnFilter>(new ColumnSum<int, float>(ksize, anchor, scale));
 262     if( ddepth == CV_32F && sdepth == CV_64F )
 263         return Ptr<BaseColumnFilter>(new ColumnSum<double, float>(ksize, anchor, scale));
 264     if( ddepth == CV_64F && sdepth == CV_32S )
 265         return Ptr<BaseColumnFilter>(new ColumnSum<int, double>(ksize, anchor, scale));
 266     if( ddepth == CV_64F && sdepth == CV_64F )
 267         return Ptr<BaseColumnFilter>(new ColumnSum<double, double>(ksize, anchor, scale));
 268
 269     CV_Error_( CV_StsNotImplemented,
 270         ("Unsupported combination of sum format (=%d), and destination format (=%d)",
 271         sumType, dstType));
 272
 273     return Ptr<BaseColumnFilter>(0);
 274 }
 275
 276
 277 cv::Ptr<cv::FilterEngine> cv::createBoxFilter( int srcType, int dstType, Size ksize,
 278                     Point anchor, bool normalize, int borderType )
 279 {
 280     int sdepth = CV_MAT_DEPTH(srcType);
 281     int cn = CV_MAT_CN(srcType), sumType = CV_64F;
 282     if( sdepth <= CV_32S && (!normalize ||
 283         ksize.width*ksize.height <= (sdepth == CV_8U ? (1<<23) :
 284             sdepth == CV_16U ? (1 << 15) : (1 << 16))) )
 285         sumType = CV_32S;
 286     sumType = CV_MAKETYPE( sumType, cn );
 287
 288     Ptr<BaseRowFilter> rowFilter = getRowSumFilter(srcType, sumType, ksize.width, anchor.x );
 289     Ptr<BaseColumnFilter> columnFilter = getColumnSumFilter(sumType,
 290         dstType, ksize.height, anchor.y, normalize ? 1./(ksize.width*ksize.height) : 1);
 291
 292     return Ptr<FilterEngine>(new FilterEngine(Ptr<BaseFilter>(0), rowFilter, columnFilter,
 293            srcType, dstType, sumType, borderType ));
 294 }
 295
 296
 297 void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
 298                 Size ksize, Point anchor,
 299                 bool normalize, int borderType )
 300 {
 301     Mat src = _src.getMat();
 302     int sdepth = src.depth(), cn = src.channels();
 303     if( ddepth < 0 )
 304         ddepth = sdepth;
 305     _dst.create( src.size(), CV_MAKETYPE(ddepth, cn) );
 306     Mat dst = _dst.getMat();
 307     if( borderType != BORDER_CONSTANT && normalize )
 308     {
 309         if( src.rows == 1 )
 310             ksize.height = 1;
 311         if( src.cols == 1 )
 312             ksize.width = 1;
 313     }
 314 #ifdef HAVE_TEGRA_OPTIMIZATION
 315     if ( tegra::box(src, dst, ksize, anchor, normalize, borderType) )
 316         return;
 317 #endif
 318
 319     Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(),
 320                         ksize, anchor, normalize, borderType );
 321     f->apply( src, dst );
 322 }
 323
 324 void cv::blur( InputArray src, OutputArray dst,
 325            Size ksize, Point anchor, int borderType )
 326 {
 327     boxFilter( src, dst, -1, ksize, anchor, true, borderType );
 328 }
 329
 330 /****************************************************************************************\
 331                                      Gaussian Blur
 332 \****************************************************************************************/
 333
 334 cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype )
 335 {
 336     const int SMALL_GAUSSIAN_SIZE = 7;
 337     static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
 338     {
 339         {1.f},
 340         {0.25f, 0.5f, 0.25f},
 341         {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},
 342         {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}
 343     };
 344
 345     const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?
 346         small_gaussian_tab[n>>1] : 0;
 347
 348     CV_Assert( ktype == CV_32F || ktype == CV_64F );
 349     Mat kernel(n, 1, ktype);
 350     float* cf = (float*)kernel.data;
 351     double* cd = (double*)kernel.data;
 352
 353     double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;
 354     double scale2X = -0.5/(sigmaX*sigmaX);
 355     double sum = 0;
 356
 357     int i;
 358     for( i = 0; i < n; i++ )
 359     {
 360         double x = i - (n-1)*0.5;
 361         double t = fixed_kernel ? (double)fixed_kernel[i] : std::exp(scale2X*x*x);
 362         if( ktype == CV_32F )
 363         {
 364             cf[i] = (float)t;
 365             sum += cf[i];
 366         }
 367         else
 368         {
 369             cd[i] = t;
 370             sum += cd[i];
 371         }
 372     }
 373
 374     sum = 1./sum;
 375     for( i = 0; i < n; i++ )
 376     {
 377         if( ktype == CV_32F )
 378             cf[i] = (float)(cf[i]*sum);
 379         else
 380             cd[i] *= sum;
 381     }
 382
 383     return kernel;
 384 }
 385
 386
 387 cv::Ptr<cv::FilterEngine> cv::createGaussianFilter( int type, Size ksize,
 388                                         double sigma1, double sigma2,
 389                                         int borderType )
 390 {
 391     int depth = CV_MAT_DEPTH(type);
 392     if( sigma2 <= 0 )
 393         sigma2 = sigma1;
 394
 395     // automatic detection of kernel size from sigma
 396     if( ksize.width <= 0 && sigma1 > 0 )
 397         ksize.width = cvRound(sigma1*(depth == CV_8U ? 3 : 4)*2 + 1)|1;
 398     if( ksize.height <= 0 && sigma2 > 0 )
 399         ksize.height = cvRound(sigma2*(depth == CV_8U ? 3 : 4)*2 + 1)|1;
 400
 401     CV_Assert( ksize.width > 0 && ksize.width % 2 == 1 &&
 402         ksize.height > 0 && ksize.height % 2 == 1 );
 403
 404     sigma1 = std::max( sigma1, 0. );
 405     sigma2 = std::max( sigma2, 0. );
 406
 407     Mat kx = getGaussianKernel( ksize.width, sigma1, std::max(depth, CV_32F) );
 408     Mat ky;
 409     if( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL_EPSILON )
 410         ky = kx;
 411     else
 412         ky = getGaussianKernel( ksize.height, sigma2, std::max(depth, CV_32F) );
 413
 414     return createSeparableLinearFilter( type, type, kx, ky, Point(-1,-1), 0, borderType );
 415 }
 416
 417
 418 void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
 419                    double sigma1, double sigma2,
 420                    int borderType )
 421 {
 422     Mat src = _src.getMat();
 423     _dst.create( src.size(), src.type() );
 424     Mat dst = _dst.getMat();
 425
 426     if( borderType != BORDER_CONSTANT )
 427     {
 428         if( src.rows == 1 )
 429             ksize.height = 1;
 430         if( src.cols == 1 )
 431             ksize.width = 1;
 432     }
 433
 434     if( ksize.width == 1 && ksize.height == 1 )
 435     {
 436         src.copyTo(dst);
 437         return;
 438     }
 439
 440 #ifdef HAVE_TEGRA_OPTIMIZATION
 441     if(sigma1 == 0 && sigma2 == 0 && tegra::gaussian(src, dst, ksize, borderType))
 442         return;
 443 #endif
 444
 445     Ptr<FilterEngine> f = createGaussianFilter( src.type(), ksize, sigma1, sigma2, borderType );
 446     f->apply( src, dst );
 447 }
 448
 449
 450 /****************************************************************************************\
 451                                       Median Filter
 452 \****************************************************************************************/
 453
 454 namespace cv
 455 {
 456 typedef ushort HT;
 457
 458 /**
 459  * This structure represents a two-tier histogram. The first tier (known as the
 460  * "coarse" level) is 4 bit wide and the second tier (known as the "fine" level)
 461  * is 8 bit wide. Pixels inserted in the fine level also get inserted into the
 462  * coarse bucket designated by the 4 MSBs of the fine bucket value.
 463  *
 464  * The structure is aligned on 16 bits, which is a prerequisite for SIMD
 465  * instructions. Each bucket is 16 bit wide, which means that extra care must be
 466  * taken to prevent overflow.
 467  */
 468 typedef struct
 469 {
 470     HT coarse[16];
 471     HT fine[16][16];
 472 } Histogram;
 473
 474
 475 #if CV_SSE2
 476 #define MEDIAN_HAVE_SIMD 1
 477
 478 static inline void histogram_add_simd( const HT x[16], HT y[16] )
 479 {
 480     const __m128i* rx = (const __m128i*)x;
 481     __m128i* ry = (__m128i*)y;
 482     __m128i r0 = _mm_add_epi16(_mm_load_si128(ry+0),_mm_load_si128(rx+0));
 483     __m128i r1 = _mm_add_epi16(_mm_load_si128(ry+1),_mm_load_si128(rx+1));
 484     _mm_store_si128(ry+0, r0);
 485     _mm_store_si128(ry+1, r1);
 486 }
 487
 488 static inline void histogram_sub_simd( const HT x[16], HT y[16] )
 489 {
 490     const __m128i* rx = (const __m128i*)x;
 491     __m128i* ry = (__m128i*)y;
 492     __m128i r0 = _mm_sub_epi16(_mm_load_si128(ry+0),_mm_load_si128(rx+0));
 493     __m128i r1 = _mm_sub_epi16(_mm_load_si128(ry+1),_mm_load_si128(rx+1));
 494     _mm_store_si128(ry+0, r0);
 495     _mm_store_si128(ry+1, r1);
 496 }
 497
 498 #else
 499 #define MEDIAN_HAVE_SIMD 0
 500 #endif
 501
 502
 503 static inline void histogram_add( const HT x[16], HT y[16] )
 504 {
 505     int i;
 506     for( i = 0; i < 16; ++i )
 507         y[i] = (HT)(y[i] + x[i]);
 508 }
 509
 510 static inline void histogram_sub( const HT x[16], HT y[16] )
 511 {
 512     int i;
 513     for( i = 0; i < 16; ++i )
 514         y[i] = (HT)(y[i] - x[i]);
 515 }
 516
 517 static inline void histogram_muladd( int a, const HT x[16],
 518         HT y[16] )
 519 {
 520     for( int i = 0; i < 16; ++i )
 521         y[i] = (HT)(y[i] + a * x[i]);
 522 }
 523
 524 static void
 525 medianBlur_8u_O1( const Mat& _src, Mat& _dst, int ksize )
 526 {
 527 /**
 528  * HOP is short for Histogram OPeration. This macro makes an operation \a op on
 529  * histogram \a h for pixel value \a x. It takes care of handling both levels.
 530  */
 531 #define HOP(h,x,op) \
 532     h.coarse[x>>4] op, \
 533     *((HT*)h.fine + x) op
 534
 535 #define COP(c,j,x,op) \
 536     h_coarse[ 16*(n*c+j) + (x>>4) ] op, \
 537     h_fine[ 16 * (n*(16*c+(x>>4)) + j) + (x & 0xF) ] op
 538
 539     int cn = _dst.channels(), m = _dst.rows, r = (ksize-1)/2;
 540     size_t sstep = _src.step, dstep = _dst.step;
 541     Histogram CV_DECL_ALIGNED(16) H[4];
 542     HT CV_DECL_ALIGNED(16) luc[4][16];
 543
 544     int STRIPE_SIZE = std::min( _dst.cols, 512/cn );
 545
 546     vector<HT> _h_coarse(1 * 16 * (STRIPE_SIZE + 2*r) * cn + 16);
 547     vector<HT> _h_fine(16 * 16 * (STRIPE_SIZE + 2*r) * cn + 16);
 548     HT* h_coarse = alignPtr(&_h_coarse[0], 16);
 549     HT* h_fine = alignPtr(&_h_fine[0], 16);
 550 #if MEDIAN_HAVE_SIMD
 551     volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
 552 #endif
 553
 554     for( int x = 0; x < _dst.cols; x += STRIPE_SIZE )
 555     {
 556         int i, j, k, c, n = std::min(_dst.cols - x, STRIPE_SIZE) + r*2;
 557         const uchar* src = _src.data + x*cn;
 558         uchar* dst = _dst.data + (x - r)*cn;
 559
 560         memset( h_coarse, 0, 16*n*cn*sizeof(h_coarse[0]) );
 561         memset( h_fine, 0, 16*16*n*cn*sizeof(h_fine[0]) );
 562
 563         // First row initialization
 564         for( c = 0; c < cn; c++ )
 565         {
 566             for( j = 0; j < n; j++ )
 567                 COP( c, j, src[cn*j+c], += (cv::HT)(r+2) );
 568
 569             for( i = 1; i < r; i++ )
 570             {
 571                 const uchar* p = src + sstep*std::min(i, m-1);
 572                 for ( j = 0; j < n; j++ )
 573                     COP( c, j, p[cn*j+c], ++ );
 574             }
 575         }
 576
 577         for( i = 0; i < m; i++ )
 578         {
 579             const uchar* p0 = src + sstep * std::max( 0, i-r-1 );
 580             const uchar* p1 = src + sstep * std::min( m-1, i+r );
 581
 582             memset( H, 0, cn*sizeof(H[0]) );
 583             memset( luc, 0, cn*sizeof(luc[0]) );
 584             for( c = 0; c < cn; c++ )
 585             {
 586                 // Update column histograms for the entire row.
 587                 for( j = 0; j < n; j++ )
 588                 {
 589                     COP( c, j, p0[j*cn + c], -- );
 590                     COP( c, j, p1[j*cn + c], ++ );
 591                 }
 592
 593                 // First column initialization
 594                 for( k = 0; k < 16; ++k )
 595                     histogram_muladd( 2*r+1, &h_fine[16*n*(16*c+k)], &H[c].fine[k][0] );
 596
 597             #if MEDIAN_HAVE_SIMD
 598                 if( useSIMD )
 599                 {
 600                     for( j = 0; j < 2*r; ++j )
 601                         histogram_add_simd( &h_coarse[16*(n*c+j)], H[c].coarse );
 602
 603                     for( j = r; j < n-r; j++ )
 604                     {
 605                         int t = 2*r*r + 2*r, b, sum = 0;
 606                         HT* segment;
 607
 608                         histogram_add_simd( &h_coarse[16*(n*c + std::min(j+r,n-1))], H[c].coarse );
 609
 610                         // Find median at coarse level
 611                         for ( k = 0; k < 16 ; ++k )
 612                         {
 613                             sum += H[c].coarse[k];
 614                             if ( sum > t )
 615                             {
 616                                 sum -= H[c].coarse[k];
 617                                 break;
 618                             }
 619                         }
 620                         assert( k < 16 );
 621
 622                         /* Update corresponding histogram segment */
 623                         if ( luc[c][k] <= j-r )
 624                         {
 625                             memset( &H[c].fine[k], 0, 16 * sizeof(HT) );
 626                             for ( luc[c][k] = cv::HT(j-r); luc[c][k] < MIN(j+r+1,n); ++luc[c][k] )
 627                                 histogram_add_simd( &h_fine[16*(n*(16*c+k)+luc[c][k])], H[c].fine[k] );
 628
 629                             if ( luc[c][k] < j+r+1 )
 630                             {
 631                                 histogram_muladd( j+r+1 - n, &h_fine[16*(n*(16*c+k)+(n-1))], &H[c].fine[k][0] );
 632                                 luc[c][k] = (HT)(j+r+1);
 633                             }
 634                         }
 635                         else
 636                         {
 637                             for ( ; luc[c][k] < j+r+1; ++luc[c][k] )
 638                             {
 639                                 histogram_sub_simd( &h_fine[16*(n*(16*c+k)+MAX(luc[c][k]-2*r-1,0))], H[c].fine[k] );
 640                                 histogram_add_simd( &h_fine[16*(n*(16*c+k)+MIN(luc[c][k],n-1))], H[c].fine[k] );
 641                             }
 642                         }
 643
 644                         histogram_sub_simd( &h_coarse[16*(n*c+MAX(j-r,0))], H[c].coarse );
 645
 646                         /* Find median in segment */
 647                         segment = H[c].fine[k];
 648                         for ( b = 0; b < 16 ; b++ )
 649                         {
 650                             sum += segment[b];
 651                             if ( sum > t )
 652                             {
 653                                 dst[dstep*i+cn*j+c] = (uchar)(16*k + b);
 654                                 break;
 655                             }
 656                         }
 657                         assert( b < 16 );
 658                     }
 659                 }
 660                 else
 661             #endif
 662                 {
 663                     for( j = 0; j < 2*r; ++j )
 664                         histogram_add( &h_coarse[16*(n*c+j)], H[c].coarse );
 665
 666                     for( j = r; j < n-r; j++ )
 667                     {
 668                         int t = 2*r*r + 2*r, b, sum = 0;
 669                         HT* segment;
 670
 671                         histogram_add( &h_coarse[16*(n*c + std::min(j+r,n-1))], H[c].coarse );
 672
 673                         // Find median at coarse level
 674                         for ( k = 0; k < 16 ; ++k )
 675                         {
 676                             sum += H[c].coarse[k];
 677                             if ( sum > t )
 678                             {
 679                                 sum -= H[c].coarse[k];
 680                                 break;
 681                             }
 682                         }
 683                         assert( k < 16 );
 684
 685                         /* Update corresponding histogram segment */
 686                         if ( luc[c][k] <= j-r )
 687                         {
 688                             memset( &H[c].fine[k], 0, 16 * sizeof(HT) );
 689                             for ( luc[c][k] = cv::HT(j-r); luc[c][k] < MIN(j+r+1,n); ++luc[c][k] )
 690                                 histogram_add( &h_fine[16*(n*(16*c+k)+luc[c][k])], H[c].fine[k] );
 691
 692                             if ( luc[c][k] < j+r+1 )
 693                             {
 694                                 histogram_muladd( j+r+1 - n, &h_fine[16*(n*(16*c+k)+(n-1))], &H[c].fine[k][0] );
 695                                 luc[c][k] = (HT)(j+r+1);
 696                             }
 697                         }
 698                         else
 699                         {
 700                             for ( ; luc[c][k] < j+r+1; ++luc[c][k] )
 701                             {
 702                                 histogram_sub( &h_fine[16*(n*(16*c+k)+MAX(luc[c][k]-2*r-1,0))], H[c].fine[k] );
 703                                 histogram_add( &h_fine[16*(n*(16*c+k)+MIN(luc[c][k],n-1))], H[c].fine[k] );
 704                             }
 705                         }
 706
 707                         histogram_sub( &h_coarse[16*(n*c+MAX(j-r,0))], H[c].coarse );
 708
 709                         /* Find median in segment */
 710                         segment = H[c].fine[k];
 711                         for ( b = 0; b < 16 ; b++ )
 712                         {
 713                             sum += segment[b];
 714                             if ( sum > t )
 715                             {
 716                                 dst[dstep*i+cn*j+c] = (uchar)(16*k + b);
 717                                 break;
 718                             }
 719                         }
 720                         assert( b < 16 );
 721                     }
 722                 }
 723             }
 724         }
 725     }
 726
 727 #undef HOP
 728 #undef COP
 729 }
 730
 731 static void
 732 medianBlur_8u_Om( const Mat& _src, Mat& _dst, int m )
 733 {
 734     #define N  16
 735     int     zone0[4][N];
 736     int     zone1[4][N*N];
 737     int     x, y;
 738     int     n2 = m*m/2;
 739     Size    size = _dst.size();
 740     const uchar* src = _src.data;
 741     uchar*  dst = _dst.data;
 742     int     src_step = (int)_src.step, dst_step = (int)_dst.step;
 743     int     cn = _src.channels();
 744     const uchar*  src_max = src + size.height*src_step;
 745
 746     #define UPDATE_ACC01( pix, cn, op ) \
 747     {                                   \
 748         int p = (pix);                  \
 749         zone1[cn][p] op;                \
 750         zone0[cn][p >> 4] op;           \
 751     }
 752
 753     //CV_Assert( size.height >= nx && size.width >= nx );
 754     for( x = 0; x < size.width; x++, src += cn, dst += cn )
 755     {
 756         uchar* dst_cur = dst;
 757         const uchar* src_top = src;
 758         const uchar* src_bottom = src;
 759         int k, c;
 760         int src_step1 = src_step, dst_step1 = dst_step;
 761
 762         if( x % 2 != 0 )
 763         {
 764             src_bottom = src_top += src_step*(size.height-1);
 765             dst_cur += dst_step*(size.height-1);
 766             src_step1 = -src_step1;
 767             dst_step1 = -dst_step1;
 768         }
 769
 770         // init accumulator
 771         memset( zone0, 0, sizeof(zone0[0])*cn );
 772         memset( zone1, 0, sizeof(zone1[0])*cn );
 773
 774         for( y = 0; y <= m/2; y++ )
 775         {
 776             for( c = 0; c < cn; c++ )
 777             {
 778                 if( y > 0 )
 779                 {
 780                     for( k = 0; k < m*cn; k += cn )
 781                         UPDATE_ACC01( src_bottom[k+c], c, ++ );
 782                 }
 783                 else
 784                 {
 785                     for( k = 0; k < m*cn; k += cn )
 786                         UPDATE_ACC01( src_bottom[k+c], c, += m/2+1 );
 787                 }
 788             }
 789
 790             if( (src_step1 > 0 && y < size.height-1) ||
 791                 (src_step1 < 0 && size.height-y-1 > 0) )
 792                 src_bottom += src_step1;
 793         }
 794
 795         for( y = 0; y < size.height; y++, dst_cur += dst_step1 )
 796         {
 797             // find median
 798             for( c = 0; c < cn; c++ )
 799             {
 800                 int s = 0;
 801                 for( k = 0; ; k++ )
 802                 {
 803                     int t = s + zone0[c][k];
 804                     if( t > n2 ) break;
 805                     s = t;
 806                 }
 807
 808                 for( k *= N; ;k++ )
 809                 {
 810                     s += zone1[c][k];
 811                     if( s > n2 ) break;
 812                 }
 813
 814                 dst_cur[c] = (uchar)k;
 815             }
 816
 817             if( y+1 == size.height )
 818                 break;
 819
 820             if( cn == 1 )
 821             {
 822                 for( k = 0; k < m; k++ )
 823                 {
 824                     int p = src_top[k];
 825                     int q = src_bottom[k];
 826                     zone1[0][p]--;
 827                     zone0[0][p>>4]--;
 828                     zone1[0][q]++;
 829                     zone0[0][q>>4]++;
 830                 }
 831             }
 832             else if( cn == 3 )
 833             {
 834                 for( k = 0; k < m*3; k += 3 )
 835                 {
 836                     UPDATE_ACC01( src_top[k], 0, -- );
 837                     UPDATE_ACC01( src_top[k+1], 1, -- );
 838                     UPDATE_ACC01( src_top[k+2], 2, -- );
 839
 840                     UPDATE_ACC01( src_bottom[k], 0, ++ );
 841                     UPDATE_ACC01( src_bottom[k+1], 1, ++ );
 842                     UPDATE_ACC01( src_bottom[k+2], 2, ++ );
 843                 }
 844             }
 845             else
 846             {
 847                 assert( cn == 4 );
 848                 for( k = 0; k < m*4; k += 4 )
 849                 {
 850                     UPDATE_ACC01( src_top[k], 0, -- );
 851                     UPDATE_ACC01( src_top[k+1], 1, -- );
 852                     UPDATE_ACC01( src_top[k+2], 2, -- );
 853                     UPDATE_ACC01( src_top[k+3], 3, -- );
 854
 855                     UPDATE_ACC01( src_bottom[k], 0, ++ );
 856                     UPDATE_ACC01( src_bottom[k+1], 1, ++ );
 857                     UPDATE_ACC01( src_bottom[k+2], 2, ++ );
 858                     UPDATE_ACC01( src_bottom[k+3], 3, ++ );
 859                 }
 860             }
 861
 862             if( (src_step1 > 0 && src_bottom + src_step1 < src_max) ||
 863                 (src_step1 < 0 && src_bottom + src_step1 >= src) )
 864                 src_bottom += src_step1;
 865
 866             if( y >= m/2 )
 867                 src_top += src_step1;
 868         }
 869     }
 870 #undef N
 871 #undef UPDATE_ACC
 872 }
 873
 874
 875 struct MinMax8u
 876 {
 877     typedef uchar value_type;
 878     typedef int arg_type;
 879     enum { SIZE = 1 };
 880     arg_type load(const uchar* ptr) { return *ptr; }
 881     void store(uchar* ptr, arg_type val) { *ptr = (uchar)val; }
 882     void operator()(arg_type& a, arg_type& b) const
 883     {
 884         int t = CV_FAST_CAST_8U(a - b);
 885         b += t; a -= t;
 886     }
 887 };
 888
 889 struct MinMax16u
 890 {
 891     typedef ushort value_type;
 892     typedef int arg_type;
 893     enum { SIZE = 1 };
 894     arg_type load(const ushort* ptr) { return *ptr; }
 895     void store(ushort* ptr, arg_type val) { *ptr = (ushort)val; }
 896     void operator()(arg_type& a, arg_type& b) const
 897     {
 898         arg_type t = a;
 899         a = std::min(a, b);
 900         b = std::max(b, t);
 901     }
 902 };
 903
 904 struct MinMax16s
 905 {
 906     typedef short value_type;
 907     typedef int arg_type;
 908     enum { SIZE = 1 };
 909     arg_type load(const short* ptr) { return *ptr; }
 910     void store(short* ptr, arg_type val) { *ptr = (short)val; }
 911     void operator()(arg_type& a, arg_type& b) const
 912     {
 913         arg_type t = a;
 914         a = std::min(a, b);
 915         b = std::max(b, t);
 916     }
 917 };
 918
 919 struct MinMax32f
 920 {
 921     typedef float value_type;
 922     typedef float arg_type;
 923     enum { SIZE = 1 };
 924     arg_type load(const float* ptr) { return *ptr; }
 925     void store(float* ptr, arg_type val) { *ptr = val; }
 926     void operator()(arg_type& a, arg_type& b) const
 927     {
 928         arg_type t = a;
 929         a = std::min(a, b);
 930         b = std::max(b, t);
 931     }
 932 };
 933
 934 #if CV_SSE2
 935
 936 struct MinMaxVec8u
 937 {
 938     typedef uchar value_type;
 939     typedef __m128i arg_type;
 940     enum { SIZE = 16 };
 941     arg_type load(const uchar* ptr) { return _mm_loadu_si128((const __m128i*)ptr); }
 942     void store(uchar* ptr, arg_type val) { _mm_storeu_si128((__m128i*)ptr, val); }
 943     void operator()(arg_type& a, arg_type& b) const
 944     {
 945         arg_type t = a;
 946         a = _mm_min_epu8(a, b);
 947         b = _mm_max_epu8(b, t);
 948     }
 949 };
 950
 951
 952 struct MinMaxVec16u
 953 {
 954     typedef ushort value_type;
 955     typedef __m128i arg_type;
 956     enum { SIZE = 8 };
 957     arg_type load(const ushort* ptr) { return _mm_loadu_si128((const __m128i*)ptr); }
 958     void store(ushort* ptr, arg_type val) { _mm_storeu_si128((__m128i*)ptr, val); }
 959     void operator()(arg_type& a, arg_type& b) const
 960     {
 961         arg_type t = _mm_subs_epu16(a, b);
 962         a = _mm_subs_epu16(a, t);
 963         b = _mm_adds_epu16(b, t);
 964     }
 965 };
 966
 967
 968 struct MinMaxVec16s
 969 {
 970     typedef short value_type;
 971     typedef __m128i arg_type;
 972     enum { SIZE = 8 };
 973     arg_type load(const short* ptr) { return _mm_loadu_si128((const __m128i*)ptr); }
 974     void store(short* ptr, arg_type val) { _mm_storeu_si128((__m128i*)ptr, val); }
 975     void operator()(arg_type& a, arg_type& b) const
 976     {
 977         arg_type t = a;
 978         a = _mm_min_epi16(a, b);
 979         b = _mm_max_epi16(b, t);
 980     }
 981 };
 982
 983
 984 struct MinMaxVec32f
 985 {
 986     typedef float value_type;
 987     typedef __m128 arg_type;
 988     enum { SIZE = 4 };
 989     arg_type load(const float* ptr) { return _mm_loadu_ps(ptr); }
 990     void store(float* ptr, arg_type val) { _mm_storeu_ps(ptr, val); }
 991     void operator()(arg_type& a, arg_type& b) const
 992     {
 993         arg_type t = a;
 994         a = _mm_min_ps(a, b);
 995         b = _mm_max_ps(b, t);
 996     }
 997 };
 998
 999
1000 #else
1001
1002 typedef MinMax8u MinMaxVec8u;
1003 typedef MinMax16u MinMaxVec16u;
1004 typedef MinMax16s MinMaxVec16s;
1005 typedef MinMax32f MinMaxVec32f;
1006
1007 #endif
1008
1009 template<class Op, class VecOp>
1010 static void
1011 medianBlur_SortNet( const Mat& _src, Mat& _dst, int m )
1012 {
1013     typedef typename Op::value_type T;
1014     typedef typename Op::arg_type WT;
1015     typedef typename VecOp::arg_type VT;
1016
1017     const T* src = (const T*)_src.data;
1018     T* dst = (T*)_dst.data;
1019     int sstep = (int)(_src.step/sizeof(T));
1020     int dstep = (int)(_dst.step/sizeof(T));
1021     Size size = _dst.size();
1022     int i, j, k, cn = _src.channels();
1023     Op op;
1024     VecOp vop;
1025     volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
1026
1027     if( m == 3 )
1028     {
1029         if( size.width == 1 || size.height == 1 )
1030         {
1031             int len = size.width + size.height - 1;
1032             int sdelta = size.height == 1 ? cn : sstep;
1033             int sdelta0 = size.height == 1 ? 0 : sstep - cn;
1034             int ddelta = size.height == 1 ? cn : dstep;
1035
1036             for( i = 0; i < len; i++, src += sdelta0, dst += ddelta )
1037                 for( j = 0; j < cn; j++, src++ )
1038                 {
1039                     WT p0 = src[i > 0 ? -sdelta : 0];
1040                     WT p1 = src[0];
1041                     WT p2 = src[i < len - 1 ? sdelta : 0];
1042
1043                     op(p0, p1); op(p1, p2); op(p0, p1);
1044                     dst[j] = (T)p1;
1045                 }
1046             return;
1047         }
1048
1049         size.width *= cn;
1050         for( i = 0; i < size.height; i++, dst += dstep )
1051         {
1052             const T* row0 = src + std::max(i - 1, 0)*sstep;
1053             const T* row1 = src + i*sstep;
1054             const T* row2 = src + std::min(i + 1, size.height-1)*sstep;
1055             int limit = useSIMD ? cn : size.width;
1056
1057             for(j = 0;; )
1058             {
1059                 for( ; j < limit; j++ )
1060                 {
1061                     int j0 = j >= cn ? j - cn : j;
1062                     int j2 = j < size.width - cn ? j + cn : j;
1063                     WT p0 = row0[j0], p1 = row0[j], p2 = row0[j2];
1064                     WT p3 = row1[j0], p4 = row1[j], p5 = row1[j2];
1065                     WT p6 = row2[j0], p7 = row2[j], p8 = row2[j2];
1066
1067                     op(p1, p2); op(p4, p5); op(p7, p8); op(p0, p1);
1068                     op(p3, p4); op(p6, p7); op(p1, p2); op(p4, p5);
1069                     op(p7, p8); op(p0, p3); op(p5, p8); op(p4, p7);
1070                     op(p3, p6); op(p1, p4); op(p2, p5); op(p4, p7);
1071                     op(p4, p2); op(p6, p4); op(p4, p2);
1072                     dst[j] = (T)p4;
1073                 }
1074
1075                 if( limit == size.width )
1076                     break;
1077
1078                 for( ; j <= size.width - VecOp::SIZE - cn; j += VecOp::SIZE )
1079                 {
1080                     VT p0 = vop.load(row0+j-cn), p1 = vop.load(row0+j), p2 = vop.load(row0+j+cn);
1081                     VT p3 = vop.load(row1+j-cn), p4 = vop.load(row1+j), p5 = vop.load(row1+j+cn);
1082                     VT p6 = vop.load(row2+j-cn), p7 = vop.load(row2+j), p8 = vop.load(row2+j+cn);
1083
1084                     vop(p1, p2); vop(p4, p5); vop(p7, p8); vop(p0, p1);
1085                     vop(p3, p4); vop(p6, p7); vop(p1, p2); vop(p4, p5);
1086                     vop(p7, p8); vop(p0, p3); vop(p5, p8); vop(p4, p7);
1087                     vop(p3, p6); vop(p1, p4); vop(p2, p5); vop(p4, p7);
1088                     vop(p4, p2); vop(p6, p4); vop(p4, p2);
1089                     vop.store(dst+j, p4);
1090                 }
1091
1092                 limit = size.width;
1093             }
1094         }
1095     }
1096     else if( m == 5 )
1097     {
1098         if( size.width == 1 || size.height == 1 )
1099         {
1100             int len = size.width + size.height - 1;
1101             int sdelta = size.height == 1 ? cn : sstep;
1102             int sdelta0 = size.height == 1 ? 0 : sstep - cn;
1103             int ddelta = size.height == 1 ? cn : dstep;
1104
1105             for( i = 0; i < len; i++, src += sdelta0, dst += ddelta )
1106                 for( j = 0; j < cn; j++, src++ )
1107                 {
1108                     int i1 = i > 0 ? -sdelta : 0;
1109                     int i0 = i > 1 ? -sdelta*2 : i1;
1110                     int i3 = i < len-1 ? sdelta : 0;
1111                     int i4 = i < len-2 ? sdelta*2 : i3;
1112                     WT p0 = src[i0], p1 = src[i1], p2 = src[0], p3 = src[i3], p4 = src[i4];
1113
1114                     op(p0, p1); op(p3, p4); op(p2, p3); op(p3, p4); op(p0, p2);
1115                     op(p2, p4); op(p1, p3); op(p1, p2);
1116                     dst[j] = (T)p2;
1117                 }
1118             return;
1119         }
1120
1121         size.width *= cn;
1122         for( i = 0; i < size.height; i++, dst += dstep )
1123         {
1124             const T* row[5];
1125             row[0] = src + std::max(i - 2, 0)*sstep;
1126             row[1] = src + std::max(i - 1, 0)*sstep;
1127             row[2] = src + i*sstep;
1128             row[3] = src + std::min(i + 1, size.height-1)*sstep;
1129             row[4] = src + std::min(i + 2, size.height-1)*sstep;
1130             int limit = useSIMD ? cn*2 : size.width;
1131
1132             for(j = 0;; )
1133             {
1134                 for( ; j < limit; j++ )
1135                 {
1136                     WT p[25];
1137                     int j1 = j >= cn ? j - cn : j;
1138                     int j0 = j >= cn*2 ? j - cn*2 : j1;
1139                     int j3 = j < size.width - cn ? j + cn : j;
1140                     int j4 = j < size.width - cn*2 ? j + cn*2 : j3;
1141                     for( k = 0; k < 5; k++ )
1142                     {
1143                         const T* rowk = row[k];
1144                         p[k*5] = rowk[j0]; p[k*5+1] = rowk[j1];
1145                         p[k*5+2] = rowk[j]; p[k*5+3] = rowk[j3];
1146                         p[k*5+4] = rowk[j4];
1147                     }
1148
1149                     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]);
1150                     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]);
1151                     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]);
1152                     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]);
1153                     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]);
1154                     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]);
1155                     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]);
1156                     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]);
1157                     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]);
1158                     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]);
1159                     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]);
1160                     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]);
1161                     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]);
1162                     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]);
1163                     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]);
1164                     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]);
1165                     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]);
1166                     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]);
1167                     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]);
1168                     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]);
1169                     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]);
1170                     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]);
1171                     op(p[7], p[11]); op(p[11], p[13]); op(p[11], p[12]);
1172                     dst[j] = (T)p[12];
1173                 }
1174
1175                 if( limit == size.width )
1176                     break;
1177
1178                 for( ; j <= size.width - VecOp::SIZE - cn*2; j += VecOp::SIZE )
1179                 {
1180                     VT p[25];
1181                     for( k = 0; k < 5; k++ )
1182                     {
1183                         const T* rowk = row[k];
1184                         p[k*5] = vop.load(rowk+j-cn*2); p[k*5+1] = vop.load(rowk+j-cn);
1185                         p[k*5+2] = vop.load(rowk+j); p[k*5+3] = vop.load(rowk+j+cn);
1186                         p[k*5+4] = vop.load(rowk+j+cn*2);
1187                     }
1188
1189                     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]);
1190                     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]);
1191                     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]);
1192                     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]);
1193                     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]);
1194                     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]);
1195                     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]);
1196                     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]);
1197                     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]);
1198                     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]);
1199                     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]);
1200                     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]);
1201                     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]);
1202                     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]);
1203                     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]);
1204                     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]);
1205                     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]);
1206                     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]);
1207                     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]);
1208                     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]);
1209                     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]);
1210                     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]);
1211                     vop(p[7], p[11]); vop(p[11], p[13]); vop(p[11], p[12]);
1212                     vop.store(dst+j, p[12]);
1213                 }
1214
1215                 limit = size.width;
1216             }
1217         }
1218     }
1219 }
1220
1221 }
1222
1223 void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
1224 {
1225     Mat src0 = _src0.getMat();
1226     _dst.create( src0.size(), src0.type() );
1227     Mat dst = _dst.getMat();
1228
1229     if( ksize <= 1 )
1230     {
1231         src0.copyTo(dst);
1232         return;
1233     }
1234
1235     CV_Assert( ksize % 2 == 1 );
1236
1237 #ifdef HAVE_TEGRA_OPTIMIZATION
1238     if (tegra::medianBlur(src0, dst, ksize))
1239         return;
1240 #endif
1241
1242     bool useSortNet = ksize == 3 || (ksize == 5
1243 #if !CV_SSE2
1244             && src0.depth() > CV_8U
1245 #endif
1246         );
1247
1248     Mat src;
1249     if( useSortNet )
1250     {
1251         if( dst.data != src0.data )
1252             src = src0;
1253         else
1254             src0.copyTo(src);
1255
1256         if( src.depth() == CV_8U )
1257             medianBlur_SortNet<MinMax8u, MinMaxVec8u>( src, dst, ksize );
1258         else if( src.depth() == CV_16U )
1259             medianBlur_SortNet<MinMax16u, MinMaxVec16u>( src, dst, ksize );
1260         else if( src.depth() == CV_16S )
1261             medianBlur_SortNet<MinMax16s, MinMaxVec16s>( src, dst, ksize );
1262         else if( src.depth() == CV_32F )
1263             medianBlur_SortNet<MinMax32f, MinMaxVec32f>( src, dst, ksize );
1264         else
1265             CV_Error(CV_StsUnsupportedFormat, "");
1266
1267         return;
1268     }
1269     else
1270     {
1271         cv::copyMakeBorder( src0, src, 0, 0, ksize/2, ksize/2, BORDER_REPLICATE );
1272
1273         int cn = src0.channels();
1274         CV_Assert( src.depth() == CV_8U && (cn == 1 || cn == 3 || cn == 4) );
1275
1276         double img_size_mp = (double)(src0.total())/(1 << 20);
1277         if( ksize <= 3 + (img_size_mp < 1 ? 12 : img_size_mp < 4 ? 6 : 2)*(MEDIAN_HAVE_SIMD && checkHardwareSupport(CV_CPU_SSE2) ? 1 : 3))
1278             medianBlur_8u_Om( src, dst, ksize );
1279         else
1280             medianBlur_8u_O1( src, dst, ksize );
1281     }
1282 }
1283
1284 /****************************************************************************************\
1285                                    Bilateral Filtering
1286 \****************************************************************************************/
1287
1288 namespace cv
1289 {
1290
1291 class BilateralFilter_8u_Invoker :
1292     public ParallelLoopBody
1293 {
1294 public:
1295     BilateralFilter_8u_Invoker(Mat& _dest, const Mat& _temp, int _radius, int _maxk,
1296         int* _space_ofs, float *_space_weight, float *_color_weight) :
1297         temp(&_temp), dest(&_dest), radius(_radius),
1298         maxk(_maxk), space_ofs(_space_ofs), space_weight(_space_weight), color_weight(_color_weight)
1299     {
1300     }
1301
1302     virtual void operator() (const Range& range) const
1303     {
1304         int i, j, cn = dest->channels(), k;
1305         Size size = dest->size();
1306                 #if CV_SSE3
1307         int CV_DECL_ALIGNED(16) buf[4];
1308         float CV_DECL_ALIGNED(16) bufSum[4];
1309         static const int CV_DECL_ALIGNED(16) bufSignMask[] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
1310         bool haveSSE3 = checkHardwareSupport(CV_CPU_SSE3);
1311                 #endif
1312
1313         for( i = range.start; i < range.end; i++ )
1314         {
1315             const uchar* sptr = temp->ptr(i+radius) + radius*cn;
1316             uchar* dptr = dest->ptr(i);
1317
1318             if( cn == 1 )
1319             {
1320                 for( j = 0; j < size.width; j++ )
1321                 {
1322                     float sum = 0, wsum = 0;
1323                     int val0 = sptr[j];
1324                                         k = 0;
1325                                         #if CV_SSE3
1326                                         if( haveSSE3 )
1327                                         {
1328                                                 __m128 _val0 = _mm_set1_ps(static_cast<float>(val0));
1329                                                 const __m128 _signMask = _mm_load_ps((const float*)bufSignMask);
1330
1331                                                 for( ; k <= maxk - 4; k += 4 )
1332                                                 {
1333                                                         __m128 _valF = _mm_set_ps(sptr[j + space_ofs[k+3]], sptr[j + space_ofs[k+2]],
1334                                                       sptr[j + space_ofs[k+1]], sptr[j + space_ofs[k]]);
1335
1336                                                         __m128 _val = _mm_andnot_ps(_signMask, _mm_sub_ps(_valF, _val0));
1337                                                         _mm_store_si128((__m128i*)buf, _mm_cvtps_epi32(_val));
1338
1339                                                         __m128 _cw = _mm_set_ps(color_weight[buf[3]],color_weight[buf[2]],
1340                                                     color_weight[buf[1]],color_weight[buf[0]]);
1341                                                         __m128 _sw = _mm_loadu_ps(space_weight+k);
1342                                                         __m128 _w = _mm_mul_ps(_cw, _sw);
1343                                                          _cw = _mm_mul_ps(_w, _valF);
1344
1345                                                          _sw = _mm_hadd_ps(_w, _cw);
1346                                                          _sw = _mm_hadd_ps(_sw, _sw);
1347                                                          _mm_storel_pi((__m64*)bufSum, _sw);
1348
1349                                                          sum += bufSum[1];
1350                                                          wsum += bufSum[0];
1351                                                 }
1352                                         }
1353                                         #endif
1354                     for( ; k < maxk; k++ )
1355                     {
1356                         int val = sptr[j + space_ofs[k]];
1357                         float w = space_weight[k]*color_weight[std::abs(val - val0)];
1358                         sum += val*w;
1359                         wsum += w;
1360                     }
1361                     // overflow is not possible here => there is no need to use CV_CAST_8U
1362                     dptr[j] = (uchar)cvRound(sum/wsum);
1363                 }
1364             }
1365             else
1366             {
1367                 assert( cn == 3 );
1368                 for( j = 0; j < size.width*3; j += 3 )
1369                 {
1370                     float sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;
1371                     int b0 = sptr[j], g0 = sptr[j+1], r0 = sptr[j+2];
1372                                         k = 0;
1373                                         #if CV_SSE3
1374                                         if( haveSSE3 )
1375                                         {
1376                                                 const __m128 _b0 = _mm_set1_ps(static_cast<float>(b0));
1377                                                 const __m128 _g0 = _mm_set1_ps(static_cast<float>(g0));
1378                                                 const __m128 _r0 = _mm_set1_ps(static_cast<float>(r0));
1379                                                 const __m128 _signMask = _mm_load_ps((const float*)bufSignMask);
1380
1381                         for( ; k <= maxk - 4; k += 4 )
1382                         {
1383                                                         const uchar* sptr_k  = sptr + j + space_ofs[k];
1384                                                         const uchar* sptr_k1 = sptr + j + space_ofs[k+1];
1385                                                         const uchar* sptr_k2 = sptr + j + space_ofs[k+2];
1386                                                         const uchar* sptr_k3 = sptr + j + space_ofs[k+3];
1387
1388                                                         __m128 _b = _mm_set_ps(sptr_k3[0],sptr_k2[0],sptr_k1[0],sptr_k[0]);
1389                                                         __m128 _g = _mm_set_ps(sptr_k3[1],sptr_k2[1],sptr_k1[1],sptr_k[1]);
1390                                                         __m128 _r = _mm_set_ps(sptr_k3[2],sptr_k2[2],sptr_k1[2],sptr_k[2]);
1391
1392                                                         __m128 bt = _mm_andnot_ps(_signMask, _mm_sub_ps(_b,_b0));
1393                                                         __m128 gt = _mm_andnot_ps(_signMask, _mm_sub_ps(_g,_g0));
1394                                                         __m128 rt = _mm_andnot_ps(_signMask, _mm_sub_ps(_r,_r0));
1395
1396                                                         bt =_mm_add_ps(rt, _mm_add_ps(bt, gt));
1397                                                         _mm_store_si128((__m128i*)buf, _mm_cvtps_epi32(bt));
1398
1399                                                         __m128 _w  = _mm_set_ps(color_weight[buf[3]],color_weight[buf[2]],
1400                                                     color_weight[buf[1]],color_weight[buf[0]]);
1401                                                         __m128 _sw = _mm_loadu_ps(space_weight+k);
1402
1403                                                         _w = _mm_mul_ps(_w,_sw);
1404                                                         _b = _mm_mul_ps(_b, _w);
1405                                                         _g = _mm_mul_ps(_g, _w);
1406                                                         _r = _mm_mul_ps(_r, _w);
1407
1408                                                          _w = _mm_hadd_ps(_w, _b);
1409                                                          _g = _mm_hadd_ps(_g, _r);
1410
1411                                                          _w = _mm_hadd_ps(_w, _g);
1412                                                          _mm_store_ps(bufSum, _w);
1413
1414                                                          wsum  += bufSum[0];
1415                                                          sum_b += bufSum[1];
1416                                                          sum_g += bufSum[2];
1417                                                          sum_r += bufSum[3];
1418                                                  }
1419                                         }
1420                                         #endif
1421
1422                     for( ; k < maxk; k++ )
1423                     {
1424                         const uchar* sptr_k = sptr + j + space_ofs[k];
1425                         int b = sptr_k[0], g = sptr_k[1], r = sptr_k[2];
1426                         float w = space_weight[k]*color_weight[std::abs(b - b0) +
1427                                                                std::abs(g - g0) + std::abs(r - r0)];
1428                         sum_b += b*w; sum_g += g*w; sum_r += r*w;
1429                         wsum += w;
1430                     }
1431                     wsum = 1.f/wsum;
1432                     b0 = cvRound(sum_b*wsum);
1433                     g0 = cvRound(sum_g*wsum);
1434                     r0 = cvRound(sum_r*wsum);
1435                     dptr[j] = (uchar)b0; dptr[j+1] = (uchar)g0; dptr[j+2] = (uchar)r0;
1436                 }
1437             }
1438         }
1439     }
1440
1441 private:
1442     const Mat *temp;
1443     Mat *dest;
1444     int radius, maxk, *space_ofs;
1445     float *space_weight, *color_weight;
1446 };
1447
1448 static void
1449 bilateralFilter_8u( const Mat& src, Mat& dst, int d,
1450     double sigma_color, double sigma_space,
1451     int borderType )
1452 {
1453
1454     int cn = src.channels();
1455     int i, j, maxk, radius;
1456     Size size = src.size();
1457
1458     CV_Assert( (src.type() == CV_8UC1 || src.type() == CV_8UC3) &&
1459               src.type() == dst.type() && src.size() == dst.size() &&
1460               src.data != dst.data );
1461
1462     if( sigma_color <= 0 )
1463         sigma_color = 1;
1464     if( sigma_space <= 0 )
1465         sigma_space = 1;
1466
1467     double gauss_color_coeff = -0.5/(sigma_color*sigma_color);
1468     double gauss_space_coeff = -0.5/(sigma_space*sigma_space);
1469
1470     if( d <= 0 )
1471         radius = cvRound(sigma_space*1.5);
1472     else
1473         radius = d/2;
1474     radius = MAX(radius, 1);
1475     d = radius*2 + 1;
1476
1477     Mat temp;
1478     copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );
1479
1480     vector<float> _color_weight(cn*256);
1481     vector<float> _space_weight(d*d);
1482     vector<int> _space_ofs(d*d);
1483     float* color_weight = &_color_weight[0];
1484     float* space_weight = &_space_weight[0];
1485     int* space_ofs = &_space_ofs[0];
1486
1487     // initialize color-related bilateral filter coefficients
1488
1489     for( i = 0; i < 256*cn; i++ )
1490         color_weight[i] = (float)std::exp(i*i*gauss_color_coeff);
1491
1492     // initialize space-related bilateral filter coefficients
1493     for( i = -radius, maxk = 0; i <= radius; i++ )
1494         {
1495                 j = -radius;
1496
1497         for( ;j <= radius; j++ )
1498         {
1499             double r = std::sqrt((double)i*i + (double)j*j);
1500             if( r > radius )
1501                 continue;
1502             space_weight[maxk] = (float)std::exp(r*r*gauss_space_coeff);
1503             space_ofs[maxk++] = (int)(i*temp.step + j*cn);
1504         }
1505         }
1506
1507     BilateralFilter_8u_Invoker body(dst, temp, radius, maxk, space_ofs, space_weight, color_weight);
1508     parallel_for_(Range(0, size.height), body);
1509 }
1510
1511
1512 class BilateralFilter_32f_Invoker :
1513     public ParallelLoopBody
1514 {
1515 public:
1516
1517     BilateralFilter_32f_Invoker(int _cn, int _radius, int _maxk, int *_space_ofs,
1518         const Mat& _temp, Mat& _dest, float _scale_index, float *_space_weight, float *_expLUT) :
1519         cn(_cn), radius(_radius), maxk(_maxk), space_ofs(_space_ofs),
1520         temp(&_temp), dest(&_dest), scale_index(_scale_index), space_weight(_space_weight), expLUT(_expLUT)
1521     {
1522     }
1523
1524     virtual void operator() (const Range& range) const
1525     {
1526         int i, j, k;
1527         Size size = dest->size();
1528                 #if CV_SSE3
1529         int CV_DECL_ALIGNED(16) idxBuf[4];
1530         float CV_DECL_ALIGNED(16) bufSum32[4];
1531         static const int CV_DECL_ALIGNED(16) bufSignMask[] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
1532         bool haveSSE3 = checkHardwareSupport(CV_CPU_SSE3);
1533                 #endif
1534
1535         for( i = range.start; i < range.end; i++ )
1536         {
1537             const float* sptr = temp->ptr<float>(i+radius) + radius*cn;
1538             float* dptr = dest->ptr<float>(i);
1539
1540             if( cn == 1 )
1541             {
1542                 for( j = 0; j < size.width; j++ )
1543                 {
1544                     float sum = 0, wsum = 0;
1545                     float val0 = sptr[j];
1546                                         k = 0;
1547                                         #if CV_SSE3
1548                                         if( haveSSE3 )
1549                                         {
1550                                                 const __m128 _val0 = _mm_set1_ps(sptr[j]);
1551                                                 const __m128 _scale_index = _mm_set1_ps(scale_index);
1552                                                 const __m128 _signMask = _mm_load_ps((const float*)bufSignMask);
1553
1554                                                 for( ; k <= maxk - 4 ; k += 4 )
1555                                                 {
1556                                                         __m128 _sw    = _mm_loadu_ps(space_weight + k);
1557                                                         __m128 _val   = _mm_set_ps(sptr[j + space_ofs[k+3]], sptr[j + space_ofs[k+2]],
1558                                                        sptr[j + space_ofs[k+1]], sptr[j + space_ofs[k]]);
1559                                                         __m128 _alpha = _mm_mul_ps(_mm_andnot_ps( _signMask, _mm_sub_ps(_val,_val0)), _scale_index);
1560
1561                                                         __m128i _idx = _mm_cvtps_epi32(_alpha);
1562                                                         _mm_store_si128((__m128i*)idxBuf, _idx);
1563                                                         _alpha = _mm_sub_ps(_alpha, _mm_cvtepi32_ps(_idx));
1564
1565                                                         __m128 _explut  = _mm_set_ps(expLUT[idxBuf[3]], expLUT[idxBuf[2]],
1566                                                          expLUT[idxBuf[1]], expLUT[idxBuf[0]]);
1567                                                         __m128 _explut1 = _mm_set_ps(expLUT[idxBuf[3]+1], expLUT[idxBuf[2]+1],
1568                                                          expLUT[idxBuf[1]+1], expLUT[idxBuf[0]+1]);
1569
1570                                                         __m128 _w = _mm_mul_ps(_sw, _mm_add_ps(_explut, _mm_mul_ps(_alpha, _mm_sub_ps(_explut1, _explut))));
1571                                                         _val = _mm_mul_ps(_w, _val);
1572
1573                                                          _sw = _mm_hadd_ps(_w, _val);
1574                                                          _sw = _mm_hadd_ps(_sw, _sw);
1575                                                          _mm_storel_pi((__m64*)bufSum32, _sw);
1576
1577                                                          sum += bufSum32[1];
1578                                                          wsum += bufSum32[0];
1579                                                 }
1580                                         }
1581                                         #endif
1582
1583                     for( ; k < maxk; k++ )
1584                     {
1585                         float val = sptr[j + space_ofs[k]];
1586                         float alpha = (float)(std::abs(val - val0)*scale_index);
1587                         int idx = cvFloor(alpha);
1588                         alpha -= idx;
1589                         float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));
1590                         sum += val*w;
1591                         wsum += w;
1592                     }
1593                     dptr[j] = (float)(sum/wsum);
1594                 }
1595             }
1596             else
1597             {
1598                 assert( cn == 3 );
1599                 for( j = 0; j < size.width*3; j += 3 )
1600                 {
1601                     float sum_b = 0, sum_g = 0, sum_r = 0, wsum = 0;
1602                     float b0 = sptr[j], g0 = sptr[j+1], r0 = sptr[j+2];
1603                                         k = 0;
1604                                         #if  CV_SSE3
1605                                         if( haveSSE3 )
1606                                         {
1607                                                 const __m128 _b0 = _mm_set1_ps(b0);
1608                                                 const __m128 _g0 = _mm_set1_ps(g0);
1609                                                 const __m128 _r0 = _mm_set1_ps(r0);
1610                                                 const __m128 _scale_index = _mm_set1_ps(scale_index);
1611                         const __m128 _signMask = _mm_load_ps((const float*)bufSignMask);
1612
1613                                                 for( ; k <= maxk-4; k += 4 )
1614                                                 {
1615                                                         __m128 _sw = _mm_loadu_ps(space_weight + k);
1616
1617                                                         const float* sptr_k  = sptr + j + space_ofs[k];
1618                                                         const float* sptr_k1 = sptr + j + space_ofs[k+1];
1619                                                         const float* sptr_k2 = sptr + j + space_ofs[k+2];
1620                                                         const float* sptr_k3 = sptr + j + space_ofs[k+3];
1621
1622                                                         __m128 _b = _mm_set_ps(sptr_k3[0], sptr_k2[0], sptr_k1[0], sptr_k[0]);
1623                                                         __m128 _g = _mm_set_ps(sptr_k3[1], sptr_k2[1], sptr_k1[1], sptr_k[1]);
1624                                                         __m128 _r = _mm_set_ps(sptr_k3[2], sptr_k2[2], sptr_k1[2], sptr_k[2]);
1625
1626                                                         __m128 _bt = _mm_andnot_ps(_signMask,_mm_sub_ps(_b,_b0));
1627                                                         __m128 _gt = _mm_andnot_ps(_signMask,_mm_sub_ps(_g,_g0));
1628                                                         __m128 _rt = _mm_andnot_ps(_signMask,_mm_sub_ps(_r,_r0));
1629
1630                                                         __m128 _alpha = _mm_mul_ps(_scale_index, _mm_add_ps(_rt,_mm_add_ps(_bt, _gt)));
1631
1632                                                         __m128i _idx  = _mm_cvtps_epi32(_alpha);
1633                                                         _mm_store_si128((__m128i*)idxBuf, _idx);
1634                                                         _alpha = _mm_sub_ps(_alpha, _mm_cvtepi32_ps(_idx));
1635
1636                                                         __m128 _explut  = _mm_set_ps(expLUT[idxBuf[3]], expLUT[idxBuf[2]], expLUT[idxBuf[1]], expLUT[idxBuf[0]]);
1637                                                         __m128 _explut1 = _mm_set_ps(expLUT[idxBuf[3]+1], expLUT[idxBuf[2]+1], expLUT[idxBuf[1]+1], expLUT[idxBuf[0]+1]);
1638
1639                                                         __m128 _w = _mm_mul_ps(_sw, _mm_add_ps(_explut, _mm_mul_ps(_alpha, _mm_sub_ps(_explut1, _explut))));
1640
1641                                                         _b = _mm_mul_ps(_b, _w);
1642                                                         _g = _mm_mul_ps(_g, _w);
1643                                                         _r = _mm_mul_ps(_r, _w);
1644
1645                                                          _w = _mm_hadd_ps(_w, _b);
1646                                                          _g = _mm_hadd_ps(_g, _r);
1647
1648                                                          _w = _mm_hadd_ps(_w, _g);
1649                                                          _mm_store_ps(bufSum32, _w);
1650
1651                                                          wsum  += bufSum32[0];
1652                                                          sum_b += bufSum32[1];
1653                                                          sum_g += bufSum32[2];
1654                                                          sum_r += bufSum32[3];
1655                                                 }
1656
1657                                         }
1658                                         #endif
1659
1660                     for(; k < maxk; k++ )
1661                     {
1662                         const float* sptr_k = sptr + j + space_ofs[k];
1663                         float b = sptr_k[0], g = sptr_k[1], r = sptr_k[2];
1664                         float alpha = (float)((std::abs(b - b0) +
1665                             std::abs(g - g0) + std::abs(r - r0))*scale_index);
1666                         int idx = cvFloor(alpha);
1667                         alpha -= idx;
1668                         float w = space_weight[k]*(expLUT[idx] + alpha*(expLUT[idx+1] - expLUT[idx]));
1669                         sum_b += b*w; sum_g += g*w; sum_r += r*w;
1670                         wsum += w;
1671                     }
1672                     wsum = 1.f/wsum;
1673                     b0 = sum_b*wsum;
1674                     g0 = sum_g*wsum;
1675                     r0 = sum_r*wsum;
1676                     dptr[j] = b0; dptr[j+1] = g0; dptr[j+2] = r0;
1677                 }
1678             }
1679         }
1680     }
1681
1682 private:
1683     int cn, radius, maxk, *space_ofs;
1684     const Mat* temp;
1685     Mat *dest;
1686     float scale_index, *space_weight, *expLUT;
1687 };
1688
1689
1690 static void
1691 bilateralFilter_32f( const Mat& src, Mat& dst, int d,
1692                      double sigma_color, double sigma_space,
1693                      int borderType )
1694 {
1695     int cn = src.channels();
1696     int i, j, maxk, radius;
1697     double minValSrc=-1, maxValSrc=1;
1698     const int kExpNumBinsPerChannel = 1 << 12;
1699     int kExpNumBins = 0;
1700     float lastExpVal = 1.f;
1701     float len, scale_index;
1702     Size size = src.size();
1703
1704     CV_Assert( (src.type() == CV_32FC1 || src.type() == CV_32FC3) &&
1705         src.type() == dst.type() && src.size() == dst.size() &&
1706         src.data != dst.data );
1707
1708     if( sigma_color <= 0 )
1709         sigma_color = 1;
1710     if( sigma_space <= 0 )
1711         sigma_space = 1;
1712
1713     double gauss_color_coeff = -0.5/(sigma_color*sigma_color);
1714     double gauss_space_coeff = -0.5/(sigma_space*sigma_space);
1715
1716     if( d <= 0 )
1717         radius = cvRound(sigma_space*1.5);
1718     else
1719         radius = d/2;
1720     radius = MAX(radius, 1);
1721     d = radius*2 + 1;
1722     // compute the min/max range for the input image (even if multichannel)
1723
1724     minMaxLoc( src.reshape(1), &minValSrc, &maxValSrc );
1725     if(std::abs(minValSrc - maxValSrc) < FLT_EPSILON)
1726     {
1727         src.copyTo(dst);
1728         return;
1729     }
1730
1731     // temporary copy of the image with borders for easy processing
1732     Mat temp;
1733     copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );
1734     const double insteadNaNValue = -5. * sigma_color;
1735     patchNaNs( temp, insteadNaNValue ); // this replacement of NaNs makes the assumption that depth values are nonnegative
1736                                         // TODO: make insteadNaNValue avalible in the outside function interface to control the cases breaking the assumption
1737     // allocate lookup tables
1738     vector<float> _space_weight(d*d);
1739     vector<int> _space_ofs(d*d);
1740     float* space_weight = &_space_weight[0];
1741     int* space_ofs = &_space_ofs[0];
1742
1743     // assign a length which is slightly more than needed
1744     len = (float)(maxValSrc - minValSrc) * cn;
1745     kExpNumBins = kExpNumBinsPerChannel * cn;
1746     vector<float> _expLUT(kExpNumBins+2);
1747     float* expLUT = &_expLUT[0];
1748
1749     scale_index = kExpNumBins/len;
1750
1751     // initialize the exp LUT
1752     for( i = 0; i < kExpNumBins+2; i++ )
1753     {
1754         if( lastExpVal > 0.f )
1755         {
1756             double val =  i / scale_index;
1757             expLUT[i] = (float)std::exp(val * val * gauss_color_coeff);
1758             lastExpVal = expLUT[i];
1759         }
1760         else
1761             expLUT[i] = 0.f;
1762     }
1763
1764     // initialize space-related bilateral filter coefficients
1765     for( i = -radius, maxk = 0; i <= radius; i++ )
1766         for( j = -radius; j <= radius; j++ )
1767         {
1768             double r = std::sqrt((double)i*i + (double)j*j);
1769             if( r > radius )
1770                 continue;
1771             space_weight[maxk] = (float)std::exp(r*r*gauss_space_coeff);
1772             space_ofs[maxk++] = (int)(i*(temp.step/sizeof(float)) + j*cn);
1773         }
1774
1775     // parallel_for usage
1776
1777     BilateralFilter_32f_Invoker body(cn, radius, maxk, space_ofs, temp, dst, scale_index, space_weight, expLUT);
1778     parallel_for_(Range(0, size.height), body);
1779 }
1780
1781 }
1782
1783 void cv::bilateralFilter( InputArray _src, OutputArray _dst, int d,
1784                       double sigmaColor, double sigmaSpace,
1785                       int borderType )
1786 {
1787     Mat src = _src.getMat();
1788     _dst.create( src.size(), src.type() );
1789     Mat dst = _dst.getMat();
1790
1791     if( src.depth() == CV_8U )
1792         bilateralFilter_8u( src, dst, d, sigmaColor, sigmaSpace, borderType );
1793     else if( src.depth() == CV_32F )
1794         bilateralFilter_32f( src, dst, d, sigmaColor, sigmaSpace, borderType );
1795     else
1796         CV_Error( CV_StsUnsupportedFormat,
1797         "Bilateral filtering is only implemented for 8u and 32f images" );
1798 }
1799
1800 //////////////////////////////////////////////////////////////////////////////////////////
1801
1802 CV_IMPL void
1803 cvSmooth( const void* srcarr, void* dstarr, int smooth_type,
1804           int param1, int param2, double param3, double param4 )
1805 {
1806     cv::Mat src = cv::cvarrToMat(srcarr), dst0 = cv::cvarrToMat(dstarr), dst = dst0;
1807
1808     CV_Assert( dst.size() == src.size() &&
1809         (smooth_type == CV_BLUR_NO_SCALE || dst.type() == src.type()) );
1810
1811     if( param2 <= 0 )
1812         param2 = param1;
1813
1814     if( smooth_type == CV_BLUR || smooth_type == CV_BLUR_NO_SCALE )
1815         cv::boxFilter( src, dst, dst.depth(), cv::Size(param1, param2), cv::Point(-1,-1),
1816             smooth_type == CV_BLUR, cv::BORDER_REPLICATE );
1817     else if( smooth_type == CV_GAUSSIAN )
1818         cv::GaussianBlur( src, dst, cv::Size(param1, param2), param3, param4, cv::BORDER_REPLICATE );
1819     else if( smooth_type == CV_MEDIAN )
1820         cv::medianBlur( src, dst, param1 );
1821     else
1822         cv::bilateralFilter( src, dst, param1, param3, param4, cv::BORDER_REPLICATE );
1823
1824     if( dst.data != dst0.data )
1825         CV_Error( CV_StsUnmatchedFormats, "The destination image does not have the proper type" );
1826 }
1827
1828 /* End of file. */