#include "_cxcore.h"

Macros
#define	ICV_DEF_PX2PL2PX_ENTRY_C2(arrtype_ptr, ptr)

#define	ICV_DEF_PX2PL2PX_ENTRY_C3(arrtype_ptr, ptr)

#define	ICV_DEF_PX2PL2PX_ENTRY_C4(arrtype_ptr, ptr)

#define	ICV_DEF_PX2PL_C2(arrtype, len)

#define	ICV_DEF_PX2PL_C3(arrtype, len)

#define	ICV_DEF_PX2PL_C4(arrtype, len)

#define	ICV_DEF_PX2PL_COI(arrtype, len, cn)

#define	ICV_DEF_COPY_PX2PL_FUNC_2D(arrtype, flavor,cn, entry_macro)

#define	ICV_DEF_COPY_PX2PL_FUNC_2D_COI(arrtype, flavor)

#define	ICV_DEF_PL2PX_C2(arrtype, len)

#define	ICV_DEF_PL2PX_C3(arrtype, len)

#define	ICV_DEF_PL2PX_C4(arrtype, len)

#define	ICV_DEF_PL2PX_COI(arrtype, len, cn)

#define	ICV_DEF_COPY_PL2PX_FUNC_2D(arrtype, flavor, cn, entry_macro)

#define	ICV_DEF_COPY_PL2PX_FUNC_2D_COI(arrtype, flavor)

#define	ICV_DEF_PXPLPX_TAB(name, FROM, TO)

#define	ICV_DEF_PXPLCOI_TAB(name, FROM, TO)

#define	ICV_DEF_MIX_CH_FUNC_2D(arrtype, flavor)

#define	ICV_DEF_CVT_SCALE_ABS_CASE(srctype, worktype,scale_macro, abs_macro, cast_macro, a, b)

#define	ICV_FIX_SHIFT 15

#define	ICV_SCALE(x) (((x) + (1 << (ICV_FIX_SHIFT-1))) >> ICV_FIX_SHIFT)

#define	ICV_DEF_CVT_SCALE_CASE(srctype, worktype,scale_macro, cast_macro, a, b)

#define	ICV_DEF_CVT_SCALE_FUNC_INT(flavor, dsttype, cast_macro)

#define	ICV_DEF_CVT_SCALE_FUNC_FLT(flavor, dsttype, cast_macro)

#define	ICV_DEF_CVT_CASE_2D(srctype, worktype,cast_macro1, cast_macro2)

#define	ICV_DEF_CVT_FUNC_2D(flavor, dsttype, worktype, cast_macro2,srcdepth1, srctype1, cast_macro11,srcdepth2, srctype2, cast_macro12,srcdepth3, srctype3, cast_macro13,srcdepth4, srctype4, cast_macro14,srcdepth5, srctype5, cast_macro15,srcdepth6, srctype6, cast_macro16)

Typedefs
typedef CvStatus(CV_STDCALL *	CvSplitFunc )(const void src, int srcstep, void *dst, int dststep, CvSize size)

typedef CvStatus(CV_STDCALL *	CvExtractPlaneFunc )(const void src, int srcstep, void dst, int dststep, CvSize size, int cn, int coi)

typedef CvStatus(CV_STDCALL *	CvMergeFunc )(const void *src, int srcstep, void dst, int dststep, CvSize size)

typedef CvStatus(CV_STDCALL *	CvInsertPlaneFunc )(const void src, int srcstep, void dst, int dststep, CvSize size, int cn, int coi)

typedef CvStatus(CV_STDCALL *	CvMixChannelsFunc )(const void *src, int sdelta0, int sdelta1, void dst, int ddelta0, int *ddelta1, int n, CvSize size)

typedef CvStatus(CV_STDCALL *	CvCvtScaleFunc )(const void src, int srcstep, void dst, int dststep, CvSize size, double scale, double shift, int param)

Functions
CV_IMPL void	cvSplit (const void srcarr, void dstarr0, void dstarr1, void dstarr2, void *dstarr3)

CV_IMPL void	cvMerge (const void srcarr0, const void srcarr1, const void srcarr2, const void srcarr3, void *dstarr)

CV_IMPL void	cvMixChannels (const CvArr src, int src_count, CvArr dst, int dst_count, const int *from_to, int pair_count)

CV_IMPL void	cvConvertScaleAbs (const void srcarr, void dstarr, double scale, double shift)

	ICV_DEF_CVT_FUNC_2D (8u, uchar, int, CV_CAST_8U, CV_8S, schar, CV_NOP, CV_16U, ushort, CV_NOP, CV_16S, short, CV_NOP, CV_32S, int, CV_NOP, CV_32F, float, cvRound, CV_64F, double, cvRound) ICV_DEF_CVT_FUNC_2D(8s

cvRound	ICV_DEF_CVT_FUNC_2D (16u, ushort, int, CV_CAST_16U, CV_8U, uchar, CV_NOP, CV_8S, schar, CV_NOP, CV_16S, short, CV_NOP, CV_32S, int, CV_NOP, CV_32F, float, cvRound, CV_64F, double, cvRound) ICV_DEF_CVT_FUNC_2D(16s

cvRound cvRound	ICV_DEF_CVT_FUNC_2D (32s, int, int, CV_NOP, CV_8U, uchar, CV_NOP, CV_8S, schar, CV_NOP, CV_16U, ushort, CV_NOP, CV_16S, short, CV_NOP, CV_32F, float, cvRound, CV_64F, double, cvRound) ICV_DEF_CVT_FUNC_2D(32f

cvRound cvRound CV_CAST_32F	ICV_DEF_CVT_FUNC_2D (64f, double, double, CV_NOP, CV_8U, uchar, CV_8TO32F, CV_8S, schar, CV_8TO32F, CV_16U, ushort, CV_NOP, CV_16S, short, CV_NOP, CV_32S, int, CV_NOP, CV_32F, float, CV_NOP) typedef CvStatus(CV_STDCALL CvCvtFunc)(const void src

CV_IMPL void	cvConvertScale (const void srcarr, void dstarr, double scale, double shift)

	IPCVAPI_IMPL (CvStatus, icvCvt_32f64f,(const float src, double dst, int len),(src, dst, len))

	IPCVAPI_IMPL (CvStatus, icvCvt_64f32f,(const double src, float dst, int len),(src, dst, len))

CvStatus CV_STDCALL	icvScale_32f (const float src, float dst, int len, float a, float b)

CvStatus CV_STDCALL	icvScale_64f (const double src, double dst, int len, double a, double b)

Variables
	schar

	int

	CV_CAST_8S

	CV_8U

	uchar

	CV_NOP

	CV_16U

	ushort

	CV_16S

	short

	CV_32S

	CV_32F

	float

	cvRound

	CV_64F

	double

cvRound	CV_CAST_16S

cvRound	CV_8S

cvRound cvRound	CV_8TO32F

cvRound cvRound	CV_CAST_32F

cvRound cvRound CV_CAST_32F int	srcstep

cvRound cvRound CV_CAST_32F int void *	dst

cvRound cvRound CV_CAST_32F int void int	dststep

cvRound cvRound CV_CAST_32F int void int CvSize	size

cvRound cvRound CV_CAST_32F int void int CvSize int	param

Macro Definition Documentation

#define ICV_DEF_COPY_PL2PX_FUNC_2D	(	arrtype,
		flavor,
		cn,
		entry_macro
	)

Value:

IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_P##cn##C##cn##R, \
( const arrtype** src, int srcstep,                         \
  arrtype* dst, int dststep, CvSize size ),                 \
  (src, srcstep, dst, dststep, size))                       \
{                                                           \
    entry_macro(const arrtype*, src);                       \
    srcstep /= sizeof(src[0][0]);                           \
    dststep /= sizeof(dst[0]);                              \
                                                            \
    for( ; size.height--; dst += dststep )                  \
    {                                                       \
        ICV_DEF_PL2PX_C##cn( arrtype, size.width );         \
        dst -= size.width*(cn);                             \
    }                                                       \
                                                            \
    return CV_OK;                                           \
}

#define ICV_DEF_COPY_PL2PX_FUNC_2D_COI	(	arrtype,
		flavor
	)

Value:

IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_C1CnCR,          \
( const arrtype* src, int srcstep,                          \
  arrtype* dst, int dststep,                                \
  CvSize size, int cn, int coi ),                           \
  (src, srcstep, dst, dststep, size, cn, coi))              \
{                                                           \
    dst += coi - 1;                                         \
    srcstep /= sizeof(src[0]); dststep /= sizeof(dst[0]);   \
                                                            \
    for( ; size.height--; src += srcstep, dst += dststep )  \
    {                                                       \
        ICV_DEF_PL2PX_COI( arrtype, size.width, cn );       \
        dst -= size.width*(cn);                             \
    }                                                       \
                                                            \
    return CV_OK;                                           \
}

#define ICV_DEF_COPY_PX2PL_FUNC_2D	(	arrtype,
		flavor,
		cn,
		entry_macro
	)

Value:

IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_C##cn##P##cn##R,\
( const arrtype* src, int srcstep,                      \
  arrtype** dst, int dststep, CvSize size ),            \
  (src, srcstep, dst, dststep, size))                   \
{                                                       \
    entry_macro(arrtype*, dst);                         \
    srcstep /= sizeof(src[0]);                          \
    dststep /= sizeof(dst[0][0]);                       \
                                                        \
    for( ; size.height--; src += srcstep )              \
    {                                                   \
        ICV_DEF_PX2PL_C##cn( arrtype, size.width );     \
        src -= size.width*(cn);                         \
    }                                                   \
                                                        \
    return CV_OK;                                       \
}

#define ICV_DEF_COPY_PX2PL_FUNC_2D_COI	(	arrtype,
		flavor
	)

Value:

IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_CnC1CR,      \
( const arrtype* src, int srcstep, arrtype* dst, int dststep,\
  CvSize size, int cn, int coi ),                       \
  (src, srcstep, dst, dststep, size, cn, coi))          \
{                                                       \
    src += coi - 1;                                     \
    srcstep /= sizeof(src[0]);                          \
    dststep /= sizeof(dst[0]);                          \
                                                        \
    for( ; size.height--; src += srcstep, dst += dststep )\
    {                                                   \
        ICV_DEF_PX2PL_COI( arrtype, size.width, cn );   \
        src -= size.width*(cn);                         \
    }                                                   \
                                                        \
    return CV_OK;                                       \
}

#define ICV_DEF_CVT_CASE_2D	(	srctype,
		worktype,
		cast_macro1,
		cast_macro2
	)

Value:

{                                                           \
    const srctype* _src = (const srctype*)src;              \
    srcstep /= sizeof(_src[0]);                             \
                                                            \
    for( ; size.height--; _src += srcstep, dst += dststep ) \
    {                                                       \
        int i;                                              \
                                                            \
        for( i = 0; i <= size.width - 4; i += 4 )           \
        {                                                   \
            worktype t0 = cast_macro1(_src[i]);             \
            worktype t1 = cast_macro1(_src[i+1]);           \
                                                            \
            dst[i] = cast_macro2(t0);                       \
            dst[i+1] = cast_macro2(t1);                     \
                                                            \
            t0 = cast_macro1(_src[i+2]);                    \
            t1 = cast_macro1(_src[i+3]);                    \
                                                            \
            dst[i+2] = cast_macro2(t0);                     \
            dst[i+3] = cast_macro2(t1);                     \
        }                                                   \
                                                            \
        for( ; i < size.width; i++ )                        \
        {                                                   \
            worktype t0 = cast_macro1(_src[i]);             \
            dst[i] = cast_macro2(t0);                       \
        }                                                   \
    }                                                       \
}

#define ICV_DEF_CVT_FUNC_2D	(	flavor,
		dsttype,
		worktype,
		cast_macro2,
		srcdepth1,
		srctype1,
		cast_macro11,
		srcdepth2,
		srctype2,
		cast_macro12,
		srcdepth3,
		srctype3,
		cast_macro13,
		srcdepth4,
		srctype4,
		cast_macro14,
		srcdepth5,
		srctype5,
		cast_macro15,
		srcdepth6,
		srctype6,
		cast_macro16
	)

#define ICV_DEF_CVT_SCALE_ABS_CASE	(	srctype,
		worktype,
		scale_macro,
		abs_macro,
		cast_macro,
		a,
		b
	)

#define ICV_DEF_CVT_SCALE_CASE	(	srctype,
		worktype,
		scale_macro,
		cast_macro,
		a,
		b
	)

Value:

\
{                                                           \
    const srctype* _src = (const srctype*)src;              \
    srcstep /= sizeof(_src[0]);                             \
                                                            \
    for( ; size.height--; _src += srcstep, dst += dststep ) \
    {                                                       \
        for( i = 0; i <= size.width - 4; i += 4 )           \
        {                                                   \
            worktype t0 = scale_macro((a)*_src[i]+(b));     \
            worktype t1 = scale_macro((a)*_src[i+1]+(b));   \
                                                            \
            dst[i] = cast_macro(t0);                        \
            dst[i+1] = cast_macro(t1);                      \
                                                            \
            t0 = scale_macro((a)*_src[i+2] + (b));          \
            t1 = scale_macro((a)*_src[i+3] + (b));          \
                                                            \
            dst[i+2] = cast_macro(t0);                      \
            dst[i+3] = cast_macro(t1);                      \
        }                                                   \
                                                            \
        for( ; i < size.width; i++ )                        \
        {                                                   \
            worktype t0 = scale_macro((a)*_src[i] + (b));   \
            dst[i] = cast_macro(t0);                        \
        }                                                   \
    }                                                       \
}

#define ICV_DEF_CVT_SCALE_FUNC_FLT	(	flavor,
		dsttype,
		cast_macro
	)

#define ICV_DEF_CVT_SCALE_FUNC_INT	(	flavor,
		dsttype,
		cast_macro
	)

#define ICV_DEF_MIX_CH_FUNC_2D	(	arrtype,
		flavor
	)

#define ICV_DEF_PL2PX_C2	(	arrtype,
		len
	)

Value:

{                                           \
    int j;                                  \
                                            \
    for( j = 0; j < (len); j++, (dst) += 2 )\
    {                                       \
        arrtype t0 = plane0[j];             \
        arrtype t1 = plane1[j];             \
                                            \
        dst[0] = t0;                        \
        dst[1] = t1;                        \
    }                                       \
    plane0 += srcstep;                      \
    plane1 += srcstep;                      \
}

#define ICV_DEF_PL2PX_C3	(	arrtype,
		len
	)

Value:

{                                           \
    int j;                                  \
                                            \
    for( j = 0; j < (len); j++, (dst) += 3 )\
    {                                       \
        arrtype t0 = plane0[j];             \
        arrtype t1 = plane1[j];             \
        arrtype t2 = plane2[j];             \
                                            \
        dst[0] = t0;                        \
        dst[1] = t1;                        \
        dst[2] = t2;                        \
    }                                       \
    plane0 += srcstep;                      \
    plane1 += srcstep;                      \
    plane2 += srcstep;                      \
}

#define ICV_DEF_PL2PX_C4	(	arrtype,
		len
	)

Value:

{                                           \
    int j;                                  \
                                            \
    for( j = 0; j < (len); j++, (dst) += 4 )\
    {                                       \
        arrtype t0 = plane0[j];             \
        arrtype t1 = plane1[j];             \
                                            \
        dst[0] = t0;                        \
        dst[1] = t1;                        \
                                            \
        t0 = plane2[j];                     \
        t1 = plane3[j];                     \
                                            \
        dst[2] = t0;                        \
        dst[3] = t1;                        \
    }                                       \
    plane0 += srcstep;                      \
    plane1 += srcstep;                      \
    plane2 += srcstep;                      \
    plane3 += srcstep;                      \
}

#define ICV_DEF_PL2PX_COI	(	arrtype,
		len,
		cn
	)

Value:

{                                                       \
    int j;                                              \
                                                        \
    for( j = 0; j <= (len) - 4; j += 4, (dst) += 4*(cn))\
    {                                                   \
        arrtype t0 = (src)[j];                          \
        arrtype t1 = (src)[j+1];                        \
                                                        \
        (dst)[0] = t0;                                  \
        (dst)[(cn)] = t1;                               \
                                                        \
        t0 = (src)[j+2];                                \
        t1 = (src)[j+3];                                \
                                                        \
        (dst)[(cn)*2] = t0;                             \
        (dst)[(cn)*3] = t1;                             \
    }                                                   \
                                                        \
    for( ; j < (len); j++, (dst) += (cn))               \
    {                                                   \
        (dst)[0] = (src)[j];                            \
    }                                                   \
}

#define ICV_DEF_PX2PL2PX_ENTRY_C2	(	arrtype_ptr,
		ptr
	)

Value:

arrtype_ptr plane0 = ptr[0]; \

arrtype_ptr plane1 = ptr[1];

#define ICV_DEF_PX2PL2PX_ENTRY_C3	(	arrtype_ptr,
		ptr
	)

Value:

arrtype_ptr plane0 = ptr[0];                        \
    arrtype_ptr plane1 = ptr[1];                        \
    arrtype_ptr plane2 = ptr[2];

#define ICV_DEF_PX2PL2PX_ENTRY_C4	(	arrtype_ptr,
		ptr
	)

Value:

arrtype_ptr plane0 = ptr[0];                        \
    arrtype_ptr plane1 = ptr[1];                        \
    arrtype_ptr plane2 = ptr[2];                        \
    arrtype_ptr plane3 = ptr[3];

#define ICV_DEF_PX2PL_C2	(	arrtype,
		len
	)

Value:

{                                                   \
    int j;                                          \
                                                    \
    for( j = 0; j < (len); j++, (src) += 2 )        \
    {                                               \
        arrtype t0 = (src)[0];                      \
        arrtype t1 = (src)[1];                      \
                                                    \
        plane0[j] = t0;                             \
        plane1[j] = t1;                             \
    }                                               \
    plane0 += dststep;                              \
    plane1 += dststep;                              \
}

#define ICV_DEF_PX2PL_C3	(	arrtype,
		len
	)

Value:

{                                                   \
    int j;                                          \
                                                    \
    for( j = 0; j < (len); j++, (src) += 3 )        \
    {                                               \
        arrtype t0 = (src)[0];                      \
        arrtype t1 = (src)[1];                      \
        arrtype t2 = (src)[2];                      \
                                                    \
        plane0[j] = t0;                             \
        plane1[j] = t1;                             \
        plane2[j] = t2;                             \
    }                                               \
    plane0 += dststep;                              \
    plane1 += dststep;                              \
    plane2 += dststep;                              \
}

#define ICV_DEF_PX2PL_C4	(	arrtype,
		len
	)

Value:

{                                                   \
    int j;                                          \
                                                    \
    for( j = 0; j < (len); j++, (src) += 4 )        \
    {                                               \
        arrtype t0 = (src)[0];                      \
        arrtype t1 = (src)[1];                      \
                                                    \
        plane0[j] = t0;                             \
        plane1[j] = t1;                             \
                                                    \
        t0 = (src)[2];                              \
        t1 = (src)[3];                              \
                                                    \
        plane2[j] = t0;                             \
        plane3[j] = t1;                             \
    }                                               \
    plane0 += dststep;                              \
    plane1 += dststep;                              \
    plane2 += dststep;                              \
    plane3 += dststep;                              \
}

#define ICV_DEF_PX2PL_COI	(	arrtype,
		len,
		cn
	)

Value:

{                                                   \
    int j;                                          \
                                                    \
    for( j = 0; j <= (len) - 4; j += 4, (src) += 4*(cn))\
    {                                               \
        arrtype t0 = (src)[0];                      \
        arrtype t1 = (src)[(cn)];                   \
                                                    \
        (dst)[j] = t0;                              \
        (dst)[j+1] = t1;                            \
                                                    \
        t0 = (src)[(cn)*2];                         \
        t1 = (src)[(cn)*3];                         \
                                                    \
        (dst)[j+2] = t0;                            \
        (dst)[j+3] = t1;                            \
    }                                               \
                                                    \
    for( ; j < (len); j++, (src) += (cn))           \
    {                                               \
        (dst)[j] = (src)[0];                        \
    }                                               \
}

#define ICV_DEF_PXPLCOI_TAB	(	name,
		FROM,
		TO
	)

Value:

static void                                                             \
name( CvFuncTable* tab )                                                \
{                                                                       \
    tab->fn_2d[CV_8U] = (void*)icvCopy##_8u_##FROM##TO##CR;             \
    tab->fn_2d[CV_8S] = (void*)icvCopy##_8u_##FROM##TO##CR;             \
    tab->fn_2d[CV_16U] = (void*)icvCopy##_16s_##FROM##TO##CR;           \
    tab->fn_2d[CV_16S] = (void*)icvCopy##_16s_##FROM##TO##CR;           \
    tab->fn_2d[CV_32S] = (void*)icvCopy##_32f_##FROM##TO##CR;           \
    tab->fn_2d[CV_32F] = (void*)icvCopy##_32f_##FROM##TO##CR;           \
    tab->fn_2d[CV_64F] = (void*)icvCopy##_64f_##FROM##TO##CR;           \
}

#define ICV_DEF_PXPLPX_TAB	(	name,
		FROM,
		TO
	)

#define ICV_FIX_SHIFT 15

#define ICV_SCALE ( x ) (((x) + (1 << (ICV_FIX_SHIFT-1))) >> ICV_FIX_SHIFT)

Typedef Documentation

typedef CvStatus(CV_STDCALL * CvCvtScaleFunc)(const void *src, int srcstep, void *dst, int dststep, CvSize size, double scale, double shift, int param)

typedef CvStatus(CV_STDCALL * CvExtractPlaneFunc)(const void *src, int srcstep, void *dst, int dststep, CvSize size, int cn, int coi)

typedef CvStatus(CV_STDCALL * CvInsertPlaneFunc)(const void *src, int srcstep, void *dst, int dststep, CvSize size, int cn, int coi)

typedef CvStatus(CV_STDCALL * CvMergeFunc)(const void **src, int srcstep, void *dst, int dststep, CvSize size)

typedef CvStatus(CV_STDCALL * CvMixChannelsFunc)(const void **src, int *sdelta0, int *sdelta1, void **dst, int *ddelta0, int *ddelta1, int n, CvSize size)

typedef CvStatus(CV_STDCALL * CvSplitFunc)(const void *src, int srcstep, void **dst, int dststep, CvSize size)

Function Documentation

CV_IMPL void cvConvertScale	(	const void *	srcarr,
		void *	dstarr,
		double	scale,
		double	shift
	)

CV_IMPL void cvConvertScaleAbs	(	const void *	srcarr,
		void *	dstarr,
		double	scale,
		double	shift
	)

CV_IMPL void cvMerge	(	const void *	srcarr0,
		const void *	srcarr1,
		const void *	srcarr2,
		const void *	srcarr3,
		void *	dstarr
	)

CV_IMPL void cvMixChannels	(	const CvArr **	src,
		int	src_count,
		CvArr **	dst,
		int	dst_count,
		const int *	from_to,
		int	pair_count
	)

CV_IMPL void cvSplit	(	const void *	srcarr,
		void *	dstarr0,
		void *	dstarr1,
		void *	dstarr2,
		void *	dstarr3
	)

ICV_DEF_CVT_FUNC_2D	(	8u	,
		uchar	,
		int	,
		CV_CAST_8U	,
		CV_8S	,
		schar	,
		CV_NOP	,
		CV_16U	,
		ushort	,
		CV_NOP	,
		CV_16S	,
		short	,
		CV_NOP	,
		CV_32S	,
		int	,
		CV_NOP	,
		CV_32F	,
		float	,
		cvRound	,
		CV_64F	,
		double	,
		cvRound
	)

cvRound ICV_DEF_CVT_FUNC_2D	(	16u	,
		ushort	,
		int	,
		CV_CAST_16U	,
		CV_8U	,
		uchar	,
		CV_NOP	,
		CV_8S	,
		schar	,
		CV_NOP	,
		CV_16S	,
		short	,
		CV_NOP	,
		CV_32S	,
		int	,
		CV_NOP	,
		CV_32F	,
		float	,
		cvRound	,
		CV_64F	,
		double	,
		cvRound
	)

cvRound cvRound ICV_DEF_CVT_FUNC_2D	(	32s	,
		int	,
		int	,
		CV_NOP	,
		CV_8U	,
		uchar	,
		CV_NOP	,
		CV_8S	,
		schar	,
		CV_NOP	,
		CV_16U	,
		ushort	,
		CV_NOP	,
		CV_16S	,
		short	,
		CV_NOP	,
		CV_32F	,
		float	,
		cvRound	,
		CV_64F	,
		double	,
		cvRound
	)

cvRound cvRound CV_CAST_32F ICV_DEF_CVT_FUNC_2D	(	64f	,
		double	,
		double	,
		CV_NOP	,
		CV_8U	,
		uchar	,
		CV_8TO32F	,
		CV_8S	,
		schar	,
		CV_8TO32F	,
		CV_16U	,
		ushort	,
		CV_NOP	,
		CV_16S	,
		short	,
		CV_NOP	,
		CV_32S	,
		int	,
		CV_NOP	,
		CV_32F	,
		float	,
		CV_NOP
	)		const