cvlogic.cpp.svn-base

来自「非结构化路识别」· SVN-BASE 代码 · 共 939 行 · 第 1/3 页

        else
            src1 = src2;
    }
    
    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 );

    src_step = src1->step;
    dst_step = dst->step;
    mask_step = mask->step;
    
    if( CV_IS_MAT_CONT( src1->type & dst->type & mask->type ))
    {
        size.width *= size.height;
        src_step = dst_step = mask_step = CV_STUB_STEP;
        size.height = 1;
    }

    IPPI_CALL( func( src1->data.ptr, src_step, mask->data.ptr, mask_step,
                     dst->data.ptr, dst_step, size, pix_size ));

    __END__;
}


#define ICV_DEF_LOG_OP_MASK_2D( __op__, _mask_op_, name )  \
    ICV_DEF_BIN_LOG_OP_MASK_2D( __op__, _mask_op_, name )  \
    ICV_DEF_UN_LOG_OP_MASK_2D( __op__, _mask_op_, name )

ICV_DEF_LOG_OP_MASK_2D( CV_XOR, CV_AND, Xor )
ICV_DEF_LOG_OP_MASK_2D( CV_AND, CV_ORN, And )
ICV_DEF_LOG_OP_MASK_2D( CV_OR,  CV_AND, Or )

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 )
{
    CV_FUNCNAME( "cvXorS" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogicS( src, &scalar, dst, (CvFunc2D_2A1P1I)icvXorC_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicSM( src, &scalar, dst, mask,
                             (CvArithmUniMaskFunc2D)icvXorC_8u_CnMR ));
    }

    __END__;
}


CV_IMPL void
cvXor( const void* src1, const void* src2, void* dst, const void* mask )
{
    CV_FUNCNAME( "cvXor" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogic( src1, src2, dst,
                           (CvFunc2D_3A)icvXor_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicM( src1, src2, dst, mask,
                            (CvArithmBinMaskFunc2D)icvXor_8u_CnMR ));
    }

    __END__;
}

/////////////////////////////////////////////////////////////////////////////////////////
//                                    A N D                                            //
/////////////////////////////////////////////////////////////////////////////////////////

CV_IMPL void
cvAndS( const void* src, CvScalar scalar, void* dst, const void* mask )
{
    CV_FUNCNAME( "cvAndS" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogicS( src, &scalar, dst, (CvFunc2D_2A1P1I)icvAndC_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicSM( src, &scalar, dst, mask,
                             (CvArithmUniMaskFunc2D)icvAndC_8u_CnMR ));
    }

    __END__;
}


CV_IMPL void
cvAnd( const void* src1, const void* src2, void* dst, const void* mask )
{
    CV_FUNCNAME( "cvAnd" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogic( src1, src2, dst,
                           (CvFunc2D_3A)icvAnd_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicM( src1, src2, dst, mask,
                            (CvArithmBinMaskFunc2D)icvAnd_8u_CnMR ));
    }

    __END__;
}


/////////////////////////////////////////////////////////////////////////////////////////
//                                      O R                                            //
/////////////////////////////////////////////////////////////////////////////////////////

CV_IMPL void
cvOrS( const void* src, CvScalar scalar, void* dst, const void* mask )
{
    CV_FUNCNAME( "cvOrS" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogicS( src, &scalar, dst, (CvFunc2D_2A1P1I)icvOrC_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicSM( src, &scalar, dst, mask,
                             (CvArithmUniMaskFunc2D)icvOrC_8u_CnMR ));
    }

    __END__;
}


CV_IMPL void
cvOr( const void* src1, const void* src2, void* dst, const void* mask )
{
    CV_FUNCNAME( "cvOr" );
    
    __BEGIN__;

    if( !mask )
    {
        CV_CALL( icvLogic( src1, src2, dst,
                           (CvFunc2D_3A)icvOr_8u_C1R ));
    }
    else
    {
        CV_CALL( icvLogicM( src1, src2, dst, mask,
                            (CvArithmBinMaskFunc2D)icvOr_8u_CnMR ));
    }

    __END__;
}


/////////////////////////////////////////////////////////////////////////////////////////
//                                      N O T                                          //
/////////////////////////////////////////////////////////////////////////////////////////


IPCVAPI_IMPL( CvStatus, icvNot_8u_C1R,
( const uchar* src1, int step1, uchar* dst, int step, CvSize size ))
{
    for( ; size.height--; src1 += step1, dst += step )
    {
        int i;

        for( i = 0; 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];
        CvMatNDIterator iterator;

        CV_CALL( icvPrepareArrayOp( 2, arrs, 0, stubs, &iterator ));

        type = CV_MAT_TYPE(iterator.hdr[0]->type);
        iterator.size.width *= icvPixSize[type];

        do
        {
            IPPI_CALL( icvNot_8u_C1R( iterator.ptr[0], CV_STUB_STEP,
                                      iterator.ptr[1], CV_STUB_STEP,
                                      iterator.size ));
        }
        while( icvNextMatNDSlice( &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 = icvGetMatSize( 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 *= icvPixSize[type];

    IPPI_CALL( icvNot_8u_C1R( src->data.ptr, src_step, dst->data.ptr, dst_step, size ));

    __END__;
}


/* End of file. */