cvmatmul.cpp.svn-base

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

    int buf_size, pix_size;
    CvMat stubA, *srcA = (CvMat*)srcAarr;
    CvMat temp1, temp2;

    if( !CV_IS_MAT(srcA) )
        CV_CALL( srcA = cvGetMat( srcA, &stubA ));

    pix_size = icvPixSize[CV_MAT_TYPE(srcA->type)];
    buf_size = srcA->rows*2*pix_size;
    
    if( buf_size <= CV_MAX_LOCAL_SIZE )
    {
        buffer = (uchar*)alloca( buf_size );
        local_alloc = 1;
    }
    else
    {
        CV_CALL( buffer = (uchar*)cvAlloc( buf_size ));
    }

    cvInitMatHeader( &temp1, srcA->rows, 1, srcA->type, buffer );
    cvInitMatHeader( &temp2, srcA->rows, 1, srcA->type, buffer + buf_size/2);

    CV_CALL( cvSub( srcA, srcB, &temp1 ));
    CV_CALL( cvMatMulAdd( mat, &temp1, 0, &temp2 ));
    CV_CALL( dist = sqrt(cvDotProduct( &temp1, &temp2 )));

    icvCheckVector_64f( &dist, 1 );

    __END__;

    if( buffer && !local_alloc )
        cvFree( (void**)&buffer );

    return  dist;
}


/****************************************************************************************\
*                                        cvMulTransposed                                 *
\****************************************************************************************/

#define ICV_DEF_MULTRANS_R_FUNC( flavor, arrtype )                      \
IPCVAPI_IMPL( CvStatus,                                                 \
icvMulTransposedR_##flavor, ( const arrtype* src, int srcstep,          \
                              arrtype* dst, int dststep, CvSize size )) \
{                                                                       \
    int i, j, k;                                                        \
    arrtype* tdst = dst;                                                \
    arrtype* col_buf = 0;                                               \
    int local_alloc = 0;                                                \
    int buf_size = size.height*sizeof(arrtype);                         \
                                                                        \
    if( buf_size <= CV_MAX_LOCAL_SIZE )                                 \
    {                                                                   \
        col_buf = (arrtype*)alloca( buf_size );                         \
        local_alloc = 1;                                                \
    }                                                                   \
    else                                                                \
    {                                                                   \
        col_buf = (arrtype*)icvAlloc( buf_size );                       \
        if( !col_buf )                                                  \
            return CV_OUTOFMEM_ERR;                                     \
    }                                                                   \
                                                                        \
    for( i = 0; i < size.width; i++, (char*&)tdst += dststep )          \
    {                                                                   \
        /* copy i-th column */                                          \
        for( j = 0; j < size.height; j++ )                              \
            col_buf[j] = ((arrtype*)((uchar*)src + j*srcstep))[i];      \
                                                                        \
        for( j = i; j < size.width; j++ )                               \
        {                                                               \
            double s = 0;                                               \
            const arrtype *tsrc = src + j;                              \
                                                                        \
            for( k = 0; k < size.height; k++, (char*&)tsrc += srcstep ) \
            {                                                           \
                s += col_buf[k] * tsrc[0];                              \
            }                                                           \
            tdst[j] = (arrtype)s;                                       \
        }                                                               \
    }                                                                   \
                                                                        \
    /* fill the lower part of the destination matrix */                 \
    for( i = 1; i < size.width; i++ )                                   \
        for( j = 0; j < i; j++ )                                        \
            ((arrtype*)((uchar*)dst + dststep*i))[j] =                  \
                ((arrtype*)((uchar*)dst + dststep*j))[i];               \
                                                                        \
    if( col_buf && !local_alloc )                                       \
        icvFree( (void**)&col_buf );                                    \
                                                                        \
    return CV_NO_ERR;                                                   \
}



#define ICV_DEF_MULTRANS_L_FUNC( flavor, arrtype )                              \
IPCVAPI_IMPL( CvStatus,                                                         \
icvMulTransposedL_##flavor, ( const arrtype* src, int srcstep,                  \
                              arrtype* dst, int dststep,                        \
                              CvSize size ))                                    \
{                                                                               \
    int i, j, k;                                                                \
    arrtype* tdst = dst;                                                        \
                                                                                \
    for( i = 0; i < size.height; i++, (char*&)tdst += dststep )                 \
    {                                                                           \
        for( j = i; j < size.height; j++ )                                      \
        {                                                                       \
            double s = 0;                                                       \
            const arrtype *tsrc1 = (const arrtype*)((uchar*)src + i*srcstep);   \
            const arrtype *tsrc2 = (const arrtype*)((uchar*)src + j*srcstep);   \
                                                                                \
            for( k = 0; k < size.width; k++ )                                   \
                s += tsrc1[k] * tsrc2[k];                                       \
            tdst[j] = (arrtype)s;                                               \
        }                                                                       \
    }                                                                           \
                                                                                \
    /* fill the lower part of the destination matrix */                         \
    for( j = 0; j < size.height - 1; j++ )                                      \
        for( i = j; i < size.height; i++ )                                      \
            ((arrtype*)((uchar*)dst + dststep*i))[j] =                          \
                ((arrtype*)((uchar*)dst + dststep*j))[i];                       \
                                                                                \
    return CV_NO_ERR;                                                           \
}


ICV_DEF_MULTRANS_R_FUNC( 32f, float )
ICV_DEF_MULTRANS_R_FUNC( 64f, double )
ICV_DEF_MULTRANS_L_FUNC( 32f, float )
ICV_DEF_MULTRANS_L_FUNC( 64f, double )

static void icvInitMulTransposedTable( CvFuncTable* tabL, CvFuncTable* tabR )   \
{                                                                               \
    tabL->fn_2d[CV_32F] = (void*)icvMulTransposedL_32f;                                \
    tabL->fn_2d[CV_64F] = (void*)icvMulTransposedL_64f;                                \
    tabR->fn_2d[CV_32F] = (void*)icvMulTransposedR_32f;                                \
    tabR->fn_2d[CV_64F] = (void*)icvMulTransposedR_64f;                                \
}


CV_IMPL void
cvMulTransposed( const CvArr* srcarr, CvArr* dstarr, int order )
{
    static CvFuncTable tab[2];
    static int inittab = 0;

    uchar* buffer = 0;
    int local_alloc = 0;

    CV_FUNCNAME( "cvMulTransposed" );

    __BEGIN__;

    CvMat sstub, *src = (CvMat*)srcarr;
    CvMat dstub, *dst = (CvMat*)dstarr;
    CvFunc2D_2A func = 0;
    int type;

    if( !inittab )
    {
        icvInitMulTransposedTable( tab + 0, tab + 1 );
        inittab = 1;
    }

    if( !CV_IS_MAT( src ))
        CV_CALL( src = cvGetMat( src, &sstub ));

    if( !CV_IS_MAT( dst ))
        CV_CALL( dst = cvGetMat( dst, &dstub ));

    if( !CV_ARE_TYPES_EQ( src, dst ))
        CV_ERROR( CV_StsUnmatchedFormats, "" );

    type = CV_MAT_TYPE( src->type );

    if( dst->width != dst->height )
        CV_ERROR( CV_StsBadSize, "The destination matrix must be square" );

    if( (order != 0 && src->width != dst->width) ||
        (order == 0 && src->height != dst->height))
        CV_ERROR( CV_StsUnmatchedSizes, "" );

    if( src->data.ptr == dst->data.ptr ) // inplace operation
        CV_ERROR( CV_StsBadArg, "Inplace operation is not allowed" );

    func = (CvFunc2D_2A)(tab[order != 0].fn_2d[CV_MAT_DEPTH(type)]);

    if( !func )
        CV_ERROR( CV_StsUnsupportedFormat, "" );

    IPPI_CALL( func( src->data.ptr, src->step,
                     dst->data.ptr, dst->step, icvGetMatSize( src )));

    CV_CHECK_NANS( dst );

    __END__;

    if( buffer && !local_alloc )
        cvFree( (void**)&buffer );
}


/****************************************************************************************\
*                                        cvDotProduct                                    *
\****************************************************************************************/

#define ICV_DEF_DOT_PROD_FUNC_2D( flavor, arrtype, temptype, sumtype )                  \
IPCVAPI_IMPL( CvStatus,                                                                 \
icvDotProduct_##flavor##_C1R, ( const arrtype* src1, int step1,                         \
                                const arrtype* src2, int step2,                         \
                                CvSize size, sumtype* _sum ))                           \
{                                                                                       \
    sumtype sum = 0;                                                                    \
                                                                                        \
    for( ; size.height--; (char*&)src1 += step1, (char*&)src2 += step2 )                \
    {                                                                                   \
        int i;                                                                          \
                                                                                        \
        for( i = 0; i <= size.width - 4; i += 4 )                                       \
        {                                                                               \
            (sum) += (temptype)src1[i]*src2[i] + (temptype)src1[i + 1]*src2[i + 1] +    \
                (temptype)src1[i + 2]*src2[i + 2] + (temptype)src1[i + 3]*src2[i + 3];  \
        }                                                                               \
                                                                                        \
        for( ; i < size.width; i++ )                                                    \
        {                                                                               \
            (sum) += (temptype)src1[i]*src2[i];                                         \
        }                                                                               \
    }                                                                                   \
                                                                                        \
    *_sum = sum;                                                                        \
    return CV_OK;                                                                       \
}


ICV_DEF_DOT_PROD_FUNC_2D( 8u, uchar, int, int64 )
ICV_DEF_DOT_PROD_FUNC_2D( 8s, char, int, int64 )
ICV_DEF_DOT_PROD_FUNC_2D( 16s, short, int64, int64 )
ICV_DEF_DOT_PROD_FUNC_2D( 32s, int, double, double )
ICV_DEF_DOT_PROD_FUNC_2D( 32f, float, double, double )
ICV_DEF_DOT_PROD_FUNC_2D( 64f, double, double, double )

CV_DEF_INIT_FUNC_TAB_2D( DotProduct, C1R )

CV_IMPL double
cvDotProduct( const CvArr* srcAarr, const CvArr* srcBarr )
{
    static CvFuncTable tab_2d;
    static int inittab = 0;

    double result = 0;
    
    CV_FUNCNAME( "cvTranspose" );

    __BEGIN__;

    CvMat stubA, *srcA = (CvMat*)srcAarr;
    CvMat stubB, *srcB = (CvMat*)srcBarr;
    CvSize size;
    int type, depth;

    if( !inittab )
    {
        icvInitDotProductC1RTable( &tab_2d );
        inittab = 1;
    }

    if( !CV_IS_MAT( srcA ))
    {
        int coi = 0;
        CV_CALL( srcA = cvGetMat( srcA, &stubA, &coi ));
        if( coi != 0 )
            CV_ERROR( CV_BadCOI, "coi is not supported" );
    }

    if( srcBarr == srcAarr )
    {
        srcB = srcA; 
    }
    else
    {
        if( !CV_IS_MAT( srcB ))
        {
            int coi = 0;
            CV_CALL( srcB = cvGetMat( srcB, &stubB, &coi ));

            if( coi != 0 )
                CV_ERROR( CV_BadCOI, "coi is not supported" );
        }

        if( !CV_ARE_TYPES_EQ( srcA, srcB ))
            CV_ERROR( CV_StsUnmatchedFormats, "" );

        if( !CV_ARE_SIZES_EQ( srcA, srcB ))
            CV_ERROR( CV_StsUnmatchedSizes, "" );
    }

    type = CV_MAT_TYPE( srcA->type );
    size = icvGetMatSize( srcA );

    size.width *= CV_MAT_CN( type );
    depth = CV_MAT_DEPTH( type );

    if( CV_IS_MAT_CONT( srcA->type & srcB->type ))
    {
        size.width *= size.height;

        if( size.width <= CV_MAX_INLINE_MAT_OP_SIZE )