{

typedef T type1;

typedef T type2;

typedef T rtype;

T operator ()(const T a, const T b) const { return std::min(a, b); }

{

typedef T type1;

typedef T type2;

typedef T rtype;

T operator ()(const T a, const T b) const { return std::max(a, b); }

{

MorphRowNoVec(int, int) {}

int operator()(const uchar*, uchar*, int, int) const { return 0; }

{

MorphColumnNoVec(int, int) {}

int operator()(const uchar**, uchar*, int, int, int) const { return 0; }

{

enum { ESZ = VecUpdate::ESZ };

MorphRowIVec(int _ksize, int _anchor) : ksize(_ksize), anchor(_anchor) {}

int operator()(const uchar* src, uchar* dst, int width, int cn) const

{

if( !checkHardwareSupport(CV_CPU_SSE2) )

return 0;

cn *= ESZ;

int i, k, _ksize = ksize*cn;

width = (width & -4)*cn;

VecUpdate updateOp;

for( i = 0; i <= width - 16; i += 16 )

{

__m128i s = _mm_loadu_si128((const __m128i*)(src + i));

for( k = cn; k < _ksize; k += cn )

{

__m128i x = _mm_loadu_si128((const __m128i*)(src + i + k));

s = updateOp(s, x);

}

_mm_storeu_si128((__m128i*)(dst + i), s);

}

for( ; i < width; i += 4 )

{

__m128i s = _mm_cvtsi32_si128(*(const int*)(src + i));

for( k = cn; k < _ksize; k += cn )

{

__m128i x = _mm_cvtsi32_si128(*(const int*)(src + i + k));

s = updateOp(s, x);

}

*(int*)(dst + i) = _mm_cvtsi128_si32(s);

}

return i/ESZ;

}

int ksize, anchor;

{

MorphRowFVec(int _ksize, int _anchor) : ksize(_ksize), anchor(_anchor) {}

int operator()(const uchar* src, uchar* dst, int width, int cn) const

{

if( !checkHardwareSupport(CV_CPU_SSE) )

return 0;

int i, k, _ksize = ksize*cn;

width = (width & -4)*cn;

VecUpdate updateOp;

for( i = 0; i < width; i += 4 )

{

__m128 s = _mm_loadu_ps((const float*)src + i);

for( k = cn; k < _ksize; k += cn )

{

__m128 x = _mm_loadu_ps((const float*)src + i + k);

s = updateOp(s, x);

}

_mm_storeu_ps((float*)dst + i, s);

}

return i;

}

int ksize, anchor;

{

enum { ESZ = VecUpdate::ESZ };

MorphColumnIVec(int _ksize, int _anchor) : ksize(_ksize), anchor(_anchor) {}

int operator()(const uchar** src, uchar* dst, int dststep, int count, int width) const

{

if( !checkHardwareSupport(CV_CPU_SSE2) )

return 0;

int i = 0, k, _ksize = ksize;

width *= ESZ;

VecUpdate updateOp;

for( i = 0; i < count + ksize - 1; i++ )

CV_Assert( ((size_t)src[i] & 15) == 0 );

for( ; _ksize > 1 && count > 1; count -= 2, dst += dststep*2, src += 2 )

{

for( i = 0; i <= width - 32; i += 32 )

{

const uchar* sptr = src[1] + i;

__m128i s0 = _mm_load_si128((const __m128i*)sptr);

__m128i s1 = _mm_load_si128((const __m128i*)(sptr + 16));

__m128i x0, x1;

for( k = 2; k < _ksize; k++ )

{

sptr = src[k] + i;

x0 = _mm_load_si128((const __m128i*)sptr);

x1 = _mm_load_si128((const __m128i*)(sptr + 16));

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

}

sptr = src[0] + i;

x0 = _mm_load_si128((const __m128i*)sptr);

x1 = _mm_load_si128((const __m128i*)(sptr + 16));

_mm_storeu_si128((__m128i*)(dst + i), updateOp(s0, x0));

_mm_storeu_si128((__m128i*)(dst + i + 16), updateOp(s1, x1));

sptr = src[k] + i;

x0 = _mm_load_si128((const __m128i*)sptr);

x1 = _mm_load_si128((const __m128i*)(sptr + 16));

_mm_storeu_si128((__m128i*)(dst + dststep + i), updateOp(s0, x0));

_mm_storeu_si128((__m128i*)(dst + dststep + i + 16), updateOp(s1, x1));

}

for( ; i <= width - 8; i += 8 )

{

__m128i s0 = _mm_loadl_epi64((const __m128i*)(src[1] + i)), x0;

for( k = 2; k < _ksize; k++ )

{

x0 = _mm_loadl_epi64((const __m128i*)(src[k] + i));

s0 = updateOp(s0, x0);

}

x0 = _mm_loadl_epi64((const __m128i*)(src[0] + i));

_mm_storel_epi64((__m128i*)(dst + i), updateOp(s0, x0));

x0 = _mm_loadl_epi64((const __m128i*)(src[k] + i));

_mm_storel_epi64((__m128i*)(dst + dststep + i), updateOp(s0, x0));

}

}

for( ; count > 0; count--, dst += dststep, src++ )

{

for( i = 0; i <= width - 32; i += 32 )

{

const uchar* sptr = src[0] + i;

__m128i s0 = _mm_load_si128((const __m128i*)sptr);

__m128i s1 = _mm_load_si128((const __m128i*)(sptr + 16));

__m128i x0, x1;

for( k = 1; k < _ksize; k++ )

{

sptr = src[k] + i;

x0 = _mm_load_si128((const __m128i*)sptr);

x1 = _mm_load_si128((const __m128i*)(sptr + 16));

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

}

_mm_storeu_si128((__m128i*)(dst + i), s0);

_mm_storeu_si128((__m128i*)(dst + i + 16), s1);

}

for( ; i <= width - 8; i += 8 )

{

__m128i s0 = _mm_loadl_epi64((const __m128i*)(src[0] + i)), x0;

for( k = 1; k < _ksize; k++ )

{

x0 = _mm_loadl_epi64((const __m128i*)(src[k] + i));

s0 = updateOp(s0, x0);

}

_mm_storel_epi64((__m128i*)(dst + i), s0);

}

}

return i/ESZ;

}

int ksize, anchor;

{

MorphColumnFVec(int _ksize, int _anchor) : ksize(_ksize), anchor(_anchor) {}

int operator()(const uchar** _src, uchar* _dst, int dststep, int count, int width) const

{

if( !checkHardwareSupport(CV_CPU_SSE) )

return 0;

int i = 0, k, _ksize = ksize;

VecUpdate updateOp;

for( i = 0; i < count + ksize - 1; i++ )

CV_Assert( ((size_t)_src[i] & 15) == 0 );

const float** src = (const float**)_src;

float* dst = (float*)_dst;

dststep /= sizeof(dst[0]);

for( ; _ksize > 1 && count > 1; count -= 2, dst += dststep*2, src += 2 )

{

for( i = 0; i <= width - 16; i += 16 )

{

const float* sptr = src[1] + i;

__m128 s0 = _mm_load_ps(sptr);

__m128 s1 = _mm_load_ps(sptr + 4);

__m128 s2 = _mm_load_ps(sptr + 8);

__m128 s3 = _mm_load_ps(sptr + 12);

__m128 x0, x1, x2, x3;

for( k = 2; k < _ksize; k++ )

{

sptr = src[k] + i;

x0 = _mm_load_ps(sptr);

x1 = _mm_load_ps(sptr + 4);

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

x2 = _mm_load_ps(sptr + 8);

x3 = _mm_load_ps(sptr + 12);

s2 = updateOp(s2, x2);

s3 = updateOp(s3, x3);

}

sptr = src[0] + i;

x0 = _mm_load_ps(sptr);

x1 = _mm_load_ps(sptr + 4);

x2 = _mm_load_ps(sptr + 8);

x3 = _mm_load_ps(sptr + 12);

_mm_storeu_ps(dst + i, updateOp(s0, x0));

_mm_storeu_ps(dst + i + 4, updateOp(s1, x1));

_mm_storeu_ps(dst + i + 8, updateOp(s2, x2));

_mm_storeu_ps(dst + i + 12, updateOp(s3, x3));

sptr = src[k] + i;

x0 = _mm_load_ps(sptr);

x1 = _mm_load_ps(sptr + 4);

x2 = _mm_load_ps(sptr + 8);

x3 = _mm_load_ps(sptr + 12);

_mm_storeu_ps(dst + dststep + i, updateOp(s0, x0));

_mm_storeu_ps(dst + dststep + i + 4, updateOp(s1, x1));

_mm_storeu_ps(dst + dststep + i + 8, updateOp(s2, x2));

_mm_storeu_ps(dst + dststep + i + 12, updateOp(s3, x3));

}

for( ; i <= width - 4; i += 4 )

{

__m128 s0 = _mm_load_ps(src[1] + i), x0;

for( k = 2; k < _ksize; k++ )

{

x0 = _mm_load_ps(src[k] + i);

s0 = updateOp(s0, x0);

}

x0 = _mm_load_ps(src[0] + i);

_mm_storeu_ps(dst + i, updateOp(s0, x0));

x0 = _mm_load_ps(src[k] + i);

_mm_storeu_ps(dst + dststep + i, updateOp(s0, x0));

}

}

for( ; count > 0; count--, dst += dststep, src++ )

{

for( i = 0; i <= width - 16; i += 16 )

{

const float* sptr = src[0] + i;

__m128 s0 = _mm_load_ps(sptr);

__m128 s1 = _mm_load_ps(sptr + 4);

__m128 s2 = _mm_load_ps(sptr + 8);

__m128 s3 = _mm_load_ps(sptr + 12);

__m128 x0, x1, x2, x3;

for( k = 1; k < _ksize; k++ )

{

sptr = src[k] + i;

x0 = _mm_load_ps(sptr);

x1 = _mm_load_ps(sptr + 4);

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

x2 = _mm_load_ps(sptr + 8);

x3 = _mm_load_ps(sptr + 12);

s2 = updateOp(s2, x2);

s3 = updateOp(s3, x3);

}

_mm_storeu_ps(dst + i, s0);

_mm_storeu_ps(dst + i + 4, s1);

_mm_storeu_ps(dst + i + 8, s2);

_mm_storeu_ps(dst + i + 12, s3);

}

for( i = 0; i <= width - 4; i += 4 )

{

__m128 s0 = _mm_load_ps(src[0] + i), x0;

for( k = 1; k < _ksize; k++ )

{

x0 = _mm_load_ps(src[k] + i);

s0 = updateOp(s0, x0);

}

_mm_storeu_ps(dst + i, s0);

}

}

return i;

}

int ksize, anchor;

{

enum { ESZ = VecUpdate::ESZ };

int operator()(uchar** src, int nz, uchar* dst, int width) const

{

if( !checkHardwareSupport(CV_CPU_SSE2) )

return 0;

int i, k;

width *= ESZ;

VecUpdate updateOp;

for( i = 0; i <= width - 32; i += 32 )

{

const uchar* sptr = src[0] + i;

__m128i s0 = _mm_loadu_si128((const __m128i*)sptr);

__m128i s1 = _mm_loadu_si128((const __m128i*)(sptr + 16));

__m128i x0, x1;

for( k = 1; k < nz; k++ )

{

sptr = src[k] + i;

x0 = _mm_loadu_si128((const __m128i*)sptr);

x1 = _mm_loadu_si128((const __m128i*)(sptr + 16));

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

}

_mm_storeu_si128((__m128i*)(dst + i), s0);

_mm_storeu_si128((__m128i*)(dst + i + 16), s1);

}

for( ; i <= width - 8; i += 8 )

{

__m128i s0 = _mm_loadl_epi64((const __m128i*)(src[0] + i)), x0;

for( k = 1; k < nz; k++ )

{

x0 = _mm_loadl_epi64((const __m128i*)(src[k] + i));

s0 = updateOp(s0, x0);

}

_mm_storel_epi64((__m128i*)(dst + i), s0);

}

return i/ESZ;

}

{

int operator()(uchar** _src, int nz, uchar* _dst, int width) const

{

if( !checkHardwareSupport(CV_CPU_SSE) )

return 0;

const float** src = (const float**)_src;

float* dst = (float*)_dst;

int i, k;

VecUpdate updateOp;

for( i = 0; i <= width - 16; i += 16 )

{

const float* sptr = src[0] + i;

__m128 s0 = _mm_loadu_ps(sptr);

__m128 s1 = _mm_loadu_ps(sptr + 4);

__m128 s2 = _mm_loadu_ps(sptr + 8);

__m128 s3 = _mm_loadu_ps(sptr + 12);

__m128 x0, x1, x2, x3;

for( k = 1; k < nz; k++ )

{

sptr = src[k] + i;

x0 = _mm_loadu_ps(sptr);

x1 = _mm_loadu_ps(sptr + 4);

x2 = _mm_loadu_ps(sptr + 8);

x3 = _mm_loadu_ps(sptr + 12);

s0 = updateOp(s0, x0);

s1 = updateOp(s1, x1);

s2 = updateOp(s2, x2);

s3 = updateOp(s3, x3);

}

_mm_storeu_ps(dst + i, s0);

_mm_storeu_ps(dst + i + 4, s1);

_mm_storeu_ps(dst + i + 8, s2);

_mm_storeu_ps(dst + i + 12, s3);

}

for( ; i <= width - 4; i += 4 )

{

__m128 s0 = _mm_loadu_ps(src[0] + i), x0;

for( k = 1; k < nz; k++ )

{

x0 = _mm_loadu_ps(src[k] + i);

s0 = updateOp(s0, x0);

}

_mm_storeu_ps(dst + i, s0);

}

for( ; i < width; i++ )

{

__m128 s0 = _mm_load_ss(src[0] + i), x0;

for( k = 1; k < nz; k++ )

{

x0 = _mm_load_ss(src[k] + i);

s0 = updateOp(s0, x0);

}

_mm_store_ss(dst + i, s0);

}

return i;

}

{

enum { ESZ = 1 };

__m128i operator()(const __m128i& a, const __m128i& b) const { return _mm_min_epu8(a,b); }

{

enum { ESZ = 1 };

__m128i operator()(const __m128i& a, const __m128i& b) const { return _mm_max_epu8(a,b); }

{

enum { ESZ = 2 };

__m128i operator()(const __m128i& a, const __m128i& b) const

{ return _mm_subs_epu16(a,_mm_subs_epu16(a,b)); }

{

enum { ESZ = 2 };

__m128i operator()(const __m128i& a, const __m128i& b) const

{ return _mm_adds_epu16(_mm_subs_epu16(a,b), b); }

{

enum { ESZ = 2 };

__m128i operator()(const __m128i& a, const __m128i& b) const

{ return _mm_min_epi16(a, b); }

{

enum { ESZ = 2 };

__m128i operator()(const __m128i& a, const __m128i& b) const

{ return _mm_max_epi16(a, b); }

{

typedef typename Op::rtype T;

MorphRowFilter( int _ksize, int _anchor ) : vecOp(_ksize, _anchor)

{

ksize = _ksize;

anchor = _anchor;

}

void operator()(const uchar* src, uchar* dst, int width, int cn) CV_OVERRIDE

{

int i, j, k, _ksize = ksize*cn;

const T* S = (const T*)src;

Op op;

T* D = (T*)dst;

if( _ksize == cn )

{

for( i = 0; i < width*cn; i++ )

D[i] = S[i];

return;

}

int i0 = vecOp(src, dst, width, cn);

width *= cn;

for( k = 0; k < cn; k++, S++, D++ )

{

for( i = i0; i <= width - cn*2; i += cn*2 )

{

const T* s = S + i;

T m = s[cn];

for( j = cn*2; j < _ksize; j += cn )

m = op(m, s[j]);

D[i] = op(m, s[0]);

D[i+cn] = op(m, s[j]);

}

for( ; i < width; i += cn )

{

const T* s = S + i;

T m = s[0];

for( j = cn; j < _ksize; j += cn )

m = op(m, s[j]);

D[i] = m;

}

}

}

VecOp vecOp;

{

typedef typename Op::rtype T;

MorphColumnFilter( int _ksize, int _anchor ) : vecOp(_ksize, _anchor)

{

ksize = _ksize;

anchor = _anchor;

}

void operator()(const uchar** _src, uchar* dst, int dststep, int count, int width) CV_OVERRIDE

{

int i, k, _ksize = ksize;

const T** src = (const T**)_src;

T* D = (T*)dst;

Op op;

int i0 = vecOp(_src, dst, dststep, count, width);

dststep /= sizeof(D[0]);

for( ; _ksize > 1 && count > 1; count -= 2, D += dststep*2, src += 2 )

{

i = i0;

#if CV_ENABLE_UNROLLED

for( ; i <= width - 4; i += 4 )

{

const T* sptr = src[1] + i;

T s0 = sptr[0], s1 = sptr[1], s2 = sptr[2], s3 = sptr[3];

for( k = 2; k < _ksize; k++ )

{

sptr = src[k] + i;

s0 = op(s0, sptr[0]); s1 = op(s1, sptr[1]);

s2 = op(s2, sptr[2]); s3 = op(s3, sptr[3]);

}

sptr = src[0] + i;

D[i] = op(s0, sptr[0]);

D[i+1] = op(s1, sptr[1]);

D[i+2] = op(s2, sptr[2]);

D[i+3] = op(s3, sptr[3]);

sptr = src[k] + i;

D[i+dststep] = op(s0, sptr[0]);

D[i+dststep+1] = op(s1, sptr[1]);

D[i+dststep+2] = op(s2, sptr[2]);

D[i+dststep+3] = op(s3, sptr[3]);

}

#endif

for( ; i < width; i++ )

{

T s0 = src[1][i];

for( k = 2; k < _ksize; k++ )

s0 = op(s0, src[k][i]);

D[i] = op(s0, src[0][i]);

D[i+dststep] = op(s0, src[k][i]);

}

}

for( ; count > 0; count--, D += dststep, src++ )

{

i = i0;

#if CV_ENABLE_UNROLLED

for( ; i <= width - 4; i += 4 )

{

const T* sptr = src[0] + i;

T s0 = sptr[0], s1 = sptr[1], s2 = sptr[2], s3 = sptr[3];

for( k = 1; k < _ksize; k++ )

{

sptr = src[k] + i;

s0 = op(s0, sptr[0]); s1 = op(s1, sptr[1]);

s2 = op(s2, sptr[2]); s3 = op(s3, sptr[3]);

}

D[i] = s0; D[i+1] = s1;

D[i+2] = s2; D[i+3] = s3;

}

#endif

for( ; i < width; i++ )

{

T s0 = src[0][i];

for( k = 1; k < _ksize; k++ )

s0 = op(s0, src[k][i]);

D[i] = s0;

}

}

}

VecOp vecOp;

{

typedef typename Op::rtype T;

MorphFilter( const Mat& _kernel, Point _anchor )

{

anchor = _anchor;

ksize = _kernel.size();

CV_Assert( _kernel.type() == CV_8U );

std::vector<uchar> coeffs; // we do not really the values of non-zero

// kernel elements, just their locations

preprocess2DKernel( _kernel, coords, coeffs );

ptrs.resize( coords.size() );

}

void operator()(const uchar** src, uchar* dst, int dststep, int count, int width, int cn) CV_OVERRIDE

{

const Point* pt = &coords[0];

const T** kp = (const T**)&ptrs[0];

int i, k, nz = (int)coords.size();

Op op;

width *= cn;

for( ; count > 0; count--, dst += dststep, src++ )

{

T* D = (T*)dst;

for( k = 0; k < nz; k++ )

kp[k] = (const T*)src[pt[k].y] + pt[k].x*cn;

i = vecOp(&ptrs[0], nz, dst, width);

#if CV_ENABLE_UNROLLED

for( ; i <= width - 4; i += 4 )

{

const T* sptr = kp[0] + i;

T s0 = sptr[0], s1 = sptr[1], s2 = sptr[2], s3 = sptr[3];

for( k = 1; k < nz; k++ )

{

sptr = kp[k] + i;

s0 = op(s0, sptr[0]); s1 = op(s1, sptr[1]);

s2 = op(s2, sptr[2]); s3 = op(s3, sptr[3]);

}

D[i] = s0; D[i+1] = s1;

D[i+2] = s2; D[i+3] = s3;

}

#endif

for( ; i < width; i++ )

{

T s0 = kp[0][i];

for( k = 1; k < nz; k++ )

s0 = op(s0, kp[k][i]);

D[i] = s0;

}

}

}

std::vector<Point> coords;

std::vector<uchar*> ptrs;

VecOp vecOp;

{

int depth = CV_MAT_DEPTH(type);

if( anchor < 0 )

anchor = ksize/2;

CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE );

if( op == MORPH_ERODE )

{

if( depth == CV_8U )

return makePtr<MorphRowFilter<MinOp<uchar>,

ErodeRowVec8u> >(ksize, anchor);

if( depth == CV_16U )

return makePtr<MorphRowFilter<MinOp<ushort>,

ErodeRowVec16u> >(ksize, anchor);

if( depth == CV_16S )

return makePtr<MorphRowFilter<MinOp<short>,

ErodeRowVec16s> >(ksize, anchor);

if( depth == CV_32F )

return makePtr<MorphRowFilter<MinOp<float>,

ErodeRowVec32f> >(ksize, anchor);

if( depth == CV_64F )

return makePtr<MorphRowFilter<MinOp<double>,

ErodeRowVec64f> >(ksize, anchor);

}

else

{

if( depth == CV_8U )

return makePtr<MorphRowFilter<MaxOp<uchar>,

DilateRowVec8u> >(ksize, anchor);

if( depth == CV_16U )

return makePtr<MorphRowFilter<MaxOp<ushort>,

DilateRowVec16u> >(ksize, anchor);

if( depth == CV_16S )

return makePtr<MorphRowFilter<MaxOp<short>,

DilateRowVec16s> >(ksize, anchor);

if( depth == CV_32F )

return makePtr<MorphRowFilter<MaxOp<float>,

DilateRowVec32f> >(ksize, anchor);

if( depth == CV_64F )

return makePtr<MorphRowFilter<MaxOp<double>,

DilateRowVec64f> >(ksize, anchor);

}

CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type));

{

int depth = CV_MAT_DEPTH(type);

if( anchor < 0 )

anchor = ksize/2;

CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE );

if( op == MORPH_ERODE )

{

if( depth == CV_8U )

return makePtr<MorphColumnFilter<MinOp<uchar>,

ErodeColumnVec8u> >(ksize, anchor);

if( depth == CV_16U )

return makePtr<MorphColumnFilter<MinOp<ushort>,

ErodeColumnVec16u> >(ksize, anchor);

if( depth == CV_16S )

return makePtr<MorphColumnFilter<MinOp<short>,

ErodeColumnVec16s> >(ksize, anchor);

if( depth == CV_32F )

return makePtr<MorphColumnFilter<MinOp<float>,

ErodeColumnVec32f> >(ksize, anchor);

if( depth == CV_64F )

return makePtr<MorphColumnFilter<MinOp<double>,

ErodeColumnVec64f> >(ksize, anchor);

}

else

{

if( depth == CV_8U )

return makePtr<MorphColumnFilter<MaxOp<uchar>,

DilateColumnVec8u> >(ksize, anchor);

if( depth == CV_16U )

return makePtr<MorphColumnFilter<MaxOp<ushort>,

DilateColumnVec16u> >(ksize, anchor);

if( depth == CV_16S )

return makePtr<MorphColumnFilter<MaxOp<short>,

DilateColumnVec16s> >(ksize, anchor);

if( depth == CV_32F )

return makePtr<MorphColumnFilter<MaxOp<float>,

DilateColumnVec32f> >(ksize, anchor);

if( depth == CV_64F )

return makePtr<MorphColumnFilter<MaxOp<double>,

DilateColumnVec64f> >(ksize, anchor);

}

CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type));

{

Mat kernel = _kernel.getMat();

int depth = CV_MAT_DEPTH(type);

anchor = normalizeAnchor(anchor, kernel.size());

CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE );

if( op == MORPH_ERODE )

{

if( depth == CV_8U )

return makePtr<MorphFilter<MinOp<uchar>, ErodeVec8u> >(kernel, anchor);

if( depth == CV_16U )

return makePtr<MorphFilter<MinOp<ushort>, ErodeVec16u> >(kernel, anchor);

if( depth == CV_16S )

return makePtr<MorphFilter<MinOp<short>, ErodeVec16s> >(kernel, anchor);

if( depth == CV_32F )

return makePtr<MorphFilter<MinOp<float>, ErodeVec32f> >(kernel, anchor);

if( depth == CV_64F )

return makePtr<MorphFilter<MinOp<double>, ErodeVec64f> >(kernel, anchor);

}

else

{

if( depth == CV_8U )

return makePtr<MorphFilter<MaxOp<uchar>, DilateVec8u> >(kernel, anchor);

if( depth == CV_16U )

return makePtr<MorphFilter<MaxOp<ushort>, DilateVec16u> >(kernel, anchor);

if( depth == CV_16S )

return makePtr<MorphFilter<MaxOp<short>, DilateVec16s> >(kernel, anchor);

if( depth == CV_32F )

return makePtr<MorphFilter<MaxOp<float>, DilateVec32f> >(kernel, anchor);

if( depth == CV_64F )

return makePtr<MorphFilter<MaxOp<double>, DilateVec64f> >(kernel, anchor);

}

CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type));

Point anchor, int _rowBorderType, int _columnBorderType,

const Scalar& _borderValue )

{

Mat kernel = _kernel.getMat();

anchor = normalizeAnchor(anchor, kernel.size());

Ptr<BaseRowFilter> rowFilter;

Ptr<BaseColumnFilter> columnFilter;

Ptr<BaseFilter> filter2D;

if( countNonZero(kernel) == kernel.rows*kernel.cols )

{

// rectangular structuring element

rowFilter = getMorphologyRowFilter(op, type, kernel.cols, anchor.x);

columnFilter = getMorphologyColumnFilter(op, type, kernel.rows, anchor.y);

}

else

filter2D = getMorphologyFilter(op, type, kernel, anchor);

Scalar borderValue = _borderValue;

if( (_rowBorderType == BORDER_CONSTANT || _columnBorderType == BORDER_CONSTANT) &&

borderValue == morphologyDefaultBorderValue() )

{