+++ /dev/null
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-// By downloading, copying, installing or using the software you agree to this license.
-// If you do not agree to this license, do not download, install,
-// copy or use the software.
-//
-//
-// Intel License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// * Redistribution's of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistribution's in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// * The name of Intel Corporation may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "_cxcore.h"
-
-/****************************************************************************************\
-* Splitting/extracting array channels *
-\****************************************************************************************/
-
-#define ICV_DEF_PX2PL2PX_ENTRY_C2( arrtype_ptr, ptr ) \
- arrtype_ptr plane0 = ptr[0]; \
- arrtype_ptr plane1 = ptr[1];
-
-#define ICV_DEF_PX2PL2PX_ENTRY_C3( arrtype_ptr, ptr ) \
- arrtype_ptr plane0 = ptr[0]; \
- arrtype_ptr plane1 = ptr[1]; \
- arrtype_ptr plane2 = ptr[2];
-
-#define ICV_DEF_PX2PL2PX_ENTRY_C4( arrtype_ptr, ptr ) \
- 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 ) \
-{ \
- 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 ) \
-{ \
- 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 ) \
-{ \
- 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 ) \
-{ \
- 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_COPY_PX2PL_FUNC_2D( arrtype, flavor, \
- cn, entry_macro ) \
-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 )\
-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; \
-}
-
-
-ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-
-
-ICV_DEF_COPY_PX2PL_FUNC_2D_COI( uchar, 8u )
-ICV_DEF_COPY_PX2PL_FUNC_2D_COI( ushort, 16s )
-ICV_DEF_COPY_PX2PL_FUNC_2D_COI( int, 32f )
-ICV_DEF_COPY_PX2PL_FUNC_2D_COI( int64, 64f )
-
-
-/****************************************************************************************\
-* Merging/inserting array channels *
-\****************************************************************************************/
-
-
-#define ICV_DEF_PL2PX_C2( arrtype, len ) \
-{ \
- 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 ) \
-{ \
- 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 ) \
-{ \
- 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 ) \
-{ \
- 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_COPY_PL2PX_FUNC_2D( arrtype, flavor, cn, entry_macro ) \
-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 ) \
-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; \
-}
-
-
-ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
-ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
-
-ICV_DEF_COPY_PL2PX_FUNC_2D_COI( uchar, 8u )
-ICV_DEF_COPY_PL2PX_FUNC_2D_COI( ushort, 16s )
-ICV_DEF_COPY_PL2PX_FUNC_2D_COI( int, 32f )
-ICV_DEF_COPY_PL2PX_FUNC_2D_COI( int64, 64f )
-
-
-#define ICV_DEF_PXPLPX_TAB( name, FROM, TO ) \
-static void \
-name( CvBigFuncTable* tab ) \
-{ \
- tab->fn_2d[CV_8UC2] = (void*)icvCopy##_8u_##FROM##2##TO##2R; \
- tab->fn_2d[CV_8UC3] = (void*)icvCopy##_8u_##FROM##3##TO##3R; \
- tab->fn_2d[CV_8UC4] = (void*)icvCopy##_8u_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_8SC2] = (void*)icvCopy##_8u_##FROM##2##TO##2R; \
- tab->fn_2d[CV_8SC3] = (void*)icvCopy##_8u_##FROM##3##TO##3R; \
- tab->fn_2d[CV_8SC4] = (void*)icvCopy##_8u_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_16UC2] = (void*)icvCopy##_16s_##FROM##2##TO##2R; \
- tab->fn_2d[CV_16UC3] = (void*)icvCopy##_16s_##FROM##3##TO##3R; \
- tab->fn_2d[CV_16UC4] = (void*)icvCopy##_16s_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_16SC2] = (void*)icvCopy##_16s_##FROM##2##TO##2R; \
- tab->fn_2d[CV_16SC3] = (void*)icvCopy##_16s_##FROM##3##TO##3R; \
- tab->fn_2d[CV_16SC4] = (void*)icvCopy##_16s_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_32SC2] = (void*)icvCopy##_32f_##FROM##2##TO##2R; \
- tab->fn_2d[CV_32SC3] = (void*)icvCopy##_32f_##FROM##3##TO##3R; \
- tab->fn_2d[CV_32SC4] = (void*)icvCopy##_32f_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_32FC2] = (void*)icvCopy##_32f_##FROM##2##TO##2R; \
- tab->fn_2d[CV_32FC3] = (void*)icvCopy##_32f_##FROM##3##TO##3R; \
- tab->fn_2d[CV_32FC4] = (void*)icvCopy##_32f_##FROM##4##TO##4R; \
- \
- tab->fn_2d[CV_64FC2] = (void*)icvCopy##_64f_##FROM##2##TO##2R; \
- tab->fn_2d[CV_64FC3] = (void*)icvCopy##_64f_##FROM##3##TO##3R; \
- tab->fn_2d[CV_64FC4] = (void*)icvCopy##_64f_##FROM##4##TO##4R; \
-}
-
-
-
-#define ICV_DEF_PXPLCOI_TAB( name, FROM, TO ) \
-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; \
-}
-
-
-ICV_DEF_PXPLPX_TAB( icvInitSplitRTable, C, P )
-ICV_DEF_PXPLCOI_TAB( icvInitSplitRCoiTable, Cn, C1 )
-ICV_DEF_PXPLPX_TAB( icvInitCvtPlaneToPixRTable, P, C )
-ICV_DEF_PXPLCOI_TAB( icvInitCvtPlaneToPixRCoiTable, C1, Cn )
-
-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 );
-
-CV_IMPL void
-cvSplit( const void* srcarr, void* dstarr0, void* dstarr1, void* dstarr2, void* dstarr3 )
-{
- static CvBigFuncTable pxpl_tab;
- static CvFuncTable pxplcoi_tab;
- static int inittab = 0;
-
- CV_FUNCNAME( "cvSplit" );
-
- __BEGIN__;
-
- CvMat stub[5], *dst[4], *src = (CvMat*)srcarr;
- CvSize size;
- void* dstptr[4] = { 0, 0, 0, 0 };
- int type, cn, coi = 0;
- int i, nzplanes = 0, nzidx = -1;
- int cont_flag;
- int src_step, dst_step = 0;
-
- if( !inittab )
- {
- icvInitSplitRTable( &pxpl_tab );
- icvInitSplitRCoiTable( &pxplcoi_tab );
- inittab = 1;
- }
-
- dst[0] = (CvMat*)dstarr0;
- dst[1] = (CvMat*)dstarr1;
- dst[2] = (CvMat*)dstarr2;
- dst[3] = (CvMat*)dstarr3;
-
- CV_CALL( src = cvGetMat( src, stub + 4, &coi ));
-
- //if( coi != 0 )
- // CV_ERROR( CV_BadCOI, "" );
-
- type = CV_MAT_TYPE( src->type );
- cn = CV_MAT_CN( type );
-
- cont_flag = src->type;
-
- if( cn == 1 )
- CV_ERROR( CV_BadNumChannels, "" );
-
- for( i = 0; i < 4; i++ )
- {
- if( dst[i] )
- {
- nzplanes++;
- nzidx = i;
- CV_CALL( dst[i] = cvGetMat( dst[i], stub + i ));
- if( CV_MAT_CN( dst[i]->type ) != 1 )
- CV_ERROR( CV_BadNumChannels, "" );
- if( !CV_ARE_DEPTHS_EQ( dst[i], src ))
- CV_ERROR( CV_StsUnmatchedFormats, "" );
- if( !CV_ARE_SIZES_EQ( dst[i], src ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
- if( nzplanes > i && i > 0 && dst[i]->step != dst[i-1]->step )
- CV_ERROR( CV_BadStep, "" );
- dst_step = dst[i]->step;
- dstptr[nzplanes-1] = dst[i]->data.ptr;
-
- cont_flag &= dst[i]->type;
- }
- }
-
- src_step = src->step;
- size = cvGetMatSize( src );
-
- if( CV_IS_MAT_CONT( cont_flag ))
- {
- size.width *= size.height;
- src_step = dst_step = CV_STUB_STEP;
-
- size.height = 1;
- }
-
- if( nzplanes == cn )
- {
- CvSplitFunc func = (CvSplitFunc)pxpl_tab.fn_2d[type];
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( src->data.ptr, src_step, dstptr, dst_step, size ));
- }
- else if( nzplanes == 1 )
- {
- CvExtractPlaneFunc func = (CvExtractPlaneFunc)pxplcoi_tab.fn_2d[CV_MAT_DEPTH(type)];
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( src->data.ptr, src_step,
- dst[nzidx]->data.ptr, dst_step,
- size, cn, nzidx + 1 ));
- }
- else
- {
- CV_ERROR( CV_StsBadArg,
- "Either all output planes or only one output plane should be non zero" );
- }
-
- __END__;
-}
-
-
-
-CV_IMPL void
-cvMerge( const void* srcarr0, const void* srcarr1, const void* srcarr2,
- const void* srcarr3, void* dstarr )
-{
- static CvBigFuncTable plpx_tab;
- static CvFuncTable plpxcoi_tab;
- static int inittab = 0;
-
- CV_FUNCNAME( "cvMerge" );
-
- __BEGIN__;
-
- int src_step = 0, dst_step;
- CvMat stub[5], *src[4], *dst = (CvMat*)dstarr;
- CvSize size;
- const void* srcptr[4] = { 0, 0, 0, 0 };
- int type, cn, coi = 0;
- int i, nzplanes = 0, nzidx = -1;
- int cont_flag;
-
- if( !inittab )
- {
- icvInitCvtPlaneToPixRTable( &plpx_tab );
- icvInitCvtPlaneToPixRCoiTable( &plpxcoi_tab );
- inittab = 1;
- }
-
- src[0] = (CvMat*)srcarr0;
- src[1] = (CvMat*)srcarr1;
- src[2] = (CvMat*)srcarr2;
- src[3] = (CvMat*)srcarr3;
-
- CV_CALL( dst = cvGetMat( dst, stub + 4, &coi ));
-
- type = CV_MAT_TYPE( dst->type );
- cn = CV_MAT_CN( type );
-
- cont_flag = dst->type;
-
- if( cn == 1 )
- CV_ERROR( CV_BadNumChannels, "" );
-
- for( i = 0; i < 4; i++ )
- {
- if( src[i] )
- {
- nzplanes++;
- nzidx = i;
- CV_CALL( src[i] = cvGetMat( src[i], stub + i ));
- if( CV_MAT_CN( src[i]->type ) != 1 )
- CV_ERROR( CV_BadNumChannels, "" );
- if( !CV_ARE_DEPTHS_EQ( src[i], dst ))
- CV_ERROR( CV_StsUnmatchedFormats, "" );
- if( !CV_ARE_SIZES_EQ( src[i], dst ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
- if( nzplanes > i && i > 0 && src[i]->step != src[i-1]->step )
- CV_ERROR( CV_BadStep, "" );
- src_step = src[i]->step;
- srcptr[nzplanes-1] = (const void*)(src[i]->data.ptr);
-
- cont_flag &= src[i]->type;
- }
- }
-
- size = cvGetMatSize( dst );
- dst_step = dst->step;
-
- if( CV_IS_MAT_CONT( cont_flag ))
- {
- size.width *= size.height;
- src_step = dst_step = CV_STUB_STEP;
- size.height = 1;
- }
-
- if( nzplanes == cn )
- {
- CvMergeFunc func = (CvMergeFunc)plpx_tab.fn_2d[type];
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( srcptr, src_step, dst->data.ptr, dst_step, size ));
- }
- else if( nzplanes == 1 )
- {
- CvInsertPlaneFunc func = (CvInsertPlaneFunc)plpxcoi_tab.fn_2d[CV_MAT_DEPTH(type)];
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( src[nzidx]->data.ptr, src_step,
- dst->data.ptr, dst_step,
- size, cn, nzidx + 1 ));
- }
- else
- {
- CV_ERROR( CV_StsBadArg,
- "Either all input planes or only one input plane should be non zero" );
- }
-
- __END__;
-}
-
-
-/****************************************************************************************\
-* Generalized split/merge: mixing channels *
-\****************************************************************************************/
-
-#define ICV_DEF_MIX_CH_FUNC_2D( arrtype, flavor ) \
-static CvStatus CV_STDCALL \
-icvMixChannels_##flavor( const arrtype** src, int* sdelta0, \
- int* sdelta1, arrtype** dst, \
- int* ddelta0, int* ddelta1, \
- int n, CvSize size ) \
-{ \
- int i, k; \
- int block_size0 = n == 1 ? size.width : 1024; \
- \
- for( ; size.height--; ) \
- { \
- int remaining = size.width; \
- for( ; remaining > 0; ) \
- { \
- int block_size = MIN( remaining, block_size0 ); \
- for( k = 0; k < n; k++ ) \
- { \
- const arrtype* s = src[k]; \
- arrtype* d = dst[k]; \
- int ds = sdelta1[k], dd = ddelta1[k]; \
- if( s ) \
- { \
- for( i = 0; i <= block_size - 2; i += 2, \
- s += ds*2, d += dd*2 ) \
- { \
- arrtype t0 = s[0], t1 = s[ds]; \
- d[0] = t0; d[dd] = t1; \
- } \
- if( i < block_size ) \
- d[0] = s[0], s += ds, d += dd; \
- src[k] = s; \
- } \
- else \
- { \
- for( i=0; i <= block_size-2; i+=2, d+=dd*2 )\
- d[0] = d[dd] = 0; \
- if( i < block_size ) \
- d[0] = 0, d += dd; \
- } \
- dst[k] = d; \
- } \
- remaining -= block_size; \
- } \
- for( k = 0; k < n; k++ ) \
- src[k] += sdelta0[k], dst[k] += ddelta0[k]; \
- } \
- \
- return CV_OK; \
-}
-
-
-ICV_DEF_MIX_CH_FUNC_2D( uchar, 8u )
-ICV_DEF_MIX_CH_FUNC_2D( ushort, 16u )
-ICV_DEF_MIX_CH_FUNC_2D( int, 32s )
-ICV_DEF_MIX_CH_FUNC_2D( int64, 64s )
-
-static void
-icvInitMixChannelsTab( CvFuncTable* tab )
-{
- tab->fn_2d[CV_8U] = (void*)icvMixChannels_8u;
- tab->fn_2d[CV_8S] = (void*)icvMixChannels_8u;
- tab->fn_2d[CV_16U] = (void*)icvMixChannels_16u;
- tab->fn_2d[CV_16S] = (void*)icvMixChannels_16u;
- tab->fn_2d[CV_32S] = (void*)icvMixChannels_32s;
- tab->fn_2d[CV_32F] = (void*)icvMixChannels_32s;
- tab->fn_2d[CV_64F] = (void*)icvMixChannels_64s;
-}
-
-typedef CvStatus (CV_STDCALL * CvMixChannelsFunc)( const void** src, int* sdelta0,
- int* sdelta1, void** dst, int* ddelta0, int* ddelta1, int n, CvSize size );
-
-CV_IMPL void
-cvMixChannels( const CvArr** src, int src_count,
- CvArr** dst, int dst_count,
- const int* from_to, int pair_count )
-{
- static CvFuncTable mixcn_tab;
- static int inittab = 0;
- uchar* buffer = 0;
- int heap_alloc = 0;
-
- CV_FUNCNAME( "cvMixChannels" );
-
- __BEGIN__;
-
- CvSize size = {0,0};
- int depth = -1, elem_size = 1;
- int *sdelta0 = 0, *sdelta1 = 0, *ddelta0 = 0, *ddelta1 = 0;
- uchar **sptr = 0, **dptr = 0;
- uchar **src0 = 0, **dst0 = 0;
- int* src_cn = 0, *dst_cn = 0;
- int* src_step = 0, *dst_step = 0;
- int buf_size, i, k;
- int cont_flag = CV_MAT_CONT_FLAG;
- CvMixChannelsFunc func;
-
- if( !inittab )
- {
- icvInitMixChannelsTab( &mixcn_tab );
- inittab = 1;
- }
-
- src_count = MAX( src_count, 0 );
-
- if( !src && src_count > 0 )
- CV_ERROR( CV_StsNullPtr, "The input array of arrays is NULL" );
-
- if( !dst )
- CV_ERROR( CV_StsNullPtr, "The output array of arrays is NULL" );
-
- if( dst_count <= 0 || pair_count <= 0 )
- CV_ERROR( CV_StsOutOfRange,
- "The number of output arrays and the number of copied channels must be positive" );
-
- if( !from_to )
- CV_ERROR( CV_StsNullPtr, "The array of copied channel indices is NULL" );
-
- buf_size = (src_count + dst_count + 2)*
- (sizeof(src0[0]) + sizeof(src_cn[0]) + sizeof(src_step[0])) +
- pair_count*2*(sizeof(sptr[0]) + sizeof(sdelta0[0]) + sizeof(sdelta1[0]));
-
- if( buf_size > CV_MAX_LOCAL_SIZE )
- {
- CV_CALL( buffer = (uchar*)cvAlloc( buf_size ) );
- heap_alloc = 1;
- }
- else
- buffer = (uchar*)cvStackAlloc( buf_size );
-
- src0 = (uchar**)buffer;
- dst0 = src0 + src_count;
- src_cn = (int*)(dst0 + dst_count);
- dst_cn = src_cn + src_count + 1;
- src_step = dst_cn + dst_count + 1;
- dst_step = src_step + src_count;
-
- sptr = (uchar**)cvAlignPtr( dst_step + dst_count, (int)sizeof(void*) );
- dptr = sptr + pair_count;
- sdelta0 = (int*)(dptr + pair_count);
- sdelta1 = sdelta0 + pair_count;
- ddelta0 = sdelta1 + pair_count;
- ddelta1 = ddelta0 + pair_count;
-
- src_cn[0] = dst_cn[0] = 0;
-
- for( k = 0; k < 2; k++ )
- {
- for( i = 0; i < (k == 0 ? src_count : dst_count); i++ )
- {
- CvMat stub, *mat = (CvMat*)(k == 0 ? src[i] : dst[i]);
- int cn;
-
- if( !CV_IS_MAT(mat) )
- CV_CALL( mat = cvGetMat( mat, &stub ));
-
- if( depth < 0 )
- {
- depth = CV_MAT_DEPTH(mat->type);
- elem_size = CV_ELEM_SIZE1(depth);
- size = cvGetMatSize(mat);
- }
-
- if( CV_MAT_DEPTH(mat->type) != depth )
- CV_ERROR( CV_StsUnmatchedFormats, "All the arrays must have the same bit depth" );
-
- if( mat->cols != size.width || mat->rows != size.height )
- CV_ERROR( CV_StsUnmatchedSizes, "All the arrays must have the same size" );
-
- if( k == 0 )
- {
- src0[i] = mat->data.ptr;
- cn = CV_MAT_CN(mat->type);
- src_cn[i+1] = src_cn[i] + cn;
- src_step[i] = mat->step / elem_size - size.width * cn;
- }
- else
- {
- dst0[i] = mat->data.ptr;
- cn = CV_MAT_CN(mat->type);
- dst_cn[i+1] = dst_cn[i] + cn;
- dst_step[i] = mat->step / elem_size - size.width * cn;
- }
-
- cont_flag &= mat->type;
- }
- }
-
- if( cont_flag )
- {
- size.width *= size.height;
- size.height = 1;
- }
-
- for( i = 0; i < pair_count; i++ )
- {
- for( k = 0; k < 2; k++ )
- {
- int cn = from_to[i*2 + k];
- const int* cn_arr = k == 0 ? src_cn : dst_cn;
- int a = 0, b = k == 0 ? src_count-1 : dst_count-1;
-
- if( cn < 0 || cn >= cn_arr[b+1] )
- {
- if( k == 0 && cn < 0 )
- {
- sptr[i] = 0;
- sdelta0[i] = sdelta1[i] = 0;
- continue;
- }
- else
- {
- char err_str[100];
- sprintf( err_str, "channel index #%d in the array of pairs is negative "
- "or exceeds the total number of channels in all the %s arrays", i*2+k,
- k == 0 ? "input" : "output" );
- CV_ERROR( CV_StsOutOfRange, err_str );
- }
- }
-
- for( ; cn >= cn_arr[a+1]; a++ )
- ;
-
- if( k == 0 )
- {
- sptr[i] = src0[a] + (cn - cn_arr[a])*elem_size;
- sdelta1[i] = cn_arr[a+1] - cn_arr[a];
- sdelta0[i] = src_step[a];
- }
- else
- {
- dptr[i] = dst0[a] + (cn - cn_arr[a])*elem_size;
- ddelta1[i] = cn_arr[a+1] - cn_arr[a];
- ddelta0[i] = dst_step[a];
- }
- }
- }
-
- func = (CvMixChannelsFunc)mixcn_tab.fn_2d[depth];
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "The data type is not supported by the function" );
-
- IPPI_CALL( func( (const void**)sptr, sdelta0, sdelta1, (void**)dptr,
- ddelta0, ddelta1, pair_count, size ));
-
- __END__;
-
- if( buffer && heap_alloc )
- cvFree( &buffer );
-}
-
-
-/****************************************************************************************\
-* cvConvertScaleAbs *
-\****************************************************************************************/
-
-#define ICV_DEF_CVT_SCALE_ABS_CASE( srctype, worktype, \
- scale_macro, abs_macro, cast_macro, a, b ) \
- \
-{ \
- const srctype* _src = (const srctype*)src; \
- srcstep /= sizeof(_src[0]); /*dststep /= sizeof(_dst[0]);*/ \
- \
- for( ; size.height--; _src += srcstep, dst += dststep ) \
- { \
- int i; \
- \
- 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)); \
- \
- t0 = (worktype)abs_macro(t0); \
- t1 = (worktype)abs_macro(t1); \
- \
- 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)); \
- \
- t0 = (worktype)abs_macro(t0); \
- t1 = (worktype)abs_macro(t1); \
- \
- 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)); \
- t0 = (worktype)abs_macro(t0); \
- dst[i] = cast_macro(t0); \
- } \
- } \
-}
-
-
-#define ICV_FIX_SHIFT 15
-#define ICV_SCALE(x) (((x) + (1 << (ICV_FIX_SHIFT-1))) >> ICV_FIX_SHIFT)
-
-static CvStatus CV_STDCALL
-icvCvtScaleAbsTo_8u_C1R( const uchar* src, int srcstep,
- uchar* dst, int dststep,
- CvSize size, double scale, double shift,
- int param )
-{
- int srctype = param;
- int srcdepth = CV_MAT_DEPTH(srctype);
-
- size.width *= CV_MAT_CN(srctype);
-
- switch( srcdepth )
- {
- case CV_8S:
- case CV_8U:
- {
- uchar lut[256];
- int i;
- double val = shift;
-
- for( i = 0; i < 128; i++, val += scale )
- {
- int t = cvRound(fabs(val));
- lut[i] = CV_CAST_8U(t);
- }
-
- if( srcdepth == CV_8S )
- val = -val;
-
- for( ; i < 256; i++, val += scale )
- {
- int t = cvRound(fabs(val));
- lut[i] = CV_CAST_8U(t);
- }
-
- icvLUT_Transform8u_8u_C1R( src, srcstep, dst,
- dststep, size, lut );
- }
- break;
- case CV_16U:
- if( fabs( scale ) <= 1. && fabs(shift) < DBL_EPSILON )
- {
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));
-
- if( iscale == ICV_FIX_SHIFT )
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, CV_NOP, CV_IABS,
- CV_CAST_8U, 1, 0 );
- }
- else
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, ICV_SCALE, CV_IABS,
- CV_CAST_8U, iscale, 0 );
- }
- }
- else
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, cvRound, CV_IABS,
- CV_CAST_8U, scale, shift );
- }
- break;
- case CV_16S:
- if( fabs( scale ) <= 1. &&
- fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT))
- {
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));
- int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT));
-
- if( iscale == ICV_FIX_SHIFT && ishift == 0 )
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( short, int, CV_NOP, CV_IABS,
- CV_CAST_8U, 1, 0 );
- }
- else
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( short, int, ICV_SCALE, CV_IABS,
- CV_CAST_8U, iscale, ishift );
- }
- }
- else
- {
- ICV_DEF_CVT_SCALE_ABS_CASE( short, int, cvRound, CV_IABS,
- CV_CAST_8U, scale, shift );
- }
- break;
- case CV_32S:
- ICV_DEF_CVT_SCALE_ABS_CASE( int, int, cvRound, CV_IABS,
- CV_CAST_8U, scale, shift );
- break;
- case CV_32F:
- ICV_DEF_CVT_SCALE_ABS_CASE( float, int, cvRound, CV_IABS,
- CV_CAST_8U, scale, shift );
- break;
- case CV_64F:
- ICV_DEF_CVT_SCALE_ABS_CASE( double, int, cvRound, CV_IABS,
- CV_CAST_8U, scale, shift );
- break;
- default:
- assert(0);
- return CV_BADFLAG_ERR;
- }
-
- return CV_OK;
-}
-
-
-CV_IMPL void
-cvConvertScaleAbs( const void* srcarr, void* dstarr,
- double scale, double shift )
-{
- CV_FUNCNAME( "cvConvertScaleAbs" );
-
- __BEGIN__;
-
- int coi1 = 0, coi2 = 0;
- CvMat srcstub, *src = (CvMat*)srcarr;
- CvMat dststub, *dst = (CvMat*)dstarr;
- CvSize size;
- int src_step, dst_step;
-
- 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_SIZES_EQ( src, dst ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
-
- if( !CV_ARE_CNS_EQ( src, dst ))
- CV_ERROR( CV_StsUnmatchedFormats, "" );
-
- if( CV_MAT_DEPTH( dst->type ) != CV_8U )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- size = cvGetMatSize( src );
- src_step = src->step;
- dst_step = dst->step;
-
- if( CV_IS_MAT_CONT( src->type & dst->type ))
- {
- size.width *= size.height;
- src_step = dst_step = CV_STUB_STEP;
- size.height = 1;
- }
-
- IPPI_CALL( icvCvtScaleAbsTo_8u_C1R( src->data.ptr, src_step,
- (uchar*)(dst->data.ptr), dst_step,
- size, scale, shift, CV_MAT_TYPE(src->type)));
- __END__;
-}
-
-/****************************************************************************************\
-* cvConvertScale *
-\****************************************************************************************/
-
-#define ICV_DEF_CVT_SCALE_CASE( srctype, worktype, \
- scale_macro, cast_macro, a, b ) \
- \
-{ \
- 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_INT( flavor, dsttype, cast_macro ) \
-static CvStatus CV_STDCALL \
-icvCvtScaleTo_##flavor##_C1R( const uchar* src, int srcstep, \
- dsttype* dst, int dststep, CvSize size, \
- double scale, double shift, int param ) \
-{ \
- int i, srctype = param; \
- dsttype lut[256]; \
- dststep /= sizeof(dst[0]); \
- \
- switch( CV_MAT_DEPTH(srctype) ) \
- { \
- case CV_8U: \
- if( size.width*size.height >= 256 ) \
- { \
- double val = shift; \
- for( i = 0; i < 256; i++, val += scale ) \
- { \
- int t = cvRound(val); \
- lut[i] = cast_macro(t); \
- } \
- \
- icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst, \
- dststep*sizeof(dst[0]), size, lut ); \
- } \
- else if( fabs( scale ) <= 128. && \
- fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT)) \
- { \
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT)); \
- int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT)); \
- \
- ICV_DEF_CVT_SCALE_CASE( uchar, int, ICV_SCALE, \
- cast_macro, iscale, ishift ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( uchar, int, cvRound, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_8S: \
- if( size.width*size.height >= 256 ) \
- { \
- for( i = 0; i < 256; i++ ) \
- { \
- int t = cvRound( (schar)i*scale + shift ); \
- lut[i] = cast_macro(t); \
- } \
- \
- icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst, \
- dststep*sizeof(dst[0]), size, lut ); \
- } \
- else if( fabs( scale ) <= 128. && \
- fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT)) \
- { \
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT)); \
- int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT)); \
- \
- ICV_DEF_CVT_SCALE_CASE( schar, int, ICV_SCALE, \
- cast_macro, iscale, ishift ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( schar, int, cvRound, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_16U: \
- if( fabs( scale ) <= 1. && fabs(shift) < DBL_EPSILON ) \
- { \
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT)); \
- \
- ICV_DEF_CVT_SCALE_CASE( ushort, int, ICV_SCALE, \
- cast_macro, iscale, 0 ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( ushort, int, cvRound, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_16S: \
- if( fabs( scale ) <= 1. && \
- fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT)) \
- { \
- int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT)); \
- int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT)); \
- \
- ICV_DEF_CVT_SCALE_CASE( short, int, ICV_SCALE, \
- cast_macro, iscale, ishift ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( short, int, cvRound, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_32S: \
- ICV_DEF_CVT_SCALE_CASE( int, int, cvRound, \
- cast_macro, scale, shift ); \
- break; \
- case CV_32F: \
- ICV_DEF_CVT_SCALE_CASE( float, int, cvRound, \
- cast_macro, scale, shift ); \
- break; \
- case CV_64F: \
- ICV_DEF_CVT_SCALE_CASE( double, int, cvRound, \
- cast_macro, scale, shift ); \
- break; \
- default: \
- assert(0); \
- return CV_BADFLAG_ERR; \
- } \
- \
- return CV_OK; \
-}
-
-
-#define ICV_DEF_CVT_SCALE_FUNC_FLT( flavor, dsttype, cast_macro ) \
-static CvStatus CV_STDCALL \
-icvCvtScaleTo_##flavor##_C1R( const uchar* src, int srcstep, \
- dsttype* dst, int dststep, CvSize size, \
- double scale, double shift, int param ) \
-{ \
- int i, srctype = param; \
- dsttype lut[256]; \
- dststep /= sizeof(dst[0]); \
- \
- switch( CV_MAT_DEPTH(srctype) ) \
- { \
- case CV_8U: \
- if( size.width*size.height >= 256 ) \
- { \
- double val = shift; \
- for( i = 0; i < 256; i++, val += scale ) \
- lut[i] = (dsttype)val; \
- \
- icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst, \
- dststep*sizeof(dst[0]), size, lut ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( uchar, double, CV_NOP, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_8S: \
- if( size.width*size.height >= 256 ) \
- { \
- for( i = 0; i < 256; i++ ) \
- lut[i] = (dsttype)((schar)i*scale + shift); \
- \
- icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst, \
- dststep*sizeof(dst[0]), size, lut ); \
- } \
- else \
- { \
- ICV_DEF_CVT_SCALE_CASE( schar, double, CV_NOP, \
- cast_macro, scale, shift ); \
- } \
- break; \
- case CV_16U: \
- ICV_DEF_CVT_SCALE_CASE( ushort, double, CV_NOP, \
- cast_macro, scale, shift ); \
- break; \
- case CV_16S: \
- ICV_DEF_CVT_SCALE_CASE( short, double, CV_NOP, \
- cast_macro, scale, shift ); \
- break; \
- case CV_32S: \
- ICV_DEF_CVT_SCALE_CASE( int, double, CV_NOP, \
- cast_macro, scale, shift ); \
- break; \
- case CV_32F: \
- ICV_DEF_CVT_SCALE_CASE( float, double, CV_NOP, \
- cast_macro, scale, shift ); \
- break; \
- case CV_64F: \
- ICV_DEF_CVT_SCALE_CASE( double, double, CV_NOP, \
- cast_macro, scale, shift ); \
- break; \
- default: \
- assert(0); \
- return CV_BADFLAG_ERR; \
- } \
- \
- return CV_OK; \
-}
-
-
-ICV_DEF_CVT_SCALE_FUNC_INT( 8u, uchar, CV_CAST_8U )
-ICV_DEF_CVT_SCALE_FUNC_INT( 8s, schar, CV_CAST_8S )
-ICV_DEF_CVT_SCALE_FUNC_INT( 16s, short, CV_CAST_16S )
-ICV_DEF_CVT_SCALE_FUNC_INT( 16u, ushort, CV_CAST_16U )
-ICV_DEF_CVT_SCALE_FUNC_INT( 32s, int, CV_CAST_32S )
-
-ICV_DEF_CVT_SCALE_FUNC_FLT( 32f, float, CV_CAST_32F )
-ICV_DEF_CVT_SCALE_FUNC_FLT( 64f, double, CV_CAST_64F )
-
-CV_DEF_INIT_FUNC_TAB_2D( CvtScaleTo, C1R )
-
-
-/****************************************************************************************\
-* Conversion w/o scaling macros *
-\****************************************************************************************/
-
-#define ICV_DEF_CVT_CASE_2D( srctype, worktype, \
- cast_macro1, cast_macro2 ) \
-{ \
- 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 ) \
-static CvStatus CV_STDCALL \
-icvCvtTo_##flavor##_C1R( const uchar* src, int srcstep, \
- dsttype* dst, int dststep, \
- CvSize size, int param ) \
-{ \
- int srctype = param; \
- dststep /= sizeof(dst[0]); \
- \
- switch( CV_MAT_DEPTH(srctype) ) \
- { \
- case srcdepth1: \
- ICV_DEF_CVT_CASE_2D( srctype1, worktype, \
- cast_macro11, cast_macro2 ); \
- break; \
- case srcdepth2: \
- ICV_DEF_CVT_CASE_2D( srctype2, worktype, \
- cast_macro12, cast_macro2 ); \
- break; \
- case srcdepth3: \
- ICV_DEF_CVT_CASE_2D( srctype3, worktype, \
- cast_macro13, cast_macro2 ); \
- break; \
- case srcdepth4: \
- ICV_DEF_CVT_CASE_2D( srctype4, worktype, \
- cast_macro14, cast_macro2 ); \
- break; \
- case srcdepth5: \
- ICV_DEF_CVT_CASE_2D( srctype5, worktype, \
- cast_macro15, cast_macro2 ); \
- break; \
- case srcdepth6: \
- ICV_DEF_CVT_CASE_2D( srctype6, worktype, \
- cast_macro16, cast_macro2 ); \
- break; \
- } \
- \
- return CV_OK; \
-}
-
-
-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, schar, int, CV_CAST_8S,
- CV_8U, uchar, 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( 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, short, int, CV_CAST_16S,
- CV_8U, uchar, CV_NOP,
- CV_8S, schar, CV_NOP,
- CV_16U, ushort, CV_NOP,
- CV_32S, int, CV_NOP,
- CV_32F, float, cvRound,
- CV_64F, double, 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, float, float, 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_CAST_32F,
- CV_64F, double, 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 )
-
-CV_DEF_INIT_FUNC_TAB_2D( CvtTo, C1R )
-
-
-typedef CvStatus (CV_STDCALL *CvCvtFunc)( const void* src, int srcstep,
- void* dst, int dststep, CvSize size,
- int param );
-
-typedef CvStatus (CV_STDCALL *CvCvtScaleFunc)( const void* src, int srcstep,
- void* dst, int dststep, CvSize size,
- double scale, double shift,
- int param );
-
-CV_IMPL void
-cvConvertScale( const void* srcarr, void* dstarr,
- double scale, double shift )
-{
- static CvFuncTable cvt_tab, cvtscale_tab;
- static int inittab = 0;
-
- CV_FUNCNAME( "cvConvertScale" );
-
- __BEGIN__;
-
- int type;
- int is_nd = 0;
- CvMat srcstub, *src = (CvMat*)srcarr;
- CvMat dststub, *dst = (CvMat*)dstarr;
- CvSize size;
- int src_step, dst_step;
- int no_scale = scale == 1 && shift == 0;
-
- if( !CV_IS_MAT(src) )
- {
- if( CV_IS_MATND(src) )
- is_nd = 1;
- else
- {
- int coi = 0;
- CV_CALL( src = cvGetMat( src, &srcstub, &coi ));
-
- if( coi != 0 )
- CV_ERROR( CV_BadCOI, "" );
- }
- }
-
- if( !CV_IS_MAT(dst) )
- {
- if( CV_IS_MATND(dst) )
- is_nd = 1;
- else
- {
- int coi = 0;
- CV_CALL( dst = cvGetMat( dst, &dststub, &coi ));
-
- if( coi != 0 )
- CV_ERROR( CV_BadCOI, "" );
- }
- }
-
- if( is_nd )
- {
- CvArr* arrs[] = { src, dst };
- CvMatND stubs[2];
- CvNArrayIterator iterator;
- int dsttype;
-
- CV_CALL( cvInitNArrayIterator( 2, arrs, 0, stubs, &iterator, CV_NO_DEPTH_CHECK ));
-
- type = iterator.hdr[0]->type;
- dsttype = iterator.hdr[1]->type;
- iterator.size.width *= CV_MAT_CN(type);
-
- if( !inittab )
- {
- icvInitCvtToC1RTable( &cvt_tab );
- icvInitCvtScaleToC1RTable( &cvtscale_tab );
- inittab = 1;
- }
-
- if( no_scale )
- {
- CvCvtFunc func = (CvCvtFunc)(cvt_tab.fn_2d[CV_MAT_DEPTH(dsttype)]);
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- do
- {
- IPPI_CALL( func( iterator.ptr[0], CV_STUB_STEP,
- iterator.ptr[1], CV_STUB_STEP,
- iterator.size, type ));
- }
- while( cvNextNArraySlice( &iterator ));
- }
- else
- {
- CvCvtScaleFunc func =
- (CvCvtScaleFunc)(cvtscale_tab.fn_2d[CV_MAT_DEPTH(dsttype)]);
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- do
- {
- IPPI_CALL( func( iterator.ptr[0], CV_STUB_STEP,
- iterator.ptr[1], CV_STUB_STEP,
- iterator.size, scale, shift, type ));
- }
- while( cvNextNArraySlice( &iterator ));
- }
- EXIT;
- }
-
- if( no_scale && CV_ARE_TYPES_EQ( src, dst ) )
- {
- if( src != dst )
- cvCopy( src, dst );
- EXIT;
- }
-
- if( !CV_ARE_SIZES_EQ( src, dst ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
-
- size = cvGetMatSize( src );
- type = CV_MAT_TYPE(src->type);
- src_step = src->step;
- dst_step = dst->step;
-
- if( CV_IS_MAT_CONT( src->type & dst->type ))
- {
- size.width *= size.height;
- src_step = dst_step = CV_STUB_STEP;
- size.height = 1;
- }
-
- size.width *= CV_MAT_CN( type );
-
- if( CV_ARE_TYPES_EQ( src, dst ) && size.height == 1 &&
- size.width <= CV_MAX_INLINE_MAT_OP_SIZE )
- {
- if( CV_MAT_DEPTH(type) == CV_32F )
- {
- const float* srcdata = (const float*)(src->data.ptr);
- float* dstdata = (float*)(dst->data.ptr);
-
- do
- {
- dstdata[size.width - 1] = (float)(srcdata[size.width-1]*scale + shift);
- }
- while( --size.width );
-
- EXIT;
- }
-
- if( CV_MAT_DEPTH(type) == CV_64F )
- {
- const double* srcdata = (const double*)(src->data.ptr);
- double* dstdata = (double*)(dst->data.ptr);
-
- do
- {
- dstdata[size.width - 1] = srcdata[size.width-1]*scale + shift;
- }
- while( --size.width );
-
- EXIT;
- }
- }
-
- if( !inittab )
- {
- icvInitCvtToC1RTable( &cvt_tab );
- icvInitCvtScaleToC1RTable( &cvtscale_tab );
- inittab = 1;
- }
-
- if( !CV_ARE_CNS_EQ( src, dst ))
- CV_ERROR( CV_StsUnmatchedFormats, "" );
-
- if( no_scale )
- {
- CvCvtFunc func = (CvCvtFunc)(cvt_tab.fn_2d[CV_MAT_DEPTH(dst->type)]);
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( src->data.ptr, src_step,
- dst->data.ptr, dst_step, size, type ));
- }
- else
- {
- CvCvtScaleFunc func = (CvCvtScaleFunc)
- (cvtscale_tab.fn_2d[CV_MAT_DEPTH(dst->type)]);
-
- if( !func )
- CV_ERROR( CV_StsUnsupportedFormat, "" );
-
- IPPI_CALL( func( src->data.ptr, src_step,
- dst->data.ptr, dst_step, size,
- scale, shift, type ));
- }
-
- __END__;
-}
-
-/********************* helper functions for converting 32f<->64f ************************/
-
-IPCVAPI_IMPL( CvStatus, icvCvt_32f64f,
- ( const float* src, double* dst, int len ), (src, dst, len) )
-{
- int i;
- for( i = 0; i <= len - 4; i += 4 )
- {
- double t0 = src[i];
- double t1 = src[i+1];
-
- dst[i] = t0;
- dst[i+1] = t1;
-
- t0 = src[i+2];
- t1 = src[i+3];
-
- dst[i+2] = t0;
- dst[i+3] = t1;
- }
-
- for( ; i < len; i++ )
- dst[i] = src[i];
-
- return CV_OK;
-}
-
-
-IPCVAPI_IMPL( CvStatus, icvCvt_64f32f,
- ( const double* src, float* dst, int len ), (src, dst, len) )
-{
- int i = 0;
- for( ; i <= len - 4; i += 4 )
- {
- double t0 = src[i];
- double t1 = src[i+1];
-
- dst[i] = (float)t0;
- dst[i+1] = (float)t1;
-
- t0 = src[i+2];
- t1 = src[i+3];
-
- dst[i+2] = (float)t0;
- dst[i+3] = (float)t1;
- }
-
- for( ; i < len; i++ )
- dst[i] = (float)src[i];
-
- return CV_OK;
-}
-
-
-CvStatus CV_STDCALL icvScale_32f( const float* src, float* dst, int len, float a, float b )
-{
- int i;
- for( i = 0; i <= len - 4; i += 4 )
- {
- double t0 = src[i]*a + b;
- double t1 = src[i+1]*a + b;
-
- dst[i] = (float)t0;
- dst[i+1] = (float)t1;
-
- t0 = src[i+2]*a + b;
- t1 = src[i+3]*a + b;
-
- dst[i+2] = (float)t0;
- dst[i+3] = (float)t1;
- }
-
- for( ; i < len; i++ )
- dst[i] = (float)(src[i]*a + b);
-
- return CV_OK;
-}
-
-
-CvStatus CV_STDCALL icvScale_64f( const double* src, double* dst, int len, double a, double b )
-{
- int i;
- for( i = 0; i <= len - 4; i += 4 )
- {
- double t0 = src[i]*a + b;
- double t1 = src[i+1]*a + b;
-
- dst[i] = t0;
- dst[i+1] = t1;
-
- t0 = src[i+2]*a + b;
- t1 = src[i+3]*a + b;
-
- dst[i+2] = t0;
- dst[i+3] = t1;
- }
-
- for( ; i < len; i++ )
- dst[i] = src[i]*a + b;
-
- return CV_OK;
-}
-
-/* End of file. */
projects / opencv / blobdiff