modules/core/src/convert.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-2011, 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 #include "opencl_kernels.hpp"
  45
  46 namespace cv
  47 {
  48
  49 /****************************************************************************************\
  50 *                                       split & merge                                    *
  51 \****************************************************************************************/
  52
  53 template<typename T> static void
  54 split_( const T* src, T** dst, int len, int cn )
  55 {
  56     int k = cn % 4 ? cn % 4 : 4;
  57     int i, j;
  58     if( k == 1 )
  59     {
  60         T* dst0 = dst[0];
  61         for( i = j = 0; i < len; i++, j += cn )
  62             dst0[i] = src[j];
  63     }
  64     else if( k == 2 )
  65     {
  66         T *dst0 = dst[0], *dst1 = dst[1];
  67         for( i = j = 0; i < len; i++, j += cn )
  68         {
  69             dst0[i] = src[j];
  70             dst1[i] = src[j+1];
  71         }
  72     }
  73     else if( k == 3 )
  74     {
  75         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
  76         for( i = j = 0; i < len; i++, j += cn )
  77         {
  78             dst0[i] = src[j];
  79             dst1[i] = src[j+1];
  80             dst2[i] = src[j+2];
  81         }
  82     }
  83     else
  84     {
  85         T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
  86         for( i = j = 0; i < len; i++, j += cn )
  87         {
  88             dst0[i] = src[j]; dst1[i] = src[j+1];
  89             dst2[i] = src[j+2]; dst3[i] = src[j+3];
  90         }
  91     }
  92
  93     for( ; k < cn; k += 4 )
  94     {
  95         T *dst0 = dst[k], *dst1 = dst[k+1], *dst2 = dst[k+2], *dst3 = dst[k+3];
  96         for( i = 0, j = k; i < len; i++, j += cn )
  97         {
  98             dst0[i] = src[j]; dst1[i] = src[j+1];
  99             dst2[i] = src[j+2]; dst3[i] = src[j+3];
 100         }
 101     }
 102 }
 103
 104 template<typename T> static void
 105 merge_( const T** src, T* dst, int len, int cn )
 106 {
 107     int k = cn % 4 ? cn % 4 : 4;
 108     int i, j;
 109     if( k == 1 )
 110     {
 111         const T* src0 = src[0];
 112         for( i = j = 0; i < len; i++, j += cn )
 113             dst[j] = src0[i];
 114     }
 115     else if( k == 2 )
 116     {
 117         const T *src0 = src[0], *src1 = src[1];
 118         for( i = j = 0; i < len; i++, j += cn )
 119         {
 120             dst[j] = src0[i];
 121             dst[j+1] = src1[i];
 122         }
 123     }
 124     else if( k == 3 )
 125     {
 126         const T *src0 = src[0], *src1 = src[1], *src2 = src[2];
 127         for( i = j = 0; i < len; i++, j += cn )
 128         {
 129             dst[j] = src0[i];
 130             dst[j+1] = src1[i];
 131             dst[j+2] = src2[i];
 132         }
 133     }
 134     else
 135     {
 136         const T *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
 137         for( i = j = 0; i < len; i++, j += cn )
 138         {
 139             dst[j] = src0[i]; dst[j+1] = src1[i];
 140             dst[j+2] = src2[i]; dst[j+3] = src3[i];
 141         }
 142     }
 143
 144     for( ; k < cn; k += 4 )
 145     {
 146         const T *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
 147         for( i = 0, j = k; i < len; i++, j += cn )
 148         {
 149             dst[j] = src0[i]; dst[j+1] = src1[i];
 150             dst[j+2] = src2[i]; dst[j+3] = src3[i];
 151         }
 152     }
 153 }
 154
 155 static void split8u(const uchar* src, uchar** dst, int len, int cn )
 156 {
 157     split_(src, dst, len, cn);
 158 }
 159
 160 static void split16u(const ushort* src, ushort** dst, int len, int cn )
 161 {
 162     split_(src, dst, len, cn);
 163 }
 164
 165 static void split32s(const int* src, int** dst, int len, int cn )
 166 {
 167     split_(src, dst, len, cn);
 168 }
 169
 170 static void split64s(const int64* src, int64** dst, int len, int cn )
 171 {
 172     split_(src, dst, len, cn);
 173 }
 174
 175 static void merge8u(const uchar** src, uchar* dst, int len, int cn )
 176 {
 177     merge_(src, dst, len, cn);
 178 }
 179
 180 static void merge16u(const ushort** src, ushort* dst, int len, int cn )
 181 {
 182     merge_(src, dst, len, cn);
 183 }
 184
 185 static void merge32s(const int** src, int* dst, int len, int cn )
 186 {
 187     merge_(src, dst, len, cn);
 188 }
 189
 190 static void merge64s(const int64** src, int64* dst, int len, int cn )
 191 {
 192     merge_(src, dst, len, cn);
 193 }
 194
 195 typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
 196 typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
 197
 198 static SplitFunc getSplitFunc(int depth)
 199 {
 200     static SplitFunc splitTab[] =
 201     {
 202         (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split8u), (SplitFunc)GET_OPTIMIZED(split16u), (SplitFunc)GET_OPTIMIZED(split16u),
 203         (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split32s), (SplitFunc)GET_OPTIMIZED(split64s), 0
 204     };
 205
 206     return splitTab[depth];
 207 }
 208
 209 static MergeFunc getMergeFunc(int depth)
 210 {
 211     static MergeFunc mergeTab[] =
 212     {
 213         (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u),
 214         (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0
 215     };
 216
 217     return mergeTab[depth];
 218 }
 219
 220 }
 221
 222 void cv::split(const Mat& src, Mat* mv)
 223 {
 224     int k, depth = src.depth(), cn = src.channels();
 225     if( cn == 1 )
 226     {
 227         src.copyTo(mv[0]);
 228         return;
 229     }
 230
 231     SplitFunc func = getSplitFunc(depth);
 232     CV_Assert( func != 0 );
 233
 234     int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
 235     int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
 236     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 237     const Mat** arrays = (const Mat**)(uchar*)_buf;
 238     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 239
 240     arrays[0] = &src;
 241     for( k = 0; k < cn; k++ )
 242     {
 243         mv[k].create(src.dims, src.size, depth);
 244         arrays[k+1] = &mv[k];
 245     }
 246
 247     NAryMatIterator it(arrays, ptrs, cn+1);
 248     int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0);
 249
 250     for( size_t i = 0; i < it.nplanes; i++, ++it )
 251     {
 252         for( int j = 0; j < total; j += blocksize )
 253         {
 254             int bsz = std::min(total - j, blocksize);
 255             func( ptrs[0], &ptrs[1], bsz, cn );
 256
 257             if( j + blocksize < total )
 258             {
 259                 ptrs[0] += bsz*esz;
 260                 for( k = 0; k < cn; k++ )
 261                     ptrs[k+1] += bsz*esz1;
 262             }
 263         }
 264     }
 265 }
 266
 267 #ifdef HAVE_OPENCL
 268
 269 namespace cv {
 270
 271 static bool ocl_split( InputArray _m, OutputArrayOfArrays _mv )
 272 {
 273     int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
 274
 275     String dstargs, dstdecl, processelem;
 276     for (int i = 0; i < cn; ++i)
 277     {
 278         dstargs += format("DECLARE_DST_PARAM(%d)", i);
 279         dstdecl += format("DECLARE_DATA(%d)", i);
 280         processelem += format("PROCESS_ELEM(%d)", i);
 281     }
 282
 283     ocl::Kernel k("split", ocl::core::split_merge_oclsrc,
 284                   format("-D T=%s -D OP_SPLIT -D cn=%d -D DECLARE_DST_PARAMS=%s "
 285                          "-D DECLARE_DATA_N=%s -D PROCESS_ELEMS_N=%s",
 286                          ocl::memopTypeToStr(depth), cn, dstargs.c_str(),
 287                          dstdecl.c_str(), processelem.c_str()));
 288     if (k.empty())
 289         return false;
 290
 291     Size size = _m.size();
 292     _mv.create(cn, 1, depth);
 293     for (int i = 0; i < cn; ++i)
 294         _mv.create(size, depth, i);
 295
 296     std::vector<UMat> dst;
 297     _mv.getUMatVector(dst);
 298
 299     int argidx = k.set(0, ocl::KernelArg::ReadOnly(_m.getUMat()));
 300     for (int i = 0; i < cn; ++i)
 301         argidx = k.set(argidx, ocl::KernelArg::WriteOnlyNoSize(dst[i]));
 302
 303     size_t globalsize[2] = { size.width, size.height };
 304     return k.run(2, globalsize, NULL, false);
 305 }
 306
 307 }
 308
 309 #endif
 310
 311 void cv::split(InputArray _m, OutputArrayOfArrays _mv)
 312 {
 313     CV_OCL_RUN(_m.dims() <= 2 && _mv.isUMatVector(),
 314                ocl_split(_m, _mv))
 315
 316     Mat m = _m.getMat();
 317     if( m.empty() )
 318     {
 319         _mv.release();
 320         return;
 321     }
 322
 323     CV_Assert( !_mv.fixedType() || _mv.empty() || _mv.type() == m.depth() );
 324
 325     Size size = m.size();
 326     int depth = m.depth(), cn = m.channels();
 327     _mv.create(cn, 1, depth);
 328     for (int i = 0; i < cn; ++i)
 329         _mv.create(size, depth, i);
 330
 331     std::vector<Mat> dst;
 332     _mv.getMatVector(dst);
 333
 334     split(m, &dst[0]);
 335 }
 336
 337 void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
 338 {
 339     CV_Assert( mv && n > 0 );
 340
 341     int depth = mv[0].depth();
 342     bool allch1 = true;
 343     int k, cn = 0;
 344     size_t i;
 345
 346     for( i = 0; i < n; i++ )
 347     {
 348         CV_Assert(mv[i].size == mv[0].size && mv[i].depth() == depth);
 349         allch1 = allch1 && mv[i].channels() == 1;
 350         cn += mv[i].channels();
 351     }
 352
 353     CV_Assert( 0 < cn && cn <= CV_CN_MAX );
 354     _dst.create(mv[0].dims, mv[0].size, CV_MAKETYPE(depth, cn));
 355     Mat dst = _dst.getMat();
 356
 357     if( n == 1 )
 358     {
 359         mv[0].copyTo(dst);
 360         return;
 361     }
 362
 363     if( !allch1 )
 364     {
 365         AutoBuffer<int> pairs(cn*2);
 366         int j, ni=0;
 367
 368         for( i = 0, j = 0; i < n; i++, j += ni )
 369         {
 370             ni = mv[i].channels();
 371             for( k = 0; k < ni; k++ )
 372             {
 373                 pairs[(j+k)*2] = j + k;
 374                 pairs[(j+k)*2+1] = j + k;
 375             }
 376         }
 377         mixChannels( mv, n, &dst, 1, &pairs[0], cn );
 378         return;
 379     }
 380
 381     size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
 382     int blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
 383     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 384     const Mat** arrays = (const Mat**)(uchar*)_buf;
 385     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 386
 387     arrays[0] = &dst;
 388     for( k = 0; k < cn; k++ )
 389         arrays[k+1] = &mv[k];
 390
 391     NAryMatIterator it(arrays, ptrs, cn+1);
 392     int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0);
 393     MergeFunc func = getMergeFunc(depth);
 394
 395     for( i = 0; i < it.nplanes; i++, ++it )
 396     {
 397         for( int j = 0; j < total; j += blocksize )
 398         {
 399             int bsz = std::min(total - j, blocksize);
 400             func( (const uchar**)&ptrs[1], ptrs[0], bsz, cn );
 401
 402             if( j + blocksize < total )
 403             {
 404                 ptrs[0] += bsz*esz;
 405                 for( int t = 0; t < cn; t++ )
 406                     ptrs[t+1] += bsz*esz1;
 407             }
 408         }
 409     }
 410 }
 411
 412 #ifdef HAVE_OPENCL
 413
 414 namespace cv {
 415
 416 static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
 417 {
 418     std::vector<UMat> src, ksrc;
 419     _mv.getUMatVector(src);
 420     CV_Assert(!src.empty());
 421
 422     int type = src[0].type(), depth = CV_MAT_DEPTH(type);
 423     Size size = src[0].size();
 424
 425     for (size_t i = 0, srcsize = src.size(); i < srcsize; ++i)
 426     {
 427         int itype = src[i].type(), icn = CV_MAT_CN(itype), idepth = CV_MAT_DEPTH(itype),
 428                 esz1 = CV_ELEM_SIZE1(idepth);
 429         if (src[i].dims > 2)
 430             return false;
 431
 432         CV_Assert(size == src[i].size() && depth == idepth);
 433
 434         for (int cn = 0; cn < icn; ++cn)
 435         {
 436             UMat tsrc = src[i];
 437             tsrc.offset += cn * esz1;
 438             ksrc.push_back(tsrc);
 439         }
 440     }
 441     int dcn = (int)ksrc.size();
 442
 443     String srcargs, srcdecl, processelem, cndecl;
 444     for (int i = 0; i < dcn; ++i)
 445     {
 446         srcargs += format("DECLARE_SRC_PARAM(%d)", i);
 447         srcdecl += format("DECLARE_DATA(%d)", i);
 448         processelem += format("PROCESS_ELEM(%d)", i);
 449         cndecl += format(" -D scn%d=%d", i, ksrc[i].channels());
 450     }
 451
 452     ocl::Kernel k("merge", ocl::core::split_merge_oclsrc,
 453                   format("-D OP_MERGE -D cn=%d -D T=%s -D DECLARE_SRC_PARAMS_N=%s"
 454                          " -D DECLARE_DATA_N=%s -D PROCESS_ELEMS_N=%s%s",
 455                          dcn, ocl::memopTypeToStr(depth), srcargs.c_str(),
 456                          srcdecl.c_str(), processelem.c_str(), cndecl.c_str()));
 457     if (k.empty())
 458         return false;
 459
 460     _dst.create(size, CV_MAKE_TYPE(depth, dcn));
 461     UMat dst = _dst.getUMat();
 462
 463     int argidx = 0;
 464     for (int i = 0; i < dcn; ++i)
 465         argidx = k.set(argidx, ocl::KernelArg::ReadOnlyNoSize(ksrc[i]));
 466     k.set(argidx, ocl::KernelArg::WriteOnly(dst));
 467
 468     size_t globalsize[2] = { dst.cols, dst.rows };
 469     return k.run(2, globalsize, NULL, false);
 470 }
 471
 472 }
 473
 474 #endif
 475
 476 void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
 477 {
 478     CV_OCL_RUN(_mv.isUMatVector() && _dst.isUMat(),
 479                ocl_merge(_mv, _dst))
 480
 481     std::vector<Mat> mv;
 482     _mv.getMatVector(mv);
 483     merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
 484 }
 485
 486 /****************************************************************************************\
 487 *                       Generalized split/merge: mixing channels                         *
 488 \****************************************************************************************/
 489
 490 namespace cv
 491 {
 492
 493 template<typename T> static void
 494 mixChannels_( const T** src, const int* sdelta,
 495               T** dst, const int* ddelta,
 496               int len, int npairs )
 497 {
 498     int i, k;
 499     for( k = 0; k < npairs; k++ )
 500     {
 501         const T* s = src[k];
 502         T* d = dst[k];
 503         int ds = sdelta[k], dd = ddelta[k];
 504         if( s )
 505         {
 506             for( i = 0; i <= len - 2; i += 2, s += ds*2, d += dd*2 )
 507             {
 508                 T t0 = s[0], t1 = s[ds];
 509                 d[0] = t0; d[dd] = t1;
 510             }
 511             if( i < len )
 512                 d[0] = s[0];
 513         }
 514         else
 515         {
 516             for( i = 0; i <= len - 2; i += 2, d += dd*2 )
 517                 d[0] = d[dd] = 0;
 518             if( i < len )
 519                 d[0] = 0;
 520         }
 521     }
 522 }
 523
 524
 525 static void mixChannels8u( const uchar** src, const int* sdelta,
 526                            uchar** dst, const int* ddelta,
 527                            int len, int npairs )
 528 {
 529     mixChannels_(src, sdelta, dst, ddelta, len, npairs);
 530 }
 531
 532 static void mixChannels16u( const ushort** src, const int* sdelta,
 533                             ushort** dst, const int* ddelta,
 534                             int len, int npairs )
 535 {
 536     mixChannels_(src, sdelta, dst, ddelta, len, npairs);
 537 }
 538
 539 static void mixChannels32s( const int** src, const int* sdelta,
 540                             int** dst, const int* ddelta,
 541                             int len, int npairs )
 542 {
 543     mixChannels_(src, sdelta, dst, ddelta, len, npairs);
 544 }
 545
 546 static void mixChannels64s( const int64** src, const int* sdelta,
 547                             int64** dst, const int* ddelta,
 548                             int len, int npairs )
 549 {
 550     mixChannels_(src, sdelta, dst, ddelta, len, npairs);
 551 }
 552
 553 typedef void (*MixChannelsFunc)( const uchar** src, const int* sdelta,
 554         uchar** dst, const int* ddelta, int len, int npairs );
 555
 556 static MixChannelsFunc getMixchFunc(int depth)
 557 {
 558     static MixChannelsFunc mixchTab[] =
 559     {
 560         (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u,
 561         (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s,
 562         (MixChannelsFunc)mixChannels64s, 0
 563     };
 564
 565     return mixchTab[depth];
 566 }
 567
 568 }
 569
 570 void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t npairs )
 571 {
 572     if( npairs == 0 )
 573         return;
 574     CV_Assert( src && nsrcs > 0 && dst && ndsts > 0 && fromTo && npairs > 0 );
 575
 576     size_t i, j, k, esz1 = dst[0].elemSize1();
 577     int depth = dst[0].depth();
 578
 579     AutoBuffer<uchar> buf((nsrcs + ndsts + 1)*(sizeof(Mat*) + sizeof(uchar*)) + npairs*(sizeof(uchar*)*2 + sizeof(int)*6));
 580     const Mat** arrays = (const Mat**)(uchar*)buf;
 581     uchar** ptrs = (uchar**)(arrays + nsrcs + ndsts);
 582     const uchar** srcs = (const uchar**)(ptrs + nsrcs + ndsts + 1);
 583     uchar** dsts = (uchar**)(srcs + npairs);
 584     int* tab = (int*)(dsts + npairs);
 585     int *sdelta = (int*)(tab + npairs*4), *ddelta = sdelta + npairs;
 586
 587     for( i = 0; i < nsrcs; i++ )
 588         arrays[i] = &src[i];
 589     for( i = 0; i < ndsts; i++ )
 590         arrays[i + nsrcs] = &dst[i];
 591     ptrs[nsrcs + ndsts] = 0;
 592
 593     for( i = 0; i < npairs; i++ )
 594     {
 595         int i0 = fromTo[i*2], i1 = fromTo[i*2+1];
 596         if( i0 >= 0 )
 597         {
 598             for( j = 0; j < nsrcs; i0 -= src[j].channels(), j++ )
 599                 if( i0 < src[j].channels() )
 600                     break;
 601             CV_Assert(j < nsrcs && src[j].depth() == depth);
 602             tab[i*4] = (int)j; tab[i*4+1] = (int)(i0*esz1);
 603             sdelta[i] = src[j].channels();
 604         }
 605         else
 606         {
 607             tab[i*4] = (int)(nsrcs + ndsts); tab[i*4+1] = 0;
 608             sdelta[i] = 0;
 609         }
 610
 611         for( j = 0; j < ndsts; i1 -= dst[j].channels(), j++ )
 612             if( i1 < dst[j].channels() )
 613                 break;
 614         CV_Assert(i1 >= 0 && j < ndsts && dst[j].depth() == depth);
 615         tab[i*4+2] = (int)(j + nsrcs); tab[i*4+3] = (int)(i1*esz1);
 616         ddelta[i] = dst[j].channels();
 617     }
 618
 619     NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
 620     int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
 621     MixChannelsFunc func = getMixchFunc(depth);
 622
 623     for( i = 0; i < it.nplanes; i++, ++it )
 624     {
 625         for( k = 0; k < npairs; k++ )
 626         {
 627             srcs[k] = ptrs[tab[k*4]] + tab[k*4+1];
 628             dsts[k] = ptrs[tab[k*4+2]] + tab[k*4+3];
 629         }
 630
 631         for( int t = 0; t < total; t += blocksize )
 632         {
 633             int bsz = std::min(total - t, blocksize);
 634             func( srcs, sdelta, dsts, ddelta, bsz, (int)npairs );
 635
 636             if( t + blocksize < total )
 637                 for( k = 0; k < npairs; k++ )
 638                 {
 639                     srcs[k] += blocksize*sdelta[k]*esz1;
 640                     dsts[k] += blocksize*ddelta[k]*esz1;
 641                 }
 642         }
 643     }
 644 }
 645
 646 #ifdef HAVE_OPENCL
 647
 648 namespace cv {
 649
 650 static void getUMatIndex(const std::vector<UMat> & um, int cn, int & idx, int & cnidx)
 651 {
 652     int totalChannels = 0;
 653     for (size_t i = 0, size = um.size(); i < size; ++i)
 654     {
 655         int ccn = um[i].channels();
 656         totalChannels += ccn;
 657
 658         if (totalChannels == cn)
 659         {
 660             idx = (int)(i + 1);
 661             cnidx = 0;
 662             return;
 663         }
 664         else if (totalChannels > cn)
 665         {
 666             idx = (int)i;
 667             cnidx = i == 0 ? cn : (cn - totalChannels + ccn);
 668             return;
 669         }
 670     }
 671
 672     idx = cnidx = -1;
 673 }
 674
 675 static bool ocl_mixChannels(InputArrayOfArrays _src, InputOutputArrayOfArrays _dst,
 676                             const int* fromTo, size_t npairs)
 677 {
 678     std::vector<UMat> src, dst;
 679     _src.getUMatVector(src);
 680     _dst.getUMatVector(dst);
 681
 682     size_t nsrc = src.size(), ndst = dst.size();
 683     CV_Assert(nsrc > 0 && ndst > 0);
 684
 685     Size size = src[0].size();
 686     int depth = src[0].depth(), esz = CV_ELEM_SIZE(depth);
 687
 688     for (size_t i = 1, ssize = src.size(); i < ssize; ++i)
 689         CV_Assert(src[i].size() == size && src[i].depth() == depth);
 690     for (size_t i = 0, dsize = dst.size(); i < dsize; ++i)
 691         CV_Assert(dst[i].size() == size && dst[i].depth() == depth);
 692
 693     String declsrc, decldst, declproc, declcn;
 694     std::vector<UMat> srcargs(npairs), dstargs(npairs);
 695
 696     for (size_t i = 0; i < npairs; ++i)
 697     {
 698         int scn = fromTo[i<<1], dcn = fromTo[(i<<1) + 1];
 699         int src_idx, src_cnidx, dst_idx, dst_cnidx;
 700
 701         getUMatIndex(src, scn, src_idx, src_cnidx);
 702         getUMatIndex(dst, dcn, dst_idx, dst_cnidx);
 703
 704         CV_Assert(dst_idx >= 0 && src_idx >= 0);
 705
 706         srcargs[i] = src[src_idx];
 707         srcargs[i].offset += src_cnidx * esz;
 708
 709         dstargs[i] = dst[dst_idx];
 710         dstargs[i].offset += dst_cnidx * esz;
 711
 712         declsrc += format("DECLARE_INPUT_MAT(%d)", i);
 713         decldst += format("DECLARE_OUTPUT_MAT(%d)", i);
 714         declproc += format("PROCESS_ELEM(%d)", i);
 715         declcn += format(" -D scn%d=%d -D dcn%d=%d", i, src[src_idx].channels(), i, dst[dst_idx].channels());
 716     }
 717
 718     ocl::Kernel k("mixChannels", ocl::core::mixchannels_oclsrc,
 719                   format("-D T=%s -D DECLARE_INPUT_MATS=%s -D DECLARE_OUTPUT_MATS=%s"
 720                          " -D PROCESS_ELEMS=%s%s", ocl::memopTypeToStr(depth),
 721                          declsrc.c_str(), decldst.c_str(), declproc.c_str(), declcn.c_str()));
 722     if (k.empty())
 723         return false;
 724
 725     int argindex = 0;
 726     for (size_t i = 0; i < npairs; ++i)
 727         argindex = k.set(argindex, ocl::KernelArg::ReadOnlyNoSize(srcargs[i]));
 728     for (size_t i = 0; i < npairs; ++i)
 729         argindex = k.set(argindex, ocl::KernelArg::WriteOnlyNoSize(dstargs[i]));
 730     k.set(k.set(argindex, size.height), size.width);
 731
 732     size_t globalsize[2] = { size.width, size.height };
 733     return k.run(2, globalsize, NULL, false);
 734 }
 735
 736 }
 737
 738 #endif
 739
 740 void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
 741                  const int* fromTo, size_t npairs)
 742 {
 743     if (npairs == 0 || fromTo == NULL)
 744         return;
 745
 746     CV_OCL_RUN(dst.isUMatVector(),
 747                ocl_mixChannels(src, dst, fromTo, npairs))
 748
 749     bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
 750             src.kind() != _InputArray::STD_VECTOR_VECTOR &&
 751             src.kind() != _InputArray::STD_VECTOR_UMAT;
 752     bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT &&
 753             dst.kind() != _InputArray::STD_VECTOR_VECTOR &&
 754             dst.kind() != _InputArray::STD_VECTOR_UMAT;
 755     int i;
 756     int nsrc = src_is_mat ? 1 : (int)src.total();
 757     int ndst = dst_is_mat ? 1 : (int)dst.total();
 758
 759     CV_Assert(nsrc > 0 && ndst > 0);
 760     cv::AutoBuffer<Mat> _buf(nsrc + ndst);
 761     Mat* buf = _buf;
 762     for( i = 0; i < nsrc; i++ )
 763         buf[i] = src.getMat(src_is_mat ? -1 : i);
 764     for( i = 0; i < ndst; i++ )
 765         buf[nsrc + i] = dst.getMat(dst_is_mat ? -1 : i);
 766     mixChannels(&buf[0], nsrc, &buf[nsrc], ndst, fromTo, npairs);
 767 }
 768
 769 void cv::mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst,
 770                      const std::vector<int>& fromTo)
 771 {
 772     if (fromTo.empty())
 773         return;
 774
 775     CV_OCL_RUN(dst.isUMatVector(),
 776                ocl_mixChannels(src, dst, &fromTo[0], fromTo.size()>>1))
 777
 778     bool src_is_mat = src.kind() != _InputArray::STD_VECTOR_MAT &&
 779             src.kind() != _InputArray::STD_VECTOR_VECTOR &&
 780             src.kind() != _InputArray::STD_VECTOR_UMAT;
 781     bool dst_is_mat = dst.kind() != _InputArray::STD_VECTOR_MAT &&
 782             dst.kind() != _InputArray::STD_VECTOR_VECTOR &&
 783             dst.kind() != _InputArray::STD_VECTOR_UMAT;
 784     int i;
 785     int nsrc = src_is_mat ? 1 : (int)src.total();
 786     int ndst = dst_is_mat ? 1 : (int)dst.total();
 787
 788     CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0);
 789     cv::AutoBuffer<Mat> _buf(nsrc + ndst);
 790     Mat* buf = _buf;
 791     for( i = 0; i < nsrc; i++ )
 792         buf[i] = src.getMat(src_is_mat ? -1 : i);
 793     for( i = 0; i < ndst; i++ )
 794         buf[nsrc + i] = dst.getMat(dst_is_mat ? -1 : i);
 795     mixChannels(&buf[0], nsrc, &buf[nsrc], ndst, &fromTo[0], fromTo.size()/2);
 796 }
 797
 798 void cv::extractChannel(InputArray _src, OutputArray _dst, int coi)
 799 {
 800     int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
 801     CV_Assert( 0 <= coi && coi < cn );
 802     int ch[] = { coi, 0 };
 803
 804     if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat())
 805     {
 806         UMat src = _src.getUMat();
 807         _dst.create(src.dims, &src.size[0], depth);
 808         UMat dst = _dst.getUMat();
 809         mixChannels(std::vector<UMat>(1, src), std::vector<UMat>(1, dst), ch, 1);
 810         return;
 811     }
 812
 813     Mat src = _src.getMat();
 814     _dst.create(src.dims, &src.size[0], depth);
 815     Mat dst = _dst.getMat();
 816     mixChannels(&src, 1, &dst, 1, ch, 1);
 817 }
 818
 819 void cv::insertChannel(InputArray _src, InputOutputArray _dst, int coi)
 820 {
 821     int stype = _src.type(), sdepth = CV_MAT_DEPTH(stype), scn = CV_MAT_CN(stype);
 822     int dtype = _dst.type(), ddepth = CV_MAT_DEPTH(dtype), dcn = CV_MAT_CN(dtype);
 823     CV_Assert( _src.sameSize(_dst) && sdepth == ddepth );
 824     CV_Assert( 0 <= coi && coi < dcn && scn == 1 );
 825
 826     int ch[] = { 0, coi };
 827     if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat())
 828     {
 829         UMat src = _src.getUMat(), dst = _dst.getUMat();
 830         mixChannels(std::vector<UMat>(1, src), std::vector<UMat>(1, dst), ch, 1);
 831         return;
 832     }
 833
 834     Mat src = _src.getMat(), dst = _dst.getMat();
 835     mixChannels(&src, 1, &dst, 1, ch, 1);
 836 }
 837
 838 /****************************************************************************************\
 839 *                                convertScale[Abs]                                       *
 840 \****************************************************************************************/
 841
 842 namespace cv
 843 {
 844
 845 template<typename T, typename DT, typename WT> static void
 846 cvtScaleAbs_( const T* src, size_t sstep,
 847               DT* dst, size_t dstep, Size size,
 848               WT scale, WT shift )
 849 {
 850     sstep /= sizeof(src[0]);
 851     dstep /= sizeof(dst[0]);
 852
 853     for( ; size.height--; src += sstep, dst += dstep )
 854     {
 855         int x = 0;
 856         #if CV_ENABLE_UNROLLED
 857         for( ; x <= size.width - 4; x += 4 )
 858         {
 859             DT t0, t1;
 860             t0 = saturate_cast<DT>(std::abs(src[x]*scale + shift));
 861             t1 = saturate_cast<DT>(std::abs(src[x+1]*scale + shift));
 862             dst[x] = t0; dst[x+1] = t1;
 863             t0 = saturate_cast<DT>(std::abs(src[x+2]*scale + shift));
 864             t1 = saturate_cast<DT>(std::abs(src[x+3]*scale + shift));
 865             dst[x+2] = t0; dst[x+3] = t1;
 866         }
 867         #endif
 868         for( ; x < size.width; x++ )
 869             dst[x] = saturate_cast<DT>(std::abs(src[x]*scale + shift));
 870     }
 871 }
 872
 873
 874 template<typename T, typename DT, typename WT> static void
 875 cvtScale_( const T* src, size_t sstep,
 876            DT* dst, size_t dstep, Size size,
 877            WT scale, WT shift )
 878 {
 879     sstep /= sizeof(src[0]);
 880     dstep /= sizeof(dst[0]);
 881
 882     for( ; size.height--; src += sstep, dst += dstep )
 883     {
 884         int x = 0;
 885         #if CV_ENABLE_UNROLLED
 886         for( ; x <= size.width - 4; x += 4 )
 887         {
 888             DT t0, t1;
 889             t0 = saturate_cast<DT>(src[x]*scale + shift);
 890             t1 = saturate_cast<DT>(src[x+1]*scale + shift);
 891             dst[x] = t0; dst[x+1] = t1;
 892             t0 = saturate_cast<DT>(src[x+2]*scale + shift);
 893             t1 = saturate_cast<DT>(src[x+3]*scale + shift);
 894             dst[x+2] = t0; dst[x+3] = t1;
 895         }
 896         #endif
 897
 898         for( ; x < size.width; x++ )
 899             dst[x] = saturate_cast<DT>(src[x]*scale + shift);
 900     }
 901 }
 902
 903 //vz optimized template specialization
 904 template<> void
 905 cvtScale_<short, short, float>( const short* src, size_t sstep,
 906            short* dst, size_t dstep, Size size,
 907            float scale, float shift )
 908 {
 909     sstep /= sizeof(src[0]);
 910     dstep /= sizeof(dst[0]);
 911
 912     for( ; size.height--; src += sstep, dst += dstep )
 913     {
 914         int x = 0;
 915         #if CV_SSE2
 916             if(USE_SSE2)
 917             {
 918                 __m128 scale128 = _mm_set1_ps (scale);
 919                 __m128 shift128 = _mm_set1_ps (shift);
 920                 for(; x <= size.width - 8; x += 8 )
 921                 {
 922                     __m128i r0 = _mm_loadl_epi64((const __m128i*)(src + x));
 923                     __m128i r1 = _mm_loadl_epi64((const __m128i*)(src + x + 4));
 924                     __m128 rf0 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r0, r0), 16));
 925                     __m128 rf1 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r1, r1), 16));
 926                     rf0 = _mm_add_ps(_mm_mul_ps(rf0, scale128), shift128);
 927                     rf1 = _mm_add_ps(_mm_mul_ps(rf1, scale128), shift128);
 928                     r0 = _mm_cvtps_epi32(rf0);
 929                     r1 = _mm_cvtps_epi32(rf1);
 930                     r0 = _mm_packs_epi32(r0, r1);
 931                     _mm_storeu_si128((__m128i*)(dst + x), r0);
 932                 }
 933             }
 934         #endif
 935
 936         for(; x < size.width; x++ )
 937             dst[x] = saturate_cast<short>(src[x]*scale + shift);
 938     }
 939 }
 940
 941 template<> void
 942 cvtScale_<short, int, float>( const short* src, size_t sstep,
 943            int* dst, size_t dstep, Size size,
 944            float scale, float shift )
 945 {
 946     sstep /= sizeof(src[0]);
 947     dstep /= sizeof(dst[0]);
 948
 949     for( ; size.height--; src += sstep, dst += dstep )
 950     {
 951         int x = 0;
 952
 953          #if CV_SSE2
 954             if(USE_SSE2)//~5X
 955             {
 956                 __m128 scale128 = _mm_set1_ps (scale);
 957                 __m128 shift128 = _mm_set1_ps (shift);
 958                 for(; x <= size.width - 8; x += 8 )
 959                 {
 960                     __m128i r0 = _mm_loadl_epi64((const __m128i*)(src + x));
 961                     __m128i r1 = _mm_loadl_epi64((const __m128i*)(src + x + 4));
 962                     __m128 rf0 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r0, r0), 16));
 963                     __m128 rf1 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r1, r1), 16));
 964                     rf0 = _mm_add_ps(_mm_mul_ps(rf0, scale128), shift128);
 965                     rf1 = _mm_add_ps(_mm_mul_ps(rf1, scale128), shift128);
 966                     r0 = _mm_cvtps_epi32(rf0);
 967                     r1 = _mm_cvtps_epi32(rf1);
 968
 969                     _mm_storeu_si128((__m128i*)(dst + x), r0);
 970                     _mm_storeu_si128((__m128i*)(dst + x + 4), r1);
 971                 }
 972             }
 973         #endif
 974
 975         //We will wait Haswell
 976         /*
 977         #if CV_AVX
 978             if(USE_AVX)//2X - bad variant
 979             {
 980                 ////TODO:AVX implementation (optimization?) required
 981                 __m256 scale256 = _mm256_set1_ps (scale);
 982                 __m256 shift256 = _mm256_set1_ps (shift);
 983                 for(; x <= size.width - 8; x += 8 )
 984                 {
 985                     __m256i buf = _mm256_set_epi32((int)(*(src+x+7)),(int)(*(src+x+6)),(int)(*(src+x+5)),(int)(*(src+x+4)),(int)(*(src+x+3)),(int)(*(src+x+2)),(int)(*(src+x+1)),(int)(*(src+x)));
 986                     __m256 r0 = _mm256_add_ps( _mm256_mul_ps(_mm256_cvtepi32_ps (buf), scale256), shift256);
 987                     __m256i res = _mm256_cvtps_epi32(r0);
 988                     _mm256_storeu_si256 ((__m256i*)(dst+x), res);
 989                 }
 990             }
 991         #endif*/
 992
 993         for(; x < size.width; x++ )
 994             dst[x] = saturate_cast<int>(src[x]*scale + shift);
 995     }
 996 }
 997
 998 template<typename T, typename DT> static void
 999 cvt_( const T* src, size_t sstep,
1000       DT* dst, size_t dstep, Size size )
1001 {
1002     sstep /= sizeof(src[0]);
1003     dstep /= sizeof(dst[0]);
1004
1005     for( ; size.height--; src += sstep, dst += dstep )
1006     {
1007         int x = 0;
1008         #if CV_ENABLE_UNROLLED
1009         for( ; x <= size.width - 4; x += 4 )
1010         {
1011             DT t0, t1;
1012             t0 = saturate_cast<DT>(src[x]);
1013             t1 = saturate_cast<DT>(src[x+1]);
1014             dst[x] = t0; dst[x+1] = t1;
1015             t0 = saturate_cast<DT>(src[x+2]);
1016             t1 = saturate_cast<DT>(src[x+3]);
1017             dst[x+2] = t0; dst[x+3] = t1;
1018         }
1019         #endif
1020         for( ; x < size.width; x++ )
1021             dst[x] = saturate_cast<DT>(src[x]);
1022     }
1023 }
1024
1025 //vz optimized template specialization, test Core_ConvertScale/ElemWiseTest
1026 template<>  void
1027 cvt_<float, short>( const float* src, size_t sstep,
1028      short* dst, size_t dstep, Size size )
1029 {
1030     sstep /= sizeof(src[0]);
1031     dstep /= sizeof(dst[0]);
1032
1033     for( ; size.height--; src += sstep, dst += dstep )
1034     {
1035         int x = 0;
1036         #if   CV_SSE2
1037         if(USE_SSE2){
1038               for( ; x <= size.width - 8; x += 8 )
1039             {
1040                 __m128 src128 = _mm_loadu_ps (src + x);
1041                 __m128i src_int128 = _mm_cvtps_epi32 (src128);
1042
1043                 src128 = _mm_loadu_ps (src + x + 4);
1044                 __m128i src1_int128 = _mm_cvtps_epi32 (src128);
1045
1046                 src1_int128 = _mm_packs_epi32(src_int128, src1_int128);
1047                 _mm_storeu_si128((__m128i*)(dst + x),src1_int128);
1048             }
1049         }
1050         #endif
1051         for( ; x < size.width; x++ )
1052             dst[x] = saturate_cast<short>(src[x]);
1053     }
1054
1055 }
1056
1057
1058 template<typename T> static void
1059 cpy_( const T* src, size_t sstep, T* dst, size_t dstep, Size size )
1060 {
1061     sstep /= sizeof(src[0]);
1062     dstep /= sizeof(dst[0]);
1063
1064     for( ; size.height--; src += sstep, dst += dstep )
1065         memcpy(dst, src, size.width*sizeof(src[0]));
1066 }
1067
1068 #define DEF_CVT_SCALE_ABS_FUNC(suffix, tfunc, stype, dtype, wtype) \
1069 static void cvtScaleAbs##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1070                          dtype* dst, size_t dstep, Size size, double* scale) \
1071 { \
1072     tfunc(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \
1073 }
1074
1075 #define DEF_CVT_SCALE_FUNC(suffix, stype, dtype, wtype) \
1076 static void cvtScale##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1077 dtype* dst, size_t dstep, Size size, double* scale) \
1078 { \
1079     cvtScale_(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \
1080 }
1081
1082 #if defined(HAVE_IPP)
1083 #define DEF_CVT_FUNC_F(suffix, stype, dtype, ippFavor) \
1084 static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1085                          dtype* dst, size_t dstep, Size size, double*) \
1086 { \
1087     if (src && dst)\
1088     {\
1089         if (ippiConvert_##ippFavor(src, (int)sstep, dst, (int)dstep, ippiSize(size.width, size.height)) >= 0) \
1090             return; \
1091         setIppErrorStatus(); \
1092     }\
1093     cvt_(src, sstep, dst, dstep, size); \
1094 }
1095
1096 #define DEF_CVT_FUNC_F2(suffix, stype, dtype, ippFavor) \
1097 static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1098                          dtype* dst, size_t dstep, Size size, double*) \
1099 { \
1100     if (src && dst)\
1101     {\
1102         if (ippiConvert_##ippFavor(src, (int)sstep, dst, (int)dstep, ippiSize(size.width, size.height), ippRndFinancial, 0) >= 0) \
1103             return; \
1104         setIppErrorStatus(); \
1105     }\
1106     cvt_(src, sstep, dst, dstep, size); \
1107 }
1108 #else
1109 #define DEF_CVT_FUNC_F(suffix, stype, dtype, ippFavor) \
1110 static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1111                          dtype* dst, size_t dstep, Size size, double*) \
1112 { \
1113     cvt_(src, sstep, dst, dstep, size); \
1114 }
1115 #define DEF_CVT_FUNC_F2 DEF_CVT_FUNC_F
1116 #endif
1117
1118 #define DEF_CVT_FUNC(suffix, stype, dtype) \
1119 static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1120                          dtype* dst, size_t dstep, Size size, double*) \
1121 { \
1122     cvt_(src, sstep, dst, dstep, size); \
1123 }
1124
1125 #define DEF_CPY_FUNC(suffix, stype) \
1126 static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
1127                          stype* dst, size_t dstep, Size size, double*) \
1128 { \
1129     cpy_(src, sstep, dst, dstep, size); \
1130 }
1131
1132
1133 DEF_CVT_SCALE_ABS_FUNC(8u, cvtScaleAbs_, uchar, uchar, float)
1134 DEF_CVT_SCALE_ABS_FUNC(8s8u, cvtScaleAbs_, schar, uchar, float)
1135 DEF_CVT_SCALE_ABS_FUNC(16u8u, cvtScaleAbs_, ushort, uchar, float)
1136 DEF_CVT_SCALE_ABS_FUNC(16s8u, cvtScaleAbs_, short, uchar, float)
1137 DEF_CVT_SCALE_ABS_FUNC(32s8u, cvtScaleAbs_, int, uchar, float)
1138 DEF_CVT_SCALE_ABS_FUNC(32f8u, cvtScaleAbs_, float, uchar, float)
1139 DEF_CVT_SCALE_ABS_FUNC(64f8u, cvtScaleAbs_, double, uchar, float)
1140
1141 DEF_CVT_SCALE_FUNC(8u,     uchar, uchar, float)
1142 DEF_CVT_SCALE_FUNC(8s8u,   schar, uchar, float)
1143 DEF_CVT_SCALE_FUNC(16u8u,  ushort, uchar, float)
1144 DEF_CVT_SCALE_FUNC(16s8u,  short, uchar, float)
1145 DEF_CVT_SCALE_FUNC(32s8u,  int, uchar, float)
1146 DEF_CVT_SCALE_FUNC(32f8u,  float, uchar, float)
1147 DEF_CVT_SCALE_FUNC(64f8u,  double, uchar, float)
1148
1149 DEF_CVT_SCALE_FUNC(8u8s,   uchar, schar, float)
1150 DEF_CVT_SCALE_FUNC(8s,     schar, schar, float)
1151 DEF_CVT_SCALE_FUNC(16u8s,  ushort, schar, float)
1152 DEF_CVT_SCALE_FUNC(16s8s,  short, schar, float)
1153 DEF_CVT_SCALE_FUNC(32s8s,  int, schar, float)
1154 DEF_CVT_SCALE_FUNC(32f8s,  float, schar, float)
1155 DEF_CVT_SCALE_FUNC(64f8s,  double, schar, float)
1156
1157 DEF_CVT_SCALE_FUNC(8u16u,  uchar, ushort, float)
1158 DEF_CVT_SCALE_FUNC(8s16u,  schar, ushort, float)
1159 DEF_CVT_SCALE_FUNC(16u,    ushort, ushort, float)
1160 DEF_CVT_SCALE_FUNC(16s16u, short, ushort, float)
1161 DEF_CVT_SCALE_FUNC(32s16u, int, ushort, float)
1162 DEF_CVT_SCALE_FUNC(32f16u, float, ushort, float)
1163 DEF_CVT_SCALE_FUNC(64f16u, double, ushort, float)
1164
1165 DEF_CVT_SCALE_FUNC(8u16s,  uchar, short, float)
1166 DEF_CVT_SCALE_FUNC(8s16s,  schar, short, float)
1167 DEF_CVT_SCALE_FUNC(16u16s, ushort, short, float)
1168 DEF_CVT_SCALE_FUNC(16s,    short, short, float)
1169 DEF_CVT_SCALE_FUNC(32s16s, int, short, float)
1170 DEF_CVT_SCALE_FUNC(32f16s, float, short, float)
1171 DEF_CVT_SCALE_FUNC(64f16s, double, short, float)
1172
1173 DEF_CVT_SCALE_FUNC(8u32s,  uchar, int, float)
1174 DEF_CVT_SCALE_FUNC(8s32s,  schar, int, float)
1175 DEF_CVT_SCALE_FUNC(16u32s, ushort, int, float)
1176 DEF_CVT_SCALE_FUNC(16s32s, short, int, float)
1177 DEF_CVT_SCALE_FUNC(32s,    int, int, double)
1178 DEF_CVT_SCALE_FUNC(32f32s, float, int, float)
1179 DEF_CVT_SCALE_FUNC(64f32s, double, int, double)
1180
1181 DEF_CVT_SCALE_FUNC(8u32f,  uchar, float, float)
1182 DEF_CVT_SCALE_FUNC(8s32f,  schar, float, float)
1183 DEF_CVT_SCALE_FUNC(16u32f, ushort, float, float)
1184 DEF_CVT_SCALE_FUNC(16s32f, short, float, float)
1185 DEF_CVT_SCALE_FUNC(32s32f, int, float, double)
1186 DEF_CVT_SCALE_FUNC(32f,    float, float, float)
1187 DEF_CVT_SCALE_FUNC(64f32f, double, float, double)
1188
1189 DEF_CVT_SCALE_FUNC(8u64f,  uchar, double, double)
1190 DEF_CVT_SCALE_FUNC(8s64f,  schar, double, double)
1191 DEF_CVT_SCALE_FUNC(16u64f, ushort, double, double)
1192 DEF_CVT_SCALE_FUNC(16s64f, short, double, double)
1193 DEF_CVT_SCALE_FUNC(32s64f, int, double, double)
1194 DEF_CVT_SCALE_FUNC(32f64f, float, double, double)
1195 DEF_CVT_SCALE_FUNC(64f,    double, double, double)
1196
1197 DEF_CPY_FUNC(8u,     uchar)
1198 DEF_CVT_FUNC_F(8s8u,   schar, uchar, 8s8u_C1Rs)
1199 DEF_CVT_FUNC_F(16u8u,  ushort, uchar, 16u8u_C1R)
1200 DEF_CVT_FUNC_F(16s8u,  short, uchar, 16s8u_C1R)
1201 DEF_CVT_FUNC_F(32s8u,  int, uchar, 32s8u_C1R)
1202 DEF_CVT_FUNC_F2(32f8u,  float, uchar, 32f8u_C1RSfs)
1203 DEF_CVT_FUNC(64f8u,  double, uchar)
1204
1205 DEF_CVT_FUNC_F2(8u8s,   uchar, schar, 8u8s_C1RSfs)
1206 DEF_CVT_FUNC_F2(16u8s,  ushort, schar, 16u8s_C1RSfs)
1207 DEF_CVT_FUNC_F2(16s8s,  short, schar, 16s8s_C1RSfs)
1208 DEF_CVT_FUNC_F(32s8s,  int, schar, 32s8s_C1R)
1209 DEF_CVT_FUNC_F2(32f8s,  float, schar, 32f8s_C1RSfs)
1210 DEF_CVT_FUNC(64f8s,  double, schar)
1211
1212 DEF_CVT_FUNC_F(8u16u,  uchar, ushort, 8u16u_C1R)
1213 DEF_CVT_FUNC_F(8s16u,  schar, ushort, 8s16u_C1Rs)
1214 DEF_CPY_FUNC(16u,    ushort)
1215 DEF_CVT_FUNC_F(16s16u, short, ushort, 16s16u_C1Rs)
1216 DEF_CVT_FUNC_F2(32s16u, int, ushort, 32s16u_C1RSfs)
1217 DEF_CVT_FUNC_F2(32f16u, float, ushort, 32f16u_C1RSfs)
1218 DEF_CVT_FUNC(64f16u, double, ushort)
1219
1220 DEF_CVT_FUNC_F(8u16s,  uchar, short, 8u16s_C1R)
1221 DEF_CVT_FUNC_F(8s16s,  schar, short, 8s16s_C1R)
1222 DEF_CVT_FUNC_F2(16u16s, ushort, short, 16u16s_C1RSfs)
1223 DEF_CVT_FUNC_F2(32s16s, int, short, 32s16s_C1RSfs)
1224 DEF_CVT_FUNC_F2(32f16s, float, short, 32f16s_C1RSfs)
1225 DEF_CVT_FUNC(64f16s, double, short)
1226
1227 DEF_CVT_FUNC_F(8u32s,  uchar, int, 8u32s_C1R)
1228 DEF_CVT_FUNC_F(8s32s,  schar, int, 8s32s_C1R)
1229 DEF_CVT_FUNC_F(16u32s, ushort, int, 16u32s_C1R)
1230 DEF_CVT_FUNC_F(16s32s, short, int, 16s32s_C1R)
1231 DEF_CPY_FUNC(32s,    int)
1232 DEF_CVT_FUNC_F2(32f32s, float, int, 32f32s_C1RSfs)
1233 DEF_CVT_FUNC(64f32s, double, int)
1234
1235 DEF_CVT_FUNC_F(8u32f,  uchar, float, 8u32f_C1R)
1236 DEF_CVT_FUNC_F(8s32f,  schar, float, 8s32f_C1R)
1237 DEF_CVT_FUNC_F(16u32f, ushort, float, 16u32f_C1R)
1238 DEF_CVT_FUNC_F(16s32f, short, float, 16s32f_C1R)
1239 DEF_CVT_FUNC_F(32s32f, int, float, 32s32f_C1R)
1240 DEF_CVT_FUNC(64f32f, double, float)
1241
1242 DEF_CVT_FUNC(8u64f,  uchar, double)
1243 DEF_CVT_FUNC(8s64f,  schar, double)
1244 DEF_CVT_FUNC(16u64f, ushort, double)
1245 DEF_CVT_FUNC(16s64f, short, double)
1246 DEF_CVT_FUNC(32s64f, int, double)
1247 DEF_CVT_FUNC(32f64f, float, double)
1248 DEF_CPY_FUNC(64s,    int64)
1249
1250 static BinaryFunc getCvtScaleAbsFunc(int depth)
1251 {
1252     static BinaryFunc cvtScaleAbsTab[] =
1253     {
1254         (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
1255         (BinaryFunc)cvtScaleAbs16s8u, (BinaryFunc)cvtScaleAbs32s8u, (BinaryFunc)cvtScaleAbs32f8u,
1256         (BinaryFunc)cvtScaleAbs64f8u, 0
1257     };
1258
1259     return cvtScaleAbsTab[depth];
1260 }
1261
1262 BinaryFunc getConvertFunc(int sdepth, int ddepth)
1263 {
1264     static BinaryFunc cvtTab[][8] =
1265     {
1266         {
1267             (BinaryFunc)(cvt8u), (BinaryFunc)GET_OPTIMIZED(cvt8s8u), (BinaryFunc)GET_OPTIMIZED(cvt16u8u),
1268             (BinaryFunc)GET_OPTIMIZED(cvt16s8u), (BinaryFunc)GET_OPTIMIZED(cvt32s8u), (BinaryFunc)GET_OPTIMIZED(cvt32f8u),
1269             (BinaryFunc)GET_OPTIMIZED(cvt64f8u), 0
1270         },
1271         {
1272             (BinaryFunc)GET_OPTIMIZED(cvt8u8s), (BinaryFunc)cvt8u, (BinaryFunc)GET_OPTIMIZED(cvt16u8s),
1273             (BinaryFunc)GET_OPTIMIZED(cvt16s8s), (BinaryFunc)GET_OPTIMIZED(cvt32s8s), (BinaryFunc)GET_OPTIMIZED(cvt32f8s),
1274             (BinaryFunc)GET_OPTIMIZED(cvt64f8s), 0
1275         },
1276         {
1277             (BinaryFunc)GET_OPTIMIZED(cvt8u16u), (BinaryFunc)GET_OPTIMIZED(cvt8s16u), (BinaryFunc)cvt16u,
1278             (BinaryFunc)GET_OPTIMIZED(cvt16s16u), (BinaryFunc)GET_OPTIMIZED(cvt32s16u), (BinaryFunc)GET_OPTIMIZED(cvt32f16u),
1279             (BinaryFunc)GET_OPTIMIZED(cvt64f16u), 0
1280         },
1281         {
1282             (BinaryFunc)GET_OPTIMIZED(cvt8u16s), (BinaryFunc)GET_OPTIMIZED(cvt8s16s), (BinaryFunc)GET_OPTIMIZED(cvt16u16s),
1283             (BinaryFunc)cvt16u, (BinaryFunc)GET_OPTIMIZED(cvt32s16s), (BinaryFunc)GET_OPTIMIZED(cvt32f16s),
1284             (BinaryFunc)GET_OPTIMIZED(cvt64f16s), 0
1285         },
1286         {
1287             (BinaryFunc)GET_OPTIMIZED(cvt8u32s), (BinaryFunc)GET_OPTIMIZED(cvt8s32s), (BinaryFunc)GET_OPTIMIZED(cvt16u32s),
1288             (BinaryFunc)GET_OPTIMIZED(cvt16s32s), (BinaryFunc)cvt32s, (BinaryFunc)GET_OPTIMIZED(cvt32f32s),
1289             (BinaryFunc)GET_OPTIMIZED(cvt64f32s), 0
1290         },
1291         {
1292             (BinaryFunc)GET_OPTIMIZED(cvt8u32f), (BinaryFunc)GET_OPTIMIZED(cvt8s32f), (BinaryFunc)GET_OPTIMIZED(cvt16u32f),
1293             (BinaryFunc)GET_OPTIMIZED(cvt16s32f), (BinaryFunc)GET_OPTIMIZED(cvt32s32f), (BinaryFunc)cvt32s,
1294             (BinaryFunc)GET_OPTIMIZED(cvt64f32f), 0
1295         },
1296         {
1297             (BinaryFunc)GET_OPTIMIZED(cvt8u64f), (BinaryFunc)GET_OPTIMIZED(cvt8s64f), (BinaryFunc)GET_OPTIMIZED(cvt16u64f),
1298             (BinaryFunc)GET_OPTIMIZED(cvt16s64f), (BinaryFunc)GET_OPTIMIZED(cvt32s64f), (BinaryFunc)GET_OPTIMIZED(cvt32f64f),
1299             (BinaryFunc)(cvt64s), 0
1300         },
1301         {
1302             0, 0, 0, 0, 0, 0, 0, 0
1303         }
1304     };
1305
1306     return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
1307 }
1308
1309 static BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
1310 {
1311     static BinaryFunc cvtScaleTab[][8] =
1312     {
1313         {
1314             (BinaryFunc)GET_OPTIMIZED(cvtScale8u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8u),
1315             (BinaryFunc)GET_OPTIMIZED(cvtScale16s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8u),
1316             (BinaryFunc)cvtScale64f8u, 0
1317         },
1318         {
1319             (BinaryFunc)GET_OPTIMIZED(cvtScale8u8s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u8s),
1320             (BinaryFunc)GET_OPTIMIZED(cvtScale16s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s8s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f8s),
1321             (BinaryFunc)cvtScale64f8s, 0
1322         },
1323         {
1324             (BinaryFunc)GET_OPTIMIZED(cvtScale8u16u), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale16u),
1325             (BinaryFunc)GET_OPTIMIZED(cvtScale16s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16u), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16u),
1326             (BinaryFunc)cvtScale64f16u, 0
1327         },
1328         {
1329             (BinaryFunc)GET_OPTIMIZED(cvtScale8u16s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u16s),
1330             (BinaryFunc)GET_OPTIMIZED(cvtScale16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s16s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f16s),
1331             (BinaryFunc)cvtScale64f16s, 0
1332         },
1333         {
1334             (BinaryFunc)GET_OPTIMIZED(cvtScale8u32s), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32s),
1335             (BinaryFunc)GET_OPTIMIZED(cvtScale16s32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32s), (BinaryFunc)GET_OPTIMIZED(cvtScale32f32s),
1336             (BinaryFunc)cvtScale64f32s, 0
1337         },
1338         {
1339             (BinaryFunc)GET_OPTIMIZED(cvtScale8u32f), (BinaryFunc)GET_OPTIMIZED(cvtScale8s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale16u32f),
1340             (BinaryFunc)GET_OPTIMIZED(cvtScale16s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32s32f), (BinaryFunc)GET_OPTIMIZED(cvtScale32f),
1341             (BinaryFunc)cvtScale64f32f, 0
1342         },
1343         {
1344             (BinaryFunc)cvtScale8u64f, (BinaryFunc)cvtScale8s64f, (BinaryFunc)cvtScale16u64f,
1345             (BinaryFunc)cvtScale16s64f, (BinaryFunc)cvtScale32s64f, (BinaryFunc)cvtScale32f64f,
1346             (BinaryFunc)cvtScale64f, 0
1347         },
1348         {
1349             0, 0, 0, 0, 0, 0, 0, 0
1350         }
1351     };
1352
1353     return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
1354 }
1355
1356 #ifdef HAVE_OPENCL
1357
1358 static bool ocl_convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
1359 {
1360     int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
1361         kercn = ocl::predictOptimalVectorWidth(_src, _dst);
1362     bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0;
1363
1364     if (!doubleSupport && depth == CV_64F)
1365         return false;
1366
1367     char cvt[2][50];
1368     int wdepth = std::max(depth, CV_32F);
1369     ocl::Kernel k("KF", ocl::core::arithm_oclsrc,
1370                   format("-D OP_CONVERT_SCALE_ABS -D UNARY_OP -D dstT=%s -D srcT1=%s"
1371                          " -D workT=%s -D wdepth=%d -D convertToWT1=%s -D convertToDT=%s -D workT1=%s%s",
1372                          ocl::typeToStr(CV_8UC(kercn)),
1373                          ocl::typeToStr(CV_MAKE_TYPE(depth, kercn)),
1374                          ocl::typeToStr(CV_MAKE_TYPE(wdepth, kercn)), wdepth,
1375                          ocl::convertTypeStr(depth, wdepth, kercn, cvt[0]),
1376                          ocl::convertTypeStr(wdepth, CV_8U, kercn, cvt[1]),
1377                          ocl::typeToStr(wdepth),
1378                          doubleSupport ? " -D DOUBLE_SUPPORT" : ""));
1379     if (k.empty())
1380         return false;
1381
1382     UMat src = _src.getUMat();
1383     _dst.create(src.size(), CV_8UC(cn));
1384     UMat dst = _dst.getUMat();
1385
1386     ocl::KernelArg srcarg = ocl::KernelArg::ReadOnlyNoSize(src),
1387             dstarg = ocl::KernelArg::WriteOnly(dst, cn, kercn);
1388
1389     if (wdepth == CV_32F)
1390         k.args(srcarg, dstarg, (float)alpha, (float)beta);
1391     else if (wdepth == CV_64F)
1392         k.args(srcarg, dstarg, alpha, beta);
1393
1394     size_t globalsize[2] = { src.cols * cn / kercn, src.rows };
1395     return k.run(2, globalsize, NULL, false);
1396 }
1397
1398 #endif
1399
1400 }
1401
1402 void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
1403 {
1404     CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
1405                ocl_convertScaleAbs(_src, _dst, alpha, beta))
1406
1407     Mat src = _src.getMat();
1408     int cn = src.channels();
1409     double scale[] = {alpha, beta};
1410     _dst.create( src.dims, src.size, CV_8UC(cn) );
1411     Mat dst = _dst.getMat();
1412     BinaryFunc func = getCvtScaleAbsFunc(src.depth());
1413     CV_Assert( func != 0 );
1414
1415     if( src.dims <= 2 )
1416     {
1417         Size sz = getContinuousSize(src, dst, cn);
1418         func( src.data, src.step, 0, 0, dst.data, dst.step, sz, scale );
1419     }
1420     else
1421     {
1422         const Mat* arrays[] = {&src, &dst, 0};
1423         uchar* ptrs[2];
1424         NAryMatIterator it(arrays, ptrs);
1425         Size sz((int)it.size*cn, 1);
1426
1427         for( size_t i = 0; i < it.nplanes; i++, ++it )
1428             func( ptrs[0], 0, 0, 0, ptrs[1], 0, sz, scale );
1429     }
1430 }
1431
1432 void cv::Mat::convertTo(OutputArray _dst, int _type, double alpha, double beta) const
1433 {
1434     bool noScale = fabs(alpha-1) < DBL_EPSILON && fabs(beta) < DBL_EPSILON;
1435
1436     if( _type < 0 )
1437         _type = _dst.fixedType() ? _dst.type() : type();
1438     else
1439         _type = CV_MAKETYPE(CV_MAT_DEPTH(_type), channels());
1440
1441     int sdepth = depth(), ddepth = CV_MAT_DEPTH(_type);
1442     if( sdepth == ddepth && noScale )
1443     {
1444         copyTo(_dst);
1445         return;
1446     }
1447
1448     Mat src = *this;
1449
1450     BinaryFunc func = noScale ? getConvertFunc(sdepth, ddepth) : getConvertScaleFunc(sdepth, ddepth);
1451     double scale[] = {alpha, beta};
1452     int cn = channels();
1453     CV_Assert( func != 0 );
1454
1455     if( dims <= 2 )
1456     {
1457         _dst.create( size(), _type );
1458         Mat dst = _dst.getMat();
1459         Size sz = getContinuousSize(src, dst, cn);
1460         func( src.data, src.step, 0, 0, dst.data, dst.step, sz, scale );
1461     }
1462     else
1463     {
1464         _dst.create( dims, size, _type );
1465         Mat dst = _dst.getMat();
1466         const Mat* arrays[] = {&src, &dst, 0};
1467         uchar* ptrs[2];
1468         NAryMatIterator it(arrays, ptrs);
1469         Size sz((int)(it.size*cn), 1);
1470
1471         for( size_t i = 0; i < it.nplanes; i++, ++it )
1472             func(ptrs[0], 1, 0, 0, ptrs[1], 1, sz, scale);
1473     }
1474 }
1475
1476 /****************************************************************************************\
1477 *                                    LUT Transform                                       *
1478 \****************************************************************************************/
1479
1480 namespace cv
1481 {
1482
1483 template<typename T> static void
1484 LUT8u_( const uchar* src, const T* lut, T* dst, int len, int cn, int lutcn )
1485 {
1486     if( lutcn == 1 )
1487     {
1488         for( int i = 0; i < len*cn; i++ )
1489             dst[i] = lut[src[i]];
1490     }
1491     else
1492     {
1493         for( int i = 0; i < len*cn; i += cn )
1494             for( int k = 0; k < cn; k++ )
1495                 dst[i+k] = lut[src[i+k]*cn+k];
1496     }
1497 }
1498
1499 static void LUT8u_8u( const uchar* src, const uchar* lut, uchar* dst, int len, int cn, int lutcn )
1500 {
1501     LUT8u_( src, lut, dst, len, cn, lutcn );
1502 }
1503
1504 static void LUT8u_8s( const uchar* src, const schar* lut, schar* dst, int len, int cn, int lutcn )
1505 {
1506     LUT8u_( src, lut, dst, len, cn, lutcn );
1507 }
1508
1509 static void LUT8u_16u( const uchar* src, const ushort* lut, ushort* dst, int len, int cn, int lutcn )
1510 {
1511     LUT8u_( src, lut, dst, len, cn, lutcn );
1512 }
1513
1514 static void LUT8u_16s( const uchar* src, const short* lut, short* dst, int len, int cn, int lutcn )
1515 {
1516     LUT8u_( src, lut, dst, len, cn, lutcn );
1517 }
1518
1519 static void LUT8u_32s( const uchar* src, const int* lut, int* dst, int len, int cn, int lutcn )
1520 {
1521     LUT8u_( src, lut, dst, len, cn, lutcn );
1522 }
1523
1524 static void LUT8u_32f( const uchar* src, const float* lut, float* dst, int len, int cn, int lutcn )
1525 {
1526     LUT8u_( src, lut, dst, len, cn, lutcn );
1527 }
1528
1529 static void LUT8u_64f( const uchar* src, const double* lut, double* dst, int len, int cn, int lutcn )
1530 {
1531     LUT8u_( src, lut, dst, len, cn, lutcn );
1532 }
1533
1534 typedef void (*LUTFunc)( const uchar* src, const uchar* lut, uchar* dst, int len, int cn, int lutcn );
1535
1536 static LUTFunc lutTab[] =
1537 {
1538     (LUTFunc)LUT8u_8u, (LUTFunc)LUT8u_8s, (LUTFunc)LUT8u_16u, (LUTFunc)LUT8u_16s,
1539     (LUTFunc)LUT8u_32s, (LUTFunc)LUT8u_32f, (LUTFunc)LUT8u_64f, 0
1540 };
1541
1542 #ifdef HAVE_OPENCL
1543
1544 static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst)
1545 {
1546     int lcn = _lut.channels(), dcn = _src.channels(), ddepth = _lut.depth();
1547
1548     UMat src = _src.getUMat(), lut = _lut.getUMat();
1549     _dst.create(src.size(), CV_MAKETYPE(ddepth, dcn));
1550     UMat dst = _dst.getUMat();
1551     bool bAligned = (1 == dcn) && (0 == (src.offset % 4)) && (0 == (src.cols % 4));
1552
1553     ocl::Kernel k("LUT", ocl::core::lut_oclsrc,
1554                   format("-D dcn=%d -D lcn=%d -D srcT=%s -D dstT=%s%s", dcn, lcn,
1555                          ocl::typeToStr(src.depth()), ocl::memopTypeToStr(ddepth),
1556                          bAligned ? " -D USE_ALIGNED" : ""
1557                          ));
1558     if (k.empty())
1559         return false;
1560
1561     k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::ReadOnlyNoSize(lut),
1562            ocl::KernelArg::WriteOnly(dst));
1563
1564     size_t globalSize[2] = { dst.cols, (dst.rows + 3) / 4};
1565     if (bAligned)
1566         globalSize[0] = (dst.cols + 3) / 4;
1567     return k.run(2, globalSize, NULL, false);
1568 }
1569
1570 #endif
1571
1572 #if defined(HAVE_IPP)
1573 namespace ipp {
1574
1575 #if 0 // there are no performance benefits (PR #2653)
1576 class IppLUTParallelBody_LUTC1 : public ParallelLoopBody
1577 {
1578 public:
1579     bool* ok;
1580     const Mat& src_;
1581     const Mat& lut_;
1582     Mat& dst_;
1583
1584     typedef IppStatus (*IppFn)(const Ipp8u* pSrc, int srcStep, void* pDst, int dstStep,
1585                           IppiSize roiSize, const void* pTable, int nBitSize);
1586     IppFn fn;
1587
1588     int width;
1589
1590     IppLUTParallelBody_LUTC1(const Mat& src, const Mat& lut, Mat& dst, bool* _ok)
1591         : ok(_ok), src_(src), lut_(lut), dst_(dst)
1592     {
1593         width = dst.cols * dst.channels();
1594
1595         size_t elemSize1 = CV_ELEM_SIZE1(dst.depth());
1596
1597         fn =
1598                 elemSize1 == 1 ? (IppFn)ippiLUTPalette_8u_C1R :
1599                 elemSize1 == 4 ? (IppFn)ippiLUTPalette_8u32u_C1R :
1600                 NULL;
1601
1602         *ok = (fn != NULL);
1603     }
1604
1605     void operator()( const cv::Range& range ) const
1606     {
1607         if (!*ok)
1608             return;
1609
1610         const int row0 = range.start;
1611         const int row1 = range.end;
1612
1613         Mat src = src_.rowRange(row0, row1);
1614         Mat dst = dst_.rowRange(row0, row1);
1615
1616         IppiSize sz = { width, dst.rows };
1617
1618         CV_DbgAssert(fn != NULL);
1619         if (fn(src.data, (int)src.step[0], dst.data, (int)dst.step[0], sz, lut_.data, 8) < 0)
1620         {
1621             setIppErrorStatus();
1622             *ok = false;
1623         }
1624     }
1625 private:
1626     IppLUTParallelBody_LUTC1(const IppLUTParallelBody_LUTC1&);
1627     IppLUTParallelBody_LUTC1& operator=(const IppLUTParallelBody_LUTC1&);
1628 };
1629 #endif
1630
1631 class IppLUTParallelBody_LUTCN : public ParallelLoopBody
1632 {
1633 public:
1634     bool *ok;
1635     const Mat& src_;
1636     const Mat& lut_;
1637     Mat& dst_;
1638
1639     int lutcn;
1640
1641     uchar* lutBuffer;
1642     uchar* lutTable[4];
1643
1644     IppLUTParallelBody_LUTCN(const Mat& src, const Mat& lut, Mat& dst, bool* _ok)
1645         : ok(_ok), src_(src), lut_(lut), dst_(dst), lutBuffer(NULL)
1646     {
1647         lutcn = lut.channels();
1648         IppiSize sz256 = {256, 1};
1649
1650         size_t elemSize1 = dst.elemSize1();
1651         CV_DbgAssert(elemSize1 == 1);
1652         lutBuffer = (uchar*)ippMalloc(256 * (int)elemSize1 * 4);
1653         lutTable[0] = lutBuffer + 0;
1654         lutTable[1] = lutBuffer + 1 * 256 * elemSize1;
1655         lutTable[2] = lutBuffer + 2 * 256 * elemSize1;
1656         lutTable[3] = lutBuffer + 3 * 256 * elemSize1;
1657
1658         CV_DbgAssert(lutcn == 3 || lutcn == 4);
1659         if (lutcn == 3)
1660         {
1661             IppStatus status = ippiCopy_8u_C3P3R(lut.data, (int)lut.step[0], lutTable, (int)lut.step[0], sz256);
1662             if (status < 0)
1663             {
1664                 setIppErrorStatus();
1665                 return;
1666             }
1667         }
1668         else if (lutcn == 4)
1669         {
1670             IppStatus status = ippiCopy_8u_C4P4R(lut.data, (int)lut.step[0], lutTable, (int)lut.step[0], sz256);
1671             if (status < 0)
1672             {
1673                 setIppErrorStatus();
1674                 return;
1675             }
1676         }
1677
1678         *ok = true;
1679     }
1680
1681     ~IppLUTParallelBody_LUTCN()
1682     {
1683         if (lutBuffer != NULL)
1684             ippFree(lutBuffer);
1685         lutBuffer = NULL;
1686         lutTable[0] = NULL;
1687     }
1688
1689     void operator()( const cv::Range& range ) const
1690     {
1691         if (!*ok)
1692             return;
1693
1694         const int row0 = range.start;
1695         const int row1 = range.end;
1696
1697         Mat src = src_.rowRange(row0, row1);
1698         Mat dst = dst_.rowRange(row0, row1);
1699
1700         if (lutcn == 3)
1701         {
1702             if (ippiLUTPalette_8u_C3R(
1703                     src.data, (int)src.step[0], dst.data, (int)dst.step[0],
1704                     ippiSize(dst.size()), lutTable, 8) >= 0)
1705                 return;
1706         }
1707         else if (lutcn == 4)
1708         {
1709             if (ippiLUTPalette_8u_C4R(
1710                     src.data, (int)src.step[0], dst.data, (int)dst.step[0],
1711                     ippiSize(dst.size()), lutTable, 8) >= 0)
1712                 return;
1713         }
1714         setIppErrorStatus();
1715         *ok = false;
1716     }
1717 private:
1718     IppLUTParallelBody_LUTCN(const IppLUTParallelBody_LUTCN&);
1719     IppLUTParallelBody_LUTCN& operator=(const IppLUTParallelBody_LUTCN&);
1720 };
1721 } // namespace ipp
1722 #endif // IPP
1723
1724 class LUTParallelBody : public ParallelLoopBody
1725 {
1726 public:
1727     bool* ok;
1728     const Mat& src_;
1729     const Mat& lut_;
1730     Mat& dst_;
1731
1732     LUTFunc func;
1733
1734     LUTParallelBody(const Mat& src, const Mat& lut, Mat& dst, bool* _ok)
1735         : ok(_ok), src_(src), lut_(lut), dst_(dst)
1736     {
1737         func = lutTab[lut.depth()];
1738         *ok = (func != NULL);
1739     }
1740
1741     void operator()( const cv::Range& range ) const
1742     {
1743         CV_DbgAssert(*ok);
1744
1745         const int row0 = range.start;
1746         const int row1 = range.end;
1747
1748         Mat src = src_.rowRange(row0, row1);
1749         Mat dst = dst_.rowRange(row0, row1);
1750
1751         int cn = src.channels();
1752         int lutcn = lut_.channels();
1753
1754         const Mat* arrays[] = {&src, &dst, 0};
1755         uchar* ptrs[2];
1756         NAryMatIterator it(arrays, ptrs);
1757         int len = (int)it.size;
1758
1759         for( size_t i = 0; i < it.nplanes; i++, ++it )
1760             func(ptrs[0], lut_.data, ptrs[1], len, cn, lutcn);
1761     }
1762 private:
1763     LUTParallelBody(const LUTParallelBody&);
1764     LUTParallelBody& operator=(const LUTParallelBody&);
1765 };
1766
1767 }
1768
1769 void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
1770 {
1771     int cn = _src.channels(), depth = _src.depth();
1772     int lutcn = _lut.channels();
1773
1774     CV_Assert( (lutcn == cn || lutcn == 1) &&
1775         _lut.total() == 256 && _lut.isContinuous() &&
1776         (depth == CV_8U || depth == CV_8S) );
1777
1778     CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2,
1779                ocl_LUT(_src, _lut, _dst))
1780
1781     Mat src = _src.getMat(), lut = _lut.getMat();
1782     _dst.create(src.dims, src.size, CV_MAKETYPE(_lut.depth(), cn));
1783     Mat dst = _dst.getMat();
1784
1785     if (_src.dims() <= 2)
1786     {
1787         bool ok = false;
1788         Ptr<ParallelLoopBody> body;
1789 #if defined(HAVE_IPP)
1790         size_t elemSize1 = CV_ELEM_SIZE1(dst.depth());
1791 #if 0 // there are no performance benefits (PR #2653)
1792         if (lutcn == 1)
1793         {
1794             ParallelLoopBody* p = new ipp::IppLUTParallelBody_LUTC1(src, lut, dst, &ok);
1795             body.reset(p);
1796         }
1797         else
1798 #endif
1799         if ((lutcn == 3 || lutcn == 4) && elemSize1 == 1)
1800         {
1801             ParallelLoopBody* p = new ipp::IppLUTParallelBody_LUTCN(src, lut, dst, &ok);
1802             body.reset(p);
1803         }
1804 #endif
1805         if (body == NULL || ok == false)
1806         {
1807             ok = false;
1808             ParallelLoopBody* p = new LUTParallelBody(src, lut, dst, &ok);
1809             body.reset(p);
1810         }
1811         if (body != NULL && ok)
1812         {
1813             Range all(0, dst.rows);
1814             if (dst.total()>>18)
1815                 parallel_for_(all, *body, (double)std::max((size_t)1, dst.total()>>16));
1816             else
1817                 (*body)(all);
1818             if (ok)
1819                 return;
1820         }
1821     }
1822
1823     LUTFunc func = lutTab[lut.depth()];
1824     CV_Assert( func != 0 );
1825
1826     const Mat* arrays[] = {&src, &dst, 0};
1827     uchar* ptrs[2];
1828     NAryMatIterator it(arrays, ptrs);
1829     int len = (int)it.size;
1830
1831     for( size_t i = 0; i < it.nplanes; i++, ++it )
1832         func(ptrs[0], lut.data, ptrs[1], len, cn, lutcn);
1833 }
1834
1835 namespace cv {
1836
1837 #ifdef HAVE_OPENCL
1838
1839 static bool ocl_normalize( InputArray _src, OutputArray _dst, InputArray _mask, int rtype,
1840                            double scale, double shift )
1841 {
1842     UMat src = _src.getUMat(), dst = _dst.getUMat();
1843
1844     if( _mask.empty() )
1845         src.convertTo( dst, rtype, scale, shift );
1846     else
1847     {
1848         UMat temp;
1849         src.convertTo( temp, rtype, scale, shift );
1850         temp.copyTo( dst, _mask );
1851     }
1852
1853     return true;
1854 }
1855
1856 #endif
1857
1858 }
1859
1860 void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
1861                     int norm_type, int rtype, InputArray _mask )
1862 {
1863     double scale = 1, shift = 0;
1864     if( norm_type == CV_MINMAX )
1865     {
1866         double smin = 0, smax = 0;
1867         double dmin = MIN( a, b ), dmax = MAX( a, b );
1868         minMaxLoc( _src, &smin, &smax, 0, 0, _mask );
1869         scale = (dmax - dmin)*(smax - smin > DBL_EPSILON ? 1./(smax - smin) : 0);
1870         shift = dmin - smin*scale;
1871     }
1872     else if( norm_type == CV_L2 || norm_type == CV_L1 || norm_type == CV_C )
1873     {
1874         scale = norm( _src, norm_type, _mask );
1875         scale = scale > DBL_EPSILON ? a/scale : 0.;
1876         shift = 0;
1877     }
1878     else
1879         CV_Error( CV_StsBadArg, "Unknown/unsupported norm type" );
1880
1881     int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
1882     if( rtype < 0 )
1883         rtype = _dst.fixedType() ? _dst.depth() : depth;
1884     _dst.createSameSize(_src, CV_MAKETYPE(rtype, cn));
1885
1886     CV_OCL_RUN(_dst.isUMat(),
1887                ocl_normalize(_src, _dst, _mask, rtype, scale, shift))
1888
1889     Mat src = _src.getMat(), dst = _dst.getMat();
1890     if( _mask.empty() )
1891         src.convertTo( dst, rtype, scale, shift );
1892     else
1893     {
1894         Mat temp;
1895         src.convertTo( temp, rtype, scale, shift );
1896         temp.copyTo( dst, _mask );
1897     }
1898 }
1899
1900 CV_IMPL void
1901 cvSplit( const void* srcarr, void* dstarr0, void* dstarr1, void* dstarr2, void* dstarr3 )
1902 {
1903     void* dptrs[] = { dstarr0, dstarr1, dstarr2, dstarr3 };
1904     cv::Mat src = cv::cvarrToMat(srcarr);
1905     int i, j, nz = 0;
1906     for( i = 0; i < 4; i++ )
1907         nz += dptrs[i] != 0;
1908     CV_Assert( nz > 0 );
1909     std::vector<cv::Mat> dvec(nz);
1910     std::vector<int> pairs(nz*2);
1911
1912     for( i = j = 0; i < 4; i++ )
1913     {
1914         if( dptrs[i] != 0 )
1915         {
1916             dvec[j] = cv::cvarrToMat(dptrs[i]);
1917             CV_Assert( dvec[j].size() == src.size() );
1918             CV_Assert( dvec[j].depth() == src.depth() );
1919             CV_Assert( dvec[j].channels() == 1 );
1920             CV_Assert( i < src.channels() );
1921             pairs[j*2] = i;
1922             pairs[j*2+1] = j;
1923             j++;
1924         }
1925     }
1926     if( nz == src.channels() )
1927         cv::split( src, dvec );
1928     else
1929     {
1930         cv::mixChannels( &src, 1, &dvec[0], nz, &pairs[0], nz );
1931     }
1932 }
1933
1934
1935 CV_IMPL void
1936 cvMerge( const void* srcarr0, const void* srcarr1, const void* srcarr2,
1937          const void* srcarr3, void* dstarr )
1938 {
1939     const void* sptrs[] = { srcarr0, srcarr1, srcarr2, srcarr3 };
1940     cv::Mat dst = cv::cvarrToMat(dstarr);
1941     int i, j, nz = 0;
1942     for( i = 0; i < 4; i++ )
1943         nz += sptrs[i] != 0;
1944     CV_Assert( nz > 0 );
1945     std::vector<cv::Mat> svec(nz);
1946     std::vector<int> pairs(nz*2);
1947
1948     for( i = j = 0; i < 4; i++ )
1949     {
1950         if( sptrs[i] != 0 )
1951         {
1952             svec[j] = cv::cvarrToMat(sptrs[i]);
1953             CV_Assert( svec[j].size == dst.size &&
1954                 svec[j].depth() == dst.depth() &&
1955                 svec[j].channels() == 1 && i < dst.channels() );
1956             pairs[j*2] = j;
1957             pairs[j*2+1] = i;
1958             j++;
1959         }
1960     }
1961
1962     if( nz == dst.channels() )
1963         cv::merge( svec, dst );
1964     else
1965     {
1966         cv::mixChannels( &svec[0], nz, &dst, 1, &pairs[0], nz );
1967     }
1968 }
1969
1970
1971 CV_IMPL void
1972 cvMixChannels( const CvArr** src, int src_count,
1973                CvArr** dst, int dst_count,
1974                const int* from_to, int pair_count )
1975 {
1976     cv::AutoBuffer<cv::Mat> buf(src_count + dst_count);
1977
1978     int i;
1979     for( i = 0; i < src_count; i++ )
1980         buf[i] = cv::cvarrToMat(src[i]);
1981     for( i = 0; i < dst_count; i++ )
1982         buf[i+src_count] = cv::cvarrToMat(dst[i]);
1983     cv::mixChannels(&buf[0], src_count, &buf[src_count], dst_count, from_to, pair_count);
1984 }
1985
1986 CV_IMPL void
1987 cvConvertScaleAbs( const void* srcarr, void* dstarr,
1988                    double scale, double shift )
1989 {
1990     cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
1991     CV_Assert( src.size == dst.size && dst.type() == CV_8UC(src.channels()));
1992     cv::convertScaleAbs( src, dst, scale, shift );
1993 }
1994
1995 CV_IMPL void
1996 cvConvertScale( const void* srcarr, void* dstarr,
1997                 double scale, double shift )
1998 {
1999     cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
2000
2001     CV_Assert( src.size == dst.size && src.channels() == dst.channels() );
2002     src.convertTo(dst, dst.type(), scale, shift);
2003 }
2004
2005 CV_IMPL void cvLUT( const void* srcarr, void* dstarr, const void* lutarr )
2006 {
2007     cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), lut = cv::cvarrToMat(lutarr);
2008
2009     CV_Assert( dst.size() == src.size() && dst.type() == CV_MAKETYPE(lut.depth(), src.channels()) );
2010     cv::LUT( src, lut, dst );
2011 }
2012
2013 CV_IMPL void cvNormalize( const CvArr* srcarr, CvArr* dstarr,
2014                           double a, double b, int norm_type, const CvArr* maskarr )
2015 {
2016     cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), mask;
2017     if( maskarr )
2018         mask = cv::cvarrToMat(maskarr);
2019     CV_Assert( dst.size() == src.size() && src.channels() == dst.channels() );
2020     cv::normalize( src, dst, a, b, norm_type, dst.type(), mask );
2021 }
2022
2023 /* End of file. */