#include "precomp.hpp"

#define CV_ORIGIN_TL 0

#define CV_ORIGIN_BL 1

#define CV_DEFAULT_IMAGE_ROW_ALIGN 4

static struct

{

Cv_iplCreateImageHeader createHeader;

Cv_iplAllocateImageData allocateData;

Cv_iplDeallocate deallocate;

Cv_iplCreateROI createROI;

Cv_iplCloneImage cloneImage;

}

CvIPL;

CV_IMPL void

cvSetIPLAllocators( Cv_iplCreateImageHeader createHeader,

}

CV_IMPL CvMat*

cvCreateMat( int height, int width, int type )

{

CvMat* arr = cvCreateMatHeader( height, width, type );

cvCreateData( arr );

return arr;

}

static void icvCheckHuge( CvMat* arr )

}

CV_IMPL CvMat*

cvCreateMatHeader( int rows, int cols, int type )

{

type = CV_MAT_TYPE(type);

if( rows < 0 || cols < 0 )

CV_Error( CV_StsBadSize, "Non-positive width or height" );

int min_step = CV_ELEM_SIZE(type);

if( min_step <= 0 )

CV_Error( CV_StsUnsupportedFormat, "Invalid matrix type" );

min_step *= cols;

CvMat* arr = (CvMat*)cvAlloc( sizeof(*arr));

arr->step = min_step;

arr->type = CV_MAT_MAGIC_VAL | type | CV_MAT_CONT_FLAG;

arr->rows = rows;

arr->cols = cols;

arr->data.ptr = 0;

arr->refcount = 0;

arr->hdr_refcount = 1;

icvCheckHuge( arr );

return arr;

}

CV_IMPL CvMat*

cvInitMatHeader( CvMat* arr, int rows, int cols,

int type, void* data, int step )

{

if( !arr )

CV_Error( CV_StsNullPtr, "" );

if( (unsigned)CV_MAT_DEPTH(type) > CV_DEPTH_MAX )

CV_Error( 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;

int pix_size = CV_ELEM_SIZE(type);

int min_step = arr->cols*pix_size;

if( step != CV_AUTOSTEP && step != 0 )

{

if( step < min_step )

CV_Error( CV_BadStep, "" );

arr->step = step;

}

else

{

arr->step = min_step;

}

arr->type = CV_MAT_MAGIC_VAL | type |

(arr->rows == 1 || arr->step == min_step ? CV_MAT_CONT_FLAG : 0);

icvCheckHuge( arr );

return arr;

}

CV_IMPL void

cvReleaseMat( CvMat** array )

}

CV_IMPL CvMat*

cvCloneMat( const CvMat* src )

{

if( !CV_IS_MAT_HDR( src ))

CV_Error( CV_StsBadArg, "Bad CvMat header" );

CvMat* dst = cvCreateMatHeader( src->rows, src->cols, src->type );

if( src->data.ptr )

{

cvCreateData( dst );

cvCopy( src, dst );

}

return dst;

}

CV_IMPL CvMatND*

cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes,

int type, void* data )

{

type = CV_MAT_TYPE(type);

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 <sizes> pointer" );

if( dims <= 0 || dims > CV_MAX_DIM )

CV_Error( CV_StsOutOfRange,

"non-positive or too large number of dimensions" );

for( int 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;

return mat;

}

CV_IMPL CvMatND*

cvCreateMatND( int dims, const int* sizes, int type )

{

CvMatND* arr = cvCreateMatNDHeader( dims, sizes, type );

cvCreateData( arr );

return arr;

}

CV_IMPL CvMatND*

cvCreateMatNDHeader( int dims, const int* sizes, int type )

{

if( dims <= 0 || dims > CV_MAX_DIM )

CV_Error( CV_StsOutOfRange,

"non-positive or too large number of dimensions" );

CvMatND* arr = (CvMatND*)cvAlloc( sizeof(*arr) );

cvInitMatNDHeader( arr, dims, sizes, type, 0 );

arr->hdr_refcount = 1;

return arr;

}

CV_IMPL CvMatND*

cvCloneMatND( const CvMatND* src )

{

if( !CV_IS_MATND_HDR( src ))

CV_Error( CV_StsBadArg, "Bad CvMatND header" );

CV_Assert( src->dims <= CV_MAX_DIM );

int sizes[CV_MAX_DIM];

for( int i = 0; i < src->dims; i++ )

sizes[i] = src->dim[i].size;

CvMatND* dst = cvCreateMatNDHeader( src->dims, sizes, src->type );

if( src->data.ptr )

{

cvCreateData( dst );

cv::Mat _src = cv::cvarrToMat(src);

cv::Mat _dst = cv::cvarrToMat(dst);

uchar* data0 = dst->data.ptr;

_src.copyTo(_dst);

CV_Assert(_dst.data == data0);

//cvCopy( src, dst );

}

return dst;

}

static CvMatND*

cvGetMatND( const CvArr* arr, CvMatND* matnd, int* coi )

{

CvMatND* result = 0;

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 ))

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;

}

return result;

}

CV_IMPL int

cvInitNArrayIterator( int count, CvArr** arrs,

}

CV_IMPL int cvNextNArraySlice( CvNArrayIterator* iterator )

}

CV_IMPL CvSparseMat*

cvCreateSparseMat( int dims, const int* sizes, int type )

{

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 )

CV_Error( CV_StsOutOfRange, "bad number of dimensions" );

if( !sizes )

CV_Error( CV_StsNullPtr, "NULL <sizes> pointer" );

for( i = 0; i < dims; i++ )

{

if( sizes[i] <= 0 )

CV_Error( CV_StsBadSize, "one of dimesion sizes is non-positive" );

}

CvSparseMat* 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));

storage = cvCreateMemStorage( CV_SPARSE_MAT_BLOCK );

arr->heap = cvCreateSet( 0, sizeof(CvSet), size, storage );

arr->hashsize = CV_SPARSE_HASH_SIZE0;

size = arr->hashsize*sizeof(arr->hashtable[0]);

arr->hashtable = (void**)cvAlloc( size );

memset( arr->hashtable, 0, size );

return arr;

}

CV_IMPL void

cvReleaseSparseMat( CvSparseMat** array )

}

CV_IMPL CvSparseMat*

cvCloneSparseMat( const CvSparseMat* src )

{

if( !CV_IS_SPARSE_MAT_HDR(src) )

CV_Error( CV_StsBadArg, "Invalid sparse array header" );

CvSparseMat* dst = cvCreateSparseMat( src->dims, src->size, src->type );

cvCopy( src, dst );

return dst;

}

CvSparseNode*

cvInitSparseMatIterator( const CvSparseMat* mat, CvSparseMatIterator* iterator )

{

CvSparseNode* node = 0;

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;

return node;

}

#define ICV_SPARSE_MAT_HASH_MULTIPLIER cv::SparseMat::HASH_SCALE

static uchar*

icvGetNodePtr( CvSparseMat* mat, const int* idx, int* _type,

int create_node, unsigned* precalc_hashval )

{

uchar* ptr = 0;

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;

if( create_node >= -1 )

{

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

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;

memcpy(CV_NODE_IDX(mat,node), idx, mat->dims*sizeof(idx[0]));

ptr = (uchar*)CV_NODE_VAL(mat,node);

if( create_node > 0 )

memset( ptr, 0, CV_ELEM_SIZE(mat->type));

}

if( _type )

*_type = CV_MAT_TYPE(mat->type);

return ptr;

}

static void

icvDeleteNode( CvSparseMat* mat, const int* idx, unsigned* precalc_hashval )

}

CV_IMPL void

cvCreateData( CvArr* arr )

}

CV_IMPL void

cvSetData( CvArr* arr, void* data, int step )

}

CV_IMPL void

cvReleaseData( CvArr* arr )