/*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, CvMatND, CvSparceMat and IplImage support functions // (creation, deletion, copying, retrieving and setting elements etc.) // // */ #include "_cxcore.h" static struct { Cv_iplCreateImageHeader createHeader; Cv_iplAllocateImageData allocateData; Cv_iplDeallocate deallocate; Cv_iplCreateROI createROI; Cv_iplCloneImage cloneImage; } CvIPL; // Makes the library use native IPL image allocators CV_IMPL void cvSetIPLAllocators( Cv_iplCreateImageHeader createHeader, Cv_iplAllocateImageData allocateData, Cv_iplDeallocate deallocate, Cv_iplCreateROI createROI, Cv_iplCloneImage cloneImage ) { CV_FUNCNAME( "cvSetIPLAllocators" ); __BEGIN__; if( !createHeader || !allocateData || !deallocate || !createROI || !cloneImage ) { if( createHeader || allocateData || deallocate || createROI || cloneImage ) CV_ERROR( CV_StsBadArg, "Either all the pointers should be null or " "they all should be non-null" ); } CvIPL.createHeader = createHeader; CvIPL.allocateData = allocateData; CvIPL.deallocate = deallocate; CvIPL.createROI = createROI; CvIPL.cloneImage = cloneImage; __END__; } /****************************************************************************************\ * CvMat creation and basic operations * \****************************************************************************************/ // Creates CvMat and underlying data CV_IMPL CvMat* cvCreateMat( int height, int width, int type ) { CvMat* arr = 0; CV_FUNCNAME( "cvCreateMat" ); __BEGIN__; CV_CALL( arr = cvCreateMatHeader( height, width, type )); CV_CALL( cvCreateData( arr )); __END__; if( cvGetErrStatus() < 0 ) cvReleaseMat( &arr ); return arr; } static void icvCheckHuge( CvMat* arr ) { if( (int64)arr->step*arr->rows > INT_MAX ) arr->type &= ~CV_MAT_CONT_FLAG; } // Creates CvMat header only CV_IMPL CvMat* cvCreateMatHeader( int rows, int cols, int type ) { CvMat* arr = 0; CV_FUNCNAME( "cvCreateMatHeader" ); __BEGIN__; int min_step; type = CV_MAT_TYPE(type); if( rows <= 0 || cols <= 0 ) CV_ERROR( CV_StsBadSize, "Non-positive width or height" ); min_step = CV_ELEM_SIZE(type)*cols; if( min_step <= 0 ) CV_ERROR( CV_StsUnsupportedFormat, "Invalid matrix type" ); CV_CALL( arr = (CvMat*)cvAlloc( sizeof(*arr))); arr->step = rows == 1 ? 0 : cvAlign(min_step, CV_DEFAULT_MAT_ROW_ALIGN); arr->type = CV_MAT_MAGIC_VAL | type | (arr->step == 0 || arr->step == min_step ? CV_MAT_CONT_FLAG : 0); arr->rows = rows; arr->cols = cols; arr->data.ptr = 0; arr->refcount = 0; arr->hdr_refcount = 1; icvCheckHuge( arr ); __END__; if( cvGetErrStatus() < 0 ) cvReleaseMat( &arr ); return arr; } // Initializes CvMat header, allocated by the user CV_IMPL CvMat* cvInitMatHeader( CvMat* arr, int rows, int cols, int type, void* data, int step ) { CV_FUNCNAME( "cvInitMatHeader" ); __BEGIN__; int mask, pix_size, min_step; if( !arr ) CV_ERROR_FROM_CODE( CV_StsNullPtr ); if( (unsigned)CV_MAT_DEPTH(type) > CV_DEPTH_MAX ) CV_ERROR_FROM_CODE( CV_BadNumChannels ); if( rows <= 0 || cols <= 0 ) CV_ERROR( CV_StsBadSize, "Non-positive cols or rows" ); type = CV_MAT_TYPE( type ); arr->type = type | CV_MAT_MAGIC_VAL; arr->rows = rows; arr->cols = cols; arr->data.ptr = (uchar*)data; arr->refcount = 0; arr->hdr_refcount = 0; mask = (arr->rows <= 1) - 1; pix_size = CV_ELEM_SIZE(type); min_step = arr->cols*pix_size & mask; if( step != CV_AUTOSTEP && step != 0 ) { if( step < min_step ) CV_ERROR_FROM_CODE( CV_BadStep ); arr->step = step & mask; } else { arr->step = min_step; } arr->type = CV_MAT_MAGIC_VAL | type | (arr->step == min_step ? CV_MAT_CONT_FLAG : 0); icvCheckHuge( arr ); __END__; return arr; } // Deallocates the CvMat structure and underlying data CV_IMPL void cvReleaseMat( CvMat** array ) { CV_FUNCNAME( "cvReleaseMat" ); __BEGIN__; if( !array ) CV_ERROR_FROM_CODE( CV_HeaderIsNull ); if( *array ) { CvMat* arr = *array; if( !CV_IS_MAT_HDR(arr) && !CV_IS_MATND_HDR(arr) ) CV_ERROR_FROM_CODE( CV_StsBadFlag ); *array = 0; cvDecRefData( arr ); cvFree( &arr ); } __END__; } // Creates a copy of matrix CV_IMPL CvMat* cvCloneMat( const CvMat* src ) { CvMat* dst = 0; CV_FUNCNAME( "cvCloneMat" ); __BEGIN__; if( !CV_IS_MAT_HDR( src )) CV_ERROR( CV_StsBadArg, "Bad CvMat header" ); CV_CALL( dst = cvCreateMatHeader( src->rows, src->cols, src->type )); if( src->data.ptr ) { CV_CALL( cvCreateData( dst )); CV_CALL( cvCopy( src, dst )); } __END__; return dst; } /****************************************************************************************\ * CvMatND creation and basic operations * \****************************************************************************************/ CV_IMPL CvMatND* cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes, int type, void* data ) { CvMatND* result = 0; CV_FUNCNAME( "cvInitMatNDHeader" ); __BEGIN__; type = CV_MAT_TYPE(type); int i; int64 step = CV_ELEM_SIZE(type); if( !mat ) CV_ERROR( CV_StsNullPtr, "NULL matrix header pointer" ); if( step == 0 ) CV_ERROR( CV_StsUnsupportedFormat, "invalid array data type" ); if( !sizes ) CV_ERROR( CV_StsNullPtr, "NULL pointer" ); if( dims <= 0 || dims > CV_MAX_DIM ) CV_ERROR( CV_StsOutOfRange, "non-positive or too large number of dimensions" ); for( i = dims - 1; i >= 0; i-- ) { if( sizes[i] <= 0 ) CV_ERROR( CV_StsBadSize, "one of dimesion sizes is non-positive" ); mat->dim[i].size = sizes[i]; if( step > INT_MAX ) CV_ERROR( CV_StsOutOfRange, "The array is too big" ); mat->dim[i].step = (int)step; step *= sizes[i]; } mat->type = CV_MATND_MAGIC_VAL | (step <= INT_MAX ? CV_MAT_CONT_FLAG : 0) | type; mat->dims = dims; mat->data.ptr = (uchar*)data; mat->refcount = 0; mat->hdr_refcount = 0; result = mat; __END__; if( cvGetErrStatus() < 0 && mat ) { mat->type = 0; mat->data.ptr = 0; } return result; } // Creates CvMatND and underlying data CV_IMPL CvMatND* cvCreateMatND( int dims, const int* sizes, int type ) { CvMatND* arr = 0; CV_FUNCNAME( "cvCreateMatND" ); __BEGIN__; CV_CALL( arr = cvCreateMatNDHeader( dims, sizes, type )); CV_CALL( cvCreateData( arr )); __END__; if( cvGetErrStatus() < 0 ) cvReleaseMatND( &arr ); return arr; } // Creates CvMatND header only CV_IMPL CvMatND* cvCreateMatNDHeader( int dims, const int* sizes, int type ) { CvMatND* arr = 0; CV_FUNCNAME( "cvCreateMatNDHeader" ); __BEGIN__; if( dims <= 0 || dims > CV_MAX_DIM ) CV_ERROR( CV_StsOutOfRange, "non-positive or too large number of dimensions" ); CV_CALL( arr = (CvMatND*)cvAlloc( sizeof(*arr) )); CV_CALL( cvInitMatNDHeader( arr, dims, sizes, type, 0 )); arr->hdr_refcount = 1; __END__; if( cvGetErrStatus() < 0 ) cvReleaseMatND( &arr ); return arr; } // Creates a copy of nD array CV_IMPL CvMatND* cvCloneMatND( const CvMatND* src ) { CvMatND* dst = 0; CV_FUNCNAME( "cvCloneMatND" ); __BEGIN__; int i, *sizes; if( !CV_IS_MATND_HDR( src )) CV_ERROR( CV_StsBadArg, "Bad CvMatND header" ); sizes = (int*)alloca( src->dims*sizeof(sizes[0]) ); for( i = 0; i < src->dims; i++ ) sizes[i] = src->dim[i].size; CV_CALL( dst = cvCreateMatNDHeader( src->dims, sizes, src->type )); if( src->data.ptr ) { CV_CALL( cvCreateData( dst )); CV_CALL( cvCopy( src, dst )); } __END__; return dst; } static CvMatND* cvGetMatND( const CvArr* arr, CvMatND* matnd, int* coi ) { CvMatND* result = 0; CV_FUNCNAME( "cvGetMatND" ); __BEGIN__; if( coi ) *coi = 0; if( !matnd || !arr ) CV_ERROR( CV_StsNullPtr, "NULL array pointer is passed" ); if( CV_IS_MATND_HDR(arr)) { if( !((CvMatND*)arr)->data.ptr ) CV_ERROR( CV_StsNullPtr, "The matrix has NULL data pointer" ); result = (CvMatND*)arr; } else { CvMat stub, *mat = (CvMat*)arr; if( CV_IS_IMAGE_HDR( mat )) CV_CALL( mat = cvGetMat( mat, &stub, coi )); if( !CV_IS_MAT_HDR( mat )) CV_ERROR( CV_StsBadArg, "Unrecognized or unsupported array type" ); if( !mat->data.ptr ) CV_ERROR( CV_StsNullPtr, "Input array has NULL data pointer" ); matnd->data.ptr = mat->data.ptr; matnd->refcount = 0; matnd->hdr_refcount = 0; matnd->type = mat->type; matnd->dims = 2; matnd->dim[0].size = mat->rows; matnd->dim[0].step = mat->step; matnd->dim[1].size = mat->cols; matnd->dim[1].step = CV_ELEM_SIZE(mat->type); result = matnd; } __END__; return result; } // returns number of dimensions to iterate. /* Checks whether arrays have equal type, sizes (mask is optional array that needs to have the same size, but 8uC1 or 8sC1 type). Returns number of dimensions to iterate through: 0 means that all arrays are continuous, 1 means that all arrays are vectors of continuous arrays etc. and the size of largest common continuous part of the arrays */ CV_IMPL int cvInitNArrayIterator( int count, CvArr** arrs, const CvArr* mask, CvMatND* stubs, CvNArrayIterator* iterator, int flags ) { int dims = -1; CV_FUNCNAME( "cvInitArrayOp" ); __BEGIN__; int i, j, size, dim0 = -1; int64 step; CvMatND* hdr0 = 0; if( count < 1 || count > CV_MAX_ARR ) CV_ERROR( CV_StsOutOfRange, "Incorrect number of arrays" ); if( !arrs || !stubs ) CV_ERROR( CV_StsNullPtr, "Some of required array pointers is NULL" ); if( !iterator ) CV_ERROR( CV_StsNullPtr, "Iterator pointer is NULL" ); for( i = 0; i <= count; i++ ) { const CvArr* arr = i < count ? arrs[i] : mask; CvMatND* hdr; if( !arr ) { if( i < count ) CV_ERROR( CV_StsNullPtr, "Some of required array pointers is NULL" ); break; } if( CV_IS_MATND( arr )) hdr = (CvMatND*)arr; else { int coi = 0; CV_CALL( hdr = cvGetMatND( arr, stubs + i, &coi )); if( coi != 0 ) CV_ERROR( CV_BadCOI, "COI set is not allowed here" ); } iterator->hdr[i] = hdr; if( i > 0 ) { if( hdr->dims != hdr0->dims ) CV_ERROR( CV_StsUnmatchedSizes, "Number of dimensions is the same for all arrays" ); if( i < count ) { switch( flags & (CV_NO_DEPTH_CHECK|CV_NO_CN_CHECK)) { case 0: if( !CV_ARE_TYPES_EQ( hdr, hdr0 )) CV_ERROR( CV_StsUnmatchedFormats, "Data type is not the same for all arrays" ); break; case CV_NO_DEPTH_CHECK: if( !CV_ARE_CNS_EQ( hdr, hdr0 )) CV_ERROR( CV_StsUnmatchedFormats, "Number of channels is not the same for all arrays" ); break; case CV_NO_CN_CHECK: if( !CV_ARE_CNS_EQ( hdr, hdr0 )) CV_ERROR( CV_StsUnmatchedFormats, "Depth is not the same for all arrays" ); break; } } else { if( !CV_IS_MASK_ARR( hdr )) CV_ERROR( CV_StsBadMask, "Mask should have 8uC1 or 8sC1 data type" ); } if( !(flags & CV_NO_SIZE_CHECK) ) { for( j = 0; j < hdr->dims; j++ ) if( hdr->dim[j].size != hdr0->dim[j].size ) CV_ERROR( CV_StsUnmatchedSizes, "Dimension sizes are the same for all arrays" ); } } else hdr0 = hdr; step = CV_ELEM_SIZE(hdr->type); for( j = hdr->dims - 1; j > dim0; j-- ) { if( step != hdr->dim[j].step ) break; step *= hdr->dim[j].size; } if( j == dim0 && step > INT_MAX ) j++; if( j > dim0 ) dim0 = j; iterator->hdr[i] = (CvMatND*)hdr; iterator->ptr[i] = (uchar*)hdr->data.ptr; } size = 1; for( j = hdr0->dims - 1; j > dim0; j-- ) size *= hdr0->dim[j].size; dims = dim0 + 1; iterator->dims = dims; iterator->count = count; iterator->size = cvSize(size,1); for( i = 0; i < dims; i++ ) iterator->stack[i] = hdr0->dim[i].size; __END__; return dims; } // returns zero value if iteration is finished, non-zero otherwise CV_IMPL int cvNextNArraySlice( CvNArrayIterator* iterator ) { assert( iterator != 0 ); int i, dims, size = 0; for( dims = iterator->dims; dims > 0; dims-- ) { for( i = 0; i < iterator->count; i++ ) iterator->ptr[i] += iterator->hdr[i]->dim[dims-1].step; if( --iterator->stack[dims-1] > 0 ) break; size = iterator->hdr[0]->dim[dims-1].size; for( i = 0; i < iterator->count; i++ ) iterator->ptr[i] -= (size_t)size*iterator->hdr[i]->dim[dims-1].step; iterator->stack[dims-1] = size; } return dims > 0; } /****************************************************************************************\ * CvSparseMat creation and basic operations * \****************************************************************************************/ // Creates CvMatND and underlying data CV_IMPL CvSparseMat* cvCreateSparseMat( int dims, const int* sizes, int type ) { CvSparseMat* arr = 0; CV_FUNCNAME( "cvCreateSparseMat" ); __BEGIN__; type = CV_MAT_TYPE( type ); int pix_size1 = CV_ELEM_SIZE1(type); int pix_size = pix_size1*CV_MAT_CN(type); int i, size; CvMemStorage* storage; if( pix_size == 0 ) CV_ERROR( CV_StsUnsupportedFormat, "invalid array data type" ); if( dims <= 0 || dims > CV_MAX_DIM_HEAP ) CV_ERROR( CV_StsOutOfRange, "bad number of dimensions" ); if( !sizes ) CV_ERROR( CV_StsNullPtr, "NULL pointer" ); for( i = 0; i < dims; i++ ) { if( sizes[i] <= 0 ) CV_ERROR( CV_StsBadSize, "one of dimesion sizes is non-positive" ); } CV_CALL( arr = (CvSparseMat*)cvAlloc(sizeof(*arr)+MAX(0,dims-CV_MAX_DIM)*sizeof(arr->size[0]))); arr->type = CV_SPARSE_MAT_MAGIC_VAL | type; arr->dims = dims; arr->refcount = 0; arr->hdr_refcount = 1; memcpy( arr->size, sizes, dims*sizeof(sizes[0])); arr->valoffset = (int)cvAlign(sizeof(CvSparseNode), pix_size1); arr->idxoffset = (int)cvAlign(arr->valoffset + pix_size, sizeof(int)); size = (int)cvAlign(arr->idxoffset + dims*sizeof(int), sizeof(CvSetElem)); CV_CALL( storage = cvCreateMemStorage( CV_SPARSE_MAT_BLOCK )); CV_CALL( arr->heap = cvCreateSet( 0, sizeof(CvSet), size, storage )); arr->hashsize = CV_SPARSE_HASH_SIZE0; size = arr->hashsize*sizeof(arr->hashtable[0]); CV_CALL( arr->hashtable = (void**)cvAlloc( size )); memset( arr->hashtable, 0, size ); __END__; if( cvGetErrStatus() < 0 ) cvReleaseSparseMat( &arr ); return arr; } // Creates CvMatND and underlying data CV_IMPL void cvReleaseSparseMat( CvSparseMat** array ) { CV_FUNCNAME( "cvReleaseSparseMat" ); __BEGIN__; if( !array ) CV_ERROR_FROM_CODE( CV_HeaderIsNull ); if( *array ) { CvSparseMat* arr = *array; if( !CV_IS_SPARSE_MAT_HDR(arr) ) CV_ERROR_FROM_CODE( CV_StsBadFlag ); *array = 0; cvReleaseMemStorage( &arr->heap->storage ); cvFree( &arr->hashtable ); cvFree( &arr ); } __END__; } // Creates CvMatND and underlying data CV_IMPL CvSparseMat* cvCloneSparseMat( const CvSparseMat* src ) { CvSparseMat* dst = 0; CV_FUNCNAME( "cvCloneSparseMat" ); __BEGIN__; if( !CV_IS_SPARSE_MAT_HDR(src) ) CV_ERROR( CV_StsBadArg, "Invalid sparse array header" ); CV_CALL( dst = cvCreateSparseMat( src->dims, src->size, src->type )); CV_CALL( cvCopy( src, dst )); __END__; if( cvGetErrStatus() < 0 ) cvReleaseSparseMat( &dst ); return dst; } CvSparseNode* cvInitSparseMatIterator( const CvSparseMat* mat, CvSparseMatIterator* iterator ) { CvSparseNode* node = 0; CV_FUNCNAME( "cvInitSparseMatIterator" ); __BEGIN__; int idx; if( !CV_IS_SPARSE_MAT( mat )) CV_ERROR( CV_StsBadArg, "Invalid sparse matrix header" ); if( !iterator ) CV_ERROR( CV_StsNullPtr, "NULL iterator pointer" ); iterator->mat = (CvSparseMat*)mat; iterator->node = 0; for( idx = 0; idx < mat->hashsize; idx++ ) if( mat->hashtable[idx] ) { node = iterator->node = (CvSparseNode*)mat->hashtable[idx]; break; } iterator->curidx = idx; __END__; return node; } #define ICV_SPARSE_MAT_HASH_MULTIPLIER 33 static uchar* icvGetNodePtr( CvSparseMat* mat, const int* idx, int* _type, int create_node, unsigned* precalc_hashval ) { uchar* ptr = 0; CV_FUNCNAME( "icvGetNodePtr" ); __BEGIN__; int i, tabidx; unsigned hashval = 0; CvSparseNode *node; assert( CV_IS_SPARSE_MAT( mat )); if( !precalc_hashval ) { for( i = 0; i < mat->dims; i++ ) { int t = idx[i]; if( (unsigned)t >= (unsigned)mat->size[i] ) CV_ERROR( CV_StsOutOfRange, "One of indices is out of range" ); hashval = hashval*ICV_SPARSE_MAT_HASH_MULTIPLIER + t; } } else { hashval = *precalc_hashval; } tabidx = hashval & (mat->hashsize - 1); hashval &= INT_MAX; for( node = (CvSparseNode*)mat->hashtable[tabidx]; node != 0; node = node->next ) { if( node->hashval == hashval ) { int* nodeidx = CV_NODE_IDX(mat,node); for( i = 0; i < mat->dims; i++ ) if( idx[i] != nodeidx[i] ) break; if( i == mat->dims ) { ptr = (uchar*)CV_NODE_VAL(mat,node); break; } } } if( !ptr && create_node ) { if( mat->heap->active_count >= mat->hashsize*CV_SPARSE_HASH_RATIO ) { void** newtable; int newsize = MAX( mat->hashsize*2, CV_SPARSE_HASH_SIZE0); int newrawsize = newsize*sizeof(newtable[0]); CvSparseMatIterator iterator; assert( (newsize & (newsize - 1)) == 0 ); // resize hash table CV_CALL( newtable = (void**)cvAlloc( newrawsize )); memset( newtable, 0, newrawsize ); node = cvInitSparseMatIterator( mat, &iterator ); while( node ) { CvSparseNode* next = cvGetNextSparseNode( &iterator ); int newidx = node->hashval & (newsize - 1); node->next = (CvSparseNode*)newtable[newidx]; newtable[newidx] = node; node = next; } cvFree( &mat->hashtable ); mat->hashtable = newtable; mat->hashsize = newsize; tabidx = hashval & (newsize - 1); } node = (CvSparseNode*)cvSetNew( mat->heap ); node->hashval = hashval; node->next = (CvSparseNode*)mat->hashtable[tabidx]; mat->hashtable[tabidx] = node; CV_MEMCPY_INT( CV_NODE_IDX(mat,node), idx, mat->dims ); ptr = (uchar*)CV_NODE_VAL(mat,node); if( create_node > 0 ) CV_ZERO_CHAR( ptr, CV_ELEM_SIZE(mat->type)); } if( _type ) *_type = CV_MAT_TYPE(mat->type); __END__; return ptr; } static void icvDeleteNode( CvSparseMat* mat, const int* idx, unsigned* precalc_hashval ) { CV_FUNCNAME( "icvDeleteNode" ); __BEGIN__; int i, tabidx; unsigned hashval = 0; CvSparseNode *node, *prev = 0; assert( CV_IS_SPARSE_MAT( mat )); if( !precalc_hashval ) { for( i = 0; i < mat->dims; i++ ) { int t = idx[i]; if( (unsigned)t >= (unsigned)mat->size[i] ) CV_ERROR( CV_StsOutOfRange, "One of indices is out of range" ); hashval = hashval*ICV_SPARSE_MAT_HASH_MULTIPLIER + t; } } else { hashval = *precalc_hashval; } tabidx = hashval & (mat->hashsize - 1); hashval &= INT_MAX; for( node = (CvSparseNode*)mat->hashtable[tabidx]; node != 0; prev = node, node = node->next ) { if( node->hashval == hashval ) { int* nodeidx = CV_NODE_IDX(mat,node); for( i = 0; i < mat->dims; i++ ) if( idx[i] != nodeidx[i] ) break; if( i == mat->dims ) break; } } if( node ) { if( prev ) prev->next = node->next; else mat->hashtable[tabidx] = node->next; cvSetRemoveByPtr( mat->heap, node ); } __END__; } /****************************************************************************************\ * Common for multiple array types operations * \****************************************************************************************/ // Allocates underlying array data CV_IMPL void cvCreateData( CvArr* arr ) { CV_FUNCNAME( "cvCreateData" ); __BEGIN__; if( CV_IS_MAT_HDR( arr )) { size_t step, total_size; CvMat* mat = (CvMat*)arr; step = mat->step; if( mat->data.ptr != 0 ) CV_ERROR( CV_StsError, "Data is already allocated" ); if( step == 0 ) step = CV_ELEM_SIZE(mat->type)*mat->cols; total_size = step*mat->rows + sizeof(int) + CV_MALLOC_ALIGN; CV_CALL( mat->refcount = (int*)cvAlloc( (size_t)total_size )); mat->data.ptr = (uchar*)cvAlignPtr( mat->refcount + 1, CV_MALLOC_ALIGN ); *mat->refcount = 1; } else if( CV_IS_IMAGE_HDR(arr)) { IplImage* img = (IplImage*)arr; if( img->imageData != 0 ) CV_ERROR( CV_StsError, "Data is already allocated" ); if( !CvIPL.allocateData ) { CV_CALL( img->imageData = img->imageDataOrigin = (char*)cvAlloc( (size_t)img->imageSize )); } else { int depth = img->depth; int width = img->width; if( img->depth == IPL_DEPTH_32F || img->nChannels == 64 ) { img->width *= img->depth == IPL_DEPTH_32F ? sizeof(float) : sizeof(double); img->depth = IPL_DEPTH_8U; } CvIPL.allocateData( img, 0, 0 ); img->width = width; img->depth = depth; } } else if( CV_IS_MATND_HDR( arr )) { CvMatND* mat = (CvMatND*)arr; int i; size_t total_size = CV_ELEM_SIZE(mat->type); if( mat->data.ptr != 0 ) CV_ERROR( CV_StsError, "Data is already allocated" ); if( CV_IS_MAT_CONT( mat->type )) { total_size = (size_t)mat->dim[0].size*(mat->dim[0].step != 0 ? mat->dim[0].step : total_size); } else { for( i = mat->dims - 1; i >= 0; i-- ) { size_t size = (size_t)mat->dim[i].step*mat->dim[i].size; if( total_size < size ) total_size = size; } } CV_CALL( mat->refcount = (int*)cvAlloc( total_size + sizeof(int) + CV_MALLOC_ALIGN )); mat->data.ptr = (uchar*)cvAlignPtr( mat->refcount + 1, CV_MALLOC_ALIGN ); *mat->refcount = 1; } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; } // Assigns external data to array CV_IMPL void cvSetData( CvArr* arr, void* data, int step ) { CV_FUNCNAME( "cvSetData" ); __BEGIN__; int pix_size, min_step; if( CV_IS_MAT_HDR(arr) || CV_IS_MATND_HDR(arr) ) cvReleaseData( arr ); if( CV_IS_MAT_HDR( arr )) { CvMat* mat = (CvMat*)arr; int type = CV_MAT_TYPE(mat->type); pix_size = CV_ELEM_SIZE(type); min_step = mat->cols*pix_size & ((mat->rows <= 1) - 1); if( step != CV_AUTOSTEP ) { if( step < min_step && data != 0 ) CV_ERROR_FROM_CODE( CV_BadStep ); mat->step = step & ((mat->rows <= 1) - 1); } else { mat->step = min_step; } mat->data.ptr = (uchar*)data; mat->type = CV_MAT_MAGIC_VAL | type | (mat->step==min_step ? CV_MAT_CONT_FLAG : 0); icvCheckHuge( mat ); } else if( CV_IS_IMAGE_HDR( arr )) { IplImage* img = (IplImage*)arr; pix_size = ((img->depth & 255) >> 3)*img->nChannels; min_step = img->width*pix_size; if( step != CV_AUTOSTEP && img->height > 1 ) { if( step < min_step && data != 0 ) CV_ERROR_FROM_CODE( CV_BadStep ); img->widthStep = step; } else { img->widthStep = min_step; } img->imageSize = img->widthStep * img->height; img->imageData = img->imageDataOrigin = (char*)data; if( (((int)(size_t)data | step) & 7) == 0 && cvAlign(img->width * pix_size, 8) == step ) { img->align = 8; } else { img->align = 4; } } else if( CV_IS_MATND_HDR( arr )) { CvMatND* mat = (CvMatND*)arr; int i; int64 cur_step; if( step != CV_AUTOSTEP ) CV_ERROR( CV_BadStep, "For multidimensional array only CV_AUTOSTEP is allowed here" ); mat->data.ptr = (uchar*)data; cur_step = CV_ELEM_SIZE(mat->type); for( i = mat->dims - 1; i >= 0; i-- ) { if( cur_step > INT_MAX ) CV_ERROR( CV_StsOutOfRange, "The array is too big" ); mat->dim[i].step = (int)cur_step; cur_step *= mat->dim[i].size; } } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; } // Deallocates array's data CV_IMPL void cvReleaseData( CvArr* arr ) { CV_FUNCNAME( "cvReleaseData" ); __BEGIN__; if( CV_IS_MAT_HDR( arr ) || CV_IS_MATND_HDR( arr )) { CvMat* mat = (CvMat*)arr; cvDecRefData( mat ); } else if( CV_IS_IMAGE_HDR( arr )) { IplImage* img = (IplImage*)arr; if( !CvIPL.deallocate ) { char* ptr = img->imageDataOrigin; img->imageData = img->imageDataOrigin = 0; cvFree( &ptr ); } else { CvIPL.deallocate( img, IPL_IMAGE_DATA ); } } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; } // Retrieves essential information about image ROI or CvMat data CV_IMPL void cvGetRawData( const CvArr* arr, uchar** data, int* step, CvSize* roi_size ) { CV_FUNCNAME( "cvGetRawData" ); __BEGIN__; if( CV_IS_MAT( arr )) { CvMat *mat = (CvMat*)arr; if( step ) *step = mat->step; if( data ) *data = mat->data.ptr; if( roi_size ) *roi_size = cvGetMatSize( mat ); } else if( CV_IS_IMAGE( arr )) { IplImage* img = (IplImage*)arr; if( step ) *step = img->widthStep; if( data ) CV_CALL( *data = cvPtr2D( img, 0, 0 )); if( roi_size ) { if( img->roi ) { *roi_size = cvSize( img->roi->width, img->roi->height ); } else { *roi_size = cvSize( img->width, img->height ); } } } else if( CV_IS_MATND( arr )) { CvMatND* mat = (CvMatND*)arr; if( !CV_IS_MAT_CONT( mat->type )) CV_ERROR( CV_StsBadArg, "Only continuous nD arrays are supported here" ); if( data ) *data = mat->data.ptr; if( roi_size || step ) { int i, size1 = mat->dim[0].size, size2 = 1; if( mat->dims > 2 ) for( i = 1; i < mat->dims; i++ ) size1 *= mat->dim[i].size; else size2 = mat->dim[1].size; if( roi_size ) { roi_size->width = size2; roi_size->height = size1; } if( step ) *step = size1 == 1 ? 0 : mat->dim[0].step; } } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; } CV_IMPL int cvGetElemType( const CvArr* arr ) { int type = -1; CV_FUNCNAME( "cvGetElemType" ); __BEGIN__; if( CV_IS_MAT_HDR(arr) || CV_IS_MATND_HDR(arr) || CV_IS_SPARSE_MAT_HDR(arr)) { type = CV_MAT_TYPE( ((CvMat*)arr)->type ); } else if( CV_IS_IMAGE(arr)) { IplImage* img = (IplImage*)arr; type = CV_MAKETYPE( icvIplToCvDepth(img->depth), img->nChannels ); } else CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); __END__; return type; } // Returns a number of array dimensions CV_IMPL int cvGetDims( const CvArr* arr, int* sizes ) { int dims = -1; CV_FUNCNAME( "cvGetDims" ); __BEGIN__; if( CV_IS_MAT_HDR( arr )) { CvMat* mat = (CvMat*)arr; dims = 2; if( sizes ) { sizes[0] = mat->rows; sizes[1] = mat->cols; } } else if( CV_IS_IMAGE( arr )) { IplImage* img = (IplImage*)arr; dims = 2; if( sizes ) { sizes[0] = img->height; sizes[1] = img->width; } } else if( CV_IS_MATND_HDR( arr )) { CvMatND* mat = (CvMatND*)arr; dims = mat->dims; if( sizes ) { int i; for( i = 0; i < dims; i++ ) sizes[i] = mat->dim[i].size; } } else if( CV_IS_SPARSE_MAT_HDR( arr )) { CvSparseMat* mat = (CvSparseMat*)arr; dims = mat->dims; if( sizes ) memcpy( sizes, mat->size, dims*sizeof(sizes[0])); } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; return dims; } // Returns the size of particular array dimension CV_IMPL int cvGetDimSize( const CvArr* arr, int index ) { int size = -1; CV_FUNCNAME( "cvGetDimSize" ); __BEGIN__; if( CV_IS_MAT( arr )) { CvMat *mat = (CvMat*)arr; switch( index ) { case 0: size = mat->rows; break; case 1: size = mat->cols; break; default: CV_ERROR( CV_StsOutOfRange, "bad dimension index" ); } } else if( CV_IS_IMAGE( arr )) { IplImage* img = (IplImage*)arr; switch( index ) { case 0: size = !img->roi ? img->height : img->roi->height; break; case 1: size = !img->roi ? img->width : img->roi->width; break; default: CV_ERROR( CV_StsOutOfRange, "bad dimension index" ); } } else if( CV_IS_MATND_HDR( arr )) { CvMatND* mat = (CvMatND*)arr; if( (unsigned)index >= (unsigned)mat->dims ) CV_ERROR( CV_StsOutOfRange, "bad dimension index" ); size = mat->dim[index].size; } else if( CV_IS_SPARSE_MAT_HDR( arr )) { CvSparseMat* mat = (CvSparseMat*)arr; if( (unsigned)index >= (unsigned)mat->dims ) CV_ERROR( CV_StsOutOfRange, "bad dimension index" ); size = mat->size[index]; } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; return size; } // Returns the size of CvMat or IplImage CV_IMPL CvSize cvGetSize( 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; int cols; if( !CV_IS_MAT( mat )) CV_CALL( mat = cvGetMat( mat, &stub )); if( !submat ) CV_ERROR( CV_StsNullPtr, "" ); cols = mat->cols; if( (unsigned)start_col >= (unsigned)cols || (unsigned)end_col > (unsigned)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 < cols ? ~CV_MAT_CONT_FLAG : -1); submat->refcount = 0; submat->hdr_refcount = 0; res = submat; } __END__; return res; } // Selects array diagonal CV_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 type CV_IMPL void cvScalarToRawData( 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 CvScalar CV_IMPL void cvRawDataToScalar( 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__; } static double icvGetReal( const void* data, int type ) { switch( type ) { case CV_8U: return *(uchar*)data; case CV_8S: return *(char*)data; case CV_16U: return *(ushort*)data; case CV_16S: return *(short*)data; case CV_32S: return *(int*)data; case CV_32F: return *(float*)data; case CV_64F: return *(double*)data; } return 0; } static void icvSetReal( double value, const void* data, int type ) { if( type < CV_32F ) { int ivalue = cvRound(value); switch( type ) { case CV_8U: *(uchar*)data = CV_CAST_8U(ivalue); break; case CV_8S: *(char*)data = CV_CAST_8S(ivalue); break; case CV_16U: *(ushort*)data = CV_CAST_16U(ivalue); break; case CV_16S: *(short*)data = CV_CAST_16S(ivalue); break; case CV_32S: *(int*)data = CV_CAST_32S(ivalue); break; } } else { switch( type ) { case CV_32F: *(float*)data = (float)value; break; case CV_64F: *(double*)data = value; break; } } } // Returns pointer to specified element of array (linear index is used) CV_IMPL uchar* cvPtr1D( const CvArr* arr, int idx, int* _type ) { uchar* ptr = 0; CV_FUNCNAME( "cvPtr1D" ); __BEGIN__; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; int type = CV_MAT_TYPE(mat->type); int pix_size = CV_ELEM_SIZE(type); if( _type ) *_type = type; // the first part is mul-free sufficient check // that the index is within the matrix if( (unsigned)idx >= (unsigned)(mat->rows + mat->cols - 1) && (unsigned)idx >= (unsigned)(mat->rows*mat->cols)) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); if( CV_IS_MAT_CONT(mat->type)) { ptr = mat->data.ptr + (size_t)idx*pix_size; } else { int row, col; if( mat->cols == 1 ) row = idx, col = 0; else row = idx/mat->cols, col = idx - row*mat->cols; ptr = mat->data.ptr + (size_t)row*mat->step + col*pix_size; } } else if( CV_IS_IMAGE_HDR( arr )) { IplImage* img = (IplImage*)arr; int width = !img->roi ? img->width : img->roi->width; int y = idx/width, x = idx - y*width; ptr = cvPtr2D( arr, y, x, _type ); } else if( CV_IS_MATND( arr )) { CvMatND* mat = (CvMatND*)arr; int j, type = CV_MAT_TYPE(mat->type); size_t size = mat->dim[0].size; if( _type ) *_type = type; for( j = 1; j < mat->dims; j++ ) size *= mat->dim[j].size; if((unsigned)idx >= (unsigned)size ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); if( CV_IS_MAT_CONT(mat->type)) { int pix_size = CV_ELEM_SIZE(type); ptr = mat->data.ptr + (size_t)idx*pix_size; } else { ptr = mat->data.ptr; for( j = mat->dims - 1; j >= 0; j-- ) { int sz = mat->dim[j].size; if( sz ) { int t = idx/sz; ptr += (idx - t*sz)*mat->dim[j].step; idx = t; } } } } else if( CV_IS_SPARSE_MAT( arr )) { CvSparseMat* m = (CvSparseMat*)arr; if( m->dims == 1 ) ptr = icvGetNodePtr( (CvSparseMat*)arr, &idx, _type, 1, 0 ); else { int i, n = m->dims; int* _idx = (int*)cvStackAlloc(n*sizeof(_idx[0])); for( i = n - 1; i >= 0; i-- ) { int t = idx / m->size[i]; _idx[i] = idx - t*m->size[i]; idx = t; } ptr = icvGetNodePtr( (CvSparseMat*)arr, _idx, _type, 1, 0 ); } } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; return ptr; } // Returns pointer to specified element of 2d array CV_IMPL uchar* cvPtr2D( const CvArr* arr, int y, int x, int* _type ) { uchar* ptr = 0; CV_FUNCNAME( "cvPtr2D" ); __BEGIN__; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; int type; if( (unsigned)y >= (unsigned)(mat->rows) || (unsigned)x >= (unsigned)(mat->cols) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); type = CV_MAT_TYPE(mat->type); if( _type ) *_type = type; ptr = mat->data.ptr + (size_t)y*mat->step + x*CV_ELEM_SIZE(type); } else if( CV_IS_IMAGE( arr )) { IplImage* img = (IplImage*)arr; int pix_size = (img->depth & 255) >> 3; int width, height; ptr = (uchar*)img->imageData; if( img->dataOrder == 0 ) pix_size *= img->nChannels; if( img->roi ) { width = img->roi->width; height = img->roi->height; ptr += img->roi->yOffset*img->widthStep + img->roi->xOffset*pix_size; if( img->dataOrder ) { int coi = img->roi->coi; if( !coi ) CV_ERROR( CV_BadCOI, "COI must be non-null in case of planar images" ); ptr += (coi - 1)*img->imageSize; } } else { width = img->width; height = img->height; } if( (unsigned)y >= (unsigned)height || (unsigned)x >= (unsigned)width ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); 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 )) { int idx[] = { y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, _type, 1, 0 ); } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; return ptr; } // Returns pointer to specified element of 3d array CV_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 )) { int idx[] = { z, y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, _type, 1, 0 ); } else { CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); } __END__; return ptr; } // Returns pointer to specified element of n-d array CV_IMPL uchar* cvPtrND( const CvArr* arr, const int* idx, int* _type, int create_node, unsigned* precalc_hashval ) { uchar* ptr = 0; CV_FUNCNAME( "cvPtrND" ); __BEGIN__; if( !idx ) CV_ERROR( CV_StsNullPtr, "NULL pointer to indices" ); if( CV_IS_SPARSE_MAT( arr )) ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, _type, create_node, precalc_hashval ); else if( CV_IS_MATND( arr )) { CvMatND* mat = (CvMatND*)arr; int i; ptr = mat->data.ptr; for( i = 0; i < mat->dims; i++ ) { if( (unsigned)idx[i] >= (unsigned)(mat->dim[i].size) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); ptr += (size_t)idx[i]*mat->dim[i].step; } if( _type ) *_type = CV_MAT_TYPE(mat->type); } else if( CV_IS_MAT_HDR(arr) || CV_IS_IMAGE_HDR(arr) ) ptr = cvPtr2D( arr, idx[0], idx[1], _type ); else CV_ERROR( CV_StsBadArg, "unrecognized or unsupported array type" ); __END__; return ptr; } // Returns specifed element of n-D array given linear index CV_IMPL CvScalar cvGet1D( const CvArr* arr, int idx ) { CvScalar scalar = {{0,0,0,0}}; CV_FUNCNAME( "cvGet1D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr ) && CV_IS_MAT_CONT( ((CvMat*)arr)->type )) { CvMat* mat = (CvMat*)arr; type = CV_MAT_TYPE(mat->type); int pix_size = CV_ELEM_SIZE(type); // the first part is mul-free sufficient check // that the index is within the matrix if( (unsigned)idx >= (unsigned)(mat->rows + mat->cols - 1) && (unsigned)idx >= (unsigned)(mat->rows*mat->cols)) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); ptr = mat->data.ptr + (size_t)idx*pix_size; } else if( !CV_IS_SPARSE_MAT( arr ) || ((CvSparseMat*)arr)->dims > 1 ) ptr = cvPtr1D( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, &idx, &type, 0, 0 ); cvRawDataToScalar( ptr, type, &scalar ); __END__; return scalar; } // Returns specifed element of 2D array CV_IMPL CvScalar cvGet2D( const CvArr* arr, int y, int x ) { CvScalar scalar = {{0,0,0,0}}; CV_FUNCNAME( "cvGet2D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; if( (unsigned)y >= (unsigned)(mat->rows) || (unsigned)x >= (unsigned)(mat->cols) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); type = CV_MAT_TYPE(mat->type); ptr = mat->data.ptr + (size_t)y*mat->step + x*CV_ELEM_SIZE(type); } else if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr2D( arr, y, x, &type ); else { int idx[] = { y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); } cvRawDataToScalar( ptr, type, &scalar ); __END__; return scalar; } // Returns specifed element of 3D array CV_IMPL CvScalar cvGet3D( const CvArr* arr, int z, int y, int x ) { CvScalar scalar = {{0,0,0,0}}; /*CV_FUNCNAME( "cvGet3D" );*/ __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr3D( arr, z, y, x, &type ); else { int idx[] = { z, y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); } cvRawDataToScalar( ptr, type, &scalar ); __END__; return scalar; } // Returns specifed element of nD array CV_IMPL CvScalar cvGetND( const CvArr* arr, const int* idx ) { CvScalar scalar = {{0,0,0,0}}; /*CV_FUNCNAME( "cvGetND" );*/ __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtrND( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); cvRawDataToScalar( ptr, type, &scalar ); __END__; return scalar; } // Returns specifed element of n-D array given linear index CV_IMPL double cvGetReal1D( const CvArr* arr, int idx ) { double value = 0; CV_FUNCNAME( "cvGetReal1D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr ) && CV_IS_MAT_CONT( ((CvMat*)arr)->type )) { CvMat* mat = (CvMat*)arr; type = CV_MAT_TYPE(mat->type); int pix_size = CV_ELEM_SIZE(type); // the first part is mul-free sufficient check // that the index is within the matrix if( (unsigned)idx >= (unsigned)(mat->rows + mat->cols - 1) && (unsigned)idx >= (unsigned)(mat->rows*mat->cols)) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); ptr = mat->data.ptr + (size_t)idx*pix_size; } else if( !CV_IS_SPARSE_MAT( arr ) || ((CvSparseMat*)arr)->dims > 1 ) ptr = cvPtr1D( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, &idx, &type, 0, 0 ); if( ptr ) { if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvGetReal* support only single-channel arrays" ); value = icvGetReal( ptr, type ); } __END__; return value; } // Returns specifed element of 2D array CV_IMPL double cvGetReal2D( const CvArr* arr, int y, int x ) { double value = 0; CV_FUNCNAME( "cvGetReal2D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; if( (unsigned)y >= (unsigned)(mat->rows) || (unsigned)x >= (unsigned)(mat->cols) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); type = CV_MAT_TYPE(mat->type); ptr = mat->data.ptr + (size_t)y*mat->step + x*CV_ELEM_SIZE(type); } else if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr2D( arr, y, x, &type ); else { int idx[] = { y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); } if( ptr ) { if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvGetReal* support only single-channel arrays" ); value = icvGetReal( ptr, type ); } __END__; return value; } // Returns specifed element of 3D array CV_IMPL double cvGetReal3D( const CvArr* arr, int z, int y, int x ) { double value = 0; CV_FUNCNAME( "cvGetReal3D" ); __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr3D( arr, z, y, x, &type ); else { int idx[] = { z, y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); } if( ptr ) { if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvGetReal* support only single-channel arrays" ); value = icvGetReal( ptr, type ); } __END__; return value; } // Returns specifed element of nD array CV_IMPL double cvGetRealND( const CvArr* arr, const int* idx ) { double value = 0; CV_FUNCNAME( "cvGetRealND" ); __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtrND( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, 0, 0 ); if( ptr ) { if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvGetReal* support only single-channel arrays" ); value = icvGetReal( ptr, type ); } __END__; return value; } // Assigns new value to specifed element of nD array given linear index CV_IMPL void cvSet1D( CvArr* arr, int idx, CvScalar scalar ) { CV_FUNCNAME( "cvSet1D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr ) && CV_IS_MAT_CONT( ((CvMat*)arr)->type )) { CvMat* mat = (CvMat*)arr; type = CV_MAT_TYPE(mat->type); int pix_size = CV_ELEM_SIZE(type); // the first part is mul-free sufficient check // that the index is within the matrix if( (unsigned)idx >= (unsigned)(mat->rows + mat->cols - 1) && (unsigned)idx >= (unsigned)(mat->rows*mat->cols)) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); ptr = mat->data.ptr + (size_t)idx*pix_size; } else if( !CV_IS_SPARSE_MAT( arr ) || ((CvSparseMat*)arr)->dims > 1 ) ptr = cvPtr1D( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, &idx, &type, -1, 0 ); cvScalarToRawData( &scalar, ptr, type ); __END__; } // Assigns new value to specifed element of 2D array CV_IMPL void cvSet2D( CvArr* arr, int y, int x, CvScalar scalar ) { CV_FUNCNAME( "cvSet2D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; if( (unsigned)y >= (unsigned)(mat->rows) || (unsigned)x >= (unsigned)(mat->cols) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); type = CV_MAT_TYPE(mat->type); ptr = mat->data.ptr + (size_t)y*mat->step + x*CV_ELEM_SIZE(type); } else if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr2D( arr, y, x, &type ); else { int idx[] = { y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); } cvScalarToRawData( &scalar, ptr, type ); __END__; } // Assigns new value to specifed element of 3D array CV_IMPL void cvSet3D( CvArr* arr, int z, int y, int x, CvScalar scalar ) { /*CV_FUNCNAME( "cvSet3D" );*/ __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr3D( arr, z, y, x, &type ); else { int idx[] = { z, y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); } cvScalarToRawData( &scalar, ptr, type ); __END__; } // Assigns new value to specifed element of nD array CV_IMPL void cvSetND( CvArr* arr, const int* idx, CvScalar scalar ) { /*CV_FUNCNAME( "cvSetND" );*/ __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtrND( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); cvScalarToRawData( &scalar, ptr, type ); __END__; } CV_IMPL void cvSetReal1D( CvArr* arr, int idx, double value ) { CV_FUNCNAME( "cvSetReal1D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr ) && CV_IS_MAT_CONT( ((CvMat*)arr)->type )) { CvMat* mat = (CvMat*)arr; type = CV_MAT_TYPE(mat->type); int pix_size = CV_ELEM_SIZE(type); // the first part is mul-free sufficient check // that the index is within the matrix if( (unsigned)idx >= (unsigned)(mat->rows + mat->cols - 1) && (unsigned)idx >= (unsigned)(mat->rows*mat->cols)) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); ptr = mat->data.ptr + (size_t)idx*pix_size; } else if( !CV_IS_SPARSE_MAT( arr ) || ((CvSparseMat*)arr)->dims > 1 ) ptr = cvPtr1D( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, &idx, &type, -1, 0 ); if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvSetReal* support only single-channel arrays" ); if( ptr ) icvSetReal( value, ptr, type ); __END__; } CV_IMPL void cvSetReal2D( CvArr* arr, int y, int x, double value ) { CV_FUNCNAME( "cvSetReal2D" ); __BEGIN__; int type = 0; uchar* ptr; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; if( (unsigned)y >= (unsigned)(mat->rows) || (unsigned)x >= (unsigned)(mat->cols) ) CV_ERROR( CV_StsOutOfRange, "index is out of range" ); type = CV_MAT_TYPE(mat->type); ptr = mat->data.ptr + (size_t)y*mat->step + x*CV_ELEM_SIZE(type); } else if( !CV_IS_SPARSE_MAT( arr )) { ptr = cvPtr2D( arr, y, x, &type ); } else { int idx[] = { y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); } if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvSetReal* support only single-channel arrays" ); if( ptr ) icvSetReal( value, ptr, type ); __END__; } CV_IMPL void cvSetReal3D( CvArr* arr, int z, int y, int x, double value ) { CV_FUNCNAME( "cvSetReal3D" ); __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtr3D( arr, z, y, x, &type ); else { int idx[] = { z, y, x }; ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); } if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvSetReal* support only single-channel arrays" ); if( ptr ) icvSetReal( value, ptr, type ); __END__; } CV_IMPL void cvSetRealND( CvArr* arr, const int* idx, double value ) { CV_FUNCNAME( "cvSetRealND" ); __BEGIN__; int type = 0; uchar* ptr; if( !CV_IS_SPARSE_MAT( arr )) ptr = cvPtrND( arr, idx, &type ); else ptr = icvGetNodePtr( (CvSparseMat*)arr, idx, &type, -1, 0 ); if( CV_MAT_CN( type ) > 1 ) CV_ERROR( CV_BadNumChannels, "cvSetReal* support only single-channel arrays" ); if( ptr ) icvSetReal( value, ptr, type ); __END__; } CV_IMPL void cvClearND( CvArr* arr, const int* idx ) { /*CV_FUNCNAME( "cvClearND" );*/ __BEGIN__; if( !CV_IS_SPARSE_MAT( arr )) { int type; uchar* ptr; ptr = cvPtrND( arr, idx, &type ); if( ptr ) CV_ZERO_CHAR( ptr, CV_ELEM_SIZE(type) ); } else { icvDeleteNode( (CvSparseMat*)arr, idx, 0 ); } __END__; } /****************************************************************************************\ * Conversion to CvMat or IplImage * \****************************************************************************************/ // convert array (CvMat or IplImage) to CvMat CV_IMPL CvMat* cvGetMat( const CvArr* array, CvMat* mat, int* pCOI, int allowND ) { CvMat* result = 0; CvMat* src = (CvMat*)array; int coi = 0; CV_FUNCNAME( "cvGetMat" ); __BEGIN__; if( !mat || !src ) CV_ERROR( CV_StsNullPtr, "NULL array pointer is passed" ); if( CV_IS_MAT_HDR(src)) { if( !src->data.ptr ) CV_ERROR( CV_StsNullPtr, "The matrix has NULL data pointer" ); result = (CvMat*)src; } else if( CV_IS_IMAGE_HDR(src) ) { const IplImage* img = (const IplImage*)src; int depth, order; if( img->imageData == 0 ) CV_ERROR( CV_StsNullPtr, "The image has NULL data pointer" ); depth = icvIplToCvDepth( img->depth ); if( depth < 0 ) CV_ERROR_FROM_CODE( CV_BadDepth ); order = img->dataOrder & (img->nChannels > 1 ? -1 : 0); if( img->roi ) { if( order == IPL_DATA_ORDER_PLANE ) { int type = depth; if( img->roi->coi == 0 ) CV_ERROR( CV_StsBadFlag, "Images with planar data layout should be used with COI selected" ); CV_CALL( cvInitMatHeader( mat, img->roi->height, img->roi->width, type, img->imageData + (img->roi->coi-1)*img->imageSize + img->roi->yOffset*img->widthStep + img->roi->xOffset*CV_ELEM_SIZE(type), img->widthStep )); } else /* pixel order */ { int type = CV_MAKETYPE( depth, img->nChannels ); coi = img->roi->coi; if( img->nChannels > CV_CN_MAX ) CV_ERROR( CV_BadNumChannels, "The image is interleaved and has over CV_CN_MAX channels" ); CV_CALL( cvInitMatHeader( mat, img->roi->height, img->roi->width, type, img->imageData + img->roi->yOffset*img->widthStep + img->roi->xOffset*CV_ELEM_SIZE(type), img->widthStep )); } } else { int type = CV_MAKETYPE( depth, img->nChannels ); if( order != IPL_DATA_ORDER_PIXEL ) CV_ERROR( CV_StsBadFlag, "Pixel order should be used with coi == 0" ); CV_CALL( cvInitMatHeader( mat, img->height, img->width, type, img->imageData, img->widthStep )); } result = mat; } else if( allowND && CV_IS_MATND_HDR(src) ) { CvMatND* matnd = (CvMatND*)src; int i; int size1 = matnd->dim[0].size, size2 = 1; if( !src->data.ptr ) CV_ERROR( CV_StsNullPtr, "Input array has NULL data pointer" ); if( !CV_IS_MAT_CONT( matnd->type )) CV_ERROR( CV_StsBadArg, "Only continuous nD arrays are supported here" ); if( matnd->dims > 2 ) for( i = 1; i < matnd->dims; i++ ) size2 *= matnd->dim[i].size; else size2 = matnd->dims == 1 ? 1 : matnd->dim[1].size; mat->refcount = 0; mat->hdr_refcount = 0; mat->data.ptr = matnd->data.ptr; mat->rows = size1; mat->cols = size2; mat->type = CV_MAT_TYPE(matnd->type) | CV_MAT_MAGIC_VAL | CV_MAT_CONT_FLAG; mat->step = size2*CV_ELEM_SIZE(matnd->type); mat->step &= size1 > 1 ? -1 : 0; icvCheckHuge( mat ); result = mat; } else { CV_ERROR( CV_StsBadFlag, "Unrecognized or unsupported array type" ); } __END__; if( pCOI ) *pCOI = coi; return result; } CV_IMPL CvArr* cvReshapeMatND( const CvArr* arr, int sizeof_header, CvArr* _header, int new_cn, int new_dims, int* new_sizes ) { CvArr* result = 0; CV_FUNCNAME( "cvReshapeMatND" ); __BEGIN__; int dims, coi = 0; if( !arr || !_header ) CV_ERROR( CV_StsNullPtr, "NULL pointer to array or destination header" ); if( new_cn == 0 && new_dims == 0 ) CV_ERROR( CV_StsBadArg, "None of array parameters is changed: dummy call?" ); CV_CALL( dims = cvGetDims( arr )); if( new_dims == 0 ) { new_sizes = 0; new_dims = dims; } else if( new_dims == 1 ) { new_sizes = 0; } else { if( new_dims <= 0 || new_dims > CV_MAX_DIM ) CV_ERROR( CV_StsOutOfRange, "Non-positive or too large number of dimensions" ); if( !new_sizes ) CV_ERROR( CV_StsNullPtr, "New dimension sizes are not specified" ); } if( new_dims <= 2 ) { CvMat* mat = (CvMat*)arr; CvMat* header = (CvMat*)_header; int* refcount = 0; int hdr_refcount = 0; int total_width, new_rows, cn; if( sizeof_header != sizeof(CvMat)) CV_ERROR( CV_StsBadArg, "The header should be CvMat" ); if( mat == header ) { refcount = mat->refcount; hdr_refcount = mat->hdr_refcount; } else if( !CV_IS_MAT( mat )) CV_CALL( mat = cvGetMat( mat, header, &coi, 1 )); cn = CV_MAT_CN( mat->type ); total_width = mat->cols * cn; if( new_cn == 0 ) new_cn = cn; if( new_sizes ) new_rows = new_sizes[0]; else if( new_dims == 1 ) new_rows = total_width*mat->rows/new_cn; else { new_rows = mat->rows; if( new_cn > total_width ) new_rows = mat->rows * total_width / new_cn; } if( new_rows != mat->rows ) { int total_size = total_width * mat->rows; if( !CV_IS_MAT_CONT( mat->type )) CV_ERROR( CV_BadStep, "The matrix is not continuous so the number of rows can not be changed" ); total_width = total_size / new_rows; if( total_width * new_rows != total_size ) CV_ERROR( CV_StsBadArg, "The total number of matrix elements " "is not divisible by the new number of rows" ); } header->rows = new_rows; header->cols = total_width / new_cn; if( header->cols * new_cn != total_width || (new_sizes && header->cols != new_sizes[1]) ) CV_ERROR( CV_StsBadArg, "The total matrix width is not " "divisible by the new number of columns" ); header->type = CV_MAKETYPE( mat->type & ~CV_MAT_CN_MASK, new_cn ); header->step = header->cols * CV_ELEM_SIZE(mat->type); header->step &= new_rows > 1 ? -1 : 0; header->refcount = refcount; header->hdr_refcount = hdr_refcount; } else { CvMatND* header = (CvMatND*)_header; if( sizeof_header != sizeof(CvMatND)) CV_ERROR( CV_StsBadSize, "The header should be CvMatND" ); if( !new_sizes ) { if( !CV_IS_MATND( arr )) CV_ERROR( CV_StsBadArg, "The source array must be CvMatND" ); { CvMatND* mat = (CvMatND*)arr; assert( new_cn > 0 ); int last_dim_size = mat->dim[mat->dims-1].size*CV_MAT_CN(mat->type); int new_size = last_dim_size/new_cn; if( new_size*new_cn != last_dim_size ) CV_ERROR( CV_StsBadArg, "The last dimension full size is not divisible by new number of channels"); if( mat != header ) { memcpy( header, mat, sizeof(*header)); header->refcount = 0; header->hdr_refcount = 0; } header->dim[header->dims-1].size = new_size; header->type = CV_MAKETYPE( header->type & ~CV_MAT_CN_MASK, new_cn ); } } else { CvMatND stub; CvMatND* mat = (CvMatND*)arr; int i, size1, size2; int step; if( new_cn != 0 ) CV_ERROR( CV_StsBadArg, "Simultaneous change of shape and number of channels is not supported. " "Do it by 2 separate calls" ); if( !CV_IS_MATND( mat )) { CV_CALL( cvGetMatND( mat, &stub, &coi )); mat = &stub; } if( CV_IS_MAT_CONT( mat->type )) CV_ERROR( CV_StsBadArg, "Non-continuous nD arrays are not supported" ); size1 = mat->dim[0].size; for( i = 1; i < dims; i++ ) size1 *= mat->dim[i].size; size2 = 1; for( i = 0; i < new_dims; i++ ) { if( new_sizes[i] <= 0 ) CV_ERROR( CV_StsBadSize, "One of new dimension sizes is non-positive" ); size2 *= new_sizes[i]; } if( size1 != size2 ) CV_ERROR( CV_StsBadSize, "Number of elements in the original and reshaped array is different" ); if( header != mat ) { header->refcount = 0; header->hdr_refcount = 0; } header->dims = new_dims; header->type = mat->type; header->data.ptr = mat->data.ptr; step = CV_ELEM_SIZE(header->type); for( i = new_dims - 1; i >= 0; i-- ) { header->dim[i].size = new_sizes[i]; header->dim[i].step = step; step *= new_sizes[i]; } } } if( !coi ) CV_ERROR( CV_BadCOI, "COI is not supported by this operation" ); result = _header; __END__; return result; } CV_IMPL CvMat* cvReshape( const CvArr* array, CvMat* header, int new_cn, int new_rows ) { CvMat* result = 0; CV_FUNCNAME( "cvReshape" ); __BEGIN__; CvMat *mat = (CvMat*)array; int total_width, new_width; if( !header ) CV_ERROR( CV_StsNullPtr, "" ); if( !CV_IS_MAT( mat )) { int coi = 0; CV_CALL( mat = cvGetMat( mat, header, &coi, 1 )); if( coi ) CV_ERROR( CV_BadCOI, "COI is not supported" ); } if( new_cn == 0 ) new_cn = CV_MAT_CN(mat->type); else if( (unsigned)(new_cn - 1) > 3 ) CV_ERROR( CV_BadNumChannels, "" ); if( mat != header ) { int hdr_refcount = header->hdr_refcount; *header = *mat; header->refcount = 0; header->hdr_refcount = hdr_refcount; } total_width = mat->cols * CV_MAT_CN( mat->type ); if( (new_cn > total_width || total_width % new_cn != 0) && new_rows == 0 ) new_rows = mat->rows * total_width / new_cn; if( new_rows == 0 || new_rows == mat->rows ) { header->rows = mat->rows; header->step = mat->step; } else { int total_size = total_width * mat->rows; if( !CV_IS_MAT_CONT( mat->type )) CV_ERROR( CV_BadStep, "The matrix is not continuous, thus its number of rows can not be changed" ); if( (unsigned)new_rows > (unsigned)total_size ) CV_ERROR( CV_StsOutOfRange, "Bad new number of rows" ); total_width = total_size / new_rows; if( total_width * new_rows != total_size ) CV_ERROR( CV_StsBadArg, "The total number of matrix elements " "is not divisible by the new number of rows" ); header->rows = new_rows; header->step = total_width * CV_ELEM_SIZE1(mat->type); } new_width = total_width / new_cn; if( new_width * new_cn != total_width ) CV_ERROR( CV_BadNumChannels, "The total width is not divisible by the new number of channels" ); header->cols = new_width; header->type = CV_MAKETYPE( mat->type & ~CV_MAT_CN_MASK, new_cn ); result = header; __END__; return result; } // convert array (CvMat or IplImage) to IplImage CV_IMPL IplImage* cvGetImage( const CvArr* array, IplImage* img ) { IplImage* result = 0; const IplImage* src = (const IplImage*)array; CV_FUNCNAME( "cvGetImage" ); __BEGIN__; int depth; if( !img ) CV_ERROR_FROM_CODE( CV_StsNullPtr ); if( !CV_IS_IMAGE_HDR(src) ) { const CvMat* mat = (const CvMat*)src; if( !CV_IS_MAT_HDR(mat)) CV_ERROR_FROM_CODE( CV_StsBadFlag ); if( mat->data.ptr == 0 ) CV_ERROR_FROM_CODE( CV_StsNullPtr ); depth = cvCvToIplDepth(mat->type); cvInitImageHeader( img, cvSize(mat->cols, mat->rows), depth, CV_MAT_CN(mat->type) ); cvSetData( img, mat->data.ptr, mat->step ); result = img; } else { result = (IplImage*)src; } __END__; return result; } /****************************************************************************************\ * IplImage-specific functions * \****************************************************************************************/ static IplROI* icvCreateROI( int coi, int xOffset, int yOffset, int width, int height ) { IplROI *roi = 0; CV_FUNCNAME( "icvCreateROI" ); __BEGIN__; if( !CvIPL.createROI ) { CV_CALL( roi = (IplROI*)cvAlloc( sizeof(*roi))); roi->coi = coi; roi->xOffset = xOffset; roi->yOffset = yOffset; roi->width = width; roi->height = height; } else { roi = CvIPL.createROI( coi, xOffset, yOffset, width, height ); } __END__; return roi; } static void icvGetColorModel( int nchannels, const char** colorModel, const char** channelSeq ) { static const char* tab[][2] = { {"GRAY", "GRAY"}, {"",""}, {"RGB","BGR"}, {"RGB","BGRA"} }; nchannels--; *colorModel = *channelSeq = ""; if( (unsigned)nchannels <= 3 ) { *colorModel = tab[nchannels][0]; *channelSeq = tab[nchannels][1]; } } // create IplImage header CV_IMPL IplImage * cvCreateImageHeader( CvSize size, int depth, int channels ) { IplImage *img = 0; CV_FUNCNAME( "cvCreateImageHeader" ); __BEGIN__; if( !CvIPL.createHeader ) { CV_CALL( img = (IplImage *)cvAlloc( sizeof( *img ))); CV_CALL( cvInitImageHeader( img, size, depth, channels, IPL_ORIGIN_TL, CV_DEFAULT_IMAGE_ROW_ALIGN )); } else { const char *colorModel, *channelSeq; icvGetColorModel( channels, &colorModel, &channelSeq ); img = CvIPL.createHeader( channels, 0, depth, (char*)colorModel, (char*)channelSeq, IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL, CV_DEFAULT_IMAGE_ROW_ALIGN, size.width, size.height, 0, 0, 0, 0 ); } __END__; if( cvGetErrStatus() < 0 && img ) cvReleaseImageHeader( &img ); return img; } // create IplImage header and allocate underlying data CV_IMPL IplImage * cvCreateImage( CvSize size, int depth, int channels ) { IplImage *img = 0; CV_FUNCNAME( "cvCreateImage" ); __BEGIN__; CV_CALL( img = cvCreateImageHeader( size, depth, channels )); assert( img ); CV_CALL( cvCreateData( img )); __END__; if( cvGetErrStatus() < 0 ) cvReleaseImage( &img ); return img; } // initalize IplImage header, allocated by the user CV_IMPL IplImage* cvInitImageHeader( IplImage * image, CvSize size, int depth, int channels, int origin, int align ) { IplImage* result = 0; CV_FUNCNAME( "cvInitImageHeader" ); __BEGIN__; const char *colorModel, *channelSeq; if( !image ) CV_ERROR( CV_HeaderIsNull, "null pointer to header" ); memset( image, 0, sizeof( *image )); image->nSize = sizeof( *image ); CV_CALL( icvGetColorModel( channels, &colorModel, &channelSeq )); strncpy( image->colorModel, colorModel, 4 ); strncpy( image->channelSeq, channelSeq, 4 ); if( size.width < 0 || size.height < 0 ) CV_ERROR( CV_BadROISize, "Bad input roi" ); if( (depth != (int)IPL_DEPTH_1U && depth != (int)IPL_DEPTH_8U && depth != (int)IPL_DEPTH_8S && depth != (int)IPL_DEPTH_16U && depth != (int)IPL_DEPTH_16S && depth != (int)IPL_DEPTH_32S && depth != (int)IPL_DEPTH_32F && depth != (int)IPL_DEPTH_64F) || channels < 0 ) CV_ERROR( CV_BadDepth, "Unsupported format" ); if( origin != CV_ORIGIN_BL && origin != CV_ORIGIN_TL ) CV_ERROR( CV_BadOrigin, "Bad input origin" ); if( align != 4 && align != 8 ) CV_ERROR( CV_BadAlign, "Bad input align" ); image->width = size.width; image->height = size.height; if( image->roi ) { image->roi->coi = 0; image->roi->xOffset = image->roi->yOffset = 0; image->roi->width = size.width; image->roi->height = size.height; } image->nChannels = MAX( channels, 1 ); image->depth = depth; image->align = align; image->widthStep = (((image->width * image->nChannels * (image->depth & ~IPL_DEPTH_SIGN) + 7)/8)+ align - 1) & (~(align - 1)); image->origin = origin; image->imageSize = image->widthStep * image->height; result = image; __END__; return result; } CV_IMPL void cvReleaseImageHeader( IplImage** image ) { CV_FUNCNAME( "cvReleaseImageHeader" ); __BEGIN__; if( !image ) CV_ERROR( CV_StsNullPtr, "" ); if( *image ) { IplImage* img = *image; *image = 0; if( !CvIPL.deallocate ) { cvFree( &img->roi ); cvFree( &img ); } else { CvIPL.deallocate( img, IPL_IMAGE_HEADER | IPL_IMAGE_ROI ); } } __END__; } CV_IMPL void cvReleaseImage( IplImage ** image ) { CV_FUNCNAME( "cvReleaseImage" ); __BEGIN__ if( !image ) CV_ERROR( CV_StsNullPtr, "" ); if( *image ) { IplImage* img = *image; *image = 0; cvReleaseData( img ); cvReleaseImageHeader( &img ); } __END__; } CV_IMPL void cvSetImageROI( IplImage* image, CvRect rect ) { CV_FUNCNAME( "cvSetImageROI" ); __BEGIN__; if( !image ) CV_ERROR( CV_HeaderIsNull, "" ); if( rect.x > image->width || rect.y > image->height ) CV_ERROR( CV_BadROISize, "" ); if( rect.x + rect.width < 0 || rect.y + rect.height < 0 ) CV_ERROR( CV_BadROISize, "" ); if( rect.x < 0 ) { rect.width += rect.x; rect.x = 0; } if( rect.y < 0 ) { rect.height += rect.y; rect.y = 0; } if( rect.x + rect.width > image->width ) rect.width = image->width - rect.x; if( rect.y + rect.height > image->height ) rect.height = image->height - rect.y; if( image->roi ) { image->roi->xOffset = rect.x; image->roi->yOffset = rect.y; image->roi->width = rect.width; image->roi->height = rect.height; } else { CV_CALL( image->roi = icvCreateROI( 0, rect.x, rect.y, rect.width, rect.height )); } __END__; } CV_IMPL void cvResetImageROI( IplImage* image ) { CV_FUNCNAME( "cvResetImageROI" ); __BEGIN__; if( !image ) CV_ERROR( CV_HeaderIsNull, "" ); if( image->roi ) { if( !CvIPL.deallocate ) { cvFree( &image->roi ); } else { CvIPL.deallocate( image, IPL_IMAGE_ROI ); image->roi = 0; } } __END__; } CV_IMPL CvRect cvGetImageROI( const IplImage* img ) { CvRect rect = { 0, 0, 0, 0 }; CV_FUNCNAME( "cvGetImageROI" ); __BEGIN__; if( !img ) CV_ERROR( CV_StsNullPtr, "Null pointer to image" ); if( img->roi ) rect = cvRect( img->roi->xOffset, img->roi->yOffset, img->roi->width, img->roi->height ); else rect = cvRect( 0, 0, img->width, img->height ); __END__; return rect; } CV_IMPL void cvSetImageCOI( IplImage* image, int coi ) { CV_FUNCNAME( "cvSetImageCOI" ); __BEGIN__; if( !image ) CV_ERROR( CV_HeaderIsNull, "" ); if( (unsigned)coi > (unsigned)(image->nChannels) ) CV_ERROR( CV_BadCOI, "" ); if( image->roi || coi != 0 ) { if( image->roi ) { image->roi->coi = coi; } else { CV_CALL( image->roi = icvCreateROI( coi, 0, 0, image->width, image->height )); } } __END__; } CV_IMPL int cvGetImageCOI( const IplImage* image ) { int coi = -1; CV_FUNCNAME( "cvGetImageCOI" ); __BEGIN__; if( !image ) CV_ERROR( CV_HeaderIsNull, "" ); coi = image->roi ? image->roi->coi : 0; __END__; return coi; } 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" ); if( !CvIPL.cloneImage ) { 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 ); } } else { dst = CvIPL.cloneImage( src ); } __END__; return dst; } /****************************************************************************************\ * Additional operations on CvTermCriteria * \****************************************************************************************/ CV_IMPL CvTermCriteria cvCheckTermCriteria( CvTermCriteria criteria, double default_eps, int default_max_iters ) { CV_FUNCNAME( "cvCheckTermCriteria" ); CvTermCriteria crit; crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS; crit.max_iter = default_max_iters; crit.epsilon = (float)default_eps; __BEGIN__; if( (criteria.type & ~(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER)) != 0 ) CV_ERROR( CV_StsBadArg, "Unknown type of term criteria" ); if( (criteria.type & CV_TERMCRIT_ITER) != 0 ) { if( criteria.max_iter <= 0 ) CV_ERROR( CV_StsBadArg, "Iterations flag is set and maximum number of iterations is <= 0" ); crit.max_iter = criteria.max_iter; } if( (criteria.type & CV_TERMCRIT_EPS) != 0 ) { if( criteria.epsilon < 0 ) CV_ERROR( CV_StsBadArg, "Accuracy flag is set and epsilon is < 0" ); crit.epsilon = criteria.epsilon; } if( (criteria.type & (CV_TERMCRIT_EPS | CV_TERMCRIT_ITER)) == 0 ) CV_ERROR( CV_StsBadArg, "Neither accuracy nor maximum iterations " "number flags are set in criteria type" ); __END__; crit.epsilon = (float)MAX( 0, crit.epsilon ); crit.max_iter = MAX( 1, crit.max_iter ); return crit; } /* End of file. */