Wondercoll
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
Macros | Functions | Variables
cxnorm.cpp File Reference
#include "_cxcore.h"

Macros

#define ICV_NORM_CASE(_op_,_update_op_, worktype, len)
 
#define ICV_NORM_COI_CASE(_op_,_update_op_, worktype, len, cn)
 
#define ICV_NORM_DIFF_CASE(_op_,_update_op_, worktype, len)
 
#define ICV_NORM_DIFF_COI_CASE(_op_, _update_op_, worktype, len, cn)
 
#define ICV_DEF_NORM_NOHINT_BLOCK_FUNC_2D(name, _op_, _update_op_, post_func, arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_NOHINT_FUNC_2D(name, _op_, _update_op_,post_func, arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_HINT_FUNC_2D(name, _op_, _update_op_,post_func, arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_NOHINT_BLOCK_FUNC_2D_COI(name, _op_,_update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_NOHINT_FUNC_2D_COI(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_NOHINT_BLOCK_FUNC_2D(name, _op_,_update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_HINT_FUNC_2D(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_NOHINT_BLOCK_FUNC_2D_COI(name, _op_, _update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D_COI(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_NORM_MASK_CASE(_op_,_update_op_, worktype, len)
 
#define ICV_NORM_DIFF_MASK_CASE(_op_, _update_op_, worktype, len)
 
#define ICV_NORM_MASK_COI_CASE(_op_, _update_op_, worktype, len, cn)
 
#define ICV_NORM_DIFF_MASK_COI_CASE(_op_, _update_op_, worktype, len, cn)
 
#define ICV_DEF_NORM_MASK_NOHINT_BLOCK_FUNC_2D(name, _op_,_update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_MASK_NOHINT_FUNC_2D(name, _op_, _update_op_, post_func, arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_MASK_NOHINT_BLOCK_FUNC_2D_COI(name, _op_, _update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_MASK_NOHINT_FUNC_2D_COI(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_BLOCK_FUNC_2D(name,_op_, _update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D(name, _op_,_update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_BLOCK_FUNC_2D_COI(name, _op_, _update_op_, post_func, arrtype,normtype, worktype, block_size)
 
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D_COI(name, _op_, _update_op_, post_func,arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_FUNC_ALL_C(flavor, _abs_, _abs_diff_, arrtype, worktype)
 
#define ICV_DEF_NORM_FUNC_ALL_L1(flavor, _abs_, _abs_diff_, hintp_func, nohint_func, arrtype, normtype, worktype, block_size)
 
#define ICV_DEF_NORM_FUNC_ALL_L2(flavor, hintp_func, nohint_func, arrtype,normtype, worktype, block_size, sqr_macro)
 
#define ICV_DEF_INIT_NORM_TAB_2D(FUNCNAME, FLAG)
 

Functions

 ICV_DEF_NORM_FUNC_ALL_L1 (8u, CV_NOP, CV_IABS, NOHINT_BLOCK, NOHINT_BLOCK, uchar, int64, int, 1<< 23) ICV_DEF_NORM_FUNC_ALL_L1(16u
 
 if (size.width<=CV_MAX_INLINE_MAT_OP_SIZE &&normType==2)
 
else if (!CV_IS_MATND(mat1)&&!CV_IS_MATND(mat2))
 
 if (!inittab)
 
 if (mask) CV_ERROR(CV_StsBadMask
 
 CV_CALL (cvInitNArrayIterator(1+(mat2!=0), arrs, 0, stubs,&iterator))
 
 if (!mat2||is_relative)
 
 if (mat2)
 
 if (CV_MAT_CN(type) > 1 &&coi==0) CV_ERROR(CV_StsBadArg
 
 CV_CALL (matmask=cvGetMat(matmask,&maskstub))
 
 if (!CV_IS_MASK_ARR(matmask)) CV_ERROR(CV_StsBadMask
 
 if (!CV_ARE_SIZES_EQ(mat1, matmask)) CV_ERROR(CV_StsUnmatchedSizes
 
 if (CV_IS_MAT_CONT(mat1->type &mat2_flag &matmask->type))
 
 if (CV_MAT_CN(type)==1||coi==0)
 

Variables

 CV_NOP
 
 CV_IABS
 
 NOHINT_BLOCK
 
 ushort
 
 int64
 
 int
 

<< 15) ICV_DEF_NORM_FUNC_ALL_L1(16s, CV_IABS, CV_IABS, NOHINT_BLOCK, NOHINT_BLOCK, short, int64, int, 1<< 15) ICV_DEF_NORM_FUNC_ALL_L1(32s, fabs, fabs, NOHINT, NOHINT, int, double, double, INT_MAX) ICV_DEF_NORM_FUNC_ALL_L1(32f, fabs, fabs, HINT, NOHINT, float, double, double, INT_MAX) ICV_DEF_NORM_FUNC_ALL_L1(64f, fabs, fabs, NOHINT, NOHINT, double, double, double, INT_MAX)#defineICV_DEF_NORM_FUNC_ALL_L2(flavor, hintp_func, nohint_func, arrtype, normtype, worktype, block_size, sqr_macro) ICV_DEF_NORM_FUNC_ALL_L2(8u, NOHINT_BLOCK, NOHINT_BLOCK, uchar, int64, int, 1<< 15, CV_SQR_8U) ICV_DEF_NORM_FUNC_ALL_L2(16u, NOHINT, NOHINT, ushort, double, double, INT_MAX, CV_SQR) ICV_DEF_NORM_FUNC_ALL_L2(16s, NOHINT, NOHINT, short, double, double, INT_MAX, CV_SQR) ICV_DEF_NORM_FUNC_ALL_L2(32s, NOHINT, NOHINT, int, double, double, INT_MAX, CV_SQR) ICV_DEF_NORM_FUNC_ALL_L2(32f, HINT, NOHINT, float, double, double, INT_MAX, CV_SQR) ICV_DEF_NORM_FUNC_ALL_L2(64f, NOHINT, NOHINT, double, double, double, INT_MAX, CV_SQR)#defineICV_DEF_INIT_NORM_TAB_2D(FUNCNAME, FLAG) staticvoidicvInitNormTabs(CvFuncTable *norm_tab, CvFuncTable *normmask_tab){icvInitNorm_InfC1RTable(&norm_tab[0]);icvInitNorm_L1C1RTable(&norm_tab[1]);icvInitNorm_L2C1RTable(&norm_tab[2]);icvInitNormDiff_InfC1RTable(&norm_tab[3]);icvInitNormDiff_L1C1RTable(&norm_tab[4]);icvInitNormDiff_L2C1RTable(&norm_tab[5]);icvInitNorm_InfCnCRTable(&norm_tab[6]);icvInitNorm_L1CnCRTable(&norm_tab[7]);icvInitNorm_L2CnCRTable(&norm_tab[8]);icvInitNormDiff_InfCnCRTable(&norm_tab[9]);icvInitNormDiff_L1CnCRTable(&norm_tab[10]);icvInitNormDiff_L2CnCRTable(&norm_tab[11]);icvInitNorm_InfC1MRTable(&normmask_tab[0]);icvInitNorm_L1C1MRTable(&normmask_tab[1]);icvInitNorm_L2C1MRTable(&normmask_tab[2]);icvInitNormDiff_InfC1MRTable(&normmask_tab[3]);icvInitNormDiff_L1C1MRTable(&normmask_tab[4]);icvInitNormDiff_L2C1MRTable(&normmask_tab[5]);icvInitNorm_InfCnCMRTable(&normmask_tab[6]);icvInitNorm_L1CnCMRTable(&normmask_tab[7]);icvInitNorm_L2CnCMRTable(&normmask_tab[8]);icvInitNormDiff_InfCnCMRTable(&normmask_tab[9]);icvInitNormDiff_L1CnCMRTable(&normmask_tab[10]);icvInitNormDiff_L2CnCMRTable(&normmask_tab[11]);}CV_IMPLdoublecvNorm(constvoid *imgA, constvoid *imgB, intnormType, constvoid *mask){staticCvFuncTablenorm_tab[12];staticCvFuncTablenormmask_tab[12];staticintinittab=0;doublenorm=0, norm_diff=0;CV_FUNCNAME("cvNorm");__BEGIN__;inttype, depth, cn, is_relative;CvSizesize;CvMatstub1,*mat1=(CvMat *) imgB;CvMatstub2,*mat2=(CvMat *) imgA;intmat2_flag=CV_MAT_CONT_FLAG;intmat1_step, mat2_step, mask_step=0;intcoi=0, coi2=0;if(!mat1){mat1=mat2;mat2=0;}is_relative=mat2 &&(normType &CV_RELATIVE);normType &=~CV_RELATIVE;switch(normType){caseCV_C:caseCV_L1:caseCV_L2:caseCV_DIFF_C:caseCV_DIFF_L1:caseCV_DIFF_L2:normType=(normType &7)>>1;break;default:CV_ERROR(CV_StsBadFlag,"");}if(CV_IS_MAT(mat1)&&(!mat2||CV_IS_MAT(mat2))&&!mask){if(mat2){if(!CV_ARE_TYPES_EQ(mat1, mat2)) CV_ERROR(CV_StsUnmatchedFormats,"");if(!CV_ARE_SIZES_EQ(mat1, mat2)) CV_ERROR(CV_StsUnmatchedSizes,"");mat2_flag=mat2->type;}size=cvGetMatSize(mat1);type=CV_MAT_TYPE(mat1->type);depth=CV_MAT_DEPTH(type);cn=CV_MAT_CN(type);if(CV_IS_MAT_CONT(mat1-> type & 		mat2_flag
 
size height = 1
 
 mat1_step = mat2_step = CV_STUB_STEP
 
 else
 
 mat2_step = mat2 ? mat2->step : 0
 
CvMatND stubs [2]
 
CvNArrayIterator iterator
 
int pass_hint = normType != 0 && (depth == CV_32F)
 
This operation on multi
dimensional arrays does not
support 		mask
 
 type = CV_MAT_TYPE(iterator.hdr[0]->type)
 
 depth = CV_MAT_DEPTH(type)
 
 EXIT
 
 mask_step = matmask->step
 
return norm
 

Macro Definition Documentation

#define ICV_DEF_INIT_NORM_TAB_2D (   FUNCNAME,
  FLAG 
)
Value:
static void icvInit##FUNCNAME##FLAG##Table( CvFuncTable* tab ) \
{ \
tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_##FLAG; \
tab->fn_2d[CV_8S] = 0; \
tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_##FLAG; \
tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_##FLAG; \
tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s_##FLAG; \
tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_##FLAG; \
tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_##FLAG; \
}
#define ICV_DEF_NORM_DIFF_HINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name,( const arrtype* src1, int step1, \
const arrtype* src2, int step2, CvSize size, double* _norm, \
CvHintAlgorithm /*hint*/ ), \
(src1, step1, src2, step2, size, _norm, cvAlgHintAccurate ))\
{ \
normtype norm = 0; \
step1 /= sizeof(src1[0]); \
step2 /= sizeof(src2[0]); \
\
for( ; size.height--; src1 += step1, src2 += step2 ) \
{ \
int x = 0; \
ICV_NORM_DIFF_CASE( _op_, _update_op_, \
worktype, size.width ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_BLOCK_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_BLOCK_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name,( const arrtype* src1, int step1, \
const arrtype* src2, int step2, const uchar* mask, \
int maskstep, CvSize size, double* _norm ), \
(src1, step1, src2, step2, mask, maskstep, size, _norm )) \
{ \
normtype norm = 0; \
step1 /= sizeof(src1[0]); \
step2 /= sizeof(src2[0]); \
\
for( ; size.height--; src1 += step1, src2 += step2, \
mask += maskstep ) \
{ \
int x = 0; \
ICV_NORM_DIFF_MASK_CASE( _op_, _update_op_, \
worktype, size.width ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
static CvStatus CV_STDCALL name( const arrtype* src1, int step1,\
const arrtype* src2, int step2, const uchar* mask, \
int maskstep, CvSize size, int cn, int coi, double* _norm ) \
{ \
normtype norm = 0; \
step1 /= sizeof(src1[0]); \
step2 /= sizeof(src2[0]); \
src1 += coi - 1; \
src2 += coi - 1; \
\
for( ; size.height--; src1 += step1, src2 += step2, \
mask += maskstep ) \
{ \
int x = 0; \
ICV_NORM_DIFF_MASK_COI_CASE( _op_, _update_op_, \
worktype, size.width, cn );\
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_DIFF_NOHINT_BLOCK_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_DIFF_NOHINT_BLOCK_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name,( const arrtype* src1, int step1, \
const arrtype* src2, int step2, CvSize size, double* _norm),\
( src1, step1, src2, step2, size, _norm )) \
{ \
normtype norm = 0; \
step1 /= sizeof(src1[0]); \
step2 /= sizeof(src2[0]); \
\
for( ; size.height--; src1 += step1, src2 += step2 ) \
{ \
int x = 0; \
ICV_NORM_DIFF_CASE( _op_, _update_op_, \
worktype, size.width ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
static CvStatus CV_STDCALL name( const arrtype* src1, int step1,\
const arrtype* src2, int step2, CvSize size, \
int cn, int coi, double* _norm ) \
{ \
normtype norm = 0; \
step1 /= sizeof(src1[0]); \
step2 /= sizeof(src2[0]); \
src1 += coi - 1; \
src2 += coi - 1; \
\
for( ; size.height--; src1 += step1, src2 += step2 ) \
{ \
int x = 0; \
ICV_NORM_DIFF_COI_CASE( _op_, _update_op_, \
worktype, size.width, cn ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_FUNC_ALL_C (   flavor,
  _abs_,
  _abs_diff_,
  arrtype,
  worktype 
)
Value:
\
ICV_DEF_NORM_NOHINT_FUNC_2D( icvNorm_Inf_##flavor##_C1R, \
_abs_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_NOHINT_FUNC_2D_COI( icvNorm_Inf_##flavor##_CnCR, \
_abs_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D( icvNormDiff_Inf_##flavor##_C1R, \
_abs_diff_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_DIFF_NOHINT_FUNC_2D_COI( icvNormDiff_Inf_##flavor##_CnCR, \
_abs_diff_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_MASK_NOHINT_FUNC_2D( icvNorm_Inf_##flavor##_C1MR, \
_abs_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_MASK_NOHINT_FUNC_2D_COI( icvNorm_Inf_##flavor##_CnCMR, \
_abs_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D( icvNormDiff_Inf_##flavor##_C1MR, \
_abs_diff_, MAX, CV_NOP, arrtype, worktype, worktype, 0 ) \
\
ICV_DEF_NORM_DIFF_MASK_NOHINT_FUNC_2D_COI( icvNormDiff_Inf_##flavor##_CnCMR,\
_abs_diff_, MAX, CV_NOP, arrtype, worktype, worktype, 0 )
#define ICV_DEF_NORM_FUNC_ALL_L1 (   flavor,
  _abs_,
  _abs_diff_,
  hintp_func,
  nohint_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
\
ICV_DEF_NORM_##hintp_func##_FUNC_2D( icvNorm_L1_##flavor##_C1R, \
_abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_##nohint_func##_FUNC_2D_COI( icvNorm_L1_##flavor##_CnCR, \
_abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_##hintp_func##_FUNC_2D( icvNormDiff_L1_##flavor##_C1R, \
_abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_##nohint_func##_FUNC_2D_COI( icvNormDiff_L1_##flavor##_CnCR, \
_abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D( icvNorm_L1_##flavor##_C1MR, \
_abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D_COI( icvNorm_L1_##flavor##_CnCMR, \
_abs_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D( icvNormDiff_L1_##flavor##_C1MR, \
_abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D_COI( icvNormDiff_L1_##flavor##_CnCMR,\
_abs_diff_, CV_ADD, CV_NOP, arrtype, normtype, worktype, block_size )
#define ICV_DEF_NORM_FUNC_ALL_L2 (   flavor,
  hintp_func,
  nohint_func,
  arrtype,
  normtype,
  worktype,
  block_size,
  sqr_macro 
)
Value:
\
ICV_DEF_NORM_##hintp_func##_FUNC_2D( icvNorm_L2_##flavor##_C1R, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_##nohint_func##_FUNC_2D_COI( icvNorm_L2_##flavor##_CnCR, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_##hintp_func##_FUNC_2D( icvNormDiff_L2_##flavor##_C1R, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_##nohint_func##_FUNC_2D_COI( icvNormDiff_L2_##flavor##_CnCR, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D( icvNorm_L2_##flavor##_C1MR, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_MASK_##nohint_func##_FUNC_2D_COI( icvNorm_L2_##flavor##_CnCMR, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D( icvNormDiff_L2_##flavor##_C1MR, \
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size ) \
\
ICV_DEF_NORM_DIFF_MASK_##nohint_func##_FUNC_2D_COI( icvNormDiff_L2_##flavor##_CnCMR,\
sqr_macro, CV_ADD, sqrt, arrtype, normtype, worktype, block_size )
#define ICV_DEF_NORM_HINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name, ( const arrtype* src, int step, \
CvSize size, double* _norm, CvHintAlgorithm /*hint*/ ), \
(src, step, size, _norm, cvAlgHintAccurate) ) \
{ \
normtype norm = 0; \
step /= sizeof(src[0]); \
\
for( ; size.height--; src += step ) \
{ \
int x = 0; \
ICV_NORM_CASE(_op_, _update_op_, worktype, size.width); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_MASK_NOHINT_BLOCK_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_MASK_NOHINT_BLOCK_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_MASK_NOHINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name, ( const arrtype* src, int step, \
const uchar* mask, int maskstep, CvSize size, double* _norm ),\
(src, step, mask, maskstep, size, _norm) ) \
{ \
normtype norm = 0; \
step /= sizeof(src[0]); \
\
for( ; size.height--; src += step, mask += maskstep ) \
{ \
int x = 0; \
ICV_NORM_MASK_CASE( _op_, _update_op_, \
worktype, size.width ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_MASK_NOHINT_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
static CvStatus CV_STDCALL name( const arrtype* src, int step, \
const uchar* mask, int maskstep, CvSize size, \
int cn, int coi, double* _norm ) \
{ \
normtype norm = 0; \
step /= sizeof(src[0]); \
src += coi - 1; \
\
for( ; size.height--; src += step, mask += maskstep ) \
{ \
int x = 0; \
ICV_NORM_MASK_COI_CASE( _op_, _update_op_, \
worktype, size.width, cn ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_NOHINT_BLOCK_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name, ( const arrtype* src, int step, \
CvSize size, double* _norm ), (src, step, size, _norm) ) \
{ \
int remaining = block_size; \
normtype total_norm = 0; \
worktype norm = 0; \
step /= sizeof(src[0]); \
\
for( ; size.height--; src += step ) \
{ \
int x = 0; \
while( x < size.width ) \
{ \
int limit = MIN( remaining, size.width - x ); \
remaining -= limit; \
limit += x; \
ICV_NORM_CASE( _op_, _update_op_, worktype, limit );\
if( remaining == 0 ) \
{ \
remaining = block_size; \
total_norm += (normtype)norm; \
norm = 0; \
} \
} \
} \
\
total_norm += (normtype)norm; \
*_norm = post_func((double)total_norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_NOHINT_BLOCK_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
#define ICV_DEF_NORM_NOHINT_FUNC_2D (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
IPCVAPI_IMPL( CvStatus, name, ( const arrtype* src, int step, \
CvSize size, double* _norm ), (src, step, size, _norm) ) \
{ \
normtype norm = 0; \
step /= sizeof(src[0]); \
\
for( ; size.height--; src += step ) \
{ \
int x = 0; \
ICV_NORM_CASE(_op_, _update_op_, worktype, size.width); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_DEF_NORM_NOHINT_FUNC_2D_COI (   name,
  _op_,
  _update_op_,
  post_func,
  arrtype,
  normtype,
  worktype,
  block_size 
)
Value:
static CvStatus CV_STDCALL name( const arrtype* src, int step, \
CvSize size, int cn, int coi, double* _norm ) \
{ \
normtype norm = 0; \
step /= sizeof(src[0]); \
src += coi - 1; \
\
for( ; size.height--; src += step ) \
{ \
int x = 0; \
ICV_NORM_COI_CASE( _op_, _update_op_, \
worktype, size.width, cn ); \
} \
\
*_norm = post_func((double)norm); \
return CV_OK; \
}
#define ICV_NORM_CASE (   _op_,
  _update_op_,
  worktype,
  len 
)
Value:
\
for( ; x <= (len) - 4; x += 4 ) \
{ \
worktype t0 = (src)[x]; \
worktype t1 = (src)[x+1]; \
t0 = _op_(t0); \
t1 = _op_(t1); \
norm = _update_op_( norm, t0 ); \
norm = _update_op_( norm, t1 ); \
\
t0 = (src)[x+2]; \
t1 = (src)[x+3]; \
t0 = _op_(t0); \
t1 = _op_(t1); \
norm = _update_op_( norm, t0 ); \
norm = _update_op_( norm, t1 ); \
} \
\
for( ; x < (len); x++ ) \
{ \
worktype t0 = (src)[x]; \
t0 = (worktype)_op_(t0); \
norm = _update_op_( norm, t0 ); \
}
#define ICV_NORM_COI_CASE (   _op_,
  _update_op_,
  worktype,
  len,
  cn 
)
Value:
\
for( ; x < (len); x++ ) \
{ \
worktype t0 = (src)[x*(cn)]; \
t0 = (worktype)_op_(t0); \
norm = _update_op_( norm, t0 ); \
}
#define ICV_NORM_DIFF_CASE (   _op_,
  _update_op_,
  worktype,
  len 
)
Value:
\
for( ; x <= (len) - 4; x += 4 ) \
{ \
worktype t0 = (src1)[x] - (src2)[x];\
worktype t1 = (src1)[x+1]-(src2)[x+1];\
\
t0 = _op_(t0); \
t1 = _op_(t1); \
\
norm = _update_op_( norm, t0 ); \
norm = _update_op_( norm, t1 ); \
\
t0 = (src1)[x+2] - (src2)[x+2]; \
t1 = (src1)[x+3] - (src2)[x+3]; \
\
t0 = _op_(t0); \
t1 = _op_(t1); \
\
norm = _update_op_( norm, t0 ); \
norm = _update_op_( norm, t1 ); \
} \
\
for( ; x < (len); x++ ) \
{ \
worktype t0 = (src1)[x] - (src2)[x];\
t0 = (worktype)_op_(t0); \
norm = _update_op_( norm, t0 ); \
}
#define ICV_NORM_DIFF_COI_CASE (   _op_,
  _update_op_,
  worktype,
  len,
  cn 
)
Value:
for( ; x < (len); x++ ) \
{ \
worktype t0 = (src1)[x*(cn)] - (src2)[x*(cn)]; \
t0 = (worktype)_op_(t0); \
norm = _update_op_( norm, t0 ); \
}
#define ICV_NORM_DIFF_MASK_CASE (   _op_,
  _update_op_,
  worktype,
  len 
)
Value:
{ \
for( ; x <= (len) - 2; x += 2 ) \
{ \
worktype t0; \
if( mask[x] ) \
{ \
t0 = (src1)[x] - (src2)[x]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
if( mask[x+1] ) \
{ \
t0 = (src1)[x+1] - (src2)[x+1]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
} \
\
for( ; x < (len); x++ ) \
if( mask[x] ) \
{ \
worktype t0 = (src1)[x] - (src2)[x];\
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
}
#define ICV_NORM_DIFF_MASK_COI_CASE (   _op_,
  _update_op_,
  worktype,
  len,
  cn 
)
Value:
{ \
for( ; x < (len); x++ ) \
if( mask[x] ) \
{ \
worktype t0 = (src1)[x*(cn)] - (src2)[x*(cn)]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
}
#define ICV_NORM_MASK_CASE (   _op_,
  _update_op_,
  worktype,
  len 
)
Value:
{ \
for( ; x <= (len) - 2; x += 2 ) \
{ \
worktype t0; \
if( mask[x] ) \
{ \
t0 = (src)[x]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
if( mask[x+1] ) \
{ \
t0 = (src)[x+1]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
} \
\
for( ; x < (len); x++ ) \
if( mask[x] ) \
{ \
worktype t0 = (src)[x]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
}
#define ICV_NORM_MASK_COI_CASE (   _op_,
  _update_op_,
  worktype,
  len,
  cn 
)
Value:
{ \
for( ; x < (len); x++ ) \
if( mask[x] ) \
{ \
worktype t0 = (src)[x*(cn)]; \
t0 = _op_(t0); \
norm = _update_op_( norm, t0 ); \
} \
}

Function Documentation

CV_CALL ( cvInitNArrayIterator(1+(mat2!=0), arrs, 0, stubs,&iterator)  )
CV_CALL ( matmask  = cvGetMat(matmask,&maskstub))
ICV_DEF_NORM_FUNC_ALL_L1 ( 8u  ,
CV_NOP  ,
CV_IABS  ,
NOHINT_BLOCK  ,
NOHINT_BLOCK  ,
uchar  ,
int64  ,
int  ,
1<<  23 
)
if ( size.width<=CV_MAX_INLINE_MAT_OP_SIZE &&  normType = = 2)
else if ( !  CV_IS_MATNDmat1)&&!CV_IS_MATND(mat2)
if ( !  inittab)
if ( mask  )
if ( !mat2||  is_relative)
if ( mat2  )
if ( CV_MAT_CN(type)  ,
1 &&  coi = = 0 
)
if ( !  CV_IS_MASK_ARRmatmask)
if ( !  CV_ARE_SIZES_EQmat1, matmask)
if ( CV_IS_MAT_CONT(mat1->type &mat2_flag &matmask->type)  )
if ( CV_MAT_CN(type)  = = 1 || coi == 0)

Variable Documentation

CV_IABS
CV_NOP
depth = CV_MAT_DEPTH(type)
else
Initial value:
{
mat1_step = mat1->step
EXIT
size height = 1
int
int64
CvNArrayIterator iterator
This operation on multi dimensional arrays does not support mask
mask_step = matmask->step
mat1_step = mat2_step = CV_STUB_STEP
<<15)ICV_DEF_NORM_FUNC_ALL_L1(16s,CV_IABS,CV_IABS,NOHINT_BLOCK,NOHINT_BLOCK,short,int64,int,1<<15)ICV_DEF_NORM_FUNC_ALL_L1(32s,fabs,fabs,NOHINT,NOHINT,int,double,double,INT_MAX)ICV_DEF_NORM_FUNC_ALL_L1(32f,fabs,fabs,HINT,NOHINT,float,double,double,INT_MAX)ICV_DEF_NORM_FUNC_ALL_L1(64f,fabs,fabs,NOHINT,NOHINT,double,double,double,INT_MAX)#defineICV_DEF_NORM_FUNC_ALL_L2(flavor,hintp_func,nohint_func,arrtype,normtype,worktype,block_size,sqr_macro)ICV_DEF_NORM_FUNC_ALL_L2(8u,NOHINT_BLOCK,NOHINT_BLOCK,uchar,int64,int,1<<15,CV_SQR_8U)ICV_DEF_NORM_FUNC_ALL_L2(16u,NOHINT,NOHINT,ushort,double,double,INT_MAX,CV_SQR)ICV_DEF_NORM_FUNC_ALL_L2(16s,NOHINT,NOHINT,short,double,double,INT_MAX,CV_SQR)ICV_DEF_NORM_FUNC_ALL_L2(32s,NOHINT,NOHINT,int,double,double,INT_MAX,CV_SQR)ICV_DEF_NORM_FUNC_ALL_L2(32f,HINT,NOHINT,float,double,double,INT_MAX,CV_SQR)ICV_DEF_NORM_FUNC_ALL_L2(64f,NOHINT,NOHINT,double,double,double,INT_MAX,CV_SQR)#defineICV_DEF_INIT_NORM_TAB_2D(FUNCNAME,FLAG)staticvoidicvInitNormTabs(CvFuncTable*norm_tab,CvFuncTable*normmask_tab){icvInitNorm_InfC1RTable(&norm_tab[0]);icvInitNorm_L1C1RTable(&norm_tab[1]);icvInitNorm_L2C1RTable(&norm_tab[2]);icvInitNormDiff_InfC1RTable(&norm_tab[3]);icvInitNormDiff_L1C1RTable(&norm_tab[4]);icvInitNormDiff_L2C1RTable(&norm_tab[5]);icvInitNorm_InfCnCRTable(&norm_tab[6]);icvInitNorm_L1CnCRTable(&norm_tab[7]);icvInitNorm_L2CnCRTable(&norm_tab[8]);icvInitNormDiff_InfCnCRTable(&norm_tab[9]);icvInitNormDiff_L1CnCRTable(&norm_tab[10]);icvInitNormDiff_L2CnCRTable(&norm_tab[11]);icvInitNorm_InfC1MRTable(&normmask_tab[0]);icvInitNorm_L1C1MRTable(&normmask_tab[1]);icvInitNorm_L2C1MRTable(&normmask_tab[2]);icvInitNormDiff_InfC1MRTable(&normmask_tab[3]);icvInitNormDiff_L1C1MRTable(&normmask_tab[4]);icvInitNormDiff_L2C1MRTable(&normmask_tab[5]);icvInitNorm_InfCnCMRTable(&normmask_tab[6]);icvInitNorm_L1CnCMRTable(&normmask_tab[7]);icvInitNorm_L2CnCMRTable(&normmask_tab[8]);icvInitNormDiff_InfCnCMRTable(&normmask_tab[9]);icvInitNormDiff_L1CnCMRTable(&normmask_tab[10]);icvInitNormDiff_L2CnCMRTable(&normmask_tab[11]);}CV_IMPLdoublecvNorm(constvoid*imgA,constvoid*imgB,intnormType,constvoid*mask){staticCvFuncTablenorm_tab[12];staticCvFuncTablenormmask_tab[12];staticintinittab=0;doublenorm=0,norm_diff=0;CV_FUNCNAME("cvNorm");__BEGIN__;inttype,depth,cn,is_relative;CvSizesize;CvMatstub1,*mat1=(CvMat*)imgB;CvMatstub2,*mat2=(CvMat*)imgA;intmat2_flag=CV_MAT_CONT_FLAG;intmat1_step,mat2_step,mask_step=0;intcoi=0,coi2=0;if(!mat1){mat1=mat2;mat2=0;}is_relative=mat2&&(normType&CV_RELATIVE);normType&=~CV_RELATIVE;switch(normType){caseCV_C:caseCV_L1:caseCV_L2:caseCV_DIFF_C:caseCV_DIFF_L1:caseCV_DIFF_L2:normType=(normType&7)>>1;break;default:CV_ERROR(CV_StsBadFlag,"");}if(CV_IS_MAT(mat1)&&(!mat2||CV_IS_MAT(mat2))&&!mask){if(mat2){if(!CV_ARE_TYPES_EQ(mat1,mat2))CV_ERROR(CV_StsUnmatchedFormats,"");if(!CV_ARE_SIZES_EQ(mat1,mat2))CV_ERROR(CV_StsUnmatchedSizes,"");mat2_flag=mat2->type;}size=cvGetMatSize(mat1);type=CV_MAT_TYPE(mat1->type);depth=CV_MAT_DEPTH(type);cn=CV_MAT_CN(type);if(CV_IS_MAT_CONT(mat1-> type& mat2_flag
Initial value:
{
size.width *= size.height
mat2_step = mat2 ? mat2->step : 0
NOHINT_BLOCK
return norm
iterator size width * pass_hint = normType != 0 && (depth == CV_32F)
CvMatND stubs[2]
type = CV_MAT_TYPE(iterator.hdr[0]->type)
ushort
Generated on Thu Apr 4 2013 14:33:05 for Wondercoll by   doxygen 1.8.3.1