opencv矩阵操作函数源代码

/* / / / 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() step*arr-rows INT_MAX ) arr-type / 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 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() CV_DEPTH_MAX ) CV_ERROR_FROM_CODE( CV_BadNumChannels ); if( rows 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 cols*pix_size if( step != CV_AUTOSTEP 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) *array = 0; cvDecRefData( arr ); cvFree( _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 CV_MAX_DIM ) CV_ERROR( CV_StsOutOfRange, “non-positive or too large number of dimensions“ ); for( i = dims - 1; i = 0; i- ) if( sizesi dimi.size = sizesi; if( step INT_MAX ) CV_ERROR( CV_StsOutOfRange, “The array is too big“ ); mat-dimi.step = (int)step; step *= sizesi; mat-type = CV_MATND_MAGIC_VAL | (step dims = dims; mat-data.ptr = (uchar*)data; mat-refcount = 0; mat-hdr_refcount = 0; result = mat; _END_; if( cvGetErrStatus() 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() 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() dims*sizeof(sizes0) ); for( i = 0; i dims; i+ ) sizesi = src-dimi.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, 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-dim0.size = mat-rows; matnd-dim0.step = mat-step; matnd-dim1.size = mat-cols; matnd-dim1.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 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 hdri = hdr; if( i 0 ) if( hdr-dims != hdr0-dims ) CV_ERROR( CV_StsUnmatchedSizes, “Number of dimensions is the same for all arrays“ ); if( i dims; j+ ) if( hdr-dimj.size != hdr0-dimj.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-dimj.step ) break; step *= hdr-dimj.size; if( j = dim0 if( j dim0 ) dim0 = j; iterator-hdri = (CvMatND*)hdr; iterator-ptri = (uchar*)hdr-data.ptr; size = 1; for( j = hdr0-dims - 1; j dim0; j- ) size *= hdr0-dimj.size; dims = dim0 + 1; iterator-dims = dims; iterator-count = count; iterator-size = cvSize(size,1); for( i = 0; i stacki = hdr0-dimi.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 count; i+ ) iterator-ptri += iterator-hdri-dimdims-1.step; if( -iterator-stackdims-1 0 ) break; size = iterator-hdr0-dimdims-1.size; for( i = 0; i count; i+ ) iterator-ptri -= (size_t)size*iterator-hdri-dimdims-1.step; iterator-stackdims-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 CV_MAX_DIM_HEAP ) CV_ERROR( CV_StsOutOfRange, “bad number of dimensions“ ); if( !sizes ) CV_ERROR( CV_StsNullPtr, “NULL pointer“ ); for( i = 0; i size0); arr-type = CV_SPARSE_MAT_MAGIC_VAL | type; arr-dims = dims; arr-refcount = 0; arr-hdr_refcount = 1; memcpy( arr-size, sizes, dims*sizeof(sizes0); 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-hashtable0); CV_CALL( arr-hashtable = (void*)cvAlloc( size ); memset( arr-hashtable, 0, size ); _END_; if( cvGetErrStatus() heap-storage ); cvFree( cvFree( _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() mat = (CvSparseMat*)mat; iterator-node = 0; for( idx = 0; idx hashsize; idx+ ) if( mat-hashtableidx ) node = iterator-node = (CvSparseNode*)mat-hashtableidx; 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 dims; i+ ) int t = idxi; if( (unsigned)t = (unsigned)mat-sizei ) 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 hashval for( node = (CvSparseNode*)mat-hashtabletabidx; node != 0; node = node-next ) if( node-hashval = hashval ) int* nodeidx = CV_NODE_IDX(mat,node); for( i = 0; i dims; i+ ) if( idxi != nodeidxi ) break; if( i = mat-dims ) ptr = (uchar*)CV_NODE_VAL(mat,node); break; if( !ptr int newsize = MAX( mat-hashsize*2, CV_SPARSE_HASH_SIZE0); int newrawsize = newsize*sizeof(newtable0); CvSparseMatIterator iterator; assert( (newsize / resize hash table CV_CALL( newtable = (void*)cvAlloc( newrawsize ); memset( newtable, 0, newrawsize ); node = cvInitSparseMatIterator( mat, while( node ) CvSparseNode* next = cvGetNextSparseNode( int newidx = node-hashval node-next = (CvSparseNode*)newtablenewidx; newtablenewidx = node; node = next; cvFree( mat-hashtable = newtable; mat-hashsize = newsize; tabidx = hashval node = (CvSparseNode*)cvSetNew( mat-heap ); node-hashval = hashval; node-next = (CvSparseNode*)mat-hashtabletabidx; mat-hashtabletabidx = 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 dims; i+ ) int t = idxi; if( (unsigned)t = (unsigned)mat-sizei ) 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 hashval for( node = (CvSparseNode*)mat-hashtabletabidx; node != 0; prev = node, node = node-next ) if( node-hashval = hashval ) int* nodeidx = CV_NODE_IDX(mat,node); for( i = 0; i dims; i+ ) if( idxi != nodeidxi ) break; if( i = mat-dims ) break; if( node ) if( prev ) prev-next = node-next; else mat-hashtabletabidx = 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-dim0.size*(mat-dim0.step != 0 ? mat-dim0.step : total_size); else for( i = mat-dims - 1; i = 0; i- ) size_t size = (size_t)mat-dimi.step*mat-dimi.size; if( total_size 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-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 min_step = img-width*pix_size; if( step != CV_AUTOSTEP else img-widthStep = min_step; img-imageSize = img-widthStep * img-height; img-imageData = img-imageDataOrigin = (char*)data; if( (int)(size_t)data | step) 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-dimi.step = (int)cur_step; cur_step *= mat-dimi.size; else CV_ERROR( CV_StsBadArg, “unrecognized or unsupported array type“ ); _END_; / Deallocates arrays 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( 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