自学教程：C++ CV_FUNCNAME函数代码示例

CV_IMPL voidcvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr,                             CvMat *rotMatr, CvMat *posVect,                             CvMat *rotMatrX, CvMat *rotMatrY,                             CvMat *rotMatrZ, CvPoint3D64f *eulerAngles){    CvMat *tmpProjMatr = 0;    CvMat *tmpMatrixD = 0;    CvMat *tmpMatrixV = 0;    CvMat *tmpMatrixM = 0;    CV_FUNCNAME("cvDecomposeProjectionMatrix");    __BEGIN__;    /* Validate parameters. */    if(projMatr == 0 || calibMatr == 0 || rotMatr == 0 || posVect == 0)        CV_ERROR(CV_StsNullPtr, "Some of parameters is a NULL pointer!");    if(!CV_IS_MAT(projMatr) || !CV_IS_MAT(calibMatr) || !CV_IS_MAT(rotMatr) || !CV_IS_MAT(posVect))        CV_ERROR(CV_StsUnsupportedFormat, "Input parameters must be a matrices!");    if(projMatr->cols != 4 || projMatr->rows != 3)        CV_ERROR(CV_StsUnmatchedSizes, "Size of projection matrix must be 3x4!");    if(calibMatr->cols != 3 || calibMatr->rows != 3 || rotMatr->cols != 3 || rotMatr->rows != 3)        CV_ERROR(CV_StsUnmatchedSizes, "Size of calibration and rotation matrices must be 3x3!");    if(posVect->cols != 1 || posVect->rows != 4)        CV_ERROR(CV_StsUnmatchedSizes, "Size of position vector must be 4x1!");    CV_CALL(tmpProjMatr = cvCreateMat(4, 4, CV_64F));    CV_CALL(tmpMatrixD = cvCreateMat(4, 4, CV_64F));    CV_CALL(tmpMatrixV = cvCreateMat(4, 4, CV_64F));    CV_CALL(tmpMatrixM = cvCreateMat(3, 3, CV_64F));    /* Compute position vector. */    cvSetZero(tmpProjMatr); // Add zero row to make matrix square.    int i, k;    for(i = 0; i < 3; i++)        for(k = 0; k < 4; k++)            cvmSet(tmpProjMatr, i, k, cvmGet(projMatr, i, k));    CV_CALL(cvSVD(tmpProjMatr, tmpMatrixD, NULL, tmpMatrixV, CV_SVD_MODIFY_A + CV_SVD_V_T));    /* Save position vector. */    for(i = 0; i < 4; i++)        cvmSet(posVect, i, 0, cvmGet(tmpMatrixV, 3, i)); // Solution is last row of V.    /* Compute calibration and rotation matrices via RQ decomposition. */    cvGetCols(projMatr, tmpMatrixM, 0, 3); // M is first square matrix of P.    assert(cvDet(tmpMatrixM) != 0.0); // So far only finite cameras could be decomposed, so M has to be nonsingular [det(M) != 0].    CV_CALL(cvRQDecomp3x3(tmpMatrixM, calibMatr, rotMatr, rotMatrX, rotMatrY, rotMatrZ, eulerAngles));    __END__;    cvReleaseMat(&tmpProjMatr);    cvReleaseMat(&tmpMatrixD);    cvReleaseMat(&tmpMatrixV);    cvReleaseMat(&tmpMatrixM);}

CV_IMPL voidcvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double eps ){    CV_FUNCNAME( "cvEigenVV" );    __BEGIN__;    CvMat sstub, *src = (CvMat*)srcarr;    CvMat estub1, *evects = (CvMat*)evectsarr;    CvMat estub2, *evals = (CvMat*)evalsarr;    if( !CV_IS_MAT( src ))        CV_CALL( src = cvGetMat( src, &sstub ));    if( !CV_IS_MAT( evects ))        CV_CALL( evects = cvGetMat( evects, &estub1 ));    if( !CV_IS_MAT( evals ))        CV_CALL( evals = cvGetMat( evals, &estub2 ));    if( src->cols != src->rows )        CV_ERROR( CV_StsUnmatchedSizes, "source is not quadratic matrix" );    if( !CV_ARE_SIZES_EQ( src, evects) )        CV_ERROR( CV_StsUnmatchedSizes, "eigenvectors matrix has inappropriate size" );    if( (evals->rows != src->rows || evals->cols != 1) &&        (evals->cols != src->rows || evals->rows != 1))        CV_ERROR( CV_StsBadSize, "eigenvalues vector has inappropriate size" );    if( !CV_ARE_TYPES_EQ( src, evects ) || !CV_ARE_TYPES_EQ( src, evals ))        CV_ERROR( CV_StsUnmatchedFormats,        "input matrix, eigenvalues and eigenvectors must have the same type" );    if( !CV_IS_MAT_CONT( src->type & evals->type & evects->type ))        CV_ERROR( CV_BadStep, "all the matrices must be continuous" );    if( CV_MAT_TYPE(src->type) == CV_32FC1 )    {        IPPI_CALL( icvJacobiEigens_32f( src->data.fl,                                        evects->data.fl,                                        evals->data.fl, src->cols, (float)eps ));    }    else if( CV_MAT_TYPE(src->type) == CV_64FC1 )    {        IPPI_CALL( icvJacobiEigens_64d( src->data.db,                                        evects->data.db,                                        evals->data.db, src->cols, eps ));    }    else    {        CV_ERROR( CV_StsUnsupportedFormat, "Only 32fC1 and 64fC1 types are supported" );    }    CV_CHECK_NANS( evects );    CV_CHECK_NANS( evals );    __END__;}

/*F/////////////////////////////////////////////////////////////////////////////////////////    Name:    cvMeanShift//    Purpose: MeanShift algorithm//    Context://    Parameters://      imgProb     - 2D object probability distribution//      windowIn    - CvRect of CAMSHIFT Window intial size//      numIters    - If CAMSHIFT iterates this many times, stop//      windowOut   - Location, height and width of converged CAMSHIFT window//      len         - If != NULL, return equivalent len//      width       - If != NULL, return equivalent width//      itersUsed   - Returns number of iterations CAMSHIFT took to converge//    Returns://      The function itself returns the area found//    Notes://F*/CV_IMPL intcvMeanShift( const void* imgProb, CvRect windowIn,             CvTermCriteria criteria, CvConnectedComp* comp ){    CvMoments moments;    int    i = 0, eps;    CvMat  stub, *mat = (CvMat*)imgProb;    CvMat  cur_win;    CvRect cur_rect = windowIn;    CV_FUNCNAME( "cvMeanShift" );    if( comp )        comp->rect = windowIn;    moments.m00 = moments.m10 = moments.m01 = 0;    __BEGIN__;    CV_CALL( mat = cvGetMat( mat, &stub ));    if( CV_MAT_CN( mat->type ) > 1 )        CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );    if( windowIn.height <= 0 || windowIn.width <= 0 )        CV_ERROR( CV_StsBadArg, "Input window has non-positive sizes" );    if( windowIn.x < 0 || windowIn.x + windowIn.width > mat->cols ||        windowIn.y < 0 || windowIn.y + windowIn.height > mat->rows )        CV_ERROR( CV_StsBadArg, "Initial window is not inside the image ROI" );    CV_CALL( criteria = cvCheckTermCriteria( criteria, 1., 100 ));    eps = cvRound( criteria.epsilon * criteria.epsilon );    for( i = 0; i < criteria.max_iter; i++ )    {        int dx, dy, nx, ny;        double inv_m00;        CV_CALL( cvGetSubRect( mat, &cur_win, cur_rect ));         CV_CALL( cvMoments( &cur_win, &moments ));        /* Calculating center of mass */        if( fabs(moments.m00) < DBL_EPSILON )            break;        inv_m00 = moments.inv_sqrt_m00*moments.inv_sqrt_m00;        dx = cvRound( moments.m10 * inv_m00 - windowIn.width*0.5 );        dy = cvRound( moments.m01 * inv_m00 - windowIn.height*0.5 );        nx = cur_rect.x + dx;        ny = cur_rect.y + dy;        if( nx < 0 )            nx = 0;        else if( nx + cur_rect.width > mat->cols )            nx = mat->cols - cur_rect.width;        if( ny < 0 )            ny = 0;        else if( ny + cur_rect.height > mat->rows )            ny = mat->rows - cur_rect.height;        dx = nx - cur_rect.x;        dy = ny - cur_rect.y;        cur_rect.x = nx;        cur_rect.y = ny;        /* Check for coverage centers mass & window */        if( dx*dx + dy*dy < eps )            break;    }    __END__;    if( comp )    {        comp->rect = cur_rect;        comp->area = (float)moments.m00;    }    return i;}

CV_IMPL voidcvKMeans2( const CvArr* samples_arr, int cluster_count,           CvArr* labels_arr, CvTermCriteria termcrit ){    CvMat* centers = 0;    CvMat* old_centers = 0;    CvMat* counters = 0;    CV_FUNCNAME( "cvKMeans2" );    __BEGIN__;    CvMat samples_stub, labels_stub;    CvMat* samples = (CvMat*)samples_arr;    CvMat* labels = (CvMat*)labels_arr;    CvMat* temp = 0;    CvRNG rng = CvRNG(-1);    int i, j, k, sample_count, dims;    int ids_delta, iter;    double max_dist;    if( !CV_IS_MAT( samples ))        CV_CALL( samples = cvGetMat( samples, &samples_stub ));    if( !CV_IS_MAT( labels ))        CV_CALL( labels = cvGetMat( labels, &labels_stub ));    if( cluster_count < 1 )        CV_ERROR( CV_StsOutOfRange, "Number of clusters should be positive" );    if( CV_MAT_DEPTH(samples->type) != CV_32F || CV_MAT_TYPE(labels->type) != CV_32SC1 )        CV_ERROR( CV_StsUnsupportedFormat,        "samples should be floating-point matrix, cluster_idx - integer vector" );    if( labels->rows != 1 && (labels->cols != 1 || !CV_IS_MAT_CONT(labels->type)) ||        labels->rows + labels->cols - 1 != samples->rows )        CV_ERROR( CV_StsUnmatchedSizes,        "cluster_idx should be 1D vector of the same number of elements as samples' number of rows" );    CV_CALL( termcrit = cvCheckTermCriteria( termcrit, 1e-6, 100 ));    termcrit.epsilon *= termcrit.epsilon;    sample_count = samples->rows;    if( cluster_count > sample_count )        cluster_count = sample_count;    dims = samples->cols*CV_MAT_CN(samples->type);    ids_delta = labels->step ? labels->step/(int)sizeof(int) : 1;    CV_CALL( centers = cvCreateMat( cluster_count, dims, CV_64FC1 ));    CV_CALL( old_centers = cvCreateMat( cluster_count, dims, CV_64FC1 ));    CV_CALL( counters = cvCreateMat( 1, cluster_count, CV_32SC1 ));    // init centers    for( i = 0; i < sample_count; i++ )        labels->data.i[i] = cvRandInt(&rng) % cluster_count;    counters->cols = cluster_count; // cut down counters    max_dist = termcrit.epsilon*2;    for( iter = 0; iter < termcrit.max_iter; iter++ )    {        // computer centers        cvZero( centers );        cvZero( counters );        for( i = 0; i < sample_count; i++ )        {            float* s = (float*)(samples->data.ptr + i*samples->step);            k = labels->data.i[i*ids_delta];            double* c = (double*)(centers->data.ptr + k*centers->step);            for( j = 0; j <= dims - 4; j += 4 )            {                double t0 = c[j] + s[j];                double t1 = c[j+1] + s[j+1];                c[j] = t0;                c[j+1] = t1;                t0 = c[j+2] + s[j+2];                t1 = c[j+3] + s[j+3];                c[j+2] = t0;                c[j+3] = t1;            }            for( ; j < dims; j++ )                c[j] += s[j];            counters->data.i[k]++;        }        if( iter > 0 )            max_dist = 0;        for( k = 0; k < cluster_count; k++ )        {            double* c = (double*)(centers->data.ptr + k*centers->step);            if( counters->data.i[k] != 0 )            {                double scale = 1./counters->data.i[k];//.........这里部分代码省略.........

CV_IMPL CvArr*cvRange( CvArr* arr, double start, double end ){    int ok = 0;        CV_FUNCNAME( "cvRange" );    __BEGIN__;        CvMat stub, *mat = (CvMat*)arr;    double delta;    int type, step;    double val = start;    int i, j;    int rows, cols;        if( !CV_IS_MAT(mat) )        CV_CALL( mat = cvGetMat( mat, &stub) );    rows = mat->rows;    cols = mat->cols;    type = CV_MAT_TYPE(mat->type);    delta = (end-start)/(rows*cols);    if( CV_IS_MAT_CONT(mat->type) )    {        cols *= rows;        rows = 1;        step = 1;    }    else        step = mat->step / CV_ELEM_SIZE(type);    if( type == CV_32SC1 )    {        int* idata = mat->data.i;        int ival = cvRound(val), idelta = cvRound(delta);        if( fabs(val - ival) < DBL_EPSILON &&            fabs(delta - idelta) < DBL_EPSILON )        {            for( i = 0; i < rows; i++, idata += step )                for( j = 0; j < cols; j++, ival += idelta )                    idata[j] = ival;        }        else        {            for( i = 0; i < rows; i++, idata += step )                for( j = 0; j < cols; j++, val += delta )                    idata[j] = cvRound(val);        }    }    else if( type == CV_32FC1 )    {        float* fdata = mat->data.fl;        for( i = 0; i < rows; i++, fdata += step )            for( j = 0; j < cols; j++, val += delta )                fdata[j] = (float)val;    }    else        CV_ERROR( CV_StsUnsupportedFormat, "The function only supports 32sC1 and 32fC1 datatypes" );    ok = 1;    __END__;    return ok ? arr : 0;}

// convert CvScalar to specified typevoidcvScalarToRawData( CvScalar* scalar, int flags, void* data, int extend_to_12 ){    CV_FUNCNAME( "cvScalarToRawData" );        __BEGIN__;    int type = CV_ARR_TYPE( flags );    int cn = CV_ARR_CN( type );    int depth = type & CV_ARR_DEPTH_MASK;    assert( scalar && data );    assert( (unsigned)(cn - 1) < 4 );    switch( depth )    {    case CV_8UC1:        while( cn-- )        {            int t = cvRound( scalar->val[cn] );            ((uchar*)data)[cn] = CV_CAST_8U(t);        }        break;    case CV_8SC1:        while( cn-- )        {            int t = cvRound( scalar->val[cn] );            ((char*)data)[cn] = CV_CAST_8S(t);        }        break;    case CV_16SC1:        while( cn-- )        {            int t = cvRound( scalar->val[cn] );            ((short*)data)[cn] = CV_CAST_16S(t);        }        break;    case CV_32SC1:        while( cn-- )            ((int*)data)[cn] = cvRound( scalar->val[cn] );        break;    case CV_32FC1:        while( cn-- )            ((float*)data)[cn] = (float)(scalar->val[cn]);        break;    case CV_64FC1:        while( cn-- )            ((double*)data)[cn] = (double)(scalar->val[cn]);        break;    default:        assert(0);        CV_ERROR_FROM_CODE( CV_BadDepth );    }    if( extend_to_12 )    {        int pix_size = icvPixSize[type];        int offset = icvPixSize[depth]*12;        do        {            offset -= pix_size;            memcpy( (char*)data + offset, data, pix_size );        }        while( offset > pix_size );    }    __END__;}

/*  Finds real roots of cubic, quadratic or linear equation.  The original code has been taken from Ken Turkowski web page  (http://www.worldserver.com/turk/opensource/) and adopted for OpenCV.  Here is the copyright notice.  -----------------------------------------------------------------------  Copyright (C) 1978-1999 Ken Turkowski. <[email
C++ CV_INSTRUMENT_REGION函数代码示例
C++ CV_ERROR函数代码示例