{

if(u->urefcount == 0 && u->refcount == 0)

{

deallocate(u);

}

int dims, const size_t sz[],

const size_t srcofs[], const size_t srcstep[],

const size_t dststep[]) const

{

if(!u)

return;

int isz[CV_MAX_DIM];

uchar* srcptr = u->data;

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

{

CV_Assert( sz[i] <= (size_t)INT_MAX );

if( sz[i] == 0 )

return;

if( srcofs )

srcptr += srcofs[i]*(i <= dims-2 ? srcstep[i] : 1);

isz[i] = (int)sz[i];

}

Mat src(dims, isz, CV_8U, srcptr, srcstep);

Mat dst(dims, isz, CV_8U, dstptr, dststep);

const Mat* arrays[] = { &src, &dst };

uchar* ptrs[2];

NAryMatIterator it(arrays, ptrs, 2);

size_t planesz = it.size;

for( size_t j = 0; j < it.nplanes; j++, ++it )

memcpy(ptrs[1], ptrs[0], planesz);

const size_t dstofs[], const size_t dststep[],

const size_t srcstep[]) const

{

if(!u)

return;

int isz[CV_MAX_DIM];

uchar* dstptr = u->data;

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

{

CV_Assert( sz[i] <= (size_t)INT_MAX );

if( sz[i] == 0 )

return;

if( dstofs )

dstptr += dstofs[i]*(i <= dims-2 ? dststep[i] : 1);

isz[i] = (int)sz[i];

}

Mat src(dims, isz, CV_8U, (void*)srcptr, srcstep);

Mat dst(dims, isz, CV_8U, dstptr, dststep);

const Mat* arrays[] = { &src, &dst };

uchar* ptrs[2];

NAryMatIterator it(arrays, ptrs, 2);

size_t planesz = it.size;

for( size_t j = 0; j < it.nplanes; j++, ++it )

memcpy(ptrs[1], ptrs[0], planesz);

const size_t srcofs[], const size_t srcstep[],

const size_t dstofs[], const size_t dststep[], bool /*sync*/) const

{

CV_INSTRUMENT_REGION()

if(!usrc || !udst)

return;

int isz[CV_MAX_DIM];

uchar* srcptr = usrc->data;

uchar* dstptr = udst->data;

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

{

CV_Assert( sz[i] <= (size_t)INT_MAX );

if( sz[i] == 0 )

return;

if( srcofs )

srcptr += srcofs[i]*(i <= dims-2 ? srcstep[i] : 1);

if( dstofs )

dstptr += dstofs[i]*(i <= dims-2 ? dststep[i] : 1);

isz[i] = (int)sz[i];

}

Mat src(dims, isz, CV_8U, srcptr, srcstep);

Mat dst(dims, isz, CV_8U, dstptr, dststep);

const Mat* arrays[] = { &src, &dst };

uchar* ptrs[2];

NAryMatIterator it(arrays, ptrs, 2);

size_t planesz = it.size;

for( size_t j = 0; j < it.nplanes; j++, ++it )

memcpy(ptrs[1], ptrs[0], planesz);

{

UMatData* allocate(int dims, const int* sizes, int type,

void* data0, size_t* step, int /*flags*/, UMatUsageFlags /*usageFlags*/) const

{

size_t total = CV_ELEM_SIZE(type);

for( int i = dims-1; i >= 0; i-- )

{

if( step )

{

if( data0 && step[i] != CV_AUTOSTEP )

{

CV_Assert(total <= step[i]);

total = step[i];

}

else

step[i] = total;

}

total *= sizes[i];

}

uchar* data = data0 ? (uchar*)data0 : (uchar*)fastMalloc(total);

UMatData* u = new UMatData(this);

u->data = u->origdata = data;

u->size = total;

if(data0)

u->flags |= UMatData::USER_ALLOCATED;

return u;

}

bool allocate(UMatData* u, int /*accessFlags*/, UMatUsageFlags /*usageFlags*/) const

{

if(!u) return false;

return true;

}

void deallocate(UMatData* u) const

{

if(!u)

return;

CV_Assert(u->urefcount == 0);

CV_Assert(u->refcount == 0);

if( !(u->flags & UMatData::USER_ALLOCATED) )

{

fastFree(u->origdata);

u->origdata = 0;

}

delete u;

}

{

std::swap(a.flags, b.flags);

std::swap(a.dims, b.dims);

std::swap(a.rows, b.rows);

std::swap(a.cols, b.cols);

std::swap(a.data, b.data);

std::swap(a.datastart, b.datastart);

std::swap(a.dataend, b.dataend);

std::swap(a.datalimit, b.datalimit);

std::swap(a.allocator, b.allocator);

std::swap(a.u, b.u);

std::swap(a.size.p, b.size.p);

std::swap(a.step.p, b.step.p);

std::swap(a.step.buf[0], b.step.buf[0]);

std::swap(a.step.buf[1], b.step.buf[1]);

if( a.step.p == b.step.buf )

{

a.step.p = a.step.buf;

a.size.p = &a.rows;

}

if( b.step.p == a.step.buf )

{

b.step.p = b.step.buf;

b.size.p = &b.rows;

}

const size_t* _steps, bool autoSteps=false )

{

CV_Assert( 0 <= _dims && _dims <= CV_MAX_DIM );

if( m.dims != _dims )

{

if( m.step.p != m.step.buf )

{

fastFree(m.step.p);

m.step.p = m.step.buf;

m.size.p = &m.rows;

}

if( _dims > 2 )

{

m.step.p = (size_t*)fastMalloc(_dims*sizeof(m.step.p[0]) + (_dims+1)*sizeof(m.size.p[0]));

m.size.p = (int*)(m.step.p + _dims) + 1;

m.size.p[-1] = _dims;

m.rows = m.cols = -1;

}

}

m.dims = _dims;

if( !_sz )

return;

size_t esz = CV_ELEM_SIZE(m.flags), esz1 = CV_ELEM_SIZE1(m.flags), total = esz;

for( int i = _dims-1; i >= 0; i-- )

{

int s = _sz[i];

CV_Assert( s >= 0 );

m.size.p[i] = s;

if( _steps )

{

if (_steps[i] % esz1 != 0)

{

CV_Error(Error::BadStep, "Step must be a multiple of esz1");

}

m.step.p[i] = i < _dims-1 ? _steps[i] : esz;

}

else if( autoSteps )

{

m.step.p[i] = total;

int64 total1 = (int64)total*s;

if( (uint64)total1 != (size_t)total1 )

CV_Error( CV_StsOutOfRange, "The total matrix size does not fit to \"size_t\" type" );

total = (size_t)total1;

}

}

if( _dims == 1 )

{

m.dims = 2;

m.cols = 1;

m.step[1] = esz;

}

{

int i, j;

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

{

if( m.size[i] > 1 )

break;

}

for( j = m.dims-1; j > i; j-- )

{

if( m.step[j]*m.size[j] < m.step[j-1] )

break;

}

uint64 t = (uint64)m.step[0]*m.size[0];

if( j <= i && t == (size_t)t )

m.flags |= Mat::CONTINUOUS_FLAG;

else

m.flags &= ~Mat::CONTINUOUS_FLAG;

{

updateContinuityFlag(m);

int d = m.dims;

if( d > 2 )

m.rows = m.cols = -1;

if(m.u)

m.datastart = m.data = m.u->data;

if( m.data )

{

m.datalimit = m.datastart + m.size[0]*m.step[0];

if( m.size[0] > 0 )

{

m.dataend = m.ptr() + m.size[d-1]*m.step[d-1];

for( int i = 0; i < d-1; i++ )

m.dataend += (m.size[i] - 1)*m.step[i];

}

else

m.dataend = m.datalimit;

}

else

m.dataend = m.datalimit = 0;

{

int i;

CV_Assert(0 <= d && d <= CV_MAX_DIM && _sizes);

_type = CV_MAT_TYPE(_type);

if( data && (d == dims || (d == 1 && dims <= 2)) && _type == type() )

{

if( d == 2 && rows == _sizes[0] && cols == _sizes[1] )

return;

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

if( size[i] != _sizes[i] )

break;

if( i == d && (d > 1 || size[1] == 1))

return;

}

int _sizes_backup[CV_MAX_DIM]; // #5991

if (_sizes == (this->size.p))

{

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

_sizes_backup[i] = _sizes[i];

_sizes = _sizes_backup;

}

release();

if( d == 0 )

return;

flags = (_type & CV_MAT_TYPE_MASK) | MAGIC_VAL;

setSize(*this, d, _sizes, 0, true);

if( total() > 0 )

{

MatAllocator *a = allocator, *a0 = getDefaultAllocator();

#ifdef HAVE_TGPU

if( !a || a == tegra::getAllocator() )

a = tegra::getAllocator(d, _sizes, _type);

#endif

if(!a)

a = a0;

CV_TRY

{

u = a->allocate(dims, size, _type, 0, step.p, 0, USAGE_DEFAULT);

CV_Assert(u != 0);

}

CV_CATCH_ALL

{

if(a != a0)

u = a0->allocate(dims, size, _type, 0, step.p, 0, USAGE_DEFAULT);

CV_Assert(u != 0);

{

setSize(*this, m.dims, 0, 0);

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

{

size[i] = m.size[i];

step[i] = m.step[i];

}

{

if(u)

{

UMatData* u_ = u;

u = NULL;

(u_->currAllocator ? u_->currAllocator : allocator ? allocator : getDefaultAllocator())->unmap(u_);

}

: flags(MAGIC_VAL), dims(0), rows(0), cols(0), data(0), datastart(0), dataend(0),

datalimit(0), allocator(0), u(0), size(&rows)

{

CV_Assert( m.dims >= 2 );

if( m.dims > 2 )

{

AutoBuffer<Range> rs(m.dims);

rs[0] = _rowRange;

rs[1] = _colRange;

for( int i = 2; i < m.dims; i++ )

rs[i] = Range::all();

*this = m(rs);

return;

}

*this = m;

CV_TRY

{

if( _rowRange != Range::all() && _rowRange != Range(0,rows) )

{

CV_Assert( 0 <= _rowRange.start && _rowRange.start <= _rowRange.end

&& _rowRange.end <= m.rows );

rows = _rowRange.size();

data += step*_rowRange.start;

flags |= SUBMATRIX_FLAG;

}

if( _colRange != Range::all() && _colRange != Range(0,cols) )

{

CV_Assert( 0 <= _colRange.start && _colRange.start <= _colRange.end

&& _colRange.end <= m.cols );

cols = _colRange.size();

data += _colRange.start*elemSize();

flags &= cols < m.cols ? ~CONTINUOUS_FLAG : -1;

flags |= SUBMATRIX_FLAG;

}

}

CV_CATCH_ALL

{

release();

CV_RETHROW();

}

if( rows == 1 )

flags |= CONTINUOUS_FLAG;

if( rows <= 0 || cols <= 0 )

{

release();

rows = cols = 0;

}

}

Mat::Mat(const Mat& m, const Rect& roi)

: flags(m.flags), dims(2), rows(roi.height), cols(roi.width),

data(m.data + roi.y*m.step[0]),

datastart(m.datastart), dataend(m.dataend), datalimit(m.datalimit),

allocator(m.allocator), u(m.u), size(&rows)

{

CV_Assert( m.dims <= 2 );

flags &= roi.width < m.cols ? ~CONTINUOUS_FLAG : -1;

flags |= roi.height == 1 ? CONTINUOUS_FLAG : 0;

size_t esz = CV_ELEM_SIZE(flags);

data += roi.x*esz;

CV_Assert( 0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols &&

0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows );

if( u )

CV_XADD(&u->refcount, 1);

if( roi.width < m.cols || roi.height < m.rows )

flags |= SUBMATRIX_FLAG;

step[0] = m.step[0]; step[1] = esz;

if( rows <= 0 || cols <= 0 )

{

release();

rows = cols = 0;

}

}

Mat::Mat(int _dims, const int* _sizes, int _type, void* _data, const size_t* _steps)

: flags(MAGIC_VAL), dims(0), rows(0), cols(0), data(0), datastart(0), dataend(0),

datalimit(0), allocator(0), u(0), size(&rows)

{

flags |= CV_MAT_TYPE(_type);

datastart = data = (uchar*)_data;

setSize(*this, _dims, _sizes, _steps, true);

finalizeHdr(*this);

}

Mat::Mat(const std::vector<int>& _sizes, int _type, void* _data, const size_t* _steps)

: flags(MAGIC_VAL), dims(0), rows(0), cols(0), data(0), datastart(0), dataend(0),

datalimit(0), allocator(0), u(0), size(&rows)

{

flags |= CV_MAT_TYPE(_type);

datastart = data = (uchar*)_data;

setSize(*this, (int)_sizes.size(), _sizes.data(), _steps, true);

finalizeHdr(*this);

}

Mat::Mat(const Mat& m, const Range* ranges)

: flags(MAGIC_VAL), dims(0), rows(0), cols(0), data(0), datastart(0), dataend(0),

datalimit(0), allocator(0), u(0), size(&rows)

{

int d = m.dims;

CV_Assert(ranges);

for( int i = 0; i < d; i++ )

{

Range r = ranges[i];

CV_Assert( r == Range::all() || (0 <= r.start && r.start < r.end && r.end <= m.size[i]) );

}

*this = m;

for( int i = 0; i < d; i++ )

{

Range r = ranges[i];

if( r != Range::all() && r != Range(0, size.p[i]))

{

size.p[i] = r.end - r.start;

data += r.start*step.p[i];

flags |= SUBMATRIX_FLAG;

}

}

updateContinuityFlag(*this);

}

Mat::Mat(const Mat& m, const std::vector<Range>& ranges)

: flags(MAGIC_VAL), dims(0), rows(0), cols(0), data(0), datastart(0), dataend(0),

datalimit(0), allocator(0), u(0), size(&rows)

{

int d = m.dims;

CV_Assert((int)ranges.size() == d);

for (int i = 0; i < d; i++)

{

Range r = ranges[i];

CV_Assert(r == Range::all() || (0 <= r.start && r.start < r.end && r.end <= m.size[i]));

}

*this = m;

for (int i = 0; i < d; i++)

{

Range r = ranges[i];

if (r != Range::all() && r != Range(0, size.p[i]))

{

size.p[i] = r.end - r.start;

data += r.start*step.p[i];

flags |= SUBMATRIX_FLAG;

}

}

updateContinuityFlag(*this);

}

static Mat cvMatNDToMat(const CvMatND* m, bool copyData)

{

Mat thiz;

if( !m )

return thiz;

thiz.datastart = thiz.data = m->data.ptr;

thiz.flags |= CV_MAT_TYPE(m->type);

int _sizes[CV_MAX_DIM];

size_t _steps[CV_MAX_DIM];

int d = m->dims;

for( int i = 0; i < d; i++ )

{

_sizes[i] = m->dim[i].size;

_steps[i] = m->dim[i].step;

}

setSize(thiz, d, _sizes, _steps);

finalizeHdr(thiz);

if( copyData )

{

Mat temp(thiz);

thiz.release();

temp.copyTo(thiz);

}

return thiz;

}

static Mat cvMatToMat(const CvMat* m, bool copyData)

{

Mat thiz;

if( !m )

return thiz;

if( !copyData )

{

thiz.flags = Mat::MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG));

thiz.dims = 2;

thiz.rows = m->rows;

thiz.cols = m->cols;

thiz.datastart = thiz.data = m->data.ptr;

size_t esz = CV_ELEM_SIZE(m->type), minstep = thiz.cols*esz, _step = m->step;

if( _step == 0 )

_step = minstep;

thiz.datalimit = thiz.datastart + _step*thiz.rows;

thiz.dataend = thiz.datalimit - _step + minstep;

thiz.step[0] = _step; thiz.step[1] = esz;

}

else

{

thiz.datastart = thiz.dataend = thiz.data = 0;

Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);

}

return thiz;

}

static Mat iplImageToMat(const IplImage* img, bool copyData)

{

Mat m;

if( !img )

return m;

m.dims = 2;

CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);

int imgdepth = IPL2CV_DEPTH(img->depth);

size_t esz;

m.step[0] = img->widthStep;

if(!img->roi)

{

CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);

m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);

m.rows = img->height;

m.cols = img->width;

m.datastart = m.data = (uchar*)img->imageData;

esz = CV_ELEM_SIZE(m.flags);

}

else

{

CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);

bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;

m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);

m.rows = img->roi->height;

m.cols = img->roi->width;

esz = CV_ELEM_SIZE(m.flags);

m.datastart = m.data = (uchar*)img->imageData +

(selectedPlane ? (img->roi->coi - 1)*m.step*img->height : 0) +

img->roi->yOffset*m.step[0] + img->roi->xOffset*esz;

}

m.datalimit = m.datastart + m.step.p[0]*m.rows;

m.dataend = m.datastart + m.step.p[0]*(m.rows-1) + esz*m.cols;

m.flags |= (m.cols*esz == m.step.p[0] || m.rows == 1 ? Mat::CONTINUOUS_FLAG : 0);

m.step[1] = esz;

if( copyData )

{

Mat m2 = m;

m.release();

if( !img->roi || !img->roi->coi ||

img->dataOrder == IPL_DATA_ORDER_PLANE)

m2.copyTo(m);

else

{

int ch[] = {img->roi->coi - 1, 0};

m.create(m2.rows, m2.cols, m2.type());

mixChannels(&m2, 1, &m, 1, ch, 1);

}

}

return m;

}

Mat Mat::diag(int d) const

{

CV_Assert( dims <= 2 );

Mat m = *this;

size_t esz = elemSize();

int len;

if( d >= 0 )

{

len = std::min(cols - d, rows);

m.data += esz*d;

}

else

{

len = std::min(rows + d, cols);

m.data -= step[0]*d;

}

CV_DbgAssert( len > 0 );

m.size[0] = m.rows = len;

m.size[1] = m.cols = 1;

m.step[0] += (len > 1 ? esz : 0);

if( m.rows > 1 )

m.flags &= ~CONTINUOUS_FLAG;

else

m.flags |= CONTINUOUS_FLAG;

if( size() != Size(1,1) )

m.flags |= SUBMATRIX_FLAG;

return m;

}

void Mat::pop_back(size_t nelems)

{

CV_Assert( nelems <= (size_t)size.p[0] );

if( isSubmatrix() )

*this = rowRange(0, size.p[0] - (int)nelems);

else

{

size.p[0] -= (int)nelems;

dataend -= nelems*step.p[0];

/*if( size.p[0] <= 1 )

}

}

void Mat::push_back_(const void* elem)

{

int r = size.p[0];

if( isSubmatrix() || dataend + step.p[0] > datalimit )

reserve( std::max(r + 1, (r*3+1)/2) );

size_t esz = elemSize();

memcpy(data + r*step.p[0], elem, esz);

size.p[0] = r + 1;

dataend += step.p[0];

if( esz < step.p[0] )

flags &= ~CONTINUOUS_FLAG;

}

void Mat::reserve(size_t nelems)

{

const size_t MIN_SIZE = 64;

CV_Assert( (int)nelems >= 0 );

if( !isSubmatrix() && data + step.p[0]*nelems <= datalimit )

return;

int r = size.p[0];

if( (size_t)r >= nelems )

return;

size.p[0] = std::max((int)nelems, 1);

size_t newsize = total()*elemSize();

if( newsize < MIN_SIZE )

size.p[0] = (int)((MIN_SIZE + newsize - 1)*nelems/newsize);

Mat m(dims, size.p, type());

size.p[0] = r;

if( r > 0 )

{

Mat mpart = m.rowRange(0, r);

copyTo(mpart);

}

*this = m;

size.p[0] = r;

dataend = data + step.p[0]*r;

}

void Mat::reserveBuffer(size_t nbytes)

{

size_t esz = 1;

int mtype = CV_8UC1;

if (!empty())

{

if (!isSubmatrix() && data + nbytes <= dataend)//Should it be datalimit?

return;

esz = elemSize();

mtype = type();

}

size_t nelems = (nbytes - 1) / esz + 1;

#if SIZE_MAX > UINT_MAX

CV_Assert(nelems <= size_t(INT_MAX)*size_t(INT_MAX));

int newrows = nelems > size_t(INT_MAX) ? nelems > 0x400*size_t(INT_MAX) ? nelems > 0x100000 * size_t(INT_MAX) ? nelems > 0x40000000 * size_t(INT_MAX) ?

size_t(INT_MAX) : 0x40000000 : 0x100000 : 0x400 : 1;

#else

int newrows = nelems > size_t(INT_MAX) ? 2 : 1;

#endif

int newcols = (int)((nelems - 1) / newrows + 1);

create(newrows, newcols, mtype);

}

void Mat::resize(size_t nelems)

{

int saveRows = size.p[0];

if( saveRows == (int)nelems )

return;

CV_Assert( (int)nelems >= 0 );

if( isSubmatrix() || data + step.p[0]*nelems > datalimit )

reserve(nelems);

size.p[0] = (int)nelems;

dataend += (size.p[0] - saveRows)*step.p[0];

//updateContinuityFlag(*this);

}

void Mat::resize(size_t nelems, const Scalar& s)

{

int saveRows = size.p[0];

resize(nelems);

if( size.p[0] > saveRows )

{

Mat part = rowRange(saveRows, size.p[0]);

part = s;

}

}

void Mat::push_back(const Mat& elems)

{

int r = size.p[0], delta = elems.size.p[0];

if( delta == 0 )

return;

if( this == &elems )

{

Mat tmp = elems;

push_back(tmp);

return;

}

if( !data )

{

*this = elems.clone();

return;

}

size.p[0] = elems.size.p[0];

bool eq = size == elems.size;

size.p[0] = r;

if( !eq )

CV_Error(CV_StsUnmatchedSizes, "Pushed vector length is not equal to matrix row length");

if( type() != elems.type() )

CV_Error(CV_StsUnmatchedFormats, "Pushed vector type is not the same as matrix type");

if( isSubmatrix() || dataend + step.p[0]*delta > datalimit )

reserve( std::max(r + delta, (r*3+1)/2) );

size.p[0] += delta;

dataend += step.p[0]*delta;

//updateContinuityFlag(*this);

if( isContinuous() && elems.isContinuous() )

memcpy(data + r*step.p[0], elems.data, elems.total()*elems.elemSize());

else

{

Mat part = rowRange(r, r + delta);

elems.copyTo(part);

}

bool /*allowND*/, int coiMode, AutoBuffer<double>* abuf )

{

if( !arr )

return Mat();

if( CV_IS_MAT_HDR_Z(arr) )

return cvMatToMat((const CvMat*)arr, copyData);

if( CV_IS_MATND(arr) )

return cvMatNDToMat((const CvMatND*)arr, copyData );

if( CV_IS_IMAGE(arr) )

{

const IplImage* iplimg = (const IplImage*)arr;

if( coiMode == 0 && iplimg->roi && iplimg->roi->coi > 0 )

CV_Error(CV_BadCOI, "COI is not supported by the function");

return iplImageToMat(iplimg, copyData);

}

if( CV_IS_SEQ(arr) )

{

CvSeq* seq = (CvSeq*)arr;

int total = seq->total, type = CV_MAT_TYPE(seq->flags), esz = seq->elem_size;

if( total == 0 )

return Mat();

CV_Assert(total > 0 && CV_ELEM_SIZE(seq->flags) == esz);

if(!copyData && seq->first->next == seq->first)

return Mat(total, 1, type, seq->first->data);

if( abuf )

{

abuf->allocate(((size_t)total*esz + sizeof(double)-1)/sizeof(double));

double* bufdata = *abuf;

cvCvtSeqToArray(seq, bufdata, CV_WHOLE_SEQ);

return Mat(total, 1, type, bufdata);

}

Mat buf(total, 1, type);

cvCvtSeqToArray(seq, buf.ptr(), CV_WHOLE_SEQ);

return buf;

}

CV_Error(CV_StsBadArg, "Unknown array type");

return Mat();

{

CV_Assert( dims <= 2 && step[0] > 0 );

size_t esz = elemSize(), minstep;

ptrdiff_t delta1 = data - datastart, delta2 = dataend - datastart;

if( delta1 == 0 )

ofs.x = ofs.y = 0;

else

{

ofs.y = (int)(delta1/step[0]);

ofs.x = (int)((delta1 - step[0]*ofs.y)/esz);