CV_IMPL void
cvCornerEigenValsAndVecs( const void* srcarr, void* eigenvarr,
int block_size, int aperture_size )
{
static CvFuncTable eig_tab;
static int inittab = 0;
void *buffer = 0;
CV_FUNCNAME( "cvCornerEigenValsAndVecs" );
__BEGIN__;
CvSize src_size;
int buf_size;
CvEigFunc func = 0;
CvMat stub, *src = (CvMat*)srcarr;
CvMat eigstub, *eigenv = (CvMat*)eigenvarr;
if( !inittab )
{
icvInitEigenValsVecsTable( &eig_tab );
inittab = 1;
}
CV_CALL( src = cvGetMat( srcarr, &stub ));
CV_CALL( eigenv = cvGetMat( eigenv, &eigstub ));
if( CV_ARR_CN(src->type) != 1 )
CV_ERROR(CV_StsBadArg, "Source image has more than 1 channel");
if( CV_ARR_CN(eigenv->type)*eigenv->width != src->width*6 )
CV_ERROR(CV_StsBadArg, "Eigen-vals&vecs image should be 6 times "
"wider than the source image");
if( src->height != eigenv->height )
CV_ERROR( CV_StsUnmatchedSizes, "" );
if( CV_ARR_DEPTH(eigenv->type) != CV_32F )
CV_ERROR( CV_BadDepth, "Eigen-vals&vecs image does not have IPL_DEPTH_32F depth" );
func = (CvEigFunc)(eig_tab.fn_2d[CV_ARR_DEPTH(src->type)]);
if( !func )
CV_ERROR( CV_StsUnsupportedFormat, "" );
src_size = icvGetMatSize( src );
IPPI_CALL( icvEigenValsVecsGetSize( src_size.width, aperture_size,
block_size, &buf_size ));
CV_CALL( buffer = cvAlloc( buf_size ));
IPPI_CALL( func( src->data.ptr, src->step, eigenv->data.ptr, eigenv->step,
src_size, aperture_size, block_size, buffer ));
__END__;
cvFree( &buffer );
}
CV_IMPL void
cvCornerMinEigenVal( const void* srcarr, void* eigenvarr,
int block_size, int aperture_size )
{
static CvFuncTable eig_tab;
static int inittab = 0;
void *buffer = 0;
CV_FUNCNAME( "cvCornerMinEigenVal" );
__BEGIN__;
CvSize src_size;
int buf_size;
CvEigFunc func = 0;
CvMat stub, *src = (CvMat*)srcarr;
CvMat eigstub, *eigenv = (CvMat*)eigenvarr;
if( !inittab )
{
icvInitMinEigenValTable( &eig_tab );
inittab = 1;
}
CV_CALL( src = cvGetMat( srcarr, &stub ));
CV_CALL( eigenv = cvGetMat( eigenv, &eigstub ));
if( CV_ARR_CN(src->type) != 1 || CV_ARR_CN(eigenv->type) != 1 )
CV_ERROR(CV_StsBadArg, "Source or min-eigen-val images have more than 1 channel");
if( CV_ARR_DEPTH(eigenv->type) != CV_32F )
CV_ERROR( CV_BadDepth, "min-eigen-val image does not have IPL_DEPTH_32F depth" );
if( !CV_ARE_SIZES_EQ( src, eigenv ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
func = (CvEigFunc)(eig_tab.fn_2d[CV_ARR_DEPTH(src->type)]);
if( !func )
CV_ERROR( CV_StsUnsupportedFormat, "" );
src_size = icvGetMatSize( src );
IPPI_CALL( icvMinEigenValGetSize( src_size.width, aperture_size, block_size, &buf_size ));
CV_CALL( buffer = cvAlloc( buf_size ));
IPPI_CALL( func( src->data.ptr, src->step, eigenv->data.ptr, eigenv->step,
src_size, aperture_size, block_size, buffer ));
__END__;
cvFree( &buffer );
}
// get essential information about image ROI or CvMat data
CV_IMPL void
cvGetRawData( const CvArr* arr, uchar** data, int* step, CvSize* roi_size )
{
CV_FUNCNAME( "cvGetRawData" );
__BEGIN__;
if( CV_IS_ARR( arr ))
{
CvMat *mat = (CvMat*)arr;
if( step )
*step = mat->step;
if( data )
*data = mat->data.ptr;
if( roi_size )
*roi_size = icvGetMatSize( mat );
}
else if( CV_IS_IMAGE( arr ))
{
IplImage* img = (IplImage*)arr;
if( step )
*step = img->widthStep;
if( data )
CV_CALL( *data = cvGetPtrAt( img, 0, 0 ));
if( roi_size )
{
if( img->roi )
{
*roi_size = cvSize( img->roi->width, img->roi->height );
}
else
{
*roi_size = cvSize( img->width, img->height );
}
}
}
else
{
CV_ERROR( CV_StsBadArg, "" );
}
__END__;
}
CV_IMPL void
cvPreCornerDetect( const void* srcarr, void* dstarr, int aperture_size )
{
static CvFuncTable pre_tab;
static int inittab = 0;
CV_FUNCNAME( "cvPreCornerDetect" );
__BEGIN__;
CvSize src_size;
CvPreCornerFunc func = 0;
CvMat srcstub, *src = (CvMat*)srcarr;
CvMat dststub, *dst = (CvMat*)dstarr;
if( !inittab )
{
icvInitPreCornerDetectTable( &pre_tab );
inittab = 1;
}
CV_CALL( src = cvGetMat( srcarr, &srcstub ));
CV_CALL( dst = cvGetMat( dstarr, &dststub ));
if( CV_ARR_CN(src->type) != 1 || CV_ARR_CN(dst->type) != 1 )
CV_ERROR(CV_StsBadArg, "Source or min-eigen-val images have more than 1 channel");
if( CV_ARR_DEPTH(dst->type) != CV_32F )
CV_ERROR( CV_BadDepth, "min-eigen-val image does not have IPL_DEPTH_32F depth" );
if( !CV_ARE_SIZES_EQ( src, dst ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
func = (CvPreCornerFunc)(pre_tab.fn_2d[CV_ARR_DEPTH(src->type)]);
if( !func )
CV_ERROR( CV_StsUnsupportedFormat, "" );
src_size = icvGetMatSize( src );
IPPI_CALL( func( src->data.ptr, src->step, dst->data.ptr, dst->step,
src_size, aperture_size ));
__END__;
}
CV_IMPL void
cvImgToObs_DCT( const void* arr, float *obs, CvSize dctSize,
CvSize obsSize, CvSize delta )
{
CV_FUNCNAME( "cvImgToObs_DCT" );
__BEGIN__;
CvMat stub, *mat = (CvMat*)arr;
CV_CALL( mat = cvGetMat( arr, &stub ));
if( CV_ARR_TYPE( mat->type ) != CV_8UC1 )
CV_ERROR( CV_StsUnsupportedFormat, "" );
IPPI_CALL( icvImgToObs_DCT_8u32f_C1R( (uchar*)mat->data.ptr, mat->step,
icvGetMatSize(mat), obs,
dctSize, obsSize, delta ));
__END__;
}
CV_IMPL void
cvAbsDiffS( const void* srcarr, void* dstarr, CvScalar scalar )
{
static CvFuncTable adiffs_tab;
static int inittab = 0;
CV_FUNCNAME( "cvAbsDiffS" );
__BEGIN__;
int coi1 = 0, coi2 = 0;
int type, sctype;
CvMat srcstub, *src = (CvMat*)srcarr;
CvMat dststub, *dst = (CvMat*)dstarr;
int src_step = src->step;
int dst_step = dst->step;
double buf[12];
CvSize size;
if( !inittab )
{
icvInitAbsDiffCTable( &adiffs_tab );
inittab = 1;
}
CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));
if( coi1 != 0 || coi2 != 0 )
CV_ERROR( CV_BadCOI, "" );
if( !CV_ARE_TYPES_EQ(src, dst) )
CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
if( !CV_ARE_SIZES_EQ(src, dst) )
CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
sctype = type = CV_MAT_TYPE( src->type );
if( CV_MAT_DEPTH(type) < CV_32S )
sctype = (type & CV_MAT_CN_MASK) | CV_32SC1;
size = icvGetMatSize( src );
size.width *= CV_MAT_CN( type );
src_step = src->step;
dst_step = dst->step;
if( CV_IS_MAT_CONT( src->type & dst->type ))
{
size.width *= size.height;
size.height = 1;
src_step = dst_step = CV_STUB_STEP;
}
CV_CALL( cvScalarToRawData( &scalar, buf, sctype, 1 ));
{
CvFunc2D_2A1P func = (CvFunc2D_2A1P)
(adiffs_tab.fn_2d[CV_MAT_DEPTH(type)]);
if( !func )
CV_ERROR( CV_StsUnsupportedFormat, "" );
IPPI_CALL( func( src->data.ptr, src_step, dst->data.ptr,
dst_step, size, buf ));
}
__END__;
}
CV_IMPL void
cvAbsDiff( const void* srcarr1, const void* srcarr2, void* dstarr )
{
static CvFuncTable adiff_tab;
static int inittab = 0;
CV_FUNCNAME( "cvAbsDiff" );
__BEGIN__;
int coi1 = 0, coi2 = 0, coi3 = 0;
CvMat srcstub1, *src1 = (CvMat*)srcarr1;
CvMat srcstub2, *src2 = (CvMat*)srcarr2;
CvMat dststub, *dst = (CvMat*)dstarr;
int src1_step, src2_step, dst_step;
CvSize size;
int type;
if( !inittab )
{
icvInitAbsDiffTable( &adiff_tab );
inittab = 1;
}
CV_CALL( src1 = cvGetMat( src1, &srcstub1, &coi1 ));
CV_CALL( src2 = cvGetMat( src2, &srcstub2, &coi2 ));
CV_CALL( dst = cvGetMat( dst, &dststub, &coi3 ));
if( coi1 != 0 || coi2 != 0 || coi3 != 0 )
CV_ERROR( CV_BadCOI, "" );
if( !CV_ARE_SIZES_EQ( src1, src2 ) )
CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
size = icvGetMatSize( src1 );
type = CV_MAT_TYPE(src1->type);
if( !CV_ARE_SIZES_EQ( src1, dst ))
CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
if( !CV_ARE_TYPES_EQ( src1, src2 ))
CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
if( !CV_ARE_TYPES_EQ( src1, dst ))
CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
size.width *= CV_MAT_CN( type );
src1_step = src1->step;
src2_step = src2->step;
dst_step = dst->step;
if( CV_IS_MAT_CONT( src1->type & src2->type & dst->type ))
{
size.width *= size.height;
size.height = 1;
src1_step = src2_step = dst_step = CV_STUB_STEP;
}
{
CvFunc2D_3A func = (CvFunc2D_3A)
(adiff_tab.fn_2d[CV_MAT_DEPTH(type)]);
if( !func )
CV_ERROR( CV_StsUnsupportedFormat, "" );
IPPI_CALL( func( src1->data.ptr, src1_step, src2->data.ptr, src2_step,
dst->data.ptr, dst_step, size ));
}
__END__;
}
CV_IMPL double
cvPseudoInv( CvArr* srcarr, CvArr* dstarr, int flags )
{
uchar* buffer = 0;
int local_alloc = 0;
double condition_number = 0;
CV_FUNCNAME( "cvPseudoInv" );
__BEGIN__;
CvMat astub, *a = (CvMat*)srcarr;
CvMat bstub, *b = (CvMat*)dstarr;
CvMat ustub, *u = &ustub;
CvMat vstub, *v = &vstub;
CvMat tmat;
uchar* tw = 0;
int type, n, m, nm, mn;
int buf_size, pix_size;
if( !CV_IS_ARR( a ))
CV_CALL( a = cvGetMat( a, &astub ));
if( !CV_IS_ARR( b ))
CV_CALL( b = cvGetMat( b, &bstub ));
if( !CV_ARE_TYPES_EQ( a, b ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
n = a->width;
m = a->height;
nm = MIN( n, m );
mn = MAX( n, m );
if( n != b->height || m != b->width )
CV_ERROR( CV_StsUnmatchedSizes, "" );
type = CV_ARR_TYPE( a->type );
pix_size = icvPixSize[type];
buf_size = nm*2 + mn + m*mn + n*n;
if( !(flags & CV_SVD_MODIFY_A) )
buf_size += m*n;
buf_size *= pix_size;
if( buf_size <= CV_MAX_LOCAL_SIZE )
{
buffer = (uchar*)alloca( buf_size );
local_alloc = 1;
}
else
{
CV_CALL( buffer = (uchar*)cvAlloc( buf_size ));
}
if( !(flags & CV_SVD_MODIFY_A) )
{
cvInitMatHeader( &tmat, a->height, a->width, type,
buffer + buf_size - n*m*pix_size );
cvCopy( a, &tmat );
a = &tmat;
}
tw = buffer + (nm + mn)*pix_size;
cvInitMatHeader( u, m, m, type, tw + nm*pix_size );
cvInitMatHeader( v, n, n, type, u->data.ptr + m*mn*pix_size );
if( type == CV_32FC1 )
{
IPPI_CALL( icvSVD_32f( a->data.fl, a->step/sizeof(float), (float*)tw,
u->data.fl, u->step/sizeof(float),
v->data.fl, v->step/sizeof(float),
icvGetMatSize(a), (float*)buffer ));
}
else if( type == CV_64FC1 )
{
IPPI_CALL( icvSVD_64f( a->data.db, a->step/sizeof(double), (double*)tw,
u->data.db, u->step/sizeof(double),
v->data.db, v->step/sizeof(double),
icvGetMatSize(a), (double*)buffer ));
}
else
{
CV_ERROR( CV_StsUnsupportedFormat, "" );
}
cvT( v, v );
cvGetRow( u, &tmat, 0 );
if( type == CV_32FC1 )
{
for( int i = 0; i < nm; i++ )
{
double t = ((float*)tw)[i];
tmat.data.ptr = u->data.ptr + i*u->step;
t = t > FLT_EPSILON ? 1./t : 0;
if( i == mn - 1 )
condition_number = t != 0 ? ((float*)tw)[0]*t : DBL_MAX;
cvScale( &tmat, &tmat, t );
}
}
else
{
for( int i = 0; i < nm; i++ )
{
double t = ((double*)tw)[i];
tmat.data.ptr = u->data.ptr + i*u->step;
t = t > DBL_EPSILON ? 1./t : 0;
if( i == mn - 1 )
condition_number = t != 0 ? ((double*)tw)[0]*t : DBL_MAX;
cvScale( &tmat, &tmat, t );
}
}
u->height = n;
if( n > m )
{
cvGetSubArr( u, &tmat, cvRect( 0, m, m, n - m ));
cvSetZero( &tmat );
}
cvMatMulAdd( v, u, 0, b );
CV_CHECK_NANS( b );
__END__;
if( buffer && !local_alloc )
cvFree( (void**)&buffer );
return condition_number;
}
CV_IMPL void
cvSVD( CvArr* aarr, CvArr* warr, CvArr* uarr, CvArr* varr, int flags )
{
uchar* buffer = 0;
int local_alloc = 0;
CV_FUNCNAME( "cvSVD" );
__BEGIN__;
CvMat astub, *a = (CvMat*)aarr;
CvMat wstub, *w = (CvMat*)warr;
CvMat ustub, *u = (CvMat*)uarr;
CvMat vstub, *v = (CvMat*)varr;
CvMat tmat;
uchar* tw = 0;
int type, nm, mn;
int buf_size, pix_size;
int t_svd = 0; // special case: a->rows < a->cols
if( !CV_IS_ARR( a ))
CV_CALL( a = cvGetMat( a, &astub ));
if( !CV_IS_ARR( w ))
CV_CALL( w = cvGetMat( w, &wstub ));
if( !CV_ARE_TYPES_EQ( a, w ))
CV_ERROR( CV_StsUnmatchedFormats, "" );
nm = MIN( a->width, a->height );
mn = MAX( a->width, a->height );
if( (w->width == 1 || w->height == 1) &&
CV_IS_ARR_CONT( w->type ) && w->width*w->height == nm )
{
tw = w->data.ptr;
}
else if( !CV_ARE_SIZES_EQ( w, a ))
{
CV_ERROR( CV_StsBadSize, "W must be either continuous vector of "
"size MIN(A->width,A->height) or matrix of "
"the same size as A" );
}
if( u )
{
if( !CV_IS_ARR( u ))
CV_CALL( u = cvGetMat( u, &ustub ));
if( !CV_ARE_TYPES_EQ( a, u ))
CV_ERROR( CV_StsUnmatchedFormats, "" );
if( u->width != u->height || u->height != a->height )
CV_ERROR( CV_StsUnmatchedSizes, "U matrix must be square and have the same "
"linear size as number of rows in A" );
if( u->data.ptr == a->data.ptr )
CV_ERROR( CV_StsBadArg, "U can not be equal A" );
}
else
{
u = &ustub;
u->data.ptr = 0;
u->step = 0;
}
if( v )
{
if( !CV_IS_ARR( v ))
CV_CALL( v = cvGetMat( v, &vstub ));
if( !CV_ARE_TYPES_EQ( a, v ))
CV_ERROR( CV_StsUnmatchedFormats, "" );
if( v->width != v->height || v->width != a->width )
CV_ERROR( CV_StsUnmatchedSizes, "V matrix must be square and have the same "
"linear size as number of columns in A" );
if( v->data.ptr == a->data.ptr || v->data.ptr == u->data.ptr )
CV_ERROR( CV_StsBadArg, "V can not be equal U or A" );
}
else
{
v = &vstub;
v->data.ptr = 0;
v->step = 0;
}
type = CV_ARR_TYPE( a->type );
pix_size = icvPixSize[type];
buf_size = nm*2 + mn;
if( a->rows < a->cols )
{
CvMat* t;
CV_SWAP( u, v, t );
flags = (flags & CV_SVD_U_T ? CV_SVD_V_T : 0)|
(flags & CV_SVD_V_T ? CV_SVD_U_T : 0);
t_svd = 1;
}
if( !(flags & CV_SVD_MODIFY_A) )
buf_size += a->width*a->height;
buf_size *= pix_size;
if( buf_size <= CV_MAX_LOCAL_SIZE )
{
buffer = (uchar*)alloca( buf_size );
local_alloc = 1;
}
else
{
CV_CALL( buffer = (uchar*)cvAlloc( buf_size ));
}
if( !(flags & CV_SVD_MODIFY_A) )
{
if( !t_svd )
{
cvInitMatHeader( &tmat, a->height, a->width, type,
buffer + (nm*2 + mn)*pix_size );
cvCopy( a, &tmat );
}
else
{
cvInitMatHeader( &tmat, a->width, a->height, type,
buffer + (nm*2 + mn)*pix_size );
cvT( a, &tmat );
}
a = &tmat;
}
if( !tw )
tw = buffer + (nm + mn)*pix_size;
if( type == CV_32FC1 )
{
IPPI_CALL( icvSVD_32f( a->data.fl, a->step/sizeof(float), (float*)tw,
u->data.fl, u->step/sizeof(float),
v->data.fl, v->step/sizeof(float),
icvGetMatSize(a), (float*)buffer ));
}
else if( type == CV_64FC1 )
{
IPPI_CALL( icvSVD_64f( a->data.db, a->step/sizeof(double), (double*)tw,
u->data.db, u->step/sizeof(double),
v->data.db, v->step/sizeof(double),
icvGetMatSize(a), (double*)buffer ));
}
else
{
CV_ERROR( CV_StsUnsupportedFormat, "" );
}
if( tw != w->data.ptr )
{
cvSetZero( w );
if( type == CV_32FC1 )
for( int i = 0; i < nm; i++ )
((float*)(w->data.ptr + i*w->step))[i] = ((float*)tw)[i];
else
for( int i = 0; i < nm; i++ )
((double*)(w->data.ptr + i*w->step))[i] = ((double*)tw)[i];
}
if( u->data.ptr )
{
if( !(flags & CV_SVD_U_T))
cvT( u, u );
CV_CHECK_NANS( u );
}
if( v->data.ptr)
{
if( !(flags & CV_SVD_V_T))
cvT( v, v );
CV_CHECK_NANS( v );
}
CV_CHECK_NANS( w );
__END__;
if( buffer && !local_alloc )
cvFree( (void**)&buffer );
}
CV_IMPL int
cvCountNonZero( const CvArr* img )
{
static CvFuncTable nz_tab;
static CvFuncTable nzcoi_tab;
static int inittab = 0;
int count = 0;
CV_FUNCNAME("cvCountNonZero");
__BEGIN__;
int type, coi = 0;
int mat_step;
CvSize size;
CvMat stub, *mat = (CvMat*)img;
if( !inittab )
{
icvInitCountNonZeroC1RTable( &nz_tab );
icvInitCountNonZeroCnCRTable( &nzcoi_tab );
inittab = 1;
}
if( !CV_IS_ARR(mat) )
{
CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
}
type = CV_ARR_TYPE(mat->type);
size = icvGetMatSize( mat );
mat_step = mat->step;
if( CV_IS_ARR_CONT( mat->type ))
{
size.width *= size.height;
size.height = 1;
mat_step = CV_STUB_STEP;
}
if( CV_ARR_CN(type) == 1 || coi == 0 )
{
CvFunc2D_1A1P func = (CvFunc2D_1A1P)(nz_tab.fn_2d[CV_ARR_DEPTH(type)]);
if( CV_ARR_CN(type) != 1 )
CV_ERROR( CV_BadNumChannels,
"The function can handle only a single channel at a time (use COI)");
if( !func )
CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size, &count ));
}
else
{
CvFunc2DnC_1A1P func = (CvFunc2DnC_1A1P)(nzcoi_tab.fn_2d[CV_ARR_DEPTH(type)]);
if( !func )
CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size, CV_ARR_CN(type), coi, &count ));
}
__END__;
return count;
}
CV_IMPL CvScalar
cvSum( const CvArr* arr )
{
static CvBigFuncTable sum_tab;
static CvFuncTable sumcoi_tab;
static int inittab = 0;
CvScalar sum = {{ 0, 0, 0, 0 }};
CV_FUNCNAME("cvSum");
__BEGIN__;
int type, coi = 0;
int mat_step;
CvSize size;
CvMat stub, *mat = (CvMat*)arr;
if( !inittab )
{
icvInitSumRTable( &sum_tab );
icvInitSumCnCRTable( &sumcoi_tab );
inittab = 1;
}
if( !CV_IS_ARR(mat) )
{
CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
}
type = CV_ARR_TYPE(mat->type);
size = icvGetMatSize( mat );
mat_step = mat->step;
if( CV_IS_ARR_CONT( mat->type ))
{
size.width *= size.height;
if( size.width <= CV_MAX_INLINE_MAT_OP_SIZE )
{
if( type == CV_32FC1 )
{
float* data = mat->data.fl;
do
{
sum.val[0] += data[size.width - 1];
}
while( --size.width );
EXIT;
}
if( type == CV_64FC1 )
{
double* data = mat->data.db;
do
{
sum.val[0] += data[size.width - 1];
}
while( --size.width );
EXIT;
}
}
size.height = 1;
mat_step = CV_STUB_STEP;
}
if( CV_ARR_CN(type) == 1 || coi == 0 )
{
CvFunc2D_1A1P func = (CvFunc2D_1A1P)(sum_tab.fn_2d[type]);
if( !func )
CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size, sum.val ));
}
else
{
CvFunc2DnC_1A1P func = (CvFunc2DnC_1A1P)(sumcoi_tab.fn_2d[CV_ARR_DEPTH(type)]);
if( !func )
CV_ERROR( CV_StsBadArg, icvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size,
CV_ARR_CN(type), coi, sum.val ));
}
__END__;
return sum;
}