ptr += y*img->widthStep + x*pix_size;        if( _type )        {            int type = icvIplToCvDepth(img->depth);            if( type < 0 || (unsigned)(img->nChannels - 1) > 3 )                CV_ERROR( CV_StsUnsupportedFormat, "" );            *_type = CV_MAKETYPE( type, img->nChannels );        }    }    else if( CV_IS_MATND( arr ))    {        CvMatND* mat = (CvMatND*)arr;        if( mat->dims != 2 ||             (unsigned)y >= (unsigned)(mat->dim[0].size) ||            (unsigned)x >= (unsigned)(mat->dim[1].size) )            CV_ERROR( CV_StsOutOfRange, "index is out of range" );        ptr = mat->data.ptr + (size_t)y*mat->dim[0].step + x*mat->dim[1].step;        if( _type )            *_type = CV_MAT_TYPE(mat->type);    }    else if( CV_IS_SPARSE_MAT( arr ))    {        CV_ERROR( CV_StsBadArg, "do not support sparse mat now" );    }    else    {        CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" );    }    __END__;    return ptr;}// Returns pointer to specified element of 3d arrayCV_IMPL  uchar*cvPtr3D( const CvArr* arr, int z, int y, int x, int* _type ){    uchar* ptr = 0;        CV_FUNCNAME( "cvPtr3D" );    __BEGIN__;    if( CV_IS_MATND( arr ))    {        CvMatND* mat = (CvMatND*)arr;        if( mat->dims != 3 ||             (unsigned)z >= (unsigned)(mat->dim[0].size) ||            (unsigned)y >= (unsigned)(mat->dim[1].size) ||            (unsigned)x >= (unsigned)(mat->dim[2].size) )            CV_ERROR( CV_StsOutOfRange, "index is out of range" );        ptr = mat->data.ptr + (size_t)z*mat->dim[0].step +              (size_t)y*mat->dim[1].step + x*mat->dim[2].step;        if( _type )            *_type = CV_MAT_TYPE(mat->type);    }    else if( CV_IS_SPARSE_MAT( arr ))    {        CV_ERROR( CV_StsBadArg, "do not support sparse mat now" );    }    else    {        CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" );    }    __END__;    return ptr;}// Returns the size of CvMat or IplImageCV_IMPL CvSizecvGetSize( const CvArr* arr ){    CvSize size = { 0, 0 };    CV_FUNCNAME( "cvGetSize" );    __BEGIN__;    if( CV_IS_MAT_HDR( arr ))    {        CvMat *mat = (CvMat*)arr;        size.width = mat->cols;        size.height = mat->rows;    }    else if( CV_IS_IMAGE_HDR( arr ))    {        IplImage* img = (IplImage*)arr;        if( img->roi )        {            size.width = img->roi->width;            size.height = img->roi->height;        }        else        {            size.width = img->width;            size.height = img->height;        }    }    else    {        CV_ERROR( CV_StsBadArg, "Array should be CvMat or IplImage" );    }    __END__;    return size;}// Selects sub-array (no data is copied)CV_IMPL  CvMat*cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect ){    CvMat* res = 0;        CV_FUNCNAME( "cvGetRect" );    __BEGIN__;    CvMat stub, *mat = (CvMat*)arr;    if( !CV_IS_MAT( mat ))        CV_CALL( mat = cvGetMat( mat, &stub ));    if( !submat )        CV_ERROR( CV_StsNullPtr, "" );    if( (rect.x|rect.y|rect.width|rect.height) < 0 )        CV_ERROR( CV_StsBadSize, "" );    if( rect.x + rect.width > mat->cols ||        rect.y + rect.height > mat->rows )        CV_ERROR( CV_StsBadSize, "" );    {    /*    int* refcount = mat->refcount;    if( refcount )        ++*refcount;    cvDecRefData( submat );    */    submat->data.ptr = mat->data.ptr + (size_t)rect.y*mat->step +                       rect.x*CV_ELEM_SIZE(mat->type);    submat->step = mat->step & (rect.height > 1 ? -1 : 0);    submat->type = (mat->type & (rect.width < mat->cols ? ~CV_MAT_CONT_FLAG : -1)) |                   (submat->step == 0 ? CV_MAT_CONT_FLAG : 0);    submat->rows = rect.height;    submat->cols = rect.width;    submat->refcount = 0;    res = submat;    }        __END__;    return res;}// Selects array's row span.CV_IMPL  CvMat*cvGetRows( const CvArr* arr, CvMat* submat,           int start_row, int end_row, int delta_row ){    CvMat* res = 0;        CV_FUNCNAME( "cvGetRows" );    __BEGIN__;    CvMat stub, *mat = (CvMat*)arr;    if( !CV_IS_MAT( mat ))        CV_CALL( mat = cvGetMat( mat, &stub ));    if( !submat )        CV_ERROR( CV_StsNullPtr, "" );    if( (unsigned)start_row >= (unsigned)mat->rows ||        (unsigned)end_row > (unsigned)mat->rows || delta_row <= 0 )        CV_ERROR( CV_StsOutOfRange, "" );    {    /*    int* refcount = mat->refcount;    if( refcount )        ++*refcount;    cvDecRefData( submat );    */    if( delta_row == 1 )    {        submat->rows = end_row - start_row;        submat->step = mat->step & (submat->rows > 1 ? -1 : 0);    }    else    {        submat->rows = (end_row - start_row + delta_row - 1)/delta_row;        submat->step = mat->step * delta_row;    }    submat->cols = mat->cols;    submat->step &= submat->rows > 1 ? -1 : 0;    submat->data.ptr = mat->data.ptr + (size_t)start_row*mat->step;    submat->type = (mat->type | (submat->step == 0 ? CV_MAT_CONT_FLAG : 0)) &                   (delta_row != 1 ? ~CV_MAT_CONT_FLAG : -1);    submat->refcount = 0;    submat->hdr_refcount = 0;    res = submat;    }        __END__;    return res;}// Selects array's column span.CV_IMPL  CvMat*cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col ){    CvMat* res = 0;        CV_FUNCNAME( "cvGetCols" );    __BEGIN__;    CvMat stub, *mat = (CvMat*)arr;    if( !CV_IS_MAT( mat ))        CV_CALL( mat = cvGetMat( mat, &stub ));    if( !submat )        CV_ERROR( CV_StsNullPtr, "" );    if( (unsigned)start_col >= (unsigned)mat->cols ||        (unsigned)end_col > (unsigned)mat->cols )        CV_ERROR( CV_StsOutOfRange, "" );    {    /*    int* refcount = mat->refcount;    if( refcount )        ++*refcount;    cvDecRefData( submat );    */    submat->rows = mat->rows;    submat->cols = end_col - start_col;    submat->step = mat->step & (submat->rows > 1 ? -1 : 0);    submat->data.ptr = mat->data.ptr + (size_t)start_col*CV_ELEM_SIZE(mat->type);    submat->type = mat->type & (submat->step && submat->cols < mat->cols ?                                ~CV_MAT_CONT_FLAG : -1);    submat->refcount = 0;    submat->hdr_refcount = 0;    res = submat;    }        __END__;    return res;}// Selects array diagonalCV_IMPL  CvMat*cvGetDiag( const CvArr* arr, CvMat* submat, int diag ){    CvMat* res = 0;        CV_FUNCNAME( "cvGetDiag" );    __BEGIN__;    CvMat stub, *mat = (CvMat*)arr;    int len, pix_size;     if( !CV_IS_MAT( mat ))        CV_CALL( mat = cvGetMat( mat, &stub ));    if( !submat )        CV_ERROR( CV_StsNullPtr, "" );    pix_size = CV_ELEM_SIZE(mat->type);    /*{    int* refcount = mat->refcount;    if( refcount )        ++*refcount;    cvDecRefData( submat );    }*/    if( diag >= 0 )    {        len = mat->cols - diag;                if( len <= 0 )            CV_ERROR( CV_StsOutOfRange, "" );        len = CV_IMIN( len, mat->rows );        submat->data.ptr = mat->data.ptr + diag*pix_size;    }    else    {        len = mat->rows + diag;                if( len <= 0 )            CV_ERROR( CV_StsOutOfRange, "" );        len = CV_IMIN( len, mat->cols );        submat->data.ptr = mat->data.ptr - diag*mat->step;    }    submat->rows = len;    submat->cols = 1;    submat->step = (mat->step + pix_size) & (submat->rows > 1 ? -1 : 0);    submat->type = mat->type;    if( submat->step )        submat->type &= ~CV_MAT_CONT_FLAG;    else        submat->type |= CV_MAT_CONT_FLAG;    submat->refcount = 0;    submat->hdr_refcount = 0;    res = submat;        __END__;    return res;}/****************************************************************************************\*                      Operations on CvScalar and accessing array elements               *\****************************************************************************************/// Converts CvScalar to specified typeCV_IMPL voidcvScalarToRawData( const CvScalar* scalar, void* data, int type, int extend_to_12 ){    CV_FUNCNAME( "cvScalarToRawData" );    type = CV_MAT_TYPE(type);        __BEGIN__;    int cn = CV_MAT_CN( type );    int depth = type & CV_MAT_DEPTH_MASK;    assert( scalar && data );    if( (unsigned)(cn - 1) >= 4 )        CV_ERROR( CV_StsOutOfRange, "The number of channels must be 1, 2, 3 or 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_16UC1:        while( cn-- )        {            int t = cvRound( scalar->val[cn] );            ((ushort*)data)[cn] = CV_CAST_16U(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 = CV_ELEM_SIZE(type);        int offset = CV_ELEM_SIZE1(depth)*12;        do        {            offset -= pix_size;            CV_MEMCPY_AUTO( (char*)data + offset, data, pix_size );        }        while( offset > pix_size );    }    __END__;}// Converts data of specified type to CvScalarCV_IMPL voidcvRawDataToScalar( const void* data, int flags, CvScalar* scalar ){    CV_FUNCNAME( "cvRawDataToScalar" );        __BEGIN__;    int cn = CV_MAT_CN( flags );    assert( scalar && data );        if( (unsigned)(cn - 1) >= 4 )        CV_ERROR( CV_StsOutOfRange, "The number of channels must be 1, 2, 3 or 4" );    memset( scalar->val, 0, sizeof(scalar->val));    switch( CV_MAT_DEPTH( flags ))    {    case CV_8U:        while( cn-- )            scalar->val[cn] = CV_8TO32F(((uchar*)data)[cn]);        break;    case CV_8S:        while( cn-- )            scalar->val[cn] = CV_8TO32F(((char*)data)[cn]);        break;    case CV_16U:        while( cn-- )            scalar->val[cn] = ((ushort*)data)[cn];        break;    case CV_16S:        while( cn-- )            scalar->val[cn] = ((short*)data)[cn];        break;    case CV_32S:        while( cn-- )            scalar->val[cn] = ((int*)data)[cn];        break;    case CV_32F:        while( cn-- )            scalar->val[cn] = ((float*)data)[cn];        break;    case CV_64F:        while( cn-- )            scalar->val[cn] = ((double*)data)[cn];        break;    default:        assert(0);        CV_ERROR_FROM_CODE( CV_BadDepth );    }    __END__;}CV_IMPL IplImage*cvCloneImage( const IplImage* src ){    IplImage* dst = 0;    CV_FUNCNAME( "cvCloneImage" );    __BEGIN__;    if( !CV_IS_IMAGE_HDR( src ))        CV_ERROR( CV_StsBadArg, "Bad image header" );    CV_CALL( dst = (IplImage*)cvAlloc( sizeof(*dst)));    memcpy( dst, src, sizeof(*src));    dst->imageData = dst->imageDataOrigin = 0;    dst->roi = 0;    if( src->roi )    {        dst->roi = icvCreateROI( src->roi->coi, src->roi->xOffset,                      src->roi->yOffset, src->roi->width, src->roi->height );    }    if( src->imageData )    {        int size = src->imageSize;        cvCreateData( dst );        memcpy( dst->imageData, src->imageData, size );    }     __END__;    return dst;}