+++ /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*/
-
-/* ////////////////////////////////////////////////////////////////////
-//
-// CvMat logical operations: &, |, ^ ...
-//
-// */
-
-#include "_cxcore.h"
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Macros for logic operations //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/* //////////////////////////////////////////////////////////////////////////////////////
- Mat op Mat
-////////////////////////////////////////////////////////////////////////////////////// */
-
-
-#define ICV_DEF_BIN_LOG_OP_2D( __op__, name ) \
-IPCVAPI_IMPL( CvStatus, icv##name##_8u_C1R, \
-( const uchar* src1, int step1, const uchar* src2, int step2, \
- uchar* dst, int step, CvSize size ), (src1, step1, src2, step2, dst, step, size) )\
-{ \
- for( ; size.height--; src1 += step1, src2 += step2, dst += step ) \
- { \
- int i = 0; \
- \
- if( (((size_t)src1 | (size_t)src2 | (size_t)dst) & 3) == 0 ) \
- { \
- for( ; i <= size.width - 16; i += 16 ) \
- { \
- int t0 = __op__(((const int*)(src1+i))[0], ((const int*)(src2+i))[0]);\
- int t1 = __op__(((const int*)(src1+i))[1], ((const int*)(src2+i))[1]);\
- \
- ((int*)(dst+i))[0] = t0; \
- ((int*)(dst+i))[1] = t1; \
- \
- t0 = __op__(((const int*)(src1+i))[2], ((const int*)(src2+i))[2]); \
- t1 = __op__(((const int*)(src1+i))[3], ((const int*)(src2+i))[3]); \
- \
- ((int*)(dst+i))[2] = t0; \
- ((int*)(dst+i))[3] = t1; \
- } \
- \
- for( ; i <= size.width - 4; i += 4 ) \
- { \
- int t = __op__(*(const int*)(src1+i), *(const int*)(src2+i)); \
- *(int*)(dst+i) = t; \
- } \
- } \
- \
- for( ; i < size.width; i++ ) \
- { \
- int t = __op__(((const uchar*)src1)[i],((const uchar*)src2)[i]); \
- dst[i] = (uchar)t; \
- } \
- } \
- \
- return CV_OK; \
-}
-
-
-/* //////////////////////////////////////////////////////////////////////////////////////
- Mat op Scalar
-////////////////////////////////////////////////////////////////////////////////////// */
-
-
-#define ICV_DEF_UN_LOG_OP_2D( __op__, name ) \
-static CvStatus CV_STDCALL icv##name##_8u_CnR \
-( const uchar* src0, int step1, uchar* dst0, int step, CvSize size, \
- const uchar* scalar, int pix_size ) \
-{ \
- int delta = 12*pix_size; \
- \
- for( ; size.height--; src0 += step1, dst0 += step ) \
- { \
- const uchar* src = (const uchar*)src0; \
- uchar* dst = dst0; \
- int i, len = size.width; \
- \
- if( (((size_t)src|(size_t)dst) & 3) == 0 ) \
- { \
- while( (len -= delta) >= 0 ) \
- { \
- for( i = 0; i < (delta); i += 12 ) \
- { \
- int t0 = __op__(((const int*)(src+i))[0], ((const int*)(scalar+i))[0]); \
- int t1 = __op__(((const int*)(src+i))[1], ((const int*)(scalar+i))[1]); \
- ((int*)(dst+i))[0] = t0; \
- ((int*)(dst+i))[1] = t1; \
- \
- t0 = __op__(((const int*)(src+i))[2], ((const int*)(scalar+i))[2]); \
- ((int*)(dst+i))[2] = t0; \
- } \
- src += delta; \
- dst += delta; \
- } \
- } \
- else \
- { \
- while( (len -= delta) >= 0 ) \
- { \
- for( i = 0; i < (delta); i += 4 ) \
- { \
- int t0 = __op__(src[i], scalar[i]); \
- int t1 = __op__(src[i+1], scalar[i+1]); \
- dst[i] = (uchar)t0; \
- dst[i+1] = (uchar)t1; \
- \
- t0 = __op__(src[i+2], scalar[i+2]); \
- t1 = __op__(src[i+3], scalar[i+3]); \
- dst[i+2] = (uchar)t0; \
- dst[i+3] = (uchar)t1; \
- } \
- src += delta; \
- dst += delta; \
- } \
- } \
- \
- for( len += delta, i = 0; i < len; i++ ) \
- { \
- int t = __op__(src[i],scalar[i]); \
- dst[i] = (uchar)t; \
- } \
- } \
- \
- return CV_OK; \
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// LOGIC OPERATIONS //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-static void
-icvLogicS( const void* srcarr, CvScalar* scalar, void* dstarr,
- const void* maskarr, CvFunc2D_2A1P1I fn_2d )
-{
- uchar* buffer = 0;
- int local_alloc = 1;
-
- CV_FUNCNAME( "icvLogicS" );
-
- __BEGIN__;
-
- CvMat srcstub, *src = (CvMat*)srcarr;
- CvMat dststub, *dst = (CvMat*)dstarr;
- CvMat maskstub, *mask = (CvMat*)maskarr;
- CvMat dstbuf, *tdst;
- CvCopyMaskFunc copym_func = 0;
-
- int y, dy;
- int coi1 = 0, coi2 = 0;
- int is_nd = 0, cont_flag = 0;
- int elem_size, elem_size1, type, depth;
- double buf[12];
- CvSize size, tsize;
- int src_step, dst_step, tdst_step, mask_step;
-
- if( !CV_IS_MAT(src))
- {
- if( CV_IS_MATND(src) )
- is_nd = 1;
- else
- CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
- }
-
- if( !CV_IS_MAT(dst))
- {
- if( CV_IS_MATND(dst) )
- is_nd = 1;
- else
- CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));
- }
-
- if( is_nd )
- {
- CvArr* arrs[] = { src, dst };
- CvMatND stubs[2];
- CvNArrayIterator iterator;
-
- if( maskarr )
- CV_ERROR( CV_StsBadMask,
- "This operation on multi-dimensional arrays does not support mask" );
-
- CV_CALL( cvInitNArrayIterator( 2, arrs, 0, stubs, &iterator ));
-
- type = CV_MAT_TYPE(iterator.hdr[0]->type);
- depth = CV_MAT_DEPTH(type);
- iterator.size.width *= CV_ELEM_SIZE(type);
- elem_size1 = CV_ELEM_SIZE1(depth);
-
- CV_CALL( cvScalarToRawData( scalar, buf, type, 1 ));
-
- do
- {
- IPPI_CALL( fn_2d( iterator.ptr[0], CV_STUB_STEP,
- iterator.ptr[1], CV_STUB_STEP,
- iterator.size, buf, elem_size1 ));
- }
- while( cvNextNArraySlice( &iterator ));
- EXIT;
- }
-
- if( coi1 != 0 || coi2 != 0 )
- CV_ERROR( CV_BadCOI, "" );
-
- if( !CV_ARE_TYPES_EQ( src, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
-
- if( !CV_ARE_SIZES_EQ( src, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
-
- size = cvGetMatSize( src );
- type = CV_MAT_TYPE(src->type);
- depth = CV_MAT_DEPTH(type);
- elem_size = CV_ELEM_SIZE(type);
- elem_size1 = CV_ELEM_SIZE1(depth);
-
- if( !mask )
- {
- cont_flag = CV_IS_MAT_CONT( src->type & dst->type );
- dy = size.height;
- tdst = dst;
- }
- else
- {
- int buf_size;
-
- if( !CV_IS_MAT(mask) )
- CV_CALL( mask = cvGetMat( mask, &maskstub ));
-
- if( !CV_IS_MASK_ARR(mask))
- CV_ERROR( CV_StsBadMask, "" );
-
- if( !CV_ARE_SIZES_EQ( mask, dst ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
-
- cont_flag = CV_IS_MAT_CONT( src->type & dst->type & mask->type );
- dy = CV_MAX_LOCAL_SIZE/(elem_size*size.height);
- dy = MAX(dy,1);
- dy = MIN(dy,size.height);
- dstbuf = cvMat( dy, size.width, type );
- if( !cont_flag )
- dstbuf.step = cvAlign( dstbuf.step, 8 );
- buf_size = dstbuf.step ? dstbuf.step*dy : size.width*elem_size;
- if( buf_size > CV_MAX_LOCAL_SIZE )
- {
- CV_CALL( buffer = (uchar*)cvAlloc( buf_size ));
- local_alloc = 0;
- }
- else
- buffer = (uchar*)cvStackAlloc( buf_size );
- dstbuf.data.ptr = buffer;
- tdst = &dstbuf;
-
- copym_func = icvGetCopyMaskFunc( elem_size );
- }
-
- src_step = src->step;
- dst_step = dst->step;
- tdst_step = tdst->step;
- mask_step = mask ? mask->step : 0;
- CV_CALL( cvScalarToRawData( scalar, buf, type, 1 ));
-
- for( y = 0; y < size.height; y += dy )
- {
- tsize.width = size.width;
- tsize.height = dy;
- if( y + dy > size.height )
- tsize.height = size.height - y;
- if( cont_flag || tsize.height == 1 )
- {
- tsize.width *= tsize.height;
- tsize.height = 1;
- src_step = tdst_step = dst_step = mask_step = CV_STUB_STEP;
- }
- IPPI_CALL( fn_2d( src->data.ptr + y*src->step, src_step, tdst->data.ptr, tdst_step,
- cvSize(tsize.width*elem_size, tsize.height), buf, elem_size1 ));
- if( mask )
- {
- IPPI_CALL( copym_func( tdst->data.ptr, tdst_step, dst->data.ptr + y*dst->step,
- dst_step, tsize, mask->data.ptr + y*mask->step, mask_step ));
- }
- }
-
- __END__;
-
- if( !local_alloc )
- cvFree( &buffer );
-}
-
-
-static void
-icvLogic( const void* srcarr1, const void* srcarr2, void* dstarr,
- const void* maskarr, CvFunc2D_3A fn_2d )
-{
- uchar* buffer = 0;
- int local_alloc = 1;
-
- CV_FUNCNAME( "icvLogic" );
-
- __BEGIN__;
-
- int y, dy;
- int coi1 = 0, coi2 = 0, coi3 = 0;
- int type, elem_size;
- int is_nd = 0, cont_flag = 0;
- CvMat srcstub1, *src1 = (CvMat*)srcarr1;
- CvMat srcstub2, *src2 = (CvMat*)srcarr2;
- CvMat dststub, *dst = (CvMat*)dstarr;
- CvMat maskstub, *mask = (CvMat*)maskarr;
- CvMat dstbuf, *tdst;
- int src1_step, src2_step, tdst_step, dst_step, mask_step;
- CvSize size, tsize;
- CvCopyMaskFunc copym_func = 0;
-
- if( !CV_IS_MAT(src1))
- {
- if( CV_IS_MATND(src1) )
- is_nd = 1;
- else
- CV_CALL( src1 = cvGetMat( src1, &srcstub1, &coi1 ));
- }
-
- if( !CV_IS_MAT(src2))
- {
- if( CV_IS_MATND(src2) )
- is_nd = 1;
- else
- CV_CALL( src2 = cvGetMat( src2, &srcstub2, &coi2 ));
- }
-
- if( !CV_IS_MAT(dst))
- {
- if( CV_IS_MATND(dst) )
- is_nd = 1;
- else
- CV_CALL( dst = cvGetMat( dst, &dststub, &coi3 ));
- }
-
- if( is_nd )
- {
- CvArr* arrs[] = { src1, src2, dst };
- CvMatND stubs[3];
- CvNArrayIterator iterator;
-
- if( maskarr )
- CV_ERROR( CV_StsBadMask,
- "This operation on multi-dimensional arrays does not support mask" );
-
- CV_CALL( cvInitNArrayIterator( 3, arrs, 0, stubs, &iterator ));
-
- type = CV_MAT_TYPE(iterator.hdr[0]->type);
- iterator.size.width *= CV_ELEM_SIZE(type);
-
- do
- {
- IPPI_CALL( fn_2d( iterator.ptr[0], CV_STUB_STEP,
- iterator.ptr[1], CV_STUB_STEP,
- iterator.ptr[2], CV_STUB_STEP,
- iterator.size ));
- }
- while( cvNextNArraySlice( &iterator ));
- EXIT;
- }
-
- if( coi1 != 0 || coi2 != 0 || coi3 != 0 )
- CV_ERROR_FROM_CODE( CV_BadCOI );
-
- if( !CV_ARE_TYPES_EQ( src1, src2 ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
-
- if( !CV_ARE_SIZES_EQ( src1, src2 ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
-
- if( !CV_ARE_TYPES_EQ( src1, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
-
- if( !CV_ARE_SIZES_EQ( src1, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
-
- size = cvGetMatSize( src1 );
- type = CV_MAT_TYPE( src1->type );
- elem_size = CV_ELEM_SIZE(type);
-
- if( !mask )
- {
- cont_flag = CV_IS_MAT_CONT( src1->type & src2->type & dst->type );
- dy = size.height;
- tdst = dst;
- }
- else
- {
- int buf_size;
-
- if( !CV_IS_MAT(mask) )
- CV_CALL( mask = cvGetMat( mask, &maskstub ));
-
- if( !CV_IS_MASK_ARR(mask))
- CV_ERROR( CV_StsBadMask, "" );
-
- if( !CV_ARE_SIZES_EQ( mask, dst ))
- CV_ERROR( CV_StsUnmatchedSizes, "" );
-
- cont_flag = CV_IS_MAT_CONT( src1->type & src2->type & dst->type & mask->type );
- dy = CV_MAX_LOCAL_SIZE/(elem_size*size.height);
- dy = MAX(dy,1);
- dy = MIN(dy,size.height);
- dstbuf = cvMat( dy, size.width, type );
- if( !cont_flag )
- dstbuf.step = cvAlign( dstbuf.step, 8 );
- buf_size = dstbuf.step ? dstbuf.step*dy : size.width*elem_size;
- if( buf_size > CV_MAX_LOCAL_SIZE )
- {
- CV_CALL( buffer = (uchar*)cvAlloc( buf_size ));
- local_alloc = 0;
- }
- else
- buffer = (uchar*)cvStackAlloc( buf_size );
- dstbuf.data.ptr = buffer;
- tdst = &dstbuf;
-
- copym_func = icvGetCopyMaskFunc( elem_size );
- }
-
- src1_step = src1->step;
- src2_step = src2->step;
- dst_step = dst->step;
- tdst_step = tdst->step;
- mask_step = mask ? mask->step : 0;
-
- for( y = 0; y < size.height; y += dy )
- {
- tsize.width = size.width;
- tsize.height = dy;
- if( y + dy > size.height )
- tsize.height = size.height - y;
- if( cont_flag || tsize.height == 1 )
- {
- tsize.width *= tsize.height;
- tsize.height = 1;
- src1_step = src2_step = tdst_step = dst_step = mask_step = CV_STUB_STEP;
- }
- IPPI_CALL( fn_2d( src1->data.ptr + y*src1->step, src1_step,
- src2->data.ptr + y*src2->step, src2_step,
- tdst->data.ptr, tdst_step,
- cvSize(tsize.width*elem_size, tsize.height) ));
- if( mask )
- {
- IPPI_CALL( copym_func( tdst->data.ptr, tdst_step, dst->data.ptr + y*dst->step,
- dst_step, tsize, mask->data.ptr + y*mask->step, mask_step ));
- }
- }
-
- __END__;
-
- if( !local_alloc )
- cvFree( &buffer );
-}
-
-ICV_DEF_BIN_LOG_OP_2D( CV_XOR, Xor )
-ICV_DEF_UN_LOG_OP_2D( CV_XOR, XorC )
-
-ICV_DEF_BIN_LOG_OP_2D( CV_AND, And )
-ICV_DEF_UN_LOG_OP_2D( CV_AND, AndC )
-
-ICV_DEF_BIN_LOG_OP_2D( CV_OR, Or )
-ICV_DEF_UN_LOG_OP_2D( CV_OR, OrC )
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// X O R //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-CV_IMPL void
-cvXorS( const void* src, CvScalar scalar, void* dst, const void* mask )
-{
- icvLogicS( src, &scalar, dst, mask, (CvFunc2D_2A1P1I)icvXorC_8u_CnR );
-}
-
-
-CV_IMPL void
-cvXor( const void* src1, const void* src2, void* dst, const void* mask )
-{
- icvLogic( src1, src2, dst, mask, (CvFunc2D_3A)icvXor_8u_C1R );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// A N D //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-CV_IMPL void
-cvAndS( const void* src, CvScalar scalar, void* dst, const void* mask )
-{
- icvLogicS( src, &scalar, dst, mask, (CvFunc2D_2A1P1I)icvAndC_8u_CnR );
-}
-
-
-CV_IMPL void
-cvAnd( const void* src1, const void* src2, void* dst, const void* mask )
-{
- icvLogic( src1, src2, dst, mask, (CvFunc2D_3A)icvAnd_8u_C1R );
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// O R //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-CV_IMPL void
-cvOrS( const void* src, CvScalar scalar, void* dst, const void* mask )
-{
- icvLogicS( src, &scalar, dst, mask, (CvFunc2D_2A1P1I)icvOrC_8u_CnR );
-}
-
-
-CV_IMPL void
-cvOr( const void* src1, const void* src2, void* dst, const void* mask )
-{
- icvLogic( src1, src2, dst, mask, (CvFunc2D_3A)icvOr_8u_C1R );
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// N O T //
-/////////////////////////////////////////////////////////////////////////////////////////
-
-
-IPCVAPI_IMPL( CvStatus, icvNot_8u_C1R,
-( const uchar* src1, int step1, uchar* dst, int step, CvSize size ),
- (src1, step1, dst, step, size) )
-{
- for( ; size.height--; src1 += step1, dst += step )
- {
- int i = 0;
-
- if( (((size_t)src1 | (size_t)dst) & 3) == 0 )
- {
- for( ; i <= size.width - 16; i += 16 )
- {
- int t0 = ~((const int*)(src1+i))[0];
- int t1 = ~((const int*)(src1+i))[1];
-
- ((int*)(dst+i))[0] = t0;
- ((int*)(dst+i))[1] = t1;
-
- t0 = ~((const int*)(src1+i))[2];
- t1 = ~((const int*)(src1+i))[3];
-
- ((int*)(dst+i))[2] = t0;
- ((int*)(dst+i))[3] = t1;
- }
-
- for( ; i <= size.width - 4; i += 4 )
- {
- int t = ~*(const int*)(src1+i);
- *(int*)(dst+i) = t;
- }
- }
-
- for( ; i < size.width; i++ )
- {
- int t = ~((const uchar*)src1)[i];
- dst[i] = (uchar)t;
- }
- }
-
- return CV_OK;
-}
-
-
-CV_IMPL void
-cvNot( const void* srcarr, void* dstarr )
-{
- CV_FUNCNAME( "cvNot" );
-
- __BEGIN__;
-
- CvMat srcstub, *src = (CvMat*)srcarr;
- CvMat dststub, *dst = (CvMat*)dstarr;
-
- int coi1 = 0, coi2 = 0;
- int type, is_nd = 0;
- CvSize size;
- int src_step, dst_step;
-
- if( !CV_IS_MAT(src))
- {
- if( CV_IS_MATND(src) )
- is_nd = 1;
- else
- CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
- }
-
- if( !CV_IS_MAT(dst))
- {
- if( CV_IS_MATND(src) )
- is_nd = 1;
- else
- CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));
- }
-
- if( is_nd )
- {
- CvArr* arrs[] = { src, dst };
- CvMatND stubs[2];
- CvNArrayIterator iterator;
-
- CV_CALL( cvInitNArrayIterator( 2, arrs, 0, stubs, &iterator ));
-
- type = CV_MAT_TYPE(iterator.hdr[0]->type);
- iterator.size.width *= CV_ELEM_SIZE(type);
-
- do
- {
- IPPI_CALL( icvNot_8u_C1R( iterator.ptr[0], CV_STUB_STEP,
- iterator.ptr[1], CV_STUB_STEP,
- iterator.size ));
- }
- while( cvNextNArraySlice( &iterator ));
- EXIT;
- }
-
- if( coi1 != 0 || coi2 != 0 )
- CV_ERROR( CV_BadCOI, "" );
-
- if( !CV_ARE_TYPES_EQ( src, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedFormats );
-
- if( !CV_ARE_SIZES_EQ( src, dst ) )
- CV_ERROR_FROM_CODE( CV_StsUnmatchedSizes );
-
- 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;
- }
-
- type = CV_MAT_TYPE( src->type );
- size.width *= CV_ELEM_SIZE(type);
-
- IPPI_CALL( icvNot_8u_C1R( src->data.ptr, src_step, dst->data.ptr, dst_step, size ));
-
- __END__;
-}
-
-/* End of file. */
projects / opencv / blobdiff