X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=modules%2Fimgproc%2Fsrc%2Fsmooth.cpp;h=f4077521e15703da7ec264bdd81273a7c07fe03e;hb=4560909a5e5cb284cdfd5619cdf4cf3622410388;hp=8ff072eb2be298b21e306f41bb963e1e2d4750d6;hpb=c89ae6e5378e2a502709728d6711931f50ee2318;p=platform%2Fupstream%2Fopencv.git diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index 8ff072e..f407752 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -42,6 +42,9 @@ //M*/ #include "precomp.hpp" + +#include + #include "opencv2/core/hal/intrin.hpp" #include "opencl_kernels_imgproc.hpp" @@ -49,6 +52,7 @@ #include "filter.hpp" +#include "fixedpoint.inl.hpp" /* * This file includes the code, contributed by Simon Perreault * (the function icvMedianBlur_8u_O1) @@ -84,7 +88,7 @@ struct RowSum : anchor = _anchor; } - virtual void operator()(const uchar* src, uchar* dst, int width, int cn) + virtual void operator()(const uchar* src, uchar* dst, int width, int cn) CV_OVERRIDE { const T* S = (const T*)src; ST* D = (ST*)dst; @@ -195,9 +199,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int i; ST* SUM; @@ -293,9 +297,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int* SUM; bool haveScale = scale != 1; @@ -440,9 +444,9 @@ public BaseColumnFilter } } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { const int ds = divScale; const int dd = divDelta; @@ -569,9 +573,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int i; int* SUM; @@ -697,9 +701,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int* SUM; bool haveScale = scale != 1; @@ -822,9 +826,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int* SUM; bool haveScale = scale != 1; @@ -941,9 +945,9 @@ struct ColumnSum : sumCount = 0; } - virtual void reset() { sumCount = 0; } + virtual void reset() CV_OVERRIDE { sumCount = 0; } - virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) + virtual void operator()(const uchar** src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE { int* SUM; bool haveScale = scale != 1; @@ -1328,8 +1332,6 @@ cv::Ptr cv::getRowSumFilter(int srcType, int sumType, int ksi CV_Error_( CV_StsNotImplemented, ("Unsupported combination of source format (=%d), and buffer format (=%d)", srcType, sumType)); - - return Ptr(); } @@ -1370,8 +1372,6 @@ cv::Ptr cv::getColumnSumFilter(int sumType, int dstType, i CV_Error_( CV_StsNotImplemented, ("Unsupported combination of sum format (=%d), and destination format (=%d)", sumType, dstType)); - - return Ptr(); } @@ -1454,7 +1454,7 @@ namespace cv ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now + //since OpenVX standard says nothing about thread-safety for now ivx::border_t prevBorder = ctx.immediateBorder(); ctx.setImmediateBorder(border, (vx_uint8)(0)); ivx::IVX_CHECK_STATUS(vxuBox3x3(ctx, ia, ib)); @@ -1602,7 +1602,7 @@ struct SqrRowSum : anchor = _anchor; } - virtual void operator()(const uchar* src, uchar* dst, int width, int cn) + virtual void operator()(const uchar* src, uchar* dst, int width, int cn) CV_OVERRIDE { const T* S = (const T*)src; ST* D = (ST*)dst; @@ -1652,8 +1652,6 @@ static Ptr getSqrRowSumFilter(int srcType, int sumType, int ksize CV_Error_( CV_StsNotImplemented, ("Unsupported combination of source format (=%d), and buffer format (=%d)", srcType, sumType)); - - return Ptr(); } } @@ -1711,6 +1709,7 @@ void cv::sqrBoxFilter( InputArray _src, OutputArray _dst, int ddepth, cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype ) { + CV_Assert(n > 0); const int SMALL_GAUSSIAN_SIZE = 7; static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] = { @@ -1749,6 +1748,7 @@ cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype ) } } + CV_DbgAssert(fabs(sum) > 0); sum = 1./sum; for( i = 0; i < n; i++ ) { @@ -1763,237 +1763,2278 @@ cv::Mat cv::getGaussianKernel( int n, double sigma, int ktype ) namespace cv { -static void createGaussianKernels( Mat & kx, Mat & ky, int type, Size & ksize, - double sigma1, double sigma2 ) +template +static std::vector getFixedpointGaussianKernel( int n, double sigma ) { - int depth = CV_MAT_DEPTH(type); - if( sigma2 <= 0 ) - sigma2 = sigma1; + if (sigma <= 0) + { + if(n == 1) + return std::vector(1, softdouble(1.0)); + else if(n == 3) + { + T v3[] = { softdouble(0.25), softdouble(0.5), softdouble(0.25) }; + return std::vector(v3, v3 + 3); + } + else if(n == 5) + { + T v5[] = { softdouble(0.0625), softdouble(0.25), softdouble(0.375), softdouble(0.25), softdouble(0.0625) }; + return std::vector(v5, v5 + 5); + } + else if(n == 7) + { + T v7[] = { softdouble(0.03125), softdouble(0.109375), softdouble(0.21875), softdouble(0.28125), softdouble(0.21875), softdouble(0.109375), softdouble(0.03125) }; + return std::vector(v7, v7 + 7); + } + } - // automatic detection of kernel size from sigma - if( ksize.width <= 0 && sigma1 > 0 ) - ksize.width = cvRound(sigma1*(depth == CV_8U ? 3 : 4)*2 + 1)|1; - if( ksize.height <= 0 && sigma2 > 0 ) - ksize.height = cvRound(sigma2*(depth == CV_8U ? 3 : 4)*2 + 1)|1; - CV_Assert( ksize.width > 0 && ksize.width % 2 == 1 && - ksize.height > 0 && ksize.height % 2 == 1 ); + softdouble sigmaX = sigma > 0 ? softdouble(sigma) : mulAdd(softdouble(n),softdouble(0.15),softdouble(0.35));// softdouble(((n-1)*0.5 - 1)*0.3 + 0.8) + softdouble scale2X = softdouble(-0.5*0.25)/(sigmaX*sigmaX); + std::vector values(n); + softdouble sum(0.); + for(int i = 0, x = 1 - n; i < n; i++, x+=2 ) + { + // x = i - (n - 1)*0.5 + // t = std::exp(scale2X*x*x) + values[i] = exp(softdouble(x*x)*scale2X); + sum += values[i]; + } + sum = softdouble::one()/sum; - sigma1 = std::max( sigma1, 0. ); - sigma2 = std::max( sigma2, 0. ); + std::vector kernel(n); + for(int i = 0; i < n; i++ ) + { + kernel[i] = values[i] * sum; + } - kx = getGaussianKernel( ksize.width, sigma1, std::max(depth, CV_32F) ); - if( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL_EPSILON ) - ky = kx; - else - ky = getGaussianKernel( ksize.height, sigma2, std::max(depth, CV_32F) ); -} + return kernel; +}; +template +void hlineSmooth1N(const ET* src, int cn, const FT* m, int, FT* dst, int len, int) +{ + for (int i = 0; i < len*cn; i++, src++, dst++) + *dst = (*m) * (*src); } - -cv::Ptr cv::createGaussianFilter( int type, Size ksize, - double sigma1, double sigma2, - int borderType ) +template <> +void hlineSmooth1N(const uint8_t* src, int cn, const ufixedpoint16* m, int, ufixedpoint16* dst, int len, int) { - Mat kx, ky; - createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2); - - return createSeparableLinearFilter( type, type, kx, ky, Point(-1,-1), 0, borderType ); + int lencn = len*cn; + v_uint16x8 v_mul = v_setall_u16(*((uint16_t*)m)); + int i = 0; + for (; i <= lencn - 16; i += 16) + { + v_uint8x16 v_src = v_load(src + i); + v_uint16x8 v_tmp0, v_tmp1; + v_expand(v_src, v_tmp0, v_tmp1); + v_store((uint16_t*)dst + i, v_mul*v_tmp0); + v_store((uint16_t*)dst + i + 8, v_mul*v_tmp1); + } + if (i <= lencn - 8) + { + v_uint16x8 v_src = v_load_expand(src + i); + v_store((uint16_t*)dst + i, v_mul*v_src); + i += 8; + } + for (; i < lencn; i++) + dst[i] = m[0] * src[i]; } - -namespace cv +template +void hlineSmooth1N1(const ET* src, int cn, const FT*, int, FT* dst, int len, int) { -#ifdef HAVE_OPENCL - -static bool ocl_GaussianBlur_8UC1(InputArray _src, OutputArray _dst, Size ksize, int ddepth, - InputArray _kernelX, InputArray _kernelY, int borderType) + for (int i = 0; i < len*cn; i++, src++, dst++) + *dst = *src; +} +template <> +void hlineSmooth1N1(const uint8_t* src, int cn, const ufixedpoint16*, int, ufixedpoint16* dst, int len, int) { - const ocl::Device & dev = ocl::Device::getDefault(); - int type = _src.type(), sdepth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); - - if ( !(dev.isIntel() && (type == CV_8UC1) && - (_src.offset() == 0) && (_src.step() % 4 == 0) && - ((ksize.width == 5 && (_src.cols() % 4 == 0)) || - (ksize.width == 3 && (_src.cols() % 16 == 0) && (_src.rows() % 2 == 0)))) ) - return false; - - Mat kernelX = _kernelX.getMat().reshape(1, 1); - if (kernelX.cols % 2 != 1) - return false; - Mat kernelY = _kernelY.getMat().reshape(1, 1); - if (kernelY.cols % 2 != 1) - return false; - - if (ddepth < 0) - ddepth = sdepth; - - Size size = _src.size(); - size_t globalsize[2] = { 0, 0 }; - size_t localsize[2] = { 0, 0 }; - - if (ksize.width == 3) + int lencn = len*cn; + int i = 0; + for (; i <= lencn - 16; i += 16) { - globalsize[0] = size.width / 16; - globalsize[1] = size.height / 2; + v_uint8x16 v_src = v_load(src + i); + v_uint16x8 v_tmp0, v_tmp1; + v_expand(v_src, v_tmp0, v_tmp1); + v_store((uint16_t*)dst + i, v_shl<8>(v_tmp0)); + v_store((uint16_t*)dst + i + 8, v_shl<8>(v_tmp1)); } - else if (ksize.width == 5) + if (i <= lencn - 8) { - globalsize[0] = size.width / 4; - globalsize[1] = size.height / 1; + v_uint16x8 v_src = v_load_expand(src + i); + v_store((uint16_t*)dst + i, v_shl<8>(v_src)); + i += 8; } - - const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", 0, "BORDER_REFLECT_101" }; - char build_opts[1024]; - sprintf(build_opts, "-D %s %s%s", borderMap[borderType & ~BORDER_ISOLATED], - ocl::kernelToStr(kernelX, CV_32F, "KERNEL_MATRIX_X").c_str(), - ocl::kernelToStr(kernelY, CV_32F, "KERNEL_MATRIX_Y").c_str()); - - ocl::Kernel kernel; - - if (ksize.width == 3) - kernel.create("gaussianBlur3x3_8UC1_cols16_rows2", cv::ocl::imgproc::gaussianBlur3x3_oclsrc, build_opts); - else if (ksize.width == 5) - kernel.create("gaussianBlur5x5_8UC1_cols4", cv::ocl::imgproc::gaussianBlur5x5_oclsrc, build_opts); - - if (kernel.empty()) - return false; - - UMat src = _src.getUMat(); - _dst.create(size, CV_MAKETYPE(ddepth, cn)); - if (!(_dst.offset() == 0 && _dst.step() % 4 == 0)) - return false; - UMat dst = _dst.getUMat(); - - int idxArg = kernel.set(0, ocl::KernelArg::PtrReadOnly(src)); - idxArg = kernel.set(idxArg, (int)src.step); - idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst)); - idxArg = kernel.set(idxArg, (int)dst.step); - idxArg = kernel.set(idxArg, (int)dst.rows); - idxArg = kernel.set(idxArg, (int)dst.cols); - - return kernel.run(2, globalsize, (localsize[0] == 0) ? NULL : localsize, false); + for (; i < lencn; i++) + dst[i] = src[i]; } +template +void hlineSmooth3N(const ET* src, int cn, const FT* m, int, FT* dst, int len, int borderType) +{ + if (len == 1) + { + FT msum = borderType != BORDER_CONSTANT ? m[0] + m[1] + m[2] : m[1]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else + { + // Point that fall left from border + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[2] * src[cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[0] * src[src_idx*cn + k]; + } -#endif - -#ifdef HAVE_OPENVX + src += cn; dst += cn; + for (int i = cn; i < (len - 1)*cn; i++, src++, dst++) + *dst = m[0] * src[-cn] + m[1] * src[0] + m[2] * src[cn]; -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } + // Point that fall right from border + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k - cn] + m[1] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[2] * src[src_idx + k]; + } + } } -static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize, - double sigma1, double sigma2, int borderType) +template <> +void hlineSmooth3N(const uint8_t* src, int cn, const ufixedpoint16* m, int, ufixedpoint16* dst, int len, int borderType) { - if (sigma2 <= 0) - sigma2 = sigma1; - // automatic detection of kernel size from sigma - if (ksize.width <= 0 && sigma1 > 0) - ksize.width = cvRound(sigma1*6 + 1) | 1; - if (ksize.height <= 0 && sigma2 > 0) - ksize.height = cvRound(sigma2*6 + 1) | 1; - - if (_src.type() != CV_8UC1 || - _src.cols() < 3 || _src.rows() < 3 || - ksize.width != 3 || ksize.height != 3) - return false; - - sigma1 = std::max(sigma1, 0.); - sigma2 = std::max(sigma2, 0.); - - if (!(sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) || !(sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON) || - ovx::skipSmallImages(_src.cols(), _src.rows())) - return false; - - Mat src = _src.getMat(); - Mat dst = _dst.getMat(); - - if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix()) - return false; //Process isolated borders only - vx_enum border; - switch (borderType & ~BORDER_ISOLATED) + if (len == 1) { - case BORDER_CONSTANT: - border = VX_BORDER_CONSTANT; - break; - case BORDER_REPLICATE: - border = VX_BORDER_REPLICATE; - break; - default: - return false; + ufixedpoint16 msum = borderType != BORDER_CONSTANT ? m[0] + m[1] + m[2] : m[1]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; } - - try + else { - ivx::Context ctx = ovx::getOpenVXContext(); - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); + // Point that fall left from border + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[2] * src[cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[0] * src[src_idx*cn + k]; + } - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); + src += cn; dst += cn; + int i = cn, lencn = (len - 1)*cn; + v_uint16x8 v_mul0 = v_setall_u16(*((uint16_t*)m)); + v_uint16x8 v_mul1 = v_setall_u16(*((uint16_t*)(m + 1))); + v_uint16x8 v_mul2 = v_setall_u16(*((uint16_t*)(m + 2))); + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21; + v_expand(v_load(src - cn), v_src00, v_src01); + v_expand(v_load(src), v_src10, v_src11); + v_expand(v_load(src + cn), v_src20, v_src21); + v_store((uint16_t*)dst, v_src00 * v_mul0 + v_src10 * v_mul1 + v_src20 * v_mul2); + v_store((uint16_t*)dst + 8, v_src01 * v_mul0 + v_src11 * v_mul1 + v_src21 * v_mul2); + } + for (; i < lencn; i++, src++, dst++) + *dst = m[0] * src[-cn] + m[1] * src[0] + m[2] * src[cn]; - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(border, (vx_uint8)(0)); - ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib)); - ctx.setImmediateBorder(prevBorder); + // Point that fall right from border + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k - cn] + m[1] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[2] * src[src_idx + k]; + } } - catch (ivx::RuntimeError & e) +} +template +void hlineSmooth3N121(const ET* src, int cn, const FT*, int, FT* dst, int len, int borderType) +{ + if (len == 1) { - VX_DbgThrow(e.what()); + if(borderType != BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + dst[k] = FT(src[k]); + else + for (int k = 0; k < cn; k++) + dst[k] = FT(src[k])>>1; } - catch (ivx::WrapperError & e) + else { - VX_DbgThrow(e.what()); - } - return true; -} + // Point that fall left from border + for (int k = 0; k < cn; k++) + dst[k] = (FT(src[k])>>1) + (FT(src[cn + k])>>2); + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + (FT(src[src_idx*cn + k])>>2); + } -#endif + src += cn; dst += cn; + for (int i = cn; i < (len - 1)*cn; i++, src++, dst++) + *dst = (FT(src[-cn])>>2) + (FT(src[cn])>>2) + (FT(src[0])>>1); -#ifdef HAVE_IPP -#if IPP_VERSION_X100 == 201702 // IW 2017u2 has bug which doesn't allow use of partial inMem with tiling -#define IPP_GAUSSIANBLUR_PARALLEL 0 -#else -#define IPP_GAUSSIANBLUR_PARALLEL 1 -#endif + // Point that fall right from border + for (int k = 0; k < cn; k++) + dst[k] = (FT(src[k - cn])>>2) + (FT(src[k])>>1); + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + (FT(src[src_idx + k])>>2); + } + } +} +template <> +void hlineSmooth3N121(const uint8_t* src, int cn, const ufixedpoint16*, int, ufixedpoint16* dst, int len, int borderType) +{ + if (len == 1) + { + if (borderType != BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + dst[k] = ufixedpoint16(src[k]); + else + for (int k = 0; k < cn; k++) + dst[k] = ufixedpoint16(src[k]) >> 1; + } + else + { + // Point that fall left from border + for (int k = 0; k < cn; k++) + dst[k] = (ufixedpoint16(src[k])>>1) + (ufixedpoint16(src[cn + k])>>2); + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + (ufixedpoint16(src[src_idx*cn + k])>>2); + } -#ifdef HAVE_IPP_IW + src += cn; dst += cn; + int i = cn, lencn = (len - 1)*cn; + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21; + v_expand(v_load(src - cn), v_src00, v_src01); + v_expand(v_load(src), v_src10, v_src11); + v_expand(v_load(src + cn), v_src20, v_src21); + v_store((uint16_t*)dst, (v_src00 + v_src20 + (v_src10 << 1)) << 6); + v_store((uint16_t*)dst + 8, (v_src01 + v_src21 + (v_src11 << 1)) << 6); + } + for (; i < lencn; i++, src++, dst++) + *((uint16_t*)dst) = (uint16_t(src[-cn]) + uint16_t(src[cn]) + (uint16_t(src[0]) << 1)) << 6; -class ipp_gaussianBlurParallel: public ParallelLoopBody -{ -public: - ipp_gaussianBlurParallel(::ipp::IwiImage &src, ::ipp::IwiImage &dst, int kernelSize, float sigma, ::ipp::IwiBorderType &border, bool *pOk): - m_src(src), m_dst(dst), m_kernelSize(kernelSize), m_sigma(sigma), m_border(border), m_pOk(pOk) { - *m_pOk = true; + // Point that fall right from border + for (int k = 0; k < cn; k++) + dst[k] = (ufixedpoint16(src[k - cn])>>2) + (ufixedpoint16(src[k])>>1); + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + (ufixedpoint16(src[src_idx + k])>>2); + } } - ~ipp_gaussianBlurParallel() +} +template +void hlineSmooth3Naba(const ET* src, int cn, const FT* m, int, FT* dst, int len, int borderType) +{ + if (len == 1) { + FT msum = borderType != BORDER_CONSTANT ? (m[0]<<1) + m[1] : m[1]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; } - - virtual void operator() (const Range& range) const + else { - CV_INSTRUMENT_REGION_IPP() + // Point that fall left from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[0] * src[cn + k] + m[0] * src[src_idx*cn + k]; + } + else + { + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[0] * src[cn + k]; + } - if(!*m_pOk) - return; + src += cn; dst += cn; + for (int i = cn; i < (len - 1)*cn; i++, src++, dst++) + *dst = m[1] * src[0] + m[0] * src[-cn] + m[0] * src[cn]; - try + // Point that fall right from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped { - ::ipp::IwiTile tile = ::ipp::IwiRoi(0, range.start, m_dst.m_size.width, range.end - range.start); - CV_INSTRUMENT_FUN_IPP(::ipp::iwiFilterGaussian, m_src, m_dst, m_kernelSize, m_sigma, ::ipp::IwDefault(), m_border, tile); + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[0] * src[k - cn] + m[0] * src[src_idx + k]; } - catch(::ipp::IwException e) + else { - *m_pOk = false; - return; + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k - cn] + m[1] * src[k]; + } + } +} +template <> +void hlineSmooth3Naba(const uint8_t* src, int cn, const ufixedpoint16* m, int, ufixedpoint16* dst, int len, int borderType) +{ + if (len == 1) + { + ufixedpoint16 msum = borderType != BORDER_CONSTANT ? (m[0]<<1) + m[1] : m[1]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else + { + // Point that fall left from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = borderInterpolate(-1, len, borderType); + for (int k = 0; k < cn; k++) + ((uint16_t*)dst)[k] = ((uint16_t*)m)[1] * src[k] + ((uint16_t*)m)[0] * ((uint16_t)(src[cn + k]) + (uint16_t)(src[src_idx*cn + k])); + } + else + { + for (int k = 0; k < cn; k++) + dst[k] = m[1] * src[k] + m[0] * src[cn + k]; + } + + src += cn; dst += cn; + int i = cn, lencn = (len - 1)*cn; + v_uint16x8 v_mul0 = v_setall_u16(*((uint16_t*)m)); + v_uint16x8 v_mul1 = v_setall_u16(*((uint16_t*)m+1)); + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21; + v_expand(v_load(src - cn), v_src00, v_src01); + v_expand(v_load(src), v_src10, v_src11); + v_expand(v_load(src + cn), v_src20, v_src21); + v_store((uint16_t*)dst, (v_src00 + v_src20) * v_mul0 + v_src10 * v_mul1); + v_store((uint16_t*)dst + 8, (v_src01 + v_src21) * v_mul0 + v_src11 * v_mul1); + } + for (; i < lencn; i++, src++, dst++) + *((uint16_t*)dst) = ((uint16_t*)m)[1] * src[0] + ((uint16_t*)m)[0] * ((uint16_t)(src[-cn]) + (uint16_t)(src[cn])); + + // Point that fall right from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int src_idx = (borderInterpolate(len, len, borderType) - (len - 1))*cn; + for (int k = 0; k < cn; k++) + ((uint16_t*)dst)[k] = ((uint16_t*)m)[1] * src[k] + ((uint16_t*)m)[0] * ((uint16_t)(src[k - cn]) + (uint16_t)(src[src_idx + k])); + } + else + { + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k - cn] + m[1] * src[k]; + } + } +} +template +void hlineSmooth5N(const ET* src, int cn, const FT* m, int, FT* dst, int len, int borderType) +{ + if (len == 1) + { + FT msum = borderType != BORDER_CONSTANT ? m[0] + m[1] + m[2] + m[3] + m[4] : m[2]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k ] = m[2] * src[k] + m[3] * src[k+cn]; + dst[k+cn] = m[1] * src[k] + m[2] * src[k+cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k ] = m[1] * src[k + idxm1] + m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + idxp1] + m[0] * src[k + idxm2]; + dst[k + cn] = m[0] * src[k + idxm1] + m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + idxp1] + m[4] * src[k + idxp2]; + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k ] = m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + 2*cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + 2*cn]; + dst[k + 2*cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2*cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k ] = m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + 2*cn] + m[0] * src[k + idxm2] + m[1] * src[k + idxm1]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + 2*cn] + m[0] * src[k + idxm1] + m[4] * src[k + idxp1]; + dst[k + 2*cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2*cn] + m[3] * src[k + idxp1] + m[4] * src[k + idxp2]; + } + } + } + else + { + // Points that fall left from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[3] * src[cn + k] + m[4] * src[2*cn + k]; + dst[k + cn] = m[1] * src[k] + m[2] * src[cn + k] + m[3] * src[2*cn + k] + m[4] * src[3*cn + k]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[0] * src[idxm2 + k] + m[1] * src[idxm1 + k]; + dst[k + cn] = dst[k + cn] + m[0] * src[idxm1 + k]; + } + } + + src += 2*cn; dst += 2*cn; + for (int i = 2*cn; i < (len - 2)*cn; i++, src++, dst++) + *dst = m[0] * src[-2*cn] + m[1] * src[-cn] + m[2] * src[0] + m[3] * src[cn] + m[4] * src[2*cn]; + + // Points that fall right from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[0] * src[k - 2*cn] + m[1] * src[k - cn] + m[2] * src[k] + m[3] * src[k + cn]; + dst[k + cn] = m[0] * src[k - cn] + m[1] * src[k] + m[2] * src[k + cn]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len+1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[4] * src[idxp1 + k]; + dst[k + cn] = dst[k + cn] + m[3] * src[idxp1 + k] + m[4] * src[idxp2 + k]; + } + } + } +} +template <> +void hlineSmooth5N(const uint8_t* src, int cn, const ufixedpoint16* m, int, ufixedpoint16* dst, int len, int borderType) +{ + if (len == 1) + { + ufixedpoint16 msum = borderType != BORDER_CONSTANT ? m[0] + m[1] + m[2] + m[3] + m[4] : m[2]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[3] * src[k + cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = m[1] * src[k + idxm1] + m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + idxp1] + m[0] * src[k + idxm2]; + dst[k + cn] = m[0] * src[k + idxm1] + m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + idxp1] + m[4] * src[k + idxp2]; + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + 2 * cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + 2 * cn]; + dst[k + 2 * cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2 * cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[3] * src[k + cn] + m[4] * src[k + 2 * cn] + m[0] * src[k + idxm2] + m[1] * src[k + idxm1]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[3] * src[k + 2 * cn] + m[0] * src[k + idxm1] + m[4] * src[k + idxp1]; + dst[k + 2 * cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2 * cn] + m[3] * src[k + idxp1] + m[4] * src[k + idxp2]; + } + } + } + else + { + // Points that fall left from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[3] * src[cn + k] + m[4] * src[2 * cn + k]; + dst[k + cn] = m[1] * src[k] + m[2] * src[cn + k] + m[3] * src[2 * cn + k] + m[4] * src[3 * cn + k]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[0] * src[idxm2 + k] + m[1] * src[idxm1 + k]; + dst[k + cn] = dst[k + cn] + m[0] * src[idxm1 + k]; + } + } + + src += 2 * cn; dst += 2 * cn; + int i = 2*cn, lencn = (len - 2)*cn; + v_uint16x8 v_mul0 = v_setall_u16(*((uint16_t*)m)); + v_uint16x8 v_mul1 = v_setall_u16(*((uint16_t*)(m + 1))); + v_uint16x8 v_mul2 = v_setall_u16(*((uint16_t*)(m + 2))); + v_uint16x8 v_mul3 = v_setall_u16(*((uint16_t*)(m + 3))); + v_uint16x8 v_mul4 = v_setall_u16(*((uint16_t*)(m + 4))); + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21, v_src30, v_src31, v_src40, v_src41; + v_expand(v_load(src - 2*cn), v_src00, v_src01); + v_expand(v_load(src - cn), v_src10, v_src11); + v_expand(v_load(src), v_src20, v_src21); + v_expand(v_load(src + cn), v_src30, v_src31); + v_expand(v_load(src + 2*cn), v_src40, v_src41); + v_store((uint16_t*)dst, v_src00 * v_mul0 + v_src10 * v_mul1 + v_src20 * v_mul2 + v_src30 * v_mul3 + v_src40 * v_mul4); + v_store((uint16_t*)dst + 8, v_src01 * v_mul0 + v_src11 * v_mul1 + v_src21 * v_mul2 + v_src31 * v_mul3 + v_src41 * v_mul4); + } + for (; i < lencn; i++, src++, dst++) + *dst = m[0] * src[-2*cn] + m[1] * src[-cn] + m[2] * src[0] + m[3] * src[cn] + m[4] * src[2*cn]; + + // Points that fall right from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[0] * src[k - 2 * cn] + m[1] * src[k - cn] + m[2] * src[k] + m[3] * src[k + cn]; + dst[k + cn] = m[0] * src[k - cn] + m[1] * src[k] + m[2] * src[k + cn]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len + 1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[4] * src[idxp1 + k]; + dst[k + cn] = dst[k + cn] + m[3] * src[idxp1 + k] + m[4] * src[idxp2 + k]; + } + } + } +} +template +void hlineSmooth5N14641(const ET* src, int cn, const FT*, int, FT* dst, int len, int borderType) +{ + if (len == 1) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + dst[k] = (FT(src[k])>>3)*(uint8_t)3; + else + for (int k = 0; k < cn; k++) + dst[k] = src[k]; + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[k + cn])>>2); + dst[k + cn] = (FT(src[k]) >> 2) + (FT(src[k + cn])>>4)*(uint8_t)6; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[k + idxm1])>>2) + (FT(src[k + cn])>>2) + (FT(src[k + idxp1])>>4) + (FT(src[k + idxm2])>>4); + dst[k + cn] = (FT(src[k + cn])>>4)*(uint8_t)6 + (FT(src[k])>>2) + (FT(src[k + idxp1])>>2) + (FT(src[k + idxm1])>>4) + (FT(src[k + idxp2])>>4); + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[k + cn])>>2) + (FT(src[k + 2 * cn])>>4); + dst[k + cn] = (FT(src[k + cn])>>4)*(uint8_t)6 + (FT(src[k])>>2) + (FT(src[k + 2 * cn])>>2); + dst[k + 2 * cn] = (FT(src[k + 2 * cn])>>4)*(uint8_t)6 + (FT(src[k + cn])>>2) + (FT(src[k])>>4); + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[k + cn])>>2) + (FT(src[k + idxm1])>>2) + (FT(src[k + 2 * cn])>>4) + (FT(src[k + idxm2])>>4); + dst[k + cn] = (FT(src[k + cn])>>4)*(uint8_t)6 + (FT(src[k])>>2) + (FT(src[k + 2 * cn])>>2) + (FT(src[k + idxm1])>>4) + (FT(src[k + idxp1])>>4); + dst[k + 2 * cn] = (FT(src[k + 2 * cn])>>4)*(uint8_t)6 + (FT(src[k + cn])>>2) + (FT(src[k + idxp1])>>2) + (FT(src[k])>>4) + (FT(src[k + idxp2])>>4); + } + } + } + else + { + // Points that fall left from border + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[cn + k])>>2) + (FT(src[2 * cn + k])>>4); + dst[k + cn] = (FT(src[cn + k])>>4)*(uint8_t)6 + (FT(src[k])>>2) + (FT(src[2 * cn + k])>>2) + (FT(src[3 * cn + k])>>4); + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + (FT(src[idxm2 + k])>>4) + (FT(src[idxm1 + k])>>2); + dst[k + cn] = dst[k + cn] + (FT(src[idxm1 + k])>>4); + } + } + + src += 2 * cn; dst += 2 * cn; + for (int i = 2 * cn; i < (len - 2)*cn; i++, src++, dst++) + *dst = (FT(src[0])>>4)*(uint8_t)6 + (FT(src[-cn])>>2) + (FT(src[cn])>>2) + (FT(src[-2 * cn])>>4) + (FT(src[2 * cn])>>4); + + // Points that fall right from border + for (int k = 0; k < cn; k++) + { + dst[k] = (FT(src[k])>>4)*(uint8_t)6 + (FT(src[k - cn])>>2) + (FT(src[k + cn])>>2) + (FT(src[k - 2 * cn])>>4); + dst[k + cn] = (FT(src[k + cn])>>4)*(uint8_t)6 + (FT(src[k])>>2) + (FT(src[k - cn])>>4); + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len + 1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + (FT(src[idxp1 + k])>>4); + dst[k + cn] = dst[k + cn] + (FT(src[idxp1 + k])>>2) + (FT(src[idxp2 + k])>>4); + } + } + } +} +template <> +void hlineSmooth5N14641(const uint8_t* src, int cn, const ufixedpoint16*, int, ufixedpoint16* dst, int len, int borderType) +{ + if (len == 1) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + dst[k] = (ufixedpoint16(src[k])>>3) * (uint8_t)3; + else + { + for (int k = 0; k < cn; k++) + dst[k] = src[k]; + } + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + cn]) >> 2); + dst[k + cn] = (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[k + cn]) >> 4) * (uint8_t)6; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + idxm1]) >> 2) + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k + idxp1]) >> 4) + (ufixedpoint16(src[k + idxm2]) >> 4); + dst[k + cn] = (ufixedpoint16(src[k + cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[k + idxp1]) >> 2) + (ufixedpoint16(src[k + idxm1]) >> 4) + (ufixedpoint16(src[k + idxp2]) >> 4); + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k + 2 * cn]) >> 4); + dst[k + cn] = (ufixedpoint16(src[k + cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[k + 2 * cn]) >> 2); + dst[k + 2 * cn] = (ufixedpoint16(src[k + 2 * cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k]) >> 4); + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k + idxm1]) >> 2) + (ufixedpoint16(src[k + 2 * cn]) >> 4) + (ufixedpoint16(src[k + idxm2]) >> 4); + dst[k + cn] = (ufixedpoint16(src[k + cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[k + 2 * cn]) >> 2) + (ufixedpoint16(src[k + idxm1]) >> 4) + (ufixedpoint16(src[k + idxp1]) >> 4); + dst[k + 2 * cn] = (ufixedpoint16(src[k + 2 * cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k + idxp1]) >> 2) + (ufixedpoint16(src[k]) >> 4) + (ufixedpoint16(src[k + idxp2]) >> 4); + } + } + } + else + { + // Points that fall left from border + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[cn + k]) >> 2) + (ufixedpoint16(src[2 * cn + k]) >> 4); + dst[k + cn] = (ufixedpoint16(src[cn + k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[2 * cn + k]) >> 2) + (ufixedpoint16(src[3 * cn + k]) >> 4); + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + (ufixedpoint16(src[idxm2 + k]) >> 4) + (ufixedpoint16(src[idxm1 + k]) >> 2); + dst[k + cn] = dst[k + cn] + (ufixedpoint16(src[idxm1 + k]) >> 4); + } + } + + src += 2 * cn; dst += 2 * cn; + int i = 2 * cn, lencn = (len - 2)*cn; + v_uint16x8 v_6 = v_setall_u16(6); + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21, v_src30, v_src31, v_src40, v_src41; + v_expand(v_load(src - 2*cn), v_src00, v_src01); + v_expand(v_load(src - cn), v_src10, v_src11); + v_expand(v_load(src), v_src20, v_src21); + v_expand(v_load(src + cn), v_src30, v_src31); + v_expand(v_load(src + 2*cn), v_src40, v_src41); + v_store((uint16_t*)dst, (v_src20 * v_6 + ((v_src10 + v_src30) << 2) + v_src00 + v_src40) << 4); + v_store((uint16_t*)dst + 8, (v_src21 * v_6 + ((v_src11 + v_src31) << 2) + v_src01 + v_src41) << 4); + } + for (; i < lencn; i++, src++, dst++) + *((uint16_t*)dst) = (uint16_t(src[0]) * 6 + ((uint16_t(src[-cn]) + uint16_t(src[cn])) << 2) + uint16_t(src[-2 * cn]) + uint16_t(src[2 * cn])) << 4; + + // Points that fall right from border + for (int k = 0; k < cn; k++) + { + dst[k] = (ufixedpoint16(src[k]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k - cn]) >> 2) + (ufixedpoint16(src[k + cn]) >> 2) + (ufixedpoint16(src[k - 2 * cn]) >> 4); + dst[k + cn] = (ufixedpoint16(src[k + cn]) >> 4) * (uint8_t)6 + (ufixedpoint16(src[k]) >> 2) + (ufixedpoint16(src[k - cn]) >> 4); + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len + 1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + (ufixedpoint16(src[idxp1 + k]) >> 4); + dst[k + cn] = dst[k + cn] + (ufixedpoint16(src[idxp1 + k]) >> 2) + (ufixedpoint16(src[idxp2 + k]) >> 4); + } + } + } +} +template +void hlineSmooth5Nabcba(const ET* src, int cn, const FT* m, int, FT* dst, int len, int borderType) +{ + if (len == 1) + { + FT msum = borderType != BORDER_CONSTANT ? ((m[0] + m[1])<<1) + m[2] : m[2]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[k + cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = m[1] * src[k + idxm1] + m[2] * src[k] + m[1] * src[k + cn] + m[0] * src[k + idxp1] + m[0] * src[k + idxm2]; + dst[k + cn] = m[0] * src[k + idxm1] + m[1] * src[k] + m[2] * src[k + cn] + m[1] * src[k + idxp1] + m[0] * src[k + idxp2]; + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[k + cn] + m[0] * src[k + 2 * cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[1] * src[k + 2 * cn]; + dst[k + 2 * cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2 * cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[k + cn] + m[0] * src[k + 2 * cn] + m[0] * src[k + idxm2] + m[1] * src[k + idxm1]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn] + m[1] * src[k + 2 * cn] + m[0] * src[k + idxm1] + m[0] * src[k + idxp1]; + dst[k + 2 * cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2 * cn] + m[1] * src[k + idxp1] + m[0] * src[k + idxp2]; + } + } + } + else + { + // Points that fall left from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[cn + k] + m[0] * src[2 * cn + k]; + dst[k + cn] = m[1] * src[k] + m[2] * src[cn + k] + m[1] * src[2 * cn + k] + m[0] * src[3 * cn + k]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[0] * src[idxm2 + k] + m[1] * src[idxm1 + k]; + dst[k + cn] = dst[k + cn] + m[0] * src[idxm1 + k]; + } + } + + src += 2 * cn; dst += 2 * cn; + for (int i = 2 * cn; i < (len - 2)*cn; i++, src++, dst++) + *dst = m[0] * src[-2 * cn] + m[1] * src[-cn] + m[2] * src[0] + m[3] * src[cn] + m[4] * src[2 * cn]; + + // Points that fall right from border + for (int k = 0; k < cn; k++) + { + dst[k] = m[0] * src[k - 2 * cn] + m[1] * src[k - cn] + m[2] * src[k] + m[3] * src[k + cn]; + dst[k + cn] = m[0] * src[k - cn] + m[1] * src[k] + m[2] * src[k + cn]; + } + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len + 1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + dst[k] = dst[k] + m[0] * src[idxp1 + k]; + dst[k + cn] = dst[k + cn] + m[1] * src[idxp1 + k] + m[0] * src[idxp2 + k]; + } + } + } +} +template <> +void hlineSmooth5Nabcba(const uint8_t* src, int cn, const ufixedpoint16* m, int, ufixedpoint16* dst, int len, int borderType) +{ + if (len == 1) + { + ufixedpoint16 msum = borderType != BORDER_CONSTANT ? ((m[0] + m[1]) << 1) + m[2] : m[2]; + for (int k = 0; k < cn; k++) + dst[k] = msum * src[k]; + } + else if (len == 2) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[k + cn]; + dst[k + cn] = m[1] * src[k] + m[2] * src[k + cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(2, len, borderType)*cn; + int idxp2 = borderInterpolate(3, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + ((uint16_t*)dst)[k] = ((uint16_t*)m)[1] * ((uint16_t)(src[k + idxm1]) + (uint16_t)(src[k + cn])) + ((uint16_t*)m)[2] * src[k] + ((uint16_t*)m)[0] * ((uint16_t)(src[k + idxp1]) + (uint16_t)(src[k + idxm2])); + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[0] * ((uint16_t)(src[k + idxm1]) + (uint16_t)(src[k + idxp2])) + ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[k + idxp1])) + ((uint16_t*)m)[2] * src[k + cn]; + } + } + } + else if (len == 3) + { + if (borderType == BORDER_CONSTANT) + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[k + cn] + m[0] * src[k + 2 * cn]; + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[k + 2 * cn])) + ((uint16_t*)m)[2] * src[k + cn]; + dst[k + 2 * cn] = m[0] * src[k] + m[1] * src[k + cn] + m[2] * src[k + 2 * cn]; + } + else + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + int idxp1 = borderInterpolate(3, len, borderType)*cn; + int idxp2 = borderInterpolate(4, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + ((uint16_t*)dst)[k] = ((uint16_t*)m)[2] * src[k] + ((uint16_t*)m)[1] * ((uint16_t)(src[k + cn]) + (uint16_t)(src[k + idxm1])) + ((uint16_t*)m)[0] * ((uint16_t)(src[k + 2 * cn]) + (uint16_t)(src[k + idxm2])); + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[2] * src[k + cn] + ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[k + 2 * cn])) + ((uint16_t*)m)[0] * ((uint16_t)(src[k + idxm1]) + (uint16_t)(src[k + idxp1])); + ((uint16_t*)dst)[k + 2 * cn] = ((uint16_t*)m)[0] * ((uint16_t)(src[k]) + (uint16_t)(src[k + idxp2])) + ((uint16_t*)m)[1] * ((uint16_t)(src[k + cn]) + (uint16_t)(src[k + idxp1])) + ((uint16_t*)m)[2] * src[k + 2 * cn]; + } + } + } + else + { + // Points that fall left from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxm2 = borderInterpolate(-2, len, borderType)*cn; + int idxm1 = borderInterpolate(-1, len, borderType)*cn; + for (int k = 0; k < cn; k++) + { + ((uint16_t*)dst)[k] = ((uint16_t*)m)[2] * src[k] + ((uint16_t*)m)[1] * ((uint16_t)(src[cn + k]) + (uint16_t)(src[idxm1 + k])) + ((uint16_t*)m)[0] * ((uint16_t)(src[2 * cn + k]) + (uint16_t)(src[idxm2 + k])); + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[2 * cn + k])) + ((uint16_t*)m)[2] * src[cn + k] + ((uint16_t*)m)[0] * ((uint16_t)(src[3 * cn + k]) + (uint16_t)(src[idxm1 + k])); + } + } + else + { + for (int k = 0; k < cn; k++) + { + dst[k] = m[2] * src[k] + m[1] * src[cn + k] + m[0] * src[2 * cn + k]; + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[2 * cn + k])) + ((uint16_t*)m)[2] * src[cn + k] + ((uint16_t*)m)[0] * src[3 * cn + k]; + } + } + + src += 2 * cn; dst += 2 * cn; + int i = 2 * cn, lencn = (len - 2)*cn; + v_uint16x8 v_mul0 = v_setall_u16(*((uint16_t*)m)); + v_uint16x8 v_mul1 = v_setall_u16(*((uint16_t*)(m + 1))); + v_uint16x8 v_mul2 = v_setall_u16(*((uint16_t*)(m + 2))); + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_src10, v_src11, v_src20, v_src21, v_src30, v_src31, v_src40, v_src41; + v_expand(v_load(src - 2 * cn), v_src00, v_src01); + v_expand(v_load(src - cn), v_src10, v_src11); + v_expand(v_load(src), v_src20, v_src21); + v_expand(v_load(src + cn), v_src30, v_src31); + v_expand(v_load(src + 2 * cn), v_src40, v_src41); + v_store((uint16_t*)dst, (v_src00 + v_src40) * v_mul0 + (v_src10 + v_src30)* v_mul1 + v_src20 * v_mul2); + v_store((uint16_t*)dst + 8, (v_src01 + v_src41) * v_mul0 + (v_src11 + v_src31) * v_mul1 + v_src21 * v_mul2); + } + for (; i < lencn; i++, src++, dst++) + *((uint16_t*)dst) = ((uint16_t*)m)[0] * ((uint16_t)(src[-2 * cn]) + (uint16_t)(src[2 * cn])) + ((uint16_t*)m)[1] * ((uint16_t)(src[-cn]) + (uint16_t)(src[cn])) + ((uint16_t*)m)[2] * src[0]; + + // Points that fall right from border + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int idxp1 = (borderInterpolate(len, len, borderType) - (len - 2))*cn; + int idxp2 = (borderInterpolate(len + 1, len, borderType) - (len - 2))*cn; + for (int k = 0; k < cn; k++) + { + ((uint16_t*)dst)[k] = ((uint16_t*)m)[0] * ((uint16_t)(src[k - 2 * cn]) + (uint16_t)(src[idxp1 + k])) + ((uint16_t*)m)[1] * ((uint16_t)(src[k - cn]) + (uint16_t)(src[k + cn])) + ((uint16_t*)m)[2] * src[k]; + ((uint16_t*)dst)[k + cn] = ((uint16_t*)m)[0] * ((uint16_t)(src[k - cn]) + (uint16_t)(src[idxp2 + k])) + ((uint16_t*)m)[1] * ((uint16_t)(src[k]) + (uint16_t)(src[idxp1 + k])) + ((uint16_t*)m)[2] * src[k + cn]; + } + } + else + { + for (int k = 0; k < cn; k++) + { + ((uint16_t*)dst)[k] = ((uint16_t*)m)[0] * src[k - 2 * cn] + ((uint16_t*)m)[1] * ((uint16_t)(src[k - cn]) + (uint16_t)(src[k + cn])) + ((uint16_t*)m)[2] * src[k]; + dst[k + cn] = m[0] * src[k - cn] + m[1] * src[k] + m[2] * src[k + cn]; + } + } + } +} +template +void hlineSmooth(const ET* src, int cn, const FT* m, int n, FT* dst, int len, int borderType) +{ + int pre_shift = n / 2; + int post_shift = n - pre_shift; + int i = 0; + for (; i < min(pre_shift, len); i++, dst += cn) // Points that fall left from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[pre_shift-i] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (int j = i - pre_shift, mid = 0; j < 0; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + int j, mid; + for (j = 1, mid = pre_shift - i + 1; j < min(i + post_shift, len); j++, mid++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT) + for (; j < i + post_shift; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + } + i *= cn; + for (; i < (len - post_shift + 1)*cn; i++, src++, dst++) + { + *dst = m[0] * src[0]; + for (int j = 1; j < n; j++) + *dst = *dst + m[j] * src[j*cn]; + } + i /= cn; + for (i -= pre_shift; i < len - pre_shift; i++, src += cn, dst += cn) // Points that fall right from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k]; + int j = 1; + for (; j < len - i; j++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (; j < n; j++) + { + int src_idx = borderInterpolate(i + j, len, borderType) - i; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[src_idx*cn + k]; + } + } +} +template <> +void hlineSmooth(const uint8_t* src, int cn, const ufixedpoint16* m, int n, ufixedpoint16* dst, int len, int borderType) +{ + int pre_shift = n / 2; + int post_shift = n - pre_shift; + int i = 0; + for (; i < min(pre_shift, len); i++, dst += cn) // Points that fall left from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[pre_shift - i] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (int j = i - pre_shift, mid = 0; j < 0; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + int j, mid; + for (j = 1, mid = pre_shift - i + 1; j < min(i + post_shift, len); j++, mid++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT) + for (; j < i + post_shift; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + } + i *= cn; + int lencn = (len - post_shift + 1)*cn; + for (; i <= lencn - 16; i+=16, src+=16, dst+=16) + { + v_uint16x8 v_src0, v_src1; + v_uint16x8 v_mul = v_setall_u16(*((uint16_t*)m)); + v_expand(v_load(src), v_src0, v_src1); + v_uint16x8 v_res0 = v_src0 * v_mul; + v_uint16x8 v_res1 = v_src1 * v_mul; + for (int j = 1; j < n; j++) + { + v_mul = v_setall_u16(*((uint16_t*)(m + j))); + v_expand(v_load(src + j * cn), v_src0, v_src1); + v_res0 += v_src0 * v_mul; + v_res1 += v_src1 * v_mul; + } + v_store((uint16_t*)dst, v_res0); + v_store((uint16_t*)dst+8, v_res1); + } + for (; i < lencn; i++, src++, dst++) + { + *dst = m[0] * src[0]; + for (int j = 1; j < n; j++) + *dst = *dst + m[j] * src[j*cn]; + } + i /= cn; + for (i -= pre_shift; i < len - pre_shift; i++, src += cn, dst += cn) // Points that fall right from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k]; + int j = 1; + for (; j < len - i; j++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (; j < n; j++) + { + int src_idx = borderInterpolate(i + j, len, borderType) - i; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[src_idx*cn + k]; + } + } +} +template +void hlineSmoothONa_yzy_a(const ET* src, int cn, const FT* m, int n, FT* dst, int len, int borderType) +{ + int pre_shift = n / 2; + int post_shift = n - pre_shift; + int i = 0; + for (; i < min(pre_shift, len); i++, dst += cn) // Points that fall left from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[pre_shift - i] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (int j = i - pre_shift, mid = 0; j < 0; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + int j, mid; + for (j = 1, mid = pre_shift - i + 1; j < min(i + post_shift, len); j++, mid++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT) + for (; j < i + post_shift; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + } + i *= cn; + for (; i < (len - post_shift + 1)*cn; i++, src++, dst++) + { + *dst = m[pre_shift] * src[pre_shift*cn]; + for (int j = 0; j < pre_shift; j++) + *dst = *dst + m[j] * src[j*cn] + m[j] * src[(n-1-j)*cn]; + } + i /= cn; + for (i -= pre_shift; i < len - pre_shift; i++, src += cn, dst += cn) // Points that fall right from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k]; + int j = 1; + for (; j < len - i; j++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (; j < n; j++) + { + int src_idx = borderInterpolate(i + j, len, borderType) - i; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[src_idx*cn + k]; + } + } +} +template <> +void hlineSmoothONa_yzy_a(const uint8_t* src, int cn, const ufixedpoint16* m, int n, ufixedpoint16* dst, int len, int borderType) +{ + int pre_shift = n / 2; + int post_shift = n - pre_shift; + int i = 0; + for (; i < min(pre_shift, len); i++, dst += cn) // Points that fall left from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[pre_shift - i] * src[k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (int j = i - pre_shift, mid = 0; j < 0; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + int j, mid; + for (j = 1, mid = pre_shift - i + 1; j < min(i + post_shift, len); j++, mid++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT) + for (; j < i + post_shift; j++, mid++) + { + int src_idx = borderInterpolate(j, len, borderType); + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[mid] * src[src_idx*cn + k]; + } + } + i *= cn; + int lencn = (len - post_shift + 1)*cn; + for (; i <= lencn - 16; i += 16, src += 16, dst += 16) + { + v_uint16x8 v_src00, v_src01, v_srcN00, v_srcN01; + + v_uint16x8 v_mul = v_setall_u16(*((uint16_t*)(m + pre_shift))); + v_expand(v_load(src + pre_shift * cn), v_src00, v_src01); + v_uint16x8 v_res0 = v_src00 * v_mul; + v_uint16x8 v_res1 = v_src01 * v_mul; + for (int j = 0; j < pre_shift; j ++) + { + v_mul = v_setall_u16(*((uint16_t*)(m + j))); + v_expand(v_load(src + j * cn), v_src00, v_src01); + v_expand(v_load(src + (n - 1 - j)*cn), v_srcN00, v_srcN01); + v_res0 += (v_src00 + v_srcN00) * v_mul; + v_res1 += (v_src01 + v_srcN01) * v_mul; + } + + v_store((uint16_t*)dst, v_res0); + v_store((uint16_t*)dst + 8, v_res1); + } + for (; i < lencn; i++, src++, dst++) + { + *dst = m[pre_shift] * src[pre_shift*cn]; + for (int j = 0; j < pre_shift; j++) + *dst = *dst + m[j] * src[j*cn] + m[j] * src[(n - 1 - j)*cn]; + } + i /= cn; + for (i -= pre_shift; i < len - pre_shift; i++, src += cn, dst += cn) // Points that fall right from border + { + for (int k = 0; k < cn; k++) + dst[k] = m[0] * src[k]; + int j = 1; + for (; j < len - i; j++) + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[j*cn + k]; + if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + for (; j < n; j++) + { + int src_idx = borderInterpolate(i + j, len, borderType) - i; + for (int k = 0; k < cn; k++) + dst[k] = dst[k] + m[j] * src[src_idx*cn + k]; + } + } +} +template +void vlineSmooth1N(const FT* const * src, const FT* m, int, ET* dst, int len) +{ + const FT* src0 = src[0]; + for (int i = 0; i < len; i++) + dst[i] = *m * src0[i]; +} +template <> +void vlineSmooth1N(const ufixedpoint16* const * src, const ufixedpoint16* m, int, uint8_t* dst, int len) +{ + const ufixedpoint16* src0 = src[0]; + v_uint16x8 v_mul = v_setall_u16(*((uint16_t*)m)); +#if CV_SSE2 + v_uint16x8 v_1 = v_setall_u16(1); + v_mul += v_mul; +#endif + int i = 0; + for (; i <= len - 16; i += 16) + { + v_uint16x8 v_src0 = v_load((uint16_t*)src0 + i); + v_uint16x8 v_src1 = v_load((uint16_t*)src0 + i + 8); + v_uint8x16 v_res; +#if CV_SSE2 + v_res.val = _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(v_1.val, _mm_mulhi_epu16(v_src0.val, v_mul.val)),1), + _mm_srli_epi16(_mm_add_epi16(v_1.val, _mm_mulhi_epu16(v_src1.val, v_mul.val)),1)); +#else + v_uint32x4 v_res0, v_res1, v_res2, v_res3; + v_mul_expand(v_src0, v_mul, v_res0, v_res1); + v_mul_expand(v_src1, v_mul, v_res2, v_res3); + v_res = v_pack(v_rshr_pack<16>(v_res0, v_res1), v_rshr_pack<16>(v_res2, v_res3)); +#endif + v_store(dst + i, v_res); + } + for (; i < len; i++) + dst[i] = m[0] * src0[i]; +} +template +void vlineSmooth1N1(const FT* const * src, const FT*, int, ET* dst, int len) +{ + const FT* src0 = src[0]; + for (int i = 0; i < len; i++) + dst[i] = src0[i]; +} +template <> +void vlineSmooth1N1(const ufixedpoint16* const * src, const ufixedpoint16*, int, uint8_t* dst, int len) +{ + const ufixedpoint16* src0 = src[0]; + int i = 0; + for (; i <= len - 8; i += 8) + v_rshr_pack_store<8>(dst + i, v_load((uint16_t*)(src0 + i))); + for (; i < len; i++) + dst[i] = src0[i]; +} +template +void vlineSmooth3N(const FT* const * src, const FT* m, int, ET* dst, int len) +{ + for (int i = 0; i < len; i++) + dst[i] = m[0] * src[0][i] + m[1] * src[1][i] + m[2] * src[2][i]; +} +template <> +void vlineSmooth3N(const ufixedpoint16* const * src, const ufixedpoint16* m, int, uint8_t* dst, int len) +{ + int i = 0; + static const v_int16x8 v_128 = v_reinterpret_as_s16(v_setall_u16((uint16_t)1 << 15)); + v_int32x4 v_128_4 = v_setall_s32(128 << 16); + if (len > 7) + { + ufixedpoint32 val[] = { (m[0] + m[1] + m[2]) * ufixedpoint16((uint8_t)128) }; + v_128_4 = v_setall_s32(*((int32_t*)val)); + } + v_int16x8 v_mul01 = v_reinterpret_as_s16(v_setall_u32(*((uint32_t*)m))); + v_int16x8 v_mul2 = v_reinterpret_as_s16(v_setall_u16(*((uint16_t*)(m + 2)))); + for (; i <= len - 32; i += 32) + { + v_int16x8 v_src00, v_src10, v_src01, v_src11, v_src02, v_src12, v_src03, v_src13; + v_int16x8 v_tmp0, v_tmp1; + + v_src00 = v_load((int16_t*)(src[0]) + i); + v_src01 = v_load((int16_t*)(src[0]) + i + 8); + v_src02 = v_load((int16_t*)(src[0]) + i + 16); + v_src03 = v_load((int16_t*)(src[0]) + i + 24); + v_src10 = v_load((int16_t*)(src[1]) + i); + v_src11 = v_load((int16_t*)(src[1]) + i + 8); + v_src12 = v_load((int16_t*)(src[1]) + i + 16); + v_src13 = v_load((int16_t*)(src[1]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src10, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res0 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res1 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src01, v_128), v_add_wrap(v_src11, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res2 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res3 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src02, v_128), v_add_wrap(v_src12, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res4 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res5 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src03, v_128), v_add_wrap(v_src13, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res6 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res7 = v_dotprod(v_tmp1, v_mul01); + + v_int32x4 v_resj0, v_resj1; + v_src00 = v_load((int16_t*)(src[2]) + i); + v_src01 = v_load((int16_t*)(src[2]) + i + 8); + v_src02 = v_load((int16_t*)(src[2]) + i + 16); + v_src03 = v_load((int16_t*)(src[2]) + i + 24); + v_mul_expand(v_add_wrap(v_src00, v_128), v_mul2, v_resj0, v_resj1); + v_res0 += v_resj0; + v_res1 += v_resj1; + v_mul_expand(v_add_wrap(v_src01, v_128), v_mul2, v_resj0, v_resj1); + v_res2 += v_resj0; + v_res3 += v_resj1; + v_mul_expand(v_add_wrap(v_src02, v_128), v_mul2, v_resj0, v_resj1); + v_res4 += v_resj0; + v_res5 += v_resj1; + v_mul_expand(v_add_wrap(v_src03, v_128), v_mul2, v_resj0, v_resj1); + v_res6 += v_resj0; + v_res7 += v_resj1; + + v_res0 += v_128_4; + v_res1 += v_128_4; + v_res2 += v_128_4; + v_res3 += v_128_4; + v_res4 += v_128_4; + v_res5 += v_128_4; + v_res6 += v_128_4; + v_res7 += v_128_4; + + v_store(dst + i , v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res0, v_res1)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res2, v_res3)))); + v_store(dst + i + 16, v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res4, v_res5)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res6, v_res7)))); + } + for (; i < len; i++) + dst[i] = m[0] * src[0][i] + m[1] * src[1][i] + m[2] * src[2][i]; +} +template +void vlineSmooth3N121(const FT* const * src, const FT*, int, ET* dst, int len) +{ + for (int i = 0; i < len; i++) + dst[i] = (FT::WT(src[0][i]) >> 2) + (FT::WT(src[2][i]) >> 2) + (FT::WT(src[1][i]) >> 1); +} +template <> +void vlineSmooth3N121(const ufixedpoint16* const * src, const ufixedpoint16*, int, uint8_t* dst, int len) +{ + int i = 0; + for (; i <= len - 16; i += 16) + { + v_uint32x4 v_src00, v_src01, v_src02, v_src03, v_src10, v_src11, v_src12, v_src13, v_src20, v_src21, v_src22, v_src23; + v_expand(v_load((uint16_t*)(src[0]) + i), v_src00, v_src01); + v_expand(v_load((uint16_t*)(src[0]) + i + 8), v_src02, v_src03); + v_expand(v_load((uint16_t*)(src[1]) + i), v_src10, v_src11); + v_expand(v_load((uint16_t*)(src[1]) + i + 8), v_src12, v_src13); + v_expand(v_load((uint16_t*)(src[2]) + i), v_src20, v_src21); + v_expand(v_load((uint16_t*)(src[2]) + i + 8), v_src22, v_src23); + v_store(dst + i, v_pack(v_rshr_pack<10>(v_src00 + v_src20 + (v_src10 + v_src10), v_src01 + v_src21 + (v_src11 + v_src11)), + v_rshr_pack<10>(v_src02 + v_src22 + (v_src12 + v_src12), v_src03 + v_src23 + (v_src13 + v_src13)))); + } + for (; i < len; i++) + dst[i] = (((uint32_t)(((uint16_t*)(src[0]))[i]) + (uint32_t)(((uint16_t*)(src[2]))[i]) + ((uint32_t)(((uint16_t*)(src[1]))[i]) << 1)) + (1 << 9)) >> 10; +} +template +void vlineSmooth5N(const FT* const * src, const FT* m, int, ET* dst, int len) +{ + for (int i = 0; i < len; i++) + dst[i] = m[0] * src[0][i] + m[1] * src[1][i] + m[2] * src[2][i] + m[3] * src[3][i] + m[4] * src[4][i]; +} +template <> +void vlineSmooth5N(const ufixedpoint16* const * src, const ufixedpoint16* m, int, uint8_t* dst, int len) +{ + int i = 0; + static const v_int16x8 v_128 = v_reinterpret_as_s16(v_setall_u16((uint16_t)1 << 15)); + v_int32x4 v_128_4 = v_setall_s32(128 << 16); + if (len > 7) + { + ufixedpoint32 val[] = { (m[0] + m[1] + m[2] + m[3] + m[4]) * ufixedpoint16((uint8_t)128) }; + v_128_4 = v_setall_s32(*((int32_t*)val)); + } + v_int16x8 v_mul01 = v_reinterpret_as_s16(v_setall_u32(*((uint32_t*)m))); + v_int16x8 v_mul23 = v_reinterpret_as_s16(v_setall_u32(*((uint32_t*)(m + 2)))); + v_int16x8 v_mul4 = v_reinterpret_as_s16(v_setall_u16(*((uint16_t*)(m + 4)))); + for (; i <= len - 32; i += 32) + { + v_int16x8 v_src00, v_src10, v_src01, v_src11, v_src02, v_src12, v_src03, v_src13; + v_int16x8 v_tmp0, v_tmp1; + + v_src00 = v_load((int16_t*)(src[0]) + i); + v_src01 = v_load((int16_t*)(src[0]) + i + 8); + v_src02 = v_load((int16_t*)(src[0]) + i + 16); + v_src03 = v_load((int16_t*)(src[0]) + i + 24); + v_src10 = v_load((int16_t*)(src[1]) + i); + v_src11 = v_load((int16_t*)(src[1]) + i + 8); + v_src12 = v_load((int16_t*)(src[1]) + i + 16); + v_src13 = v_load((int16_t*)(src[1]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src10, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res0 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res1 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src01, v_128), v_add_wrap(v_src11, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res2 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res3 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src02, v_128), v_add_wrap(v_src12, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res4 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res5 = v_dotprod(v_tmp1, v_mul01); + v_zip(v_add_wrap(v_src03, v_128), v_add_wrap(v_src13, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res6 = v_dotprod(v_tmp0, v_mul01); + v_int32x4 v_res7 = v_dotprod(v_tmp1, v_mul01); + + v_src00 = v_load((int16_t*)(src[2]) + i); + v_src01 = v_load((int16_t*)(src[2]) + i + 8); + v_src02 = v_load((int16_t*)(src[2]) + i + 16); + v_src03 = v_load((int16_t*)(src[2]) + i + 24); + v_src10 = v_load((int16_t*)(src[3]) + i); + v_src11 = v_load((int16_t*)(src[3]) + i + 8); + v_src12 = v_load((int16_t*)(src[3]) + i + 16); + v_src13 = v_load((int16_t*)(src[3]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src10, v_128), v_tmp0, v_tmp1); + v_res0 += v_dotprod(v_tmp0, v_mul23); + v_res1 += v_dotprod(v_tmp1, v_mul23); + v_zip(v_add_wrap(v_src01, v_128), v_add_wrap(v_src11, v_128), v_tmp0, v_tmp1); + v_res2 += v_dotprod(v_tmp0, v_mul23); + v_res3 += v_dotprod(v_tmp1, v_mul23); + v_zip(v_add_wrap(v_src02, v_128), v_add_wrap(v_src12, v_128), v_tmp0, v_tmp1); + v_res4 += v_dotprod(v_tmp0, v_mul23); + v_res5 += v_dotprod(v_tmp1, v_mul23); + v_zip(v_add_wrap(v_src03, v_128), v_add_wrap(v_src13, v_128), v_tmp0, v_tmp1); + v_res6 += v_dotprod(v_tmp0, v_mul23); + v_res7 += v_dotprod(v_tmp1, v_mul23); + + v_int32x4 v_resj0, v_resj1; + v_src00 = v_load((int16_t*)(src[4]) + i); + v_src01 = v_load((int16_t*)(src[4]) + i + 8); + v_src02 = v_load((int16_t*)(src[4]) + i + 16); + v_src03 = v_load((int16_t*)(src[4]) + i + 24); + v_mul_expand(v_add_wrap(v_src00, v_128), v_mul4, v_resj0, v_resj1); + v_res0 += v_resj0; + v_res1 += v_resj1; + v_mul_expand(v_add_wrap(v_src01, v_128), v_mul4, v_resj0, v_resj1); + v_res2 += v_resj0; + v_res3 += v_resj1; + v_mul_expand(v_add_wrap(v_src02, v_128), v_mul4, v_resj0, v_resj1); + v_res4 += v_resj0; + v_res5 += v_resj1; + v_mul_expand(v_add_wrap(v_src03, v_128), v_mul4, v_resj0, v_resj1); + v_res6 += v_resj0; + v_res7 += v_resj1; + + v_res0 += v_128_4; + v_res1 += v_128_4; + v_res2 += v_128_4; + v_res3 += v_128_4; + v_res4 += v_128_4; + v_res5 += v_128_4; + v_res6 += v_128_4; + v_res7 += v_128_4; + + v_store(dst + i , v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res0, v_res1)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res2, v_res3)))); + v_store(dst + i + 16, v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res4, v_res5)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res6, v_res7)))); + } + for (; i < len; i++) + dst[i] = m[0] * src[0][i] + m[1] * src[1][i] + m[2] * src[2][i] + m[3] * src[3][i] + m[4] * src[4][i]; +} +template +void vlineSmooth5N14641(const FT* const * src, const FT*, int, ET* dst, int len) +{ + for (int i = 0; i < len; i++) + dst[i] = (FT::WT(src[2][i])*(uint8_t)6 + ((FT::WT(src[1][i]) + FT::WT(src[3][i]))<<2) + FT::WT(src[0][i]) + FT::WT(src[4][i])) >> 4; +} +template <> +void vlineSmooth5N14641(const ufixedpoint16* const * src, const ufixedpoint16*, int, uint8_t* dst, int len) +{ + int i = 0; + v_uint32x4 v_6 = v_setall_u32(6); + for (; i <= len - 16; i += 16) + { + v_uint32x4 v_src00, v_src10, v_src20, v_src30, v_src40; + v_uint32x4 v_src01, v_src11, v_src21, v_src31, v_src41; + v_uint32x4 v_src02, v_src12, v_src22, v_src32, v_src42; + v_uint32x4 v_src03, v_src13, v_src23, v_src33, v_src43; + v_expand(v_load((uint16_t*)(src[0]) + i), v_src00, v_src01); + v_expand(v_load((uint16_t*)(src[0]) + i + 8), v_src02, v_src03); + v_expand(v_load((uint16_t*)(src[1]) + i), v_src10, v_src11); + v_expand(v_load((uint16_t*)(src[1]) + i + 8), v_src12, v_src13); + v_expand(v_load((uint16_t*)(src[2]) + i), v_src20, v_src21); + v_expand(v_load((uint16_t*)(src[2]) + i + 8), v_src22, v_src23); + v_expand(v_load((uint16_t*)(src[3]) + i), v_src30, v_src31); + v_expand(v_load((uint16_t*)(src[3]) + i + 8), v_src32, v_src33); + v_expand(v_load((uint16_t*)(src[4]) + i), v_src40, v_src41); + v_expand(v_load((uint16_t*)(src[4]) + i + 8), v_src42, v_src43); + v_store(dst + i, v_pack(v_rshr_pack<12>(v_src20*v_6 + ((v_src10 + v_src30) << 2) + v_src00 + v_src40, + v_src21*v_6 + ((v_src11 + v_src31) << 2) + v_src01 + v_src41), + v_rshr_pack<12>(v_src22*v_6 + ((v_src12 + v_src32) << 2) + v_src02 + v_src42, + v_src23*v_6 + ((v_src13 + v_src33) << 2) + v_src03 + v_src43))); + } + for (; i < len; i++) + dst[i] = ((uint32_t)(((uint16_t*)(src[2]))[i]) * 6 + + (((uint32_t)(((uint16_t*)(src[1]))[i]) + (uint32_t)(((uint16_t*)(src[3]))[i])) << 2) + + (uint32_t)(((uint16_t*)(src[0]))[i]) + (uint32_t)(((uint16_t*)(src[4]))[i]) + (1 << 11)) >> 12; +} +template +void vlineSmooth(const FT* const * src, const FT* m, int n, ET* dst, int len) +{ + for (int i = 0; i < len; i++) + { + typename FT::WT val = m[0] * src[0][i]; + for (int j = 1; j < n; j++) + val = val + m[j] * src[j][i]; + dst[i] = val; + } +} +template <> +void vlineSmooth(const ufixedpoint16* const * src, const ufixedpoint16* m, int n, uint8_t* dst, int len) +{ + int i = 0; + static const v_int16x8 v_128 = v_reinterpret_as_s16(v_setall_u16((uint16_t)1 << 15)); + v_int32x4 v_128_4 = v_setall_s32(128 << 16); + if (len > 7) + { + ufixedpoint16 msum = m[0] + m[1]; + for (int j = 2; j < n; j++) + msum = msum + m[j]; + ufixedpoint32 val[] = { msum * ufixedpoint16((uint8_t)128) }; + v_128_4 = v_setall_s32(*((int32_t*)val)); + } + for (; i <= len - 32; i += 32) + { + v_int16x8 v_src00, v_src10, v_src01, v_src11, v_src02, v_src12, v_src03, v_src13; + v_int16x8 v_tmp0, v_tmp1; + + v_int16x8 v_mul = v_reinterpret_as_s16(v_setall_u32(*((uint32_t*)m))); + + v_src00 = v_load((int16_t*)(src[0]) + i); + v_src01 = v_load((int16_t*)(src[0]) + i + 8); + v_src02 = v_load((int16_t*)(src[0]) + i + 16); + v_src03 = v_load((int16_t*)(src[0]) + i + 24); + v_src10 = v_load((int16_t*)(src[1]) + i); + v_src11 = v_load((int16_t*)(src[1]) + i + 8); + v_src12 = v_load((int16_t*)(src[1]) + i + 16); + v_src13 = v_load((int16_t*)(src[1]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src10, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res0 = v_dotprod(v_tmp0, v_mul); + v_int32x4 v_res1 = v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src01, v_128), v_add_wrap(v_src11, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res2 = v_dotprod(v_tmp0, v_mul); + v_int32x4 v_res3 = v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src02, v_128), v_add_wrap(v_src12, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res4 = v_dotprod(v_tmp0, v_mul); + v_int32x4 v_res5 = v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src03, v_128), v_add_wrap(v_src13, v_128), v_tmp0, v_tmp1); + v_int32x4 v_res6 = v_dotprod(v_tmp0, v_mul); + v_int32x4 v_res7 = v_dotprod(v_tmp1, v_mul); + + int j = 2; + for (; j < n - 1; j+=2) + { + v_mul = v_reinterpret_as_s16(v_setall_u32(*((uint32_t*)(m+j)))); + + v_src00 = v_load((int16_t*)(src[j]) + i); + v_src01 = v_load((int16_t*)(src[j]) + i + 8); + v_src02 = v_load((int16_t*)(src[j]) + i + 16); + v_src03 = v_load((int16_t*)(src[j]) + i + 24); + v_src10 = v_load((int16_t*)(src[j+1]) + i); + v_src11 = v_load((int16_t*)(src[j+1]) + i + 8); + v_src12 = v_load((int16_t*)(src[j+1]) + i + 16); + v_src13 = v_load((int16_t*)(src[j+1]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src10, v_128), v_tmp0, v_tmp1); + v_res0 += v_dotprod(v_tmp0, v_mul); + v_res1 += v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src01, v_128), v_add_wrap(v_src11, v_128), v_tmp0, v_tmp1); + v_res2 += v_dotprod(v_tmp0, v_mul); + v_res3 += v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src02, v_128), v_add_wrap(v_src12, v_128), v_tmp0, v_tmp1); + v_res4 += v_dotprod(v_tmp0, v_mul); + v_res5 += v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src03, v_128), v_add_wrap(v_src13, v_128), v_tmp0, v_tmp1); + v_res6 += v_dotprod(v_tmp0, v_mul); + v_res7 += v_dotprod(v_tmp1, v_mul); + } + if(j < n) + { + v_int32x4 v_resj0, v_resj1; + v_mul = v_reinterpret_as_s16(v_setall_u16(*((uint16_t*)(m + j)))); + v_src00 = v_load((int16_t*)(src[j]) + i); + v_src01 = v_load((int16_t*)(src[j]) + i + 8); + v_src02 = v_load((int16_t*)(src[j]) + i + 16); + v_src03 = v_load((int16_t*)(src[j]) + i + 24); + v_mul_expand(v_add_wrap(v_src00, v_128), v_mul, v_resj0, v_resj1); + v_res0 += v_resj0; + v_res1 += v_resj1; + v_mul_expand(v_add_wrap(v_src01, v_128), v_mul, v_resj0, v_resj1); + v_res2 += v_resj0; + v_res3 += v_resj1; + v_mul_expand(v_add_wrap(v_src02, v_128), v_mul, v_resj0, v_resj1); + v_res4 += v_resj0; + v_res5 += v_resj1; + v_mul_expand(v_add_wrap(v_src03, v_128), v_mul, v_resj0, v_resj1); + v_res6 += v_resj0; + v_res7 += v_resj1; + } + v_res0 += v_128_4; + v_res1 += v_128_4; + v_res2 += v_128_4; + v_res3 += v_128_4; + v_res4 += v_128_4; + v_res5 += v_128_4; + v_res6 += v_128_4; + v_res7 += v_128_4; + + v_store(dst + i , v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res0, v_res1)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res2, v_res3)))); + v_store(dst + i + 16, v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res4, v_res5)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res6, v_res7)))); + } + for (; i < len; i++) + { + ufixedpoint32 val = m[0] * src[0][i]; + for (int j = 1; j < n; j++) + { + val = val + m[j] * src[j][i]; + } + dst[i] = val; + } +} +template +void vlineSmoothONa_yzy_a(const FT* const * src, const FT* m, int n, ET* dst, int len) +{ + int pre_shift = n / 2; + for (int i = 0; i < len; i++) + { + typename FT::WT val = m[pre_shift] * src[pre_shift][i]; + for (int j = 0; j < pre_shift; j++) + val = val + m[j] * src[j][i] + m[j] * src[(n - 1 - j)][i]; + dst[i] = val; + } +} +template <> +void vlineSmoothONa_yzy_a(const ufixedpoint16* const * src, const ufixedpoint16* m, int n, uint8_t* dst, int len) +{ + int pre_shift = n / 2; + int i = 0; + static const v_int16x8 v_128 = v_reinterpret_as_s16(v_setall_u16((uint16_t)1 << 15)); + v_int32x4 v_128_4 = v_setall_s32(128 << 16); + if (len > 7) + { + ufixedpoint16 msum = m[0] + m[pre_shift] + m[n - 1]; + for (int j = 1; j < pre_shift; j++) + msum = msum + m[j] + m[n - 1 - j]; + ufixedpoint32 val[] = { msum * ufixedpoint16((uint8_t)128) }; + v_128_4 = v_setall_s32(*((int32_t*)val)); + } + for (; i <= len - 32; i += 32) + { + v_int16x8 v_src00, v_src10, v_src20, v_src30, v_src01, v_src11, v_src21, v_src31; + v_int32x4 v_res0, v_res1, v_res2, v_res3, v_res4, v_res5, v_res6, v_res7; + v_int16x8 v_tmp0, v_tmp1, v_tmp2, v_tmp3, v_tmp4, v_tmp5, v_tmp6, v_tmp7; + + v_int16x8 v_mul = v_reinterpret_as_s16(v_setall_u16(*((uint16_t*)(m + pre_shift)))); + v_src00 = v_load((int16_t*)(src[pre_shift]) + i); + v_src10 = v_load((int16_t*)(src[pre_shift]) + i + 8); + v_src20 = v_load((int16_t*)(src[pre_shift]) + i + 16); + v_src30 = v_load((int16_t*)(src[pre_shift]) + i + 24); + v_mul_expand(v_add_wrap(v_src00, v_128), v_mul, v_res0, v_res1); + v_mul_expand(v_add_wrap(v_src10, v_128), v_mul, v_res2, v_res3); + v_mul_expand(v_add_wrap(v_src20, v_128), v_mul, v_res4, v_res5); + v_mul_expand(v_add_wrap(v_src30, v_128), v_mul, v_res6, v_res7); + + int j = 0; + for (; j < pre_shift; j++) + { + v_mul = v_reinterpret_as_s16(v_setall_u16(*((uint16_t*)(m + j)))); + + v_src00 = v_load((int16_t*)(src[j]) + i); + v_src10 = v_load((int16_t*)(src[j]) + i + 8); + v_src20 = v_load((int16_t*)(src[j]) + i + 16); + v_src30 = v_load((int16_t*)(src[j]) + i + 24); + v_src01 = v_load((int16_t*)(src[n - 1 - j]) + i); + v_src11 = v_load((int16_t*)(src[n - 1 - j]) + i + 8); + v_src21 = v_load((int16_t*)(src[n - 1 - j]) + i + 16); + v_src31 = v_load((int16_t*)(src[n - 1 - j]) + i + 24); + v_zip(v_add_wrap(v_src00, v_128), v_add_wrap(v_src01, v_128), v_tmp0, v_tmp1); + v_res0 += v_dotprod(v_tmp0, v_mul); + v_res1 += v_dotprod(v_tmp1, v_mul); + v_zip(v_add_wrap(v_src10, v_128), v_add_wrap(v_src11, v_128), v_tmp2, v_tmp3); + v_res2 += v_dotprod(v_tmp2, v_mul); + v_res3 += v_dotprod(v_tmp3, v_mul); + v_zip(v_add_wrap(v_src20, v_128), v_add_wrap(v_src21, v_128), v_tmp4, v_tmp5); + v_res4 += v_dotprod(v_tmp4, v_mul); + v_res5 += v_dotprod(v_tmp5, v_mul); + v_zip(v_add_wrap(v_src30, v_128), v_add_wrap(v_src31, v_128), v_tmp6, v_tmp7); + v_res6 += v_dotprod(v_tmp6, v_mul); + v_res7 += v_dotprod(v_tmp7, v_mul); + } + + v_res0 += v_128_4; + v_res1 += v_128_4; + v_res2 += v_128_4; + v_res3 += v_128_4; + v_res4 += v_128_4; + v_res5 += v_128_4; + v_res6 += v_128_4; + v_res7 += v_128_4; + + v_store(dst + i , v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res0, v_res1)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res2, v_res3)))); + v_store(dst + i + 16, v_pack(v_reinterpret_as_u16(v_rshr_pack<16>(v_res4, v_res5)), + v_reinterpret_as_u16(v_rshr_pack<16>(v_res6, v_res7)))); + } + for (; i < len; i++) + { + ufixedpoint32 val = m[0] * src[0][i]; + for (int j = 1; j < n; j++) + { + val = val + m[j] * src[j][i]; + } + dst[i] = val; + } +} +template +class fixedSmoothInvoker : public ParallelLoopBody +{ +public: + fixedSmoothInvoker(const ET* _src, size_t _src_stride, ET* _dst, size_t _dst_stride, + int _width, int _height, int _cn, const FT* _kx, int _kxlen, const FT* _ky, int _kylen, int _borderType) : ParallelLoopBody(), + src(_src), dst(_dst), src_stride(_src_stride), dst_stride(_dst_stride), + width(_width), height(_height), cn(_cn), kx(_kx), ky(_ky), kxlen(_kxlen), kylen(_kylen), borderType(_borderType) + { + if (kxlen == 1) + { + if (kx[0] == FT::one()) + hlineSmoothFunc = hlineSmooth1N1; + else + hlineSmoothFunc = hlineSmooth1N; + } + else if (kxlen == 3) + { + if (kx[0] == (FT::one()>>2)&&kx[1] == (FT::one()>>1)&&kx[2] == (FT::one()>>2)) + hlineSmoothFunc = hlineSmooth3N121; + else if ((kx[0] - kx[2]).isZero()) + hlineSmoothFunc = hlineSmooth3Naba; + else + hlineSmoothFunc = hlineSmooth3N; + } + else if (kxlen == 5) + { + if (kx[2] == (FT::one()*(uint8_t)3>>3) && + kx[1] == (FT::one()>>2) && kx[3] == (FT::one()>>2) && + kx[0] == (FT::one()>>4) && kx[4] == (FT::one()>>4)) + hlineSmoothFunc = hlineSmooth5N14641; + else if (kx[0] == kx[4] && kx[1] == kx[3]) + hlineSmoothFunc = hlineSmooth5Nabcba; + else + hlineSmoothFunc = hlineSmooth5N; + } + else if (kxlen % 2 == 1) + { + hlineSmoothFunc = hlineSmoothONa_yzy_a; + for (int i = 0; i < kxlen / 2; i++) + if (!(kx[i] == kx[kxlen - 1 - i])) + { + hlineSmoothFunc = hlineSmooth; + break; + } + } + else + hlineSmoothFunc = hlineSmooth; + if (kylen == 1) + { + if (ky[0] == FT::one()) + vlineSmoothFunc = vlineSmooth1N1; + else + vlineSmoothFunc = vlineSmooth1N; + } + else if (kylen == 3) + { + if (ky[0] == (FT::one() >> 2) && ky[1] == (FT::one() >> 1) && ky[2] == (FT::one() >> 2)) + vlineSmoothFunc = vlineSmooth3N121; + else + vlineSmoothFunc = vlineSmooth3N; + } + else if (kylen == 5) + { + if (ky[2] == (FT::one() * (uint8_t)3 >> 3) && + ky[1] == (FT::one() >> 2) && ky[3] == (FT::one() >> 2) && + ky[0] == (FT::one() >> 4) && ky[4] == (FT::one() >> 4)) + vlineSmoothFunc = vlineSmooth5N14641; + else + vlineSmoothFunc = vlineSmooth5N; + } + else if (kylen % 2 == 1) + { + vlineSmoothFunc = vlineSmoothONa_yzy_a; + for (int i = 0; i < kylen / 2; i++) + if (!(ky[i] == ky[kylen - 1 - i])) + { + vlineSmoothFunc = vlineSmooth; + break; + } + } + else + vlineSmoothFunc = vlineSmooth; + } + virtual void operator() (const Range& range) const CV_OVERRIDE + { + AutoBuffer _buf(width*cn*kylen); + FT* buf = _buf.data(); + AutoBuffer _ptrs(kylen*2); + FT** ptrs = _ptrs.data(); + + if (kylen == 1) + { + ptrs[0] = buf; + for (int i = range.start; i < range.end; i++) + { + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[0], width, borderType); + vlineSmoothFunc(ptrs, ky, kylen, dst + i * dst_stride, width*cn); + } + } + else if (borderType != BORDER_CONSTANT)// If BORDER_CONSTANT out of border values are equal to zero and could be skipped + { + int pre_shift = kylen / 2; + int post_shift = kylen - pre_shift - 1; + // First line evaluation + int idst = range.start; + int ifrom = max(0, idst - pre_shift); + int ito = idst + post_shift + 1; + int i = ifrom; + int bufline = 0; + for (; i < min(ito, height); i++, bufline++) + { + ptrs[bufline+kylen] = ptrs[bufline] = buf + bufline * width*cn; + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + } + for (; i < ito; i++, bufline++) + { + int src_idx = borderInterpolate(i, height, borderType); + if (src_idx < ifrom) + { + ptrs[bufline + kylen] = ptrs[bufline] = buf + bufline * width*cn; + hlineSmoothFunc(src + src_idx * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + } + else + { + ptrs[bufline + kylen] = ptrs[bufline] = ptrs[src_idx - ifrom]; + } + } + for (int j = idst - pre_shift; j < 0; j++) + { + int src_idx = borderInterpolate(j, height, borderType); + if (src_idx >= ito) + { + ptrs[2*kylen + j] = ptrs[kylen + j] = buf + (kylen + j) * width*cn; + hlineSmoothFunc(src + src_idx * src_stride, cn, kx, kxlen, ptrs[kylen + j], width, borderType); + } + else + { + ptrs[2*kylen + j] = ptrs[kylen + j] = ptrs[src_idx]; + } + } + vlineSmoothFunc(ptrs + bufline, ky, kylen, dst + idst*dst_stride, width*cn); idst++; + + // border mode dependent part evaluation + // i points to last src row to evaluate in convolution + bufline %= kylen; ito = min(height, range.end + post_shift); + for (; i < min(kylen, ito); i++, idst++) + { + ptrs[bufline + kylen] = ptrs[bufline] = buf + bufline * width*cn; + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + bufline = (bufline + 1) % kylen; + vlineSmoothFunc(ptrs + bufline, ky, kylen, dst + idst*dst_stride, width*cn); + } + // Points inside the border + for (; i < ito; i++, idst++) + { + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + bufline = (bufline + 1) % kylen; + vlineSmoothFunc(ptrs + bufline, ky, kylen, dst + idst*dst_stride, width*cn); + } + // Points that could fall below border + for (; i < range.end + post_shift; i++, idst++) + { + int src_idx = borderInterpolate(i, height, borderType); + if ((i - src_idx) > kylen) + hlineSmoothFunc(src + src_idx * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + else + ptrs[bufline + kylen] = ptrs[bufline] = ptrs[(bufline + kylen - (i - src_idx)) % kylen]; + bufline = (bufline + 1) % kylen; + vlineSmoothFunc(ptrs + bufline, ky, kylen, dst + idst*dst_stride, width*cn); + } + } + else + { + int pre_shift = kylen / 2; + int post_shift = kylen - pre_shift - 1; + // First line evaluation + int idst = range.start; + int ifrom = idst - pre_shift; + int ito = min(idst + post_shift + 1, height); + int i = max(0, ifrom); + int bufline = 0; + for (; i < ito; i++, bufline++) + { + ptrs[bufline + kylen] = ptrs[bufline] = buf + bufline * width*cn; + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + } + + if (bufline == 1) + vlineSmooth1N(ptrs, ky - min(ifrom, 0), bufline, dst + idst*dst_stride, width*cn); + else if (bufline == 3) + vlineSmooth3N(ptrs, ky - min(ifrom, 0), bufline, dst + idst*dst_stride, width*cn); + else if (bufline == 5) + vlineSmooth5N(ptrs, ky - min(ifrom, 0), bufline, dst + idst*dst_stride, width*cn); + else + vlineSmooth(ptrs, ky - min(ifrom, 0), bufline, dst + idst*dst_stride, width*cn); + idst++; + + // border mode dependent part evaluation + // i points to last src row to evaluate in convolution + bufline %= kylen; ito = min(height, range.end + post_shift); + for (; i < min(kylen, ito); i++, idst++) + { + ptrs[bufline + kylen] = ptrs[bufline] = buf + bufline * width*cn; + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + bufline++; + if (bufline == 3) + vlineSmooth3N(ptrs, ky + kylen - bufline, i + 1, dst + idst*dst_stride, width*cn); + else if (bufline == 5) + vlineSmooth5N(ptrs, ky + kylen - bufline, i + 1, dst + idst*dst_stride, width*cn); + else + vlineSmooth(ptrs, ky + kylen - bufline, i + 1, dst + idst*dst_stride, width*cn); + bufline %= kylen; + } + // Points inside the border + if (i - max(0, ifrom) >= kylen) + { + for (; i < ito; i++, idst++) + { + hlineSmoothFunc(src + i * src_stride, cn, kx, kxlen, ptrs[bufline], width, borderType); + bufline = (bufline + 1) % kylen; + vlineSmoothFunc(ptrs + bufline, ky, kylen, dst + idst*dst_stride, width*cn); + } + + // Points that could fall below border + // i points to first src row to evaluate in convolution + bufline = (bufline + 1) % kylen; + for (i = idst - pre_shift; i < range.end - pre_shift; i++, idst++, bufline++) + if (height - i == 3) + vlineSmooth3N(ptrs + bufline, ky, height - i, dst + idst*dst_stride, width*cn); + else if (height - i == 5) + vlineSmooth5N(ptrs + bufline, ky, height - i, dst + idst*dst_stride, width*cn); + else + vlineSmooth(ptrs + bufline, ky, height - i, dst + idst*dst_stride, width*cn); + } + else + { + // i points to first src row to evaluate in convolution + for (i = idst - pre_shift; i < min(range.end - pre_shift, 0); i++, idst++) + if (height == 3) + vlineSmooth3N(ptrs, ky - i, height, dst + idst*dst_stride, width*cn); + else if (height == 5) + vlineSmooth5N(ptrs, ky - i, height, dst + idst*dst_stride, width*cn); + else + vlineSmooth(ptrs, ky - i, height, dst + idst*dst_stride, width*cn); + for (; i < range.end - pre_shift; i++, idst++) + if (height - i == 3) + vlineSmooth3N(ptrs + i - max(0, ifrom), ky, height - i, dst + idst*dst_stride, width*cn); + else if (height - i == 5) + vlineSmooth5N(ptrs + i - max(0, ifrom), ky, height - i, dst + idst*dst_stride, width*cn); + else + vlineSmooth(ptrs + i - max(0, ifrom), ky, height - i, dst + idst*dst_stride, width*cn); + } + } + } +private: + const ET* src; + ET* dst; + size_t src_stride, dst_stride; + int width, height, cn; + const FT *kx, *ky; + int kxlen, kylen; + int borderType; + void(*hlineSmoothFunc)(const ET* src, int cn, const FT* m, int n, FT* dst, int len, int borderType); + void(*vlineSmoothFunc)(const FT* const * src, const FT* m, int n, ET* dst, int len); + + fixedSmoothInvoker(const fixedSmoothInvoker&); + fixedSmoothInvoker& operator=(const fixedSmoothInvoker&); +}; + +static void getGaussianKernel(int n, double sigma, int ktype, Mat& res) { res = getGaussianKernel(n, sigma, ktype); } +template static void getGaussianKernel(int n, double sigma, int, std::vector& res) { res = getFixedpointGaussianKernel(n, sigma); } + +template +static void createGaussianKernels( T & kx, T & ky, int type, Size &ksize, + double sigma1, double sigma2 ) +{ + int depth = CV_MAT_DEPTH(type); + if( sigma2 <= 0 ) + sigma2 = sigma1; + + // automatic detection of kernel size from sigma + if( ksize.width <= 0 && sigma1 > 0 ) + ksize.width = cvRound(sigma1*(depth == CV_8U ? 3 : 4)*2 + 1)|1; + if( ksize.height <= 0 && sigma2 > 0 ) + ksize.height = cvRound(sigma2*(depth == CV_8U ? 3 : 4)*2 + 1)|1; + + CV_Assert( ksize.width > 0 && ksize.width % 2 == 1 && + ksize.height > 0 && ksize.height % 2 == 1 ); + + sigma1 = std::max( sigma1, 0. ); + sigma2 = std::max( sigma2, 0. ); + + getGaussianKernel( ksize.width, sigma1, std::max(depth, CV_32F), kx ); + if( ksize.height == ksize.width && std::abs(sigma1 - sigma2) < DBL_EPSILON ) + ky = kx; + else + getGaussianKernel( ksize.height, sigma2, std::max(depth, CV_32F), ky ); +} + +} + +cv::Ptr cv::createGaussianFilter( int type, Size ksize, + double sigma1, double sigma2, + int borderType ) +{ + Mat kx, ky; + createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2); + + return createSeparableLinearFilter( type, type, kx, ky, Point(-1,-1), 0, borderType ); +} + +namespace cv +{ +#ifdef HAVE_OPENCL + +static bool ocl_GaussianBlur_8UC1(InputArray _src, OutputArray _dst, Size ksize, int ddepth, + InputArray _kernelX, InputArray _kernelY, int borderType) +{ + const ocl::Device & dev = ocl::Device::getDefault(); + int type = _src.type(), sdepth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); + + if ( !(dev.isIntel() && (type == CV_8UC1) && + (_src.offset() == 0) && (_src.step() % 4 == 0) && + ((ksize.width == 5 && (_src.cols() % 4 == 0)) || + (ksize.width == 3 && (_src.cols() % 16 == 0) && (_src.rows() % 2 == 0)))) ) + return false; + + Mat kernelX = _kernelX.getMat().reshape(1, 1); + if (kernelX.cols % 2 != 1) + return false; + Mat kernelY = _kernelY.getMat().reshape(1, 1); + if (kernelY.cols % 2 != 1) + return false; + + if (ddepth < 0) + ddepth = sdepth; + + Size size = _src.size(); + size_t globalsize[2] = { 0, 0 }; + size_t localsize[2] = { 0, 0 }; + + if (ksize.width == 3) + { + globalsize[0] = size.width / 16; + globalsize[1] = size.height / 2; + } + else if (ksize.width == 5) + { + globalsize[0] = size.width / 4; + globalsize[1] = size.height / 1; + } + + const char * const borderMap[] = { "BORDER_CONSTANT", "BORDER_REPLICATE", "BORDER_REFLECT", 0, "BORDER_REFLECT_101" }; + char build_opts[1024]; + sprintf(build_opts, "-D %s %s%s", borderMap[borderType & ~BORDER_ISOLATED], + ocl::kernelToStr(kernelX, CV_32F, "KERNEL_MATRIX_X").c_str(), + ocl::kernelToStr(kernelY, CV_32F, "KERNEL_MATRIX_Y").c_str()); + + ocl::Kernel kernel; + + if (ksize.width == 3) + kernel.create("gaussianBlur3x3_8UC1_cols16_rows2", cv::ocl::imgproc::gaussianBlur3x3_oclsrc, build_opts); + else if (ksize.width == 5) + kernel.create("gaussianBlur5x5_8UC1_cols4", cv::ocl::imgproc::gaussianBlur5x5_oclsrc, build_opts); + + if (kernel.empty()) + return false; + + UMat src = _src.getUMat(); + _dst.create(size, CV_MAKETYPE(ddepth, cn)); + if (!(_dst.offset() == 0 && _dst.step() % 4 == 0)) + return false; + UMat dst = _dst.getUMat(); + + int idxArg = kernel.set(0, ocl::KernelArg::PtrReadOnly(src)); + idxArg = kernel.set(idxArg, (int)src.step); + idxArg = kernel.set(idxArg, ocl::KernelArg::PtrWriteOnly(dst)); + idxArg = kernel.set(idxArg, (int)dst.step); + idxArg = kernel.set(idxArg, (int)dst.rows); + idxArg = kernel.set(idxArg, (int)dst.cols); + + return kernel.run(2, globalsize, (localsize[0] == 0) ? NULL : localsize, false); +} + +#endif + +#ifdef HAVE_OPENVX + +namespace ovx { + template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } +} +static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize, + double sigma1, double sigma2, int borderType) +{ + if (sigma2 <= 0) + sigma2 = sigma1; + // automatic detection of kernel size from sigma + if (ksize.width <= 0 && sigma1 > 0) + ksize.width = cvRound(sigma1*6 + 1) | 1; + if (ksize.height <= 0 && sigma2 > 0) + ksize.height = cvRound(sigma2*6 + 1) | 1; + + if (_src.type() != CV_8UC1 || + _src.cols() < 3 || _src.rows() < 3 || + ksize.width != 3 || ksize.height != 3) + return false; + + sigma1 = std::max(sigma1, 0.); + sigma2 = std::max(sigma2, 0.); + + if (!(sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) || !(sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON) || + ovx::skipSmallImages(_src.cols(), _src.rows())) + return false; + + Mat src = _src.getMat(); + Mat dst = _dst.getMat(); + + if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix()) + return false; //Process isolated borders only + vx_enum border; + switch (borderType & ~BORDER_ISOLATED) + { + case BORDER_CONSTANT: + border = VX_BORDER_CONSTANT; + break; + case BORDER_REPLICATE: + border = VX_BORDER_REPLICATE; + break; + default: + return false; + } + + try + { + ivx::Context ctx = ovx::getOpenVXContext(); + + Mat a; + if (dst.data != src.data) + a = src; + else + src.copyTo(a); + + ivx::Image + ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, + ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), + ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, + ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); + + //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments + //since OpenVX standard says nothing about thread-safety for now + ivx::border_t prevBorder = ctx.immediateBorder(); + ctx.setImmediateBorder(border, (vx_uint8)(0)); + ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib)); + ctx.setImmediateBorder(prevBorder); + } + catch (ivx::RuntimeError & e) + { + VX_DbgThrow(e.what()); + } + catch (ivx::WrapperError & e) + { + VX_DbgThrow(e.what()); + } + return true; +} + +#endif + +#ifdef HAVE_IPP +// IW 2017u2 has bug which doesn't allow use of partial inMem with tiling +#if IPP_DISABLE_GAUSSIANBLUR_PARALLEL +#define IPP_GAUSSIANBLUR_PARALLEL 0 +#else +#define IPP_GAUSSIANBLUR_PARALLEL 1 +#endif + +#ifdef HAVE_IPP_IW + +class ipp_gaussianBlurParallel: public ParallelLoopBody +{ +public: + ipp_gaussianBlurParallel(::ipp::IwiImage &src, ::ipp::IwiImage &dst, int kernelSize, float sigma, ::ipp::IwiBorderType &border, bool *pOk): + m_src(src), m_dst(dst), m_kernelSize(kernelSize), m_sigma(sigma), m_border(border), m_pOk(pOk) { + *m_pOk = true; + } + ~ipp_gaussianBlurParallel() + { + } + + virtual void operator() (const Range& range) const CV_OVERRIDE + { + CV_INSTRUMENT_REGION_IPP() + + if(!*m_pOk) + return; + + try + { + ::ipp::IwiTile tile = ::ipp::IwiRoi(0, range.start, m_dst.m_size.width, range.end - range.start); + CV_INSTRUMENT_FUN_IPP(::ipp::iwiFilterGaussian, m_src, m_dst, m_kernelSize, m_sigma, ::ipp::IwDefault(), m_border, tile); + } + catch(::ipp::IwException e) + { + *m_pOk = false; + return; } } private: @@ -2082,7 +4123,8 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, Size size = _src.size(); _dst.create( size, type ); - if( borderType != BORDER_CONSTANT && (borderType & BORDER_ISOLATED) != 0 ) + if( (borderType & ~BORDER_ISOLATED) != BORDER_CONSTANT && + ((borderType & BORDER_ISOLATED) != 0 || !_src.getMat().isSubmatrix()) ) { if( size.height == 1 ) ksize.height = 1; @@ -2104,6 +4146,20 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize, int sdepth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); + if(sdepth == CV_8U && ((borderType & BORDER_ISOLATED) || !_src.getMat().isSubmatrix())) + { + std::vector fkx, fky; + createGaussianKernels(fkx, fky, type, ksize, sigma1, sigma2); + Mat src = _src.getMat(); + Mat dst = _dst.getMat(); + if (src.data == dst.data) + src = src.clone(); + fixedSmoothInvoker invoker(src.ptr(), src.step1(), dst.ptr(), dst.step1(), dst.cols, dst.rows, dst.channels(), &fkx[0], (int)fkx.size(), &fky[0], (int)fky.size(), borderType & ~BORDER_ISOLATED); + parallel_for_(Range(0, dst.rows), invoker, std::max(1, std::min(getNumThreads(), getNumberOfCPUs()))); + return; + } + + Mat kx, ky; createGaussianKernels(kx, ky, type, ksize, sigma1, sigma2); @@ -2995,7 +5051,7 @@ namespace cv ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now + //since OpenVX standard says nothing about thread-safety for now ivx::border_t prevBorder = ctx.immediateBorder(); ctx.setImmediateBorder(VX_BORDER_REPLICATE); #ifdef VX_VERSION_1_1 @@ -3145,11 +5201,6 @@ void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize ) CV_IPP_RUN_FAST(ipp_medianFilter(src0, dst, ksize)); -#ifdef HAVE_TEGRA_OPTIMIZATION - if (tegra::useTegra() && tegra::medianBlur(src0, dst, ksize)) - return; -#endif - bool useSortNet = ksize == 3 || (ksize == 5 #if !(CV_SIMD128) && ( src0.depth() > CV_8U || src0.channels() == 2 || src0.channels() > 4 ) @@ -3211,7 +5262,7 @@ public: { } - virtual void operator() (const Range& range) const + virtual void operator() (const Range& range) const CV_OVERRIDE { int i, j, cn = dest->channels(), k; Size size = dest->size(); @@ -3253,11 +5304,17 @@ public: color_weight[buf[2]], color_weight[buf[3]]); v_float32x4 _sw = v_load(space_weight+k); +#if defined(_MSC_VER) && _MSC_VER == 1700/* MSVS 2012 */ && CV_AVX + // details: https://github.com/opencv/opencv/issues/11004 + vsumw += _cw * _sw; + vsumc += _cw * _sw * _valF; +#else v_float32x4 _w = _cw * _sw; _cw = _w * _valF; vsumw += _w; vsumc += _cw; +#endif } float *bufFloat = (float*)buf; v_float32x4 sum4 = v_reduce_sum4(vsumw, vsumc, vsumw, vsumc); @@ -3274,6 +5331,7 @@ public: wsum += w; } // overflow is not possible here => there is no need to use cv::saturate_cast + CV_DbgAssert(fabs(wsum) > 0); dptr[j] = (uchar)cvRound(sum/wsum); } } @@ -3322,6 +5380,13 @@ public: color_weight[buf[2]],color_weight[buf[3]]); v_float32x4 _sw = v_load(space_weight+k); +#if defined(_MSC_VER) && _MSC_VER == 1700/* MSVS 2012 */ && CV_AVX + // details: https://github.com/opencv/opencv/issues/11004 + vsumw += _w * _sw; + vsumb += _w * _sw * _b; + vsumg += _w * _sw * _g; + vsumr += _w * _sw * _r; +#else _w *= _sw; _b *= _w; _g *= _w; @@ -3331,6 +5396,7 @@ public: vsumb += _b; vsumg += _g; vsumr += _r; +#endif } float *bufFloat = (float*)buf; v_float32x4 sum4 = v_reduce_sum4(vsumw, vsumb, vsumg, vsumr); @@ -3351,6 +5417,7 @@ public: sum_b += b*w; sum_g += g*w; sum_r += r*w; wsum += w; } + CV_DbgAssert(fabs(wsum) > 0); wsum = 1.f/wsum; b0 = cvRound(sum_b*wsum); g0 = cvRound(sum_g*wsum); @@ -3535,7 +5602,7 @@ public: { } - virtual void operator() (const Range& range) const + virtual void operator() (const Range& range) const CV_OVERRIDE { int i, j, k; Size size = dest->size(); @@ -3610,6 +5677,7 @@ public: sum += val*w; wsum += w; } + CV_DbgAssert(fabs(wsum) > 0); dptr[j] = (float)(sum/wsum); } } @@ -3700,6 +5768,7 @@ public: sum_b += b*w; sum_g += g*w; sum_r += r*w; wsum += w; } + CV_DbgAssert(fabs(wsum) > 0); wsum = 1.f/wsum; b0 = sum_b*wsum; g0 = sum_g*wsum; @@ -3828,7 +5897,7 @@ public: } ~ipp_bilateralFilterParallel() {} - virtual void operator() (const Range& range) const + virtual void operator() (const Range& range) const CV_OVERRIDE { if(*pOk == false) return;