modules/core/src/merge.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html
   4
   5
   6 #include "precomp.hpp"
   7 #include "opencl_kernels_core.hpp"
   8
   9 namespace cv { namespace hal {
  10
  11 #if CV_SIMD
  12 template<typename T, typename VecT> static void
  13 vecmerge_( const T** src, T* dst, int len, int cn )
  14 {
  15     int i;
  16     const T* src0 = src[0];
  17     const T* src1 = src[1];
  18
  19     const int VECSZ = VecT::nlanes;
  20     if( cn == 2 )
  21     {
  22         for( i = 0; i < len; i += VECSZ )
  23         {
  24             i = std::min( len - VECSZ, i );
  25             VecT a = vx_load(src0 + i), b = vx_load(src1 + i);
  26             v_store_interleave(dst + i*cn, a, b);
  27         }
  28     }
  29     else if( cn == 3 )
  30     {
  31         const T* src2 = src[2];
  32         for( i = 0; i < len; i += VECSZ )
  33         {
  34             i = std::min( len - VECSZ, i );
  35             VecT a = vx_load(src0 + i), b = vx_load(src1 + i), c = vx_load(src2 + i);
  36             v_store_interleave(dst + i*cn, a, b, c);
  37         }
  38     }
  39     else
  40     {
  41         CV_Assert( cn == 4 );
  42         const T* src2 = src[2];
  43         const T* src3 = src[3];
  44         for( i = 0; i < len; i += VECSZ )
  45         {
  46             i = std::min( len - VECSZ, i );
  47             VecT a = vx_load(src0 + i), b = vx_load(src1 + i);
  48             VecT c = vx_load(src2 + i), d = vx_load(src3 + i);
  49             v_store_interleave(dst + i*cn, a, b, c, d);
  50         }
  51     }
  52     vx_cleanup();
  53 }
  54 #endif
  55
  56 template<typename T> static void
  57 merge_( const T** src, T* dst, int len, int cn )
  58 {
  59     int k = cn % 4 ? cn % 4 : 4;
  60     int i, j;
  61     if( k == 1 )
  62     {
  63         const T* src0 = src[0];
  64         for( i = j = 0; i < len; i++, j += cn )
  65             dst[j] = src0[i];
  66     }
  67     else if( k == 2 )
  68     {
  69         const T *src0 = src[0], *src1 = src[1];
  70         i = j = 0;
  71         for( ; i < len; i++, j += cn )
  72         {
  73             dst[j] = src0[i];
  74             dst[j+1] = src1[i];
  75         }
  76     }
  77     else if( k == 3 )
  78     {
  79         const T *src0 = src[0], *src1 = src[1], *src2 = src[2];
  80         i = j = 0;
  81         for( ; i < len; i++, j += cn )
  82         {
  83             dst[j] = src0[i];
  84             dst[j+1] = src1[i];
  85             dst[j+2] = src2[i];
  86         }
  87     }
  88     else
  89     {
  90         const T *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
  91         i = j = 0;
  92         for( ; i < len; i++, j += cn )
  93         {
  94             dst[j] = src0[i]; dst[j+1] = src1[i];
  95             dst[j+2] = src2[i]; dst[j+3] = src3[i];
  96         }
  97     }
  98
  99     for( ; k < cn; k += 4 )
 100     {
 101         const T *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
 102         for( i = 0, j = k; i < len; i++, j += cn )
 103         {
 104             dst[j] = src0[i]; dst[j+1] = src1[i];
 105             dst[j+2] = src2[i]; dst[j+3] = src3[i];
 106         }
 107     }
 108 }
 109
 110 void merge8u(const uchar** src, uchar* dst, int len, int cn )
 111 {
 112     CALL_HAL(merge8u, cv_hal_merge8u, src, dst, len, cn)
 113 #if CV_SIMD
 114     if( len >= v_uint8::nlanes && 2 <= cn && cn <= 4 )
 115         vecmerge_<uchar, v_uint8>(src, dst, len, cn);
 116     else
 117 #endif
 118         merge_(src, dst, len, cn);
 119 }
 120
 121 void merge16u(const ushort** src, ushort* dst, int len, int cn )
 122 {
 123     CALL_HAL(merge16u, cv_hal_merge16u, src, dst, len, cn)
 124 #if CV_SIMD
 125     if( len >= v_uint16::nlanes && 2 <= cn && cn <= 4 )
 126         vecmerge_<ushort, v_uint16>(src, dst, len, cn);
 127     else
 128 #endif
 129         merge_(src, dst, len, cn);
 130 }
 131
 132 void merge32s(const int** src, int* dst, int len, int cn )
 133 {
 134     CALL_HAL(merge32s, cv_hal_merge32s, src, dst, len, cn)
 135 #if CV_SIMD
 136     if( len >= v_int32::nlanes && 2 <= cn && cn <= 4 )
 137         vecmerge_<int, v_int32>(src, dst, len, cn);
 138     else
 139 #endif
 140         merge_(src, dst, len, cn);
 141 }
 142
 143 void merge64s(const int64** src, int64* dst, int len, int cn )
 144 {
 145     CALL_HAL(merge64s, cv_hal_merge64s, src, dst, len, cn)
 146 #if CV_SIMD
 147     if( len >= v_int64::nlanes && 2 <= cn && cn <= 4 )
 148         vecmerge_<int64, v_int64>(src, dst, len, cn);
 149     else
 150 #endif
 151         merge_(src, dst, len, cn);
 152 }
 153
 154 }} // cv::hal::
 155
 156
 157 typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
 158
 159 static MergeFunc getMergeFunc(int depth)
 160 {
 161     static MergeFunc mergeTab[] =
 162     {
 163         (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge8u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u), (MergeFunc)GET_OPTIMIZED(cv::hal::merge16u),
 164         (MergeFunc)GET_OPTIMIZED(cv::hal::merge32s), (MergeFunc)GET_OPTIMIZED(cv::hal::merge32s), (MergeFunc)GET_OPTIMIZED(cv::hal::merge64s), 0
 165     };
 166
 167     return mergeTab[depth];
 168 }
 169
 170 #ifdef HAVE_IPP
 171
 172 namespace cv {
 173 static bool ipp_merge(const Mat* mv, Mat& dst, int channels)
 174 {
 175 #ifdef HAVE_IPP_IW
 176     CV_INSTRUMENT_REGION_IPP()
 177
 178     if(channels != 3 && channels != 4)
 179         return false;
 180
 181     if(mv[0].dims <= 2)
 182     {
 183         IppiSize    size       = ippiSize(mv[0].size());
 184         const void *srcPtrs[4] = {NULL};
 185         size_t      srcStep    = mv[0].step;
 186         for(int i = 0; i < channels; i++)
 187         {
 188             srcPtrs[i] = mv[i].ptr();
 189             if(srcStep != mv[i].step)
 190                 return false;
 191         }
 192
 193         return CV_INSTRUMENT_FUN_IPP(llwiCopyMerge, srcPtrs, (int)srcStep, dst.ptr(), (int)dst.step, size, (int)mv[0].elemSize1(), channels, 0) >= 0;
 194     }
 195     else
 196     {
 197         const Mat *arrays[5] = {NULL};
 198         uchar     *ptrs[5]   = {NULL};
 199         arrays[0] = &dst;
 200
 201         for(int i = 1; i < channels; i++)
 202         {
 203             arrays[i] = &mv[i-1];
 204         }
 205
 206         NAryMatIterator it(arrays, ptrs);
 207         IppiSize size = { (int)it.size, 1 };
 208
 209         for( size_t i = 0; i < it.nplanes; i++, ++it )
 210         {
 211             if(CV_INSTRUMENT_FUN_IPP(llwiCopyMerge, (const void**)&ptrs[1], 0, ptrs[0], 0, size, (int)mv[0].elemSize1(), channels, 0) < 0)
 212                 return false;
 213         }
 214         return true;
 215     }
 216 #else
 217     CV_UNUSED(dst); CV_UNUSED(mv); CV_UNUSED(channels);
 218     return false;
 219 #endif
 220 }
 221 }
 222 #endif
 223
 224 void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
 225 {
 226     CV_INSTRUMENT_REGION()
 227
 228     CV_Assert( mv && n > 0 );
 229
 230     int depth = mv[0].depth();
 231     bool allch1 = true;
 232     int k, cn = 0;
 233     size_t i;
 234
 235     for( i = 0; i < n; i++ )
 236     {
 237         CV_Assert(mv[i].size == mv[0].size && mv[i].depth() == depth);
 238         allch1 = allch1 && mv[i].channels() == 1;
 239         cn += mv[i].channels();
 240     }
 241
 242     CV_Assert( 0 < cn && cn <= CV_CN_MAX );
 243     _dst.create(mv[0].dims, mv[0].size, CV_MAKETYPE(depth, cn));
 244     Mat dst = _dst.getMat();
 245
 246     if( n == 1 )
 247     {
 248         mv[0].copyTo(dst);
 249         return;
 250     }
 251
 252     CV_IPP_RUN_FAST(ipp_merge(mv, dst, (int)n));
 253
 254     if( !allch1 )
 255     {
 256         AutoBuffer<int> pairs(cn*2);
 257         int j, ni=0;
 258
 259         for( i = 0, j = 0; i < n; i++, j += ni )
 260         {
 261             ni = mv[i].channels();
 262             for( k = 0; k < ni; k++ )
 263             {
 264                 pairs[(j+k)*2] = j + k;
 265                 pairs[(j+k)*2+1] = j + k;
 266             }
 267         }
 268         mixChannels( mv, n, &dst, 1, &pairs[0], cn );
 269         return;
 270     }
 271
 272     MergeFunc func = getMergeFunc(depth);
 273     CV_Assert( func != 0 );
 274
 275     size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
 276     size_t blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
 277     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
 278     const Mat** arrays = (const Mat**)_buf.data();
 279     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
 280
 281     arrays[0] = &dst;
 282     for( k = 0; k < cn; k++ )
 283         arrays[k+1] = &mv[k];
 284
 285     NAryMatIterator it(arrays, ptrs, cn+1);
 286     size_t total = (int)it.size;
 287     size_t blocksize = std::min((size_t)CV_SPLIT_MERGE_MAX_BLOCK_SIZE(cn), cn <= 4 ? total : std::min(total, blocksize0));
 288
 289     for( i = 0; i < it.nplanes; i++, ++it )
 290     {
 291         for( size_t j = 0; j < total; j += blocksize )
 292         {
 293             size_t bsz = std::min(total - j, blocksize);
 294             func( (const uchar**)&ptrs[1], ptrs[0], (int)bsz, cn );
 295
 296             if( j + blocksize < total )
 297             {
 298                 ptrs[0] += bsz*esz;
 299                 for( int t = 0; t < cn; t++ )
 300                     ptrs[t+1] += bsz*esz1;
 301             }
 302         }
 303     }
 304 }
 305
 306 #ifdef HAVE_OPENCL
 307
 308 namespace cv {
 309
 310 static bool ocl_merge( InputArrayOfArrays _mv, OutputArray _dst )
 311 {
 312     std::vector<UMat> src, ksrc;
 313     _mv.getUMatVector(src);
 314     CV_Assert(!src.empty());
 315
 316     int type = src[0].type(), depth = CV_MAT_DEPTH(type),
 317             rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 318     Size size = src[0].size();
 319
 320     for (size_t i = 0, srcsize = src.size(); i < srcsize; ++i)
 321     {
 322         int itype = src[i].type(), icn = CV_MAT_CN(itype), idepth = CV_MAT_DEPTH(itype),
 323                 esz1 = CV_ELEM_SIZE1(idepth);
 324         if (src[i].dims > 2)
 325             return false;
 326
 327         CV_Assert(size == src[i].size() && depth == idepth);
 328
 329         for (int cn = 0; cn < icn; ++cn)
 330         {
 331             UMat tsrc = src[i];
 332             tsrc.offset += cn * esz1;
 333             ksrc.push_back(tsrc);
 334         }
 335     }
 336     int dcn = (int)ksrc.size();
 337
 338     String srcargs, processelem, cndecl, indexdecl;
 339     for (int i = 0; i < dcn; ++i)
 340     {
 341         srcargs += format("DECLARE_SRC_PARAM(%d)", i);
 342         processelem += format("PROCESS_ELEM(%d)", i);
 343         indexdecl += format("DECLARE_INDEX(%d)", i);
 344         cndecl += format(" -D scn%d=%d", i, ksrc[i].channels());
 345     }
 346
 347     ocl::Kernel k("merge", ocl::core::split_merge_oclsrc,
 348                   format("-D OP_MERGE -D cn=%d -D T=%s -D DECLARE_SRC_PARAMS_N=%s"
 349                          " -D DECLARE_INDEX_N=%s -D PROCESS_ELEMS_N=%s%s",
 350                          dcn, ocl::memopTypeToStr(depth), srcargs.c_str(),
 351                          indexdecl.c_str(), processelem.c_str(), cndecl.c_str()));
 352     if (k.empty())
 353         return false;
 354
 355     _dst.create(size, CV_MAKE_TYPE(depth, dcn));
 356     UMat dst = _dst.getUMat();
 357
 358     int argidx = 0;
 359     for (int i = 0; i < dcn; ++i)
 360         argidx = k.set(argidx, ocl::KernelArg::ReadOnlyNoSize(ksrc[i]));
 361     argidx = k.set(argidx, ocl::KernelArg::WriteOnly(dst));
 362     k.set(argidx, rowsPerWI);
 363
 364     size_t globalsize[2] = { (size_t)dst.cols, ((size_t)dst.rows + rowsPerWI - 1) / rowsPerWI };
 365     return k.run(2, globalsize, NULL, false);
 366 }
 367
 368 }
 369
 370 #endif
 371
 372 void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
 373 {
 374     CV_INSTRUMENT_REGION()
 375
 376     CV_OCL_RUN(_mv.isUMatVector() && _dst.isUMat(),
 377                ocl_merge(_mv, _dst))
 378
 379     std::vector<Mat> mv;
 380     _mv.getMatVector(mv);
 381     merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
 382 }