void cvLSHQuery(CvLSH* lsh, const CvMat* data, CvMat* indices, CvMat* dist, int k, int emax) {
int dims;
switch (lsh->type) {
case CV_32FC1: dims = lsh->u.lsh_32f->dims(); break;
case CV_64FC1: dims = lsh->u.lsh_64f->dims(); break;
default: assert(0); return;
}
if (k<1)
CV_Error(CV_StsOutOfRange, "k must be positive");
if (CV_MAT_TYPE(data->type) != lsh->type)
CV_Error(CV_StsUnsupportedFormat, "type of data and constructed LSH must agree");
if (dims != data->cols)
CV_Error(CV_StsBadSize, "data must be n x d, where d is what was used to construct LSH");
if (dist->rows != data->rows || dist->cols != k)
CV_Error(CV_StsBadSize, "dist must be n x k for n x d data");
if (dist->rows != indices->rows || dist->cols != indices->cols)
CV_Error(CV_StsBadSize, "dist and indices must be same size");
if (CV_MAT_TYPE(dist->type) != CV_64FC1)
CV_Error(CV_StsUnsupportedFormat, "dist must be CV_64FC1");
if (CV_MAT_TYPE(indices->type) != CV_32SC1)
CV_Error(CV_StsUnsupportedFormat, "indices must be CV_32SC1");
switch (lsh->type) {
case CV_32FC1: lsh->u.lsh_32f->query(data->data.fl, data->rows,
k, emax, dist->data.db, indices->data.i); break;
case CV_64FC1: lsh->u.lsh_64f->query(data->data.db, data->rows,
k, emax, dist->data.db, indices->data.i); break;
default: assert(0); return;
}
}
int grow_mat::init(int r, int c, int type, int maxrows, int maxcols)
{
int no_max = 0;
if (maxrows==0) {maxrows=r*_expand_factor;no_max=1;}
if (maxcols==0) {maxcols=c*_expand_factor;no_max=1;}
if (type==0) type=CV_64FC1;
if (r<=0 || c<=0 || maxrows<0 || maxcols<0 || r>maxrows || c>maxcols)
return 0;
// 为了和mini_solver的set_solver一致，允许再次初始化！
if (_mat)
{
// 若矩阵_mat存在，且类型相同，表示客户想改变大小。
int mat_type = CV_MAT_TYPE(_mat->type);
if (CV_MAT_TYPE(type)==mat_type)
{
return resize(r,c);
}
}
if(_mat) cvReleaseMat(&_mat);
if (no_max)
_mat = cvCreateMat(r, c, type);
else
_mat = cvCreateMat(maxrows, maxcols, type);
if (_mat==0) return 0;
if (_zero_flag) cvSetZero(_mat);
cvGetSubRect(_mat, this, cvRect(0,0,c,r));
return 1;
}
void cvLSHAdd(CvLSH* lsh, const CvMat* data, CvMat* indices) {
int dims, n;
int* ret_indices = 0;
switch (lsh->type) {
case CV_32FC1: dims = lsh->u.lsh_32f->dims(); break;
case CV_64FC1: dims = lsh->u.lsh_64f->dims(); break;
default: assert(0); return;
}
n = data->rows;
if (dims != data->cols)
CV_Error(CV_StsBadSize, "data must be n x d, where d is what was used to construct LSH");
if (CV_MAT_TYPE(data->type) != lsh->type)
CV_Error(CV_StsUnsupportedFormat, "type of data and constructed LSH must agree");
if (indices) {
if (CV_MAT_TYPE(indices->type) != CV_32SC1)
CV_Error(CV_StsUnsupportedFormat, "indices must be CV_32SC1");
if (indices->rows * indices->cols != n)
CV_Error(CV_StsBadSize, "indices must be n x 1 or 1 x n for n x d data");
ret_indices = indices->data.i;
}
switch (lsh->type) {
case CV_32FC1: lsh->u.lsh_32f->add(data->data.fl, n, ret_indices); break;
case CV_64FC1: lsh->u.lsh_64f->add(data->data.db, n, ret_indices); break;
default: assert(0); return;
}
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvCalcOpticalFlowLK
// Purpose: Optical flow implementation
// Context:
// Parameters:
// srcA, srcB - source image
// velx, vely - destination image
// Returns:
//
// Notes:
//F*/
CV_IMPL void
cvCalcOpticalFlowLK(const void* srcarrA, const void* srcarrB, CvSize winSize,
void* velarrx, void* velarry) {
CvMat stubA, *srcA = cvGetMat(srcarrA, &stubA);
CvMat stubB, *srcB = cvGetMat(srcarrB, &stubB);
CvMat stubx, *velx = cvGetMat(velarrx, &stubx);
CvMat stuby, *vely = cvGetMat(velarry, &stuby);
if (!CV_ARE_TYPES_EQ(srcA, srcB)) {
CV_Error(CV_StsUnmatchedFormats, "Source images have different formats");
}
if (!CV_ARE_TYPES_EQ(velx, vely)) {
CV_Error(CV_StsUnmatchedFormats, "Destination images have different formats");
}
if (!CV_ARE_SIZES_EQ(srcA, srcB) ||
!CV_ARE_SIZES_EQ(velx, vely) ||
!CV_ARE_SIZES_EQ(srcA, velx)) {
CV_Error(CV_StsUnmatchedSizes, "");
}
if (CV_MAT_TYPE(srcA->type) != CV_8UC1 ||
CV_MAT_TYPE(velx->type) != CV_32FC1)
CV_Error(CV_StsUnsupportedFormat, "Source images must have 8uC1 type and "
"destination images must have 32fC1 type");
if (srcA->step != srcB->step || velx->step != vely->step) {
CV_Error(CV_BadStep, "source and destination images have different step");
}
IPPI_CALL(icvCalcOpticalFlowLK_8u32fR((uchar*)srcA->data.ptr, (uchar*)srcB->data.ptr,
srcA->step, cvGetMatSize(srcA), winSize,
velx->data.fl, vely->data.fl, velx->step));
}
CVAPI(void) cvShowImageEx(const char * id, const CvArr * arr,
const int cm)
{
CvMat * src, src_stub;
double minval, maxval, maxdiff; CvPoint minloc, maxloc;
int type = cvGetElemType(arr);
CvMat * disp, * src_scaled;
int i, j;
if (!CV_IS_MAT(arr))
src = cvGetMat(arr, &src_stub);
else{
src = (CvMat*)arr;
}
src = cvCloneMat(src);
if ( (src->rows<60) || (src->rows<60) )
{
CvMat * orig = cvCloneMat(src);
int scale=60./MIN(orig->rows, orig->cols);
cvReleaseMat(&src);
src = cvCreateMat(orig->rows*scale, orig->cols*scale,
CV_MAT_TYPE(orig->type));
int m,n;
if (CV_MAT_TYPE(src->type)==CV_64F){
for (m=0;m<orig->rows;m++) {
for (n=0;n<orig->cols;n++) {
for (i=0;i<scale;i++) {
for (j=0;j<scale;j++) {
CV_MAT_ELEM(*src, double, m*scale+i, n*scale+j) = CV_MAT_ELEM(*orig, double, m, n);
}
}
}
}
}else if (CV_MAT_TYPE(src->type)==CV_32F){
CV_IMPL void
cvCornerMinEigenVal( const void* srcarr, void* eigenvarr,
int block_size, int aperture_size )
{
CV_FUNCNAME( "cvCornerMinEigenVal" );
__BEGIN__;
CvMat stub, *src = (CvMat*)srcarr;
CvMat eigstub, *eigenv = (CvMat*)eigenvarr;
CV_CALL( src = cvGetMat( srcarr, &stub ));
CV_CALL( eigenv = cvGetMat( eigenv, &eigstub ));
if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 ||
CV_MAT_TYPE(eigenv->type) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" );
if( !CV_ARE_SIZES_EQ( src, eigenv ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_MINEIGENVAL ));
__END__;
}
CV_IMPL void
cvCornerHarris( const CvArr* srcarr, CvArr* harris_responce,
int block_size, int aperture_size, double k )
{
CV_FUNCNAME( "cvCornerHarris" );
__BEGIN__;
CvMat stub, *src = (CvMat*)srcarr;
CvMat eigstub, *eigenv = (CvMat*)harris_responce;
CV_CALL( src = cvGetMat( srcarr, &stub ));
CV_CALL( eigenv = cvGetMat( eigenv, &eigstub ));
if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 ||
CV_MAT_TYPE(eigenv->type) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" );
if( !CV_ARE_SIZES_EQ( src, eigenv ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_HARRIS, k ));
__END__;
}
CV_IMPL void
cvCornerEigenValsAndVecs( const void* srcarr, void* eigenvarr,
int block_size, int aperture_size )
{
CV_FUNCNAME( "cvCornerEigenValsAndVecs" );
__BEGIN__;
CvMat stub, *src = (CvMat*)srcarr;
CvMat eigstub, *eigenv = (CvMat*)eigenvarr;
CV_CALL( src = cvGetMat( srcarr, &stub ));
CV_CALL( eigenv = cvGetMat( eigenv, &eigstub ));
if( CV_MAT_CN(eigenv->type)*eigenv->cols != src->cols*6 ||
eigenv->rows != src->rows )
CV_ERROR( CV_StsUnmatchedSizes, "Output array should be 6 times "
"wider than the input array and they should have the same height");
if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 ||
CV_MAT_TYPE(eigenv->type) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" );
CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_EIGENVALSVECS ));
__END__;
}
void icvConvertIntToDecimal(const int ndigits, CvMat * src, CvMat * dst)
{
const int nsamples = src->rows;
const int nnumbers = src->cols;
assert(dst->rows==nsamples);
assert(CV_MAT_TYPE(src->type)==CV_32S);
assert(CV_MAT_TYPE(dst->type)==CV_32F);
CvMat * values = cvCreateMat(ndigits,10,CV_32F);
int stepsize = ndigits*10*sizeof(float);
for (int ii=0;ii<nsamples;ii++){
#if 0 // debug
fprintf(stderr,"number: ");
for (int jj=0;jj<nnumbers;jj++){
fprintf(stderr,"%d ",CV_MAT_ELEM(*src,int,ii,jj));
}
#endif
for (int jj=0;jj<nnumbers;jj++){
cvZero(values);
int number = CV_MAT_ELEM(*src,int,ii,jj);
for (int kk=0;kk<ndigits;kk++){
int pos = cvFloor((number%int(pow(10.f,kk+1)))/pow(10.f,kk));
CV_MAT_ELEM(*values,float,kk,pos)=1;
}
memcpy(dst->data.ptr+stepsize*(nnumbers*ii+jj),values->data.ptr,stepsize);
}
#if 0 // debug
fprintf(stderr,"\noutput:\n");
cvPrintf(stderr,"%.0f ",dst,cvRect(0,ii,dst->cols,1));
#endif
}
cvReleaseMat(&values);
}
void cvSolvePoly(const CvMat* a, CvMat *r, int maxiter, int fig) {
int m = a->rows * a->cols;
int n = r->rows * r->cols;
__BEGIN__;
CV_FUNCNAME("cvSolvePoly");
if (CV_MAT_TYPE(a->type) != CV_32FC1 &&
CV_MAT_TYPE(a->type) != CV_64FC1)
CV_ERROR(CV_StsUnsupportedFormat, "coeffs must be either CV_32FC1 or CV_64FC1");
if (CV_MAT_TYPE(r->type) != CV_32FC2 &&
CV_MAT_TYPE(r->type) != CV_64FC2)
CV_ERROR(CV_StsUnsupportedFormat, "roots must be either CV_32FC2 or CV_64FC2");
if (CV_MAT_DEPTH(a->type) != CV_MAT_DEPTH(r->type))
CV_ERROR(CV_StsUnmatchedFormats, "coeffs and roots must have same depth");
if (m - 1 != n)
CV_ERROR(CV_StsUnmatchedFormats, "must have n + 1 coefficients");
switch (CV_MAT_DEPTH(a->type)) {
case CV_32F:
icvFindPolynomialRoots(a->data.fl, r->data.fl, n, maxiter, fig);
break;
case CV_64F:
icvFindPolynomialRoots(a->data.db, r->data.db, n, maxiter, fig);
break;
}
__END__;
}
/* Calculates bounding rectagnle of a point set or retrieves already calculated */
CV_IMPL CvRect
cvBoundingRect( CvArr* array, int update )
{
CvRect rect = { 0, 0, 0, 0 };
CvContour contour_header;
CvSeq* ptseq = 0;
CvSeqBlock block;
CvMat stub, *mat = 0;
int calculate = update;
if( CV_IS_SEQ( array ))
{
ptseq = (CvSeq*)array;
if( !CV_IS_SEQ_POINT_SET( ptseq ))
CV_Error( CV_StsBadArg, "Unsupported sequence type" );
if( ptseq->header_size < (int)sizeof(CvContour))
{
update = 0;
calculate = 1;
}
}
else
{
mat = cvGetMat( array, &stub );
if( CV_MAT_TYPE(mat->type) == CV_32SC2 ||
CV_MAT_TYPE(mat->type) == CV_32FC2 )
{
ptseq = cvPointSeqFromMat(CV_SEQ_KIND_GENERIC, mat, &contour_header, &block);
mat = 0;
}
else if( CV_MAT_TYPE(mat->type) != CV_8UC1 &&
CV_MAT_TYPE(mat->type) != CV_8SC1 )
CV_Error( CV_StsUnsupportedFormat,
"The image/matrix format is not supported by the function" );
update = 0;
calculate = 1;
}
if( !calculate )
return ((CvContour*)ptseq)->rect;
if( mat )
{
rect = cv::maskBoundingRect(cv::cvarrToMat(mat));
}
else if( ptseq->total )
{
cv::AutoBuffer<double> abuf;
rect = cv::pointSetBoundingRect(cv::cvarrToMat(ptseq, false, false, 0, &abuf));
}
if( update )
((CvContour*)ptseq)->rect = rect;
return rect;
}
CV_IMPL void cvNeumannBoundCond(const CvArr * srcarr,
CvArr * dstarr)
{
CV_FUNCNAME("cvNeumannBoundCond");
__BEGIN__;
CvMat sstub, *src;
CvMat dstub, *dst;
CvSize size;
int i, j;
float * ptr_src, * ptr_dst;
int iStep_src, iStep_dst;
CV_CALL( src = cvGetMat(srcarr, &sstub ));
CV_CALL( dst = cvGetMat(dstarr, &dstub ));
if( CV_MAT_TYPE(src->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(dst->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( !CV_ARE_SIZES_EQ(src, dst))
CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" );
size = cvGetMatSize( src );
cvCopy(src, dst);
ptr_src = src->data.fl;
iStep_src = src->step / sizeof(ptr_src[0]);
ptr_dst = dst->data.fl;
iStep_dst = dst->step / sizeof(ptr_dst[0]);
ptr_dst[0] = ptr_src[2+iStep_src*2];
//dst(0,0)=src(3,3)
ptr_dst[size.width-1] = ptr_src[size.width-3+iStep_src*2];
//dst(0,col-1)=src(3,col-3)
ptr_dst[iStep_dst*(size.height-1)] = ptr_src[2+iStep_src*(size.height-3)];
//dst(row-1,0)=src(row-3,3)
ptr_dst[size.width-1+iStep_dst*(size.height-1)] = ptr_src[size.width-3+iStep_dst*(size.height-3)];
//dst(row-1,col-1)=src(row-3,col-3)
for(i = 1; i < size.width-1; i++){
ptr_dst[i] = ptr_src[i+iStep_src*2];
ptr_dst[i+iStep_dst*(size.height-1)]=ptr_src[i+iStep_src*(size.height-3)];
}
for(j = 1; j < size.height-1; j++){
ptr_dst[iStep_dst*j] = ptr_src[2+iStep_src*j];
ptr_dst[size.width-1+iStep_dst*j]=ptr_src[size.width-3+iStep_src*j];
}
__END__;
}
CV_IMPL void cvCalS(const CvArr* srcarr,
CvArr* dstarr)
{
CV_FUNCNAME("cvCalS");
__BEGIN__;
CvMat sstub, *src;
CvMat dstub, *dst;
CvMat* src_dx=0, *src_dy=0;
CvSize size;
int i, j;
int iStep;
float* fPtr;
CV_CALL( src = cvGetMat(srcarr, &sstub ));
CV_CALL( dst = cvGetMat(dstarr, &dstub ));
if( CV_MAT_TYPE(src->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(dst->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( !CV_ARE_SIZES_EQ( src, dst ))
CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" );
size = cvGetMatSize( src );
src_dx = cvCreateMat(size.height, size.width, CV_32FC1 );
src_dy = cvCreateMat(size.height, size.width, CV_32FC1 );
cvSetZero(src_dx);
cvSetZero(src_dy);
iStep = dst->step / sizeof(fPtr[0]);
fPtr = dst->data.fl;
cvSobel(src, src_dx, 1, 0, 1);
cvSobel(src, src_dy, 0, 1, 1);
cvMul(src_dx, src_dx, src_dx, 0.25f*0.25f); //rescale gradient
cvMul(src_dy, src_dy, src_dy, 0.25f*0.25f); //rescale gradient
cvAdd(src_dx, src_dy, dst);
for(j=0; j<size.height; j++){
for (i=0; i<size.width; i++)
fPtr[i+iStep*j] = sqrt(fPtr[i+iStep*j])+SMALLNUM;
}
cvReleaseMat(&src_dx);
cvReleaseMat(&src_dy);
__END__;
}
CV_IMPL void cvCurvature(const CvArr* srcarr_x,
const CvArr* srcarr_y,
CvArr* dstarr)
{
CV_FUNCNAME("cvCurvature");
__BEGIN__;
CvMat sstub_x, sstub_y, *src_x, *src_y;
CvMat dstub, *dst;
CvSize size;
CvMat *Nxx=0, *Nyy=0, *ones=0;
CV_CALL( src_x = cvGetMat(srcarr_x, &sstub_x ));
CV_CALL( src_y = cvGetMat(srcarr_y, &sstub_y ));
CV_CALL( dst = cvGetMat(dstarr, &dstub ));
if( CV_MAT_TYPE(src_x->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(src_y->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(dst->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( !CV_ARE_SIZES_EQ( src_x, src_y ))
CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" );
size = cvGetMatSize( src_x );
Nxx = cvCreateMat(size.height, size.width, CV_32FC1 );
Nyy = cvCreateMat(size.height, size.width, CV_32FC1 );
ones= cvCreateMat(size.height, size.width, CV_32FC1 );
cvSetZero(Nxx);
cvSetZero(Nyy);
cvSet(ones, cvScalar(1.0f));
cvSobel(src_x, Nxx, 1, 0, 1);
cvSobel(src_y, Nyy, 0, 1, 1);
cvMul(Nxx, ones, Nxx, 0.25f);
cvMul(Nyy, ones, Nyy, 0.25f);
cvAdd(Nxx, Nyy, dst);
cvReleaseMat(&Nxx);
cvReleaseMat(&Nyy);
cvReleaseMat(&ones);
__END__;
}
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;
}
CV_IMPL void
cvImgToObs_DCT( const void* arr, float *obs, CvSize dctSize,
CvSize obsSize, CvSize delta )
{
CV_FUNCNAME( "cvImgToObs_DCT" );
__BEGIN__;
CvMat stub, *mat = (CvMat*)arr;
CV_CALL( mat = cvGetMat( arr, &stub ));
switch( CV_MAT_TYPE( mat->type ))
{
case CV_8UC1:
IPPI_CALL( icvImgToObs_DCT_8u32f_C1R( mat->data.ptr, mat->step,
cvGetMatSize(mat), obs,
dctSize, obsSize, delta ));
break;
case CV_32FC1:
IPPI_CALL( icvImgToObs_DCT_32f_C1R( mat->data.fl, mat->step,
cvGetMatSize(mat), obs,
dctSize, obsSize, delta ));
break;
default:
CV_ERROR( CV_StsUnsupportedFormat, "" );
}
__END__;
}
CV_IMPL CvSeq* cvPointSeqFromMat( int seq_kind, const CvArr* arr,
CvContour* contour_header, CvSeqBlock* block )
{
CV_Assert( arr != 0 && contour_header != 0 && block != 0 );
int eltype;
CvMat* mat = (CvMat*)arr;
if( !CV_IS_MAT( mat ))
CV_Error( CV_StsBadArg, "Input array is not a valid matrix" );
eltype = CV_MAT_TYPE( mat->type );
if( eltype != CV_32SC2 && eltype != CV_32FC2 )
CV_Error( CV_StsUnsupportedFormat,
"The matrix can not be converted to point sequence because of "
"inappropriate element type" );
if( (mat->width != 1 && mat->height != 1) || !CV_IS_MAT_CONT(mat->type))
CV_Error( CV_StsBadArg,
"The matrix converted to point sequence must be "
"1-dimensional and continuous" );
cvMakeSeqHeaderForArray(
(seq_kind & (CV_SEQ_KIND_MASK|CV_SEQ_FLAG_CLOSED)) | eltype,
sizeof(CvContour), CV_ELEM_SIZE(eltype), mat->data.ptr,
mat->width*mat->height, (CvSeq*)contour_header, block );
return (CvSeq*)contour_header;
}
/* Create empty sequence: */
CV_IMPL CvSeq *
cvCreateSeq( int seq_flags, size_t header_size, size_t elem_size, CvMemStorage* storage )
{
CvSeq *seq = 0;
if( !storage )
CV_Error( CV_StsNullPtr, "" );
if( header_size < sizeof( CvSeq ) || elem_size <= 0 )
CV_Error( CV_StsBadSize, "" );
/* allocate sequence header */
seq = (CvSeq*)cvMemStorageAlloc( storage, header_size );
memset( seq, 0, header_size );
seq->header_size = (int)header_size;
seq->flags = (seq_flags & ~CV_MAGIC_MASK) | CV_SEQ_MAGIC_VAL;
{
int elemtype = CV_MAT_TYPE(seq_flags);
int typesize = CV_ELEM_SIZE(elemtype);
if( elemtype != CV_SEQ_ELTYPE_GENERIC && elemtype != CV_USRTYPE1 &&
typesize != 0 && typesize != (int)elem_size )
CV_Error( CV_StsBadSize,
"Specified element size doesn't match to the size of the specified element type "
"(try to use 0 for element type)" );
}
seq->elem_size = (int)elem_size;
seq->storage = storage;
cvSetSeqBlockSize( seq, (int)((1 << 10)/elem_size) );
return seq;
}
void pix_opencv_patreco :: loadIntraMess (t_symbol *filename)
{
CvMat* intrinsic_matrix;
if ( filename->s_name[0] == 0 ) {
error("no filename passed to loadIntra message");
return;
}
if ( filename == NULL ) { error("%s is not a valid matrix", filename->s_name); return;}
intrinsic_matrix = (CvMat*)cvLoad(filename->s_name, 0, 0, 0);// TODO crash when passing non-XML file
if (intrinsic_matrix == NULL) {
intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1);
error("can't open file %s", filename->s_name);
//~ resetCorrectionMatrix();
}
else if ( intrinsic_matrix->rows != 3 || intrinsic_matrix->cols != 3 || CV_MAT_TYPE(intrinsic_matrix->type) != CV_32FC1 ) {
error("%s is not a valid intrinsic matrix", filename->s_name);
cvReleaseMat(&intrinsic_matrix);
intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1);
//~ resetCorrectionMatrix();
}
else post("load transformation matrix from %s",filename->s_name);
m_cameraMatrix = cvarrToMat(intrinsic_matrix);
t_atom intra_out[9];
for ( int i = 0 ; i < 9 ; i++ ){
SETFLOAT(&intra_out[i], CV_MAT_ELEM( *intrinsic_matrix, float, i%3, i/3));
}
outlet_anything( this->m_dataout, gensym("intrinsic_matrix"), 9, intra_out);
}
void CvANN_MLP::scale_input( const CvMat* _src, CvMat* _dst ) const
{
int i, j, cols = _src->cols;
double* dst = _dst->data.db;
const double* w = weights[0];
int step = _src->step;
if( CV_MAT_TYPE( _src->type ) == CV_32F )
{
const float* src = _src->data.fl;
step /= sizeof(src[0]);
for( i = 0; i < _src->rows; i++, src += step, dst += cols )
for( j = 0; j < cols; j++ )
dst[j] = src[j]*w[j*2] + w[j*2+1];
}
else
{
const double* src = _src->data.db;
step /= sizeof(src[0]);
for( i = 0; i < _src->rows; i++, src += step, dst += cols )
for( j = 0; j < cols; j++ )
dst[j] = src[j]*w[j*2] + w[j*2+1];
}
}
void pix_opencv_patreco :: loadDistMess (t_symbol *filename)
{
CvMat* distortion_coeffs;
if ( filename->s_name[0] == 0 ) {
error("no filename passed to loadDist message");
return;
}
if ( filename == NULL ) { error("NULL pointer passed to function loadDist"); return;}
distortion_coeffs = (CvMat*)cvLoad(filename->s_name); // TODO crash when passing non-XML file
if (distortion_coeffs == NULL) {
distortion_coeffs = cvCreateMat(5, 1, CV_32FC1);
error("can't open file %s", filename->s_name);
//~ resetCorrectionMatrix();
}
else if( distortion_coeffs->rows != 5 || distortion_coeffs->cols != 1 || CV_MAT_TYPE(distortion_coeffs->type) != CV_32FC1 ) {
error("%s is not a valid distortions coeffs file", filename->s_name);
cvReleaseMat(&distortion_coeffs);
distortion_coeffs = cvCreateMat(3, 3, CV_32FC1);
//~ resetCorrectionMatrix();
}
else post("load distortion coefficients from %s",filename->s_name);
m_distortions = cvarrToMat(distortion_coeffs);
t_atom dist_out[5];
for ( int i = 0 ; i < 5 ; i++ ){
SETFLOAT(&dist_out[i], CV_MAT_ELEM( *distortion_coeffs, float, i, 0));
}
outlet_anything( m_dataout, gensym("distortion_coeffs"), 5, dist_out);
}
void cvSoftmaxDer(CvMat * X, CvMat * dE_dY, CvMat * dE_dY_afder) {
CV_FUNCNAME("cvSoftmaxDer");
__BEGIN__;
const int nr = X->rows, nc = X->cols, dtype = CV_MAT_TYPE(X->type);
CvMat * Y = cvCreateMat(nr, nc, dtype);
CvMat * dE_dY_transpose = cvCreateMat(nr, nc, dtype);
CvMat * sum = cvCreateMat(nr, 1, dtype);
CvMat * sum_repeat = cvCreateMat(nr, nc, dtype);
cvSoftmax(X, Y);
if (dE_dY->rows==nc && dE_dY->cols==nr){
cvTranspose(dE_dY,dE_dY_transpose);
cvMul(Y,dE_dY_transpose,dE_dY_afder);
}else{
cvMul(Y,dE_dY,dE_dY_afder);
}
cvReduce(dE_dY_afder,sum,-1,CV_REDUCE_SUM);
cvRepeat(sum,sum_repeat);
cvMul(Y,sum_repeat,sum_repeat);
cvSub(dE_dY_afder,sum_repeat,dE_dY_afder);
cvReleaseMat(&dE_dY_transpose);
cvReleaseMat(&sum);
cvReleaseMat(&sum_repeat);
cvReleaseMat(&Y);
__END__;
}
CvSeq*
create_seq(int seq_flags, size_t header_size, VALUE storage_value)
{
VALUE klass = Qnil;
int eltype = seq_flags & CV_SEQ_ELTYPE_MASK;
storage_value = CHECK_CVMEMSTORAGE(storage_value);
if (!eltype2class(eltype, &klass)) {
seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC;
}
int mat_type = CV_MAT_TYPE(seq_flags);
size_t elem_size = (size_t)(CV_ELEM_SIZE(mat_type));
CvSeq* seq = NULL;
try {
seq = cvCreateSeq(seq_flags, header_size, elem_size, CVMEMSTORAGE(storage_value));
}
catch (cv::Exception& e) {
raise_cverror(e);
}
register_elem_class(seq, klass);
register_root_object(seq, storage_value);
return seq;
}
void CvANN_MLP::scale_output( const CvMat* _src, CvMat* _dst ) const
{
int i, j, cols = _src->cols;
const double* src = _src->data.db;
const double* w = weights[layer_sizes->cols];
int step = _dst->step;
if( CV_MAT_TYPE( _dst->type ) == CV_32F )
{
float* dst = _dst->data.fl;
step /= sizeof(dst[0]);
for( i = 0; i < _src->rows; i++, src += cols, dst += step )
for( j = 0; j < cols; j++ )
dst[j] = (float)(src[j]*w[j*2] + w[j*2+1]);
}
else
{
double* dst = _dst->data.db;
step /= sizeof(dst[0]);
for( i = 0; i < _src->rows; i++, src += cols, dst += step )
for( j = 0; j < cols; j++ )
dst[j] = src[j]*w[j*2] + w[j*2+1];
}
}
CV_IMPL void
cvCopyMakeBorder( const CvArr* srcarr, CvArr* dstarr, CvPoint offset,
int bordertype, CvScalar value )
{
CvMat srcstub, *src = (CvMat*)srcarr;
CvMat dststub, *dst = (CvMat*)dstarr;
CvSize srcsize, dstsize;
int srcstep, dststep;
int pix_size, type;
if( !CV_IS_MAT(src) )
src = cvGetMat( src, &srcstub );
if( !CV_IS_MAT(dst) )
dst = cvGetMat( dst, &dststub );
if( offset.x < 0 || offset.y < 0 )
CV_Error( CV_StsOutOfRange, "Offset (left/top border width) is negative" );
if( src->rows + offset.y > dst->rows || src->cols + offset.x > dst->cols )
CV_Error( CV_StsBadSize, "Source array is too big or destination array is too small" );
if( !CV_ARE_TYPES_EQ( src, dst ))
CV_Error( CV_StsUnmatchedFormats, "" );
type = CV_MAT_TYPE(src->type);
pix_size = CV_ELEM_SIZE(type);
srcsize = cvGetMatSize(src);
dstsize = cvGetMatSize(dst);
srcstep = src->step;
dststep = dst->step;
if( srcstep == 0 )
srcstep = CV_STUB_STEP;
if( dststep == 0 )
dststep = CV_STUB_STEP;
bordertype &= 15;
if( bordertype == IPL_BORDER_REPLICATE )
{
icvCopyReplicateBorder_8u( src->data.ptr, srcstep, srcsize,
dst->data.ptr, dststep, dstsize,
offset.y, offset.x, pix_size );
}
else if( bordertype == IPL_BORDER_REFLECT_101 )
{
icvCopyReflect101Border_8u( src->data.ptr, srcstep, srcsize,
dst->data.ptr, dststep, dstsize,
offset.y, offset.x, pix_size );
}
else if( bordertype == IPL_BORDER_CONSTANT )
{
double buf[4];
cvScalarToRawData( &value, buf, src->type, 0 );
icvCopyConstBorder_8u( src->data.ptr, srcstep, srcsize,
dst->data.ptr, dststep, dstsize,
offset.y, offset.x, pix_size, (uchar*)buf );
}
else
CV_Error( CV_StsBadFlag, "Unknown/unsupported border type" );
}
void UMat::create(int d, const int* _sizes, int _type, UMatUsageFlags _usageFlags)
{
this->usageFlags = _usageFlags;
int i;
CV_Assert(0 <= d && d <= CV_MAX_DIM && _sizes);
_type = CV_MAT_TYPE(_type);
if( u && (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);
offset = 0;
if( total() > 0 )
{
MatAllocator *a = allocator, *a0 = getStdAllocator();
if (!a)
{
a = a0;
a0 = Mat::getDefaultAllocator();
}
try
{
u = a->allocate(dims, size, _type, 0, step.p, 0, usageFlags);
CV_Assert(u != 0);
}
catch(...)
{
if(a != a0)
u = a0->allocate(dims, size, _type, 0, step.p, 0, usageFlags);
CV_Assert(u != 0);
}
CV_Assert( step[dims-1] == (size_t)CV_ELEM_SIZE(flags) );
}
finalizeHdr(*this);
addref();
}
CV_IMPL void cvDirac(const CvArr* srcarr,
CvArr* dstarr,
double sigma)
{
CV_FUNCNAME("cvDirac");
__BEGIN__;
CvMat sstub, *src;
CvMat dstub, *dst;
CvSize size;
int i, j, iStep_src, iStep_dst;
float* fPtr_src, *fPtr_dst, flag=0.0f;
float temp1=0.0f, temp2=0.0f;
CV_CALL( src = cvGetMat(srcarr, &sstub ));
CV_CALL( dst = cvGetMat(dstarr, &dstub ));
if( CV_MAT_TYPE(src->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(dst->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel output images are supported" );
if( !CV_ARE_SIZES_EQ( src, dst ))
CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" );
size = cvGetMatSize( src );
iStep_src = src->step / sizeof(fPtr_src[0]);
fPtr_src = src->data.fl;
iStep_dst = dst->step / sizeof(fPtr_dst[0]);
fPtr_dst = dst->data.fl;
for (j=0; j<size.height; j++){
for (i=0; i<size.width; i++){
temp1 = fPtr_src[i+iStep_src*j];
temp2 = (1.0f/2.0f/sigma)*(1.0f+cos(PI*temp1/sigma));
if (int(temp1*10000)<=int(sigma*10000) && int(temp1*10000)>=int(-sigma*10000)) {
flag = 1.0f;
} else {
flag = 0.0f;
}
fPtr_dst[i+iStep_dst*j]=temp2*flag;
}
}
__END__;
}
/*F///////////////////////////////////////////////////////////////////////////////////////
// Name: cvCalcOpticalFlowHS
// Purpose: Optical flow implementation
// Context:
// Parameters:
// srcA, srcB - source image
// velx, vely - destination image
// Returns:
//
// Notes:
//F*/
CV_IMPL void
cvCalcOpticalFlowHS( const void* srcarrA, const void* srcarrB, int usePrevious,
void* velarrx, void* velarry,
double lambda, CvTermCriteria criteria )
{
CV_FUNCNAME( "cvCalcOpticalFlowHS" );
__BEGIN__;
CvMat stubA, *srcA = (CvMat*)srcarrA;
CvMat stubB, *srcB = (CvMat*)srcarrB;
CvMat stubx, *velx = (CvMat*)velarrx;
CvMat stuby, *vely = (CvMat*)velarry;
CV_CALL( srcA = cvGetMat( srcA, &stubA ));
CV_CALL( srcB = cvGetMat( srcB, &stubB ));
CV_CALL( velx = cvGetMat( velx, &stubx ));
CV_CALL( vely = cvGetMat( vely, &stuby ));
if( !CV_ARE_TYPES_EQ( srcA, srcB ))
CV_ERROR( CV_StsUnmatchedFormats, "Source images have different formats" );
if( !CV_ARE_TYPES_EQ( velx, vely ))
CV_ERROR( CV_StsUnmatchedFormats, "Destination images have different formats" );
if( !CV_ARE_SIZES_EQ( srcA, srcB ) ||
!CV_ARE_SIZES_EQ( velx, vely ) ||
!CV_ARE_SIZES_EQ( srcA, velx ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
if( CV_MAT_TYPE( srcA->type ) != CV_8UC1 ||
CV_MAT_TYPE( velx->type ) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "Source images must have 8uC1 type and "
"destination images must have 32fC1 type" );
if( srcA->step != srcB->step || velx->step != vely->step )
CV_ERROR( CV_BadStep, "source and destination images have different step" );
IPPI_CALL( icvCalcOpticalFlowHS_8u32fR( (uchar*)srcA->data.ptr, (uchar*)srcB->data.ptr,
srcA->step, cvGetMatSize( srcA ), usePrevious,
velx->data.fl, vely->data.fl,
velx->step, (float)lambda, criteria ));
__END__;
}
int cvL1QCSolve( CvMatOps AOps, CvMatOps AtOps, void* userdata, CvMat* B, CvMat* X, double epsilon, double mu, CvTermCriteria lb_term_crit, CvTermCriteria cg_term_crit )
{
CvMat* Z = cvCreateMat( X->rows, 1, CV_MAT_TYPE(X->type) );
CvMat* W = cvCreateMat( B->rows, 1, CV_MAT_TYPE(B->type) );
CvAAtOpsData AAtData;
AAtData.AOps = AOps;
AAtData.AtOps = AtOps;
AAtData.AtR = Z;
AAtData.userdata = userdata;
if ( cvCGSolve( icvAAtOps, &AAtData, B, W, cg_term_crit ) > .5 )
{
cvReleaseMat( &W );
cvReleaseMat( &Z );
return -1;
}
AtOps( W, X, userdata );
AAtData.AR = W;
CvMat* U = cvCreateMat( X->rows, X->cols, CV_MAT_TYPE(X->type) );
cvAbsDiffS( X, U, cvScalar(0) );
CvScalar sumAbsX = cvSum( U );
double minAbsX, maxAbsX;
cvMinMaxLoc( U, &minAbsX, &maxAbsX );
cvConvertScale( U, U, .95, maxAbsX * .1 );
double tau = MAX( (2 * X->rows + 1) / sumAbsX.val[0], 1 );
if ( !(lb_term_crit.type & CV_TERMCRIT_ITER) )
lb_term_crit.max_iter = ceil( (log(2 * X->rows + 1) - log(lb_term_crit.epsilon) - log(tau)) / log(mu) );
CvTermCriteria nt_term_crit = cvTermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 50, lb_term_crit.epsilon );
int totaliter = 0;
for ( int i = 0; i < lb_term_crit.max_iter; ++i )
{
totaliter += icvL1QCNewton( AAtData, B, X, U, epsilon, tau, nt_term_crit, cg_term_crit );
tau *= mu;
}
cvReleaseMat( &U );
cvReleaseMat( &W );
cvReleaseMat( &Z );
return 0;
}
CV_IMPL void
cvConDensInitSampleSet( CvConDensation * conDens, CvMat * lowerBound, CvMat * upperBound )
{
int i, j;
float *LBound;
float *UBound;
float Prob = 1.f / conDens->SamplesNum;
CV_FUNCNAME( "cvConDensInitSampleSet" );
__BEGIN__;
if( !conDens || !lowerBound || !upperBound )
CV_ERROR( CV_StsNullPtr, "" );
if( CV_MAT_TYPE(lowerBound->type) != CV_32FC1 ||
!CV_ARE_TYPES_EQ(lowerBound,upperBound) )
CV_ERROR( CV_StsBadArg, "source has not appropriate format" );
if( (lowerBound->cols != 1) || (upperBound->cols != 1) )
CV_ERROR( CV_StsBadArg, "source has not appropriate size" );
if( (lowerBound->rows != conDens->DP) || (upperBound->rows != conDens->DP) )
CV_ERROR( CV_StsBadArg, "source has not appropriate size" );
LBound = lowerBound->data.fl;
UBound = upperBound->data.fl;
/* Initializing the structures to create initial Sample set */
//这里根据输入的动态范围给每个系统状态分配一个产生随机数的结构
for( i = 0; i < conDens->DP; i++ )
{
cvRandInit( &(conDens->RandS[i]),
LBound[i],
UBound[i],
i );
}
/* Generating the samples */
//根据产生的随即数，为每个粒子的每个系统状态分配初始值，并将每个粒子的置信度设置为相同的1/n
for( j = 0; j < conDens->SamplesNum; j++ )
{
for( i = 0; i < conDens->DP; i++ )
{
cvbRand( conDens->RandS + i, conDens->flSamples[j] + i, 1 );
}
conDens->flConfidence[j] = Prob;
}
/* Reinitializes the structures to update samples randomly */
//产生以后更新粒子系统状态的随即结构，采样范围为原来初始范围的-1/5到1/5
for( i = 0; i < conDens->DP; i++ )
{
cvRandInit( &(conDens->RandS[i]),
(LBound[i] - UBound[i]) / 5,
(UBound[i] - LBound[i]) / 5,
i);
}
__END__;
}
