void pushSparseMatrix(CvSparseMat *tcm, char* matName)
{
int nzCnt = 0;
CvSparseMatIterator it;
for(CvSparseNode *node = cvInitSparseMatIterator(tcm, &it); node != 0; node = cvGetNextSparseNode( &it))
{
nzCnt++;
}
double *mData = new double[3 * nzCnt];
int ii=0;
for(CvSparseNode *node = cvInitSparseMatIterator( tcm, &it );
node != 0; node = cvGetNextSparseNode( &it ))
{
int* idx = CV_NODE_IDX(tcm,node);
float val = ((float*)cvPtrND(tcm, idx))[0];
mData[ii*3 + 0] = idx[0];
mData[ii*3 + 1] = idx[1];
mData[ii*3 + 2] = val;
ii++;
}
mexPrintf("%s nzCnt: %d\n", matName, ii);
mxArray *mArray = mxCreateDoubleMatrix(3, nzCnt, mxREAL);
memcpy((void*)mxGetPr(mArray), (void*)mData, sizeof(double)*3*nzCnt);
mexPutVariable("caller", "consMat", mArray);
int pixCnt = tcm->size[0];
char buffer[512];
//_SS_ sprintf_s(buffer,"%s = sparse(consMat(1,:)+1,consMat(2,:)+1,consMat(3,:),%d,%d);", matName, pixCnt,pixCnt);
sprintf(buffer,"%s = sparse(consMat(1,:)+1,consMat(2,:)+1,consMat(3,:),%d,%d);", matName, pixCnt,pixCnt);
mexEvalString(buffer);
delete [] mData;
mxDestroyArray(mArray);
}
int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
{
int code = CV_BaseHistTest::prepare_test_case( test_case_idx );
if( code > 0 )
{
CvRNG* rng = ts->get_rng();
threshold = cvTsRandReal(rng)*gen_hist_max_val;
if( hist_type == CV_HIST_ARRAY )
{
orig_nz_count = total_size;
values = cvCreateMat( 1, total_size, CV_32F );
memcpy( values->data.fl, cvPtr1D( hist[0]->bins, 0 ), total_size*sizeof(float) );
}
else
{
CvSparseMat* sparse = (CvSparseMat*)hist[0]->bins;
CvSparseMatIterator iterator;
CvSparseNode* node;
int i, k;
orig_nz_count = sparse->heap->active_count;
values = cvCreateMat( 1, orig_nz_count+1, CV_32F );
indices = cvCreateMat( 1, (orig_nz_count+1)*cdims, CV_32S );
for( node = cvInitSparseMatIterator( sparse, &iterator ), i = 0;
node != 0; node = cvGetNextSparseNode( &iterator ), i++ )
{
const int* idx = CV_NODE_IDX(sparse,node);
OPENCV_ASSERT( i < orig_nz_count, "CV_ThreshHistTest::prepare_test_case", "Buffer overflow" );
values->data.fl[i] = *(float*)CV_NODE_VAL(sparse,node);
for( k = 0; k < cdims; k++ )
indices->data.i[i*cdims + k] = idx[k];
}
OPENCV_ASSERT( i == orig_nz_count, "Unmatched buffer size",
"CV_ThreshHistTest::prepare_test_case" );
}
}
return code;
}
int CV_NormHistTest::validate_test_results( int /*test_case_idx*/ )
{
int code = CvTS::OK;
double sum = 0;
if( hist_type == CV_HIST_ARRAY )
{
int i;
const float* ptr = (float*)cvPtr1D( hist[0]->bins, 0 );
for( i = 0; i < total_size; i++ )
sum += ptr[i];
}
else
{
CvSparseMat* sparse = (CvSparseMat*)hist[0]->bins;
CvSparseMatIterator iterator;
CvSparseNode *node;
for( node = cvInitSparseMatIterator( sparse, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
sum += *(float*)CV_NODE_VAL(sparse,node);
}
}
if( cvIsNaN(sum) || cvIsInf(sum) )
{
ts->printf( CvTS::LOG,
"The normalized histogram has invalid sum =%g\n", sum );
code = CvTS::FAIL_INVALID_OUTPUT;
}
else if( fabs(sum - factor) > FLT_EPSILON*10*fabs(factor) )
{
ts->printf( CvTS::LOG,
"The normalized histogram has incorrect sum =%g, while it should be =%g\n", sum, factor );
code = CvTS::FAIL_BAD_ACCURACY;
}
if( code < 0 )
ts->set_failed_test_info( code );
return code;
}
/* dst = src */
CV_IMPL void
cvCopy( const void* srcarr, void* dstarr, const void* maskarr )
{
if( CV_IS_SPARSE_MAT(srcarr) && CV_IS_SPARSE_MAT(dstarr))
{
CV_Assert( maskarr == 0 );
CvSparseMat* src1 = (CvSparseMat*)srcarr;
CvSparseMat* dst1 = (CvSparseMat*)dstarr;
CvSparseMatIterator iterator;
CvSparseNode* node;
dst1->dims = src1->dims;
memcpy( dst1->size, src1->size, src1->dims*sizeof(src1->size[0]));
dst1->valoffset = src1->valoffset;
dst1->idxoffset = src1->idxoffset;
cvClearSet( dst1->heap );
if( src1->heap->active_count >= dst1->hashsize*CV_SPARSE_HASH_RATIO )
{
cvFree( &dst1->hashtable );
dst1->hashsize = src1->hashsize;
dst1->hashtable =
(void**)cvAlloc( dst1->hashsize*sizeof(dst1->hashtable[0]));
}
memset( dst1->hashtable, 0, dst1->hashsize*sizeof(dst1->hashtable[0]));
for( node = cvInitSparseMatIterator( src1, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
CvSparseNode* node_copy = (CvSparseNode*)cvSetNew( dst1->heap );
int tabidx = node->hashval & (dst1->hashsize - 1);
CV_MEMCPY_AUTO( node_copy, node, dst1->heap->elem_size );
node_copy->next = (CvSparseNode*)dst1->hashtable[tabidx];
dst1->hashtable[tabidx] = node_copy;
}
return;
}
cv::Mat src = cv::cvarrToMat(srcarr, false, true, 1), dst = cv::cvarrToMat(dstarr, false, true, 1);
CV_Assert( src.depth() == dst.depth() && src.size() == dst.size() );
int coi1 = 0, coi2 = 0;
if( CV_IS_IMAGE(srcarr) )
coi1 = cvGetImageCOI((const IplImage*)srcarr);
if( CV_IS_IMAGE(dstarr) )
coi2 = cvGetImageCOI((const IplImage*)dstarr);
if( coi1 || coi2 )
{
CV_Assert( (coi1 != 0 || src.channels() == 1) &&
(coi2 != 0 || dst.channels() == 1) );
int pair[] = { std::max(coi1-1, 0), std::max(coi2-1, 0) };
cv::mixChannels( &src, 1, &dst, 1, pair, 1 );
return;
}
else
CV_Assert( src.channels() == dst.channels() );
if( !maskarr )
src.copyTo(dst);
else
src.copyTo(dst, cv::cvarrToMat(maskarr));
}
int CV_CompareHistTest::validate_test_results( int /*test_case_idx*/ )
{
int code = CvTS::OK;
int i;
double result0[MAX_METHOD+1];
double s0 = 0, s1 = 0, sq0 = 0, sq1 = 0, t;
for( i = 0; i < MAX_METHOD; i++ )
result0[i] = 0;
if( hist_type == CV_HIST_ARRAY )
{
float* ptr0 = (float*)cvPtr1D( hist[0]->bins, 0 );
float* ptr1 = (float*)cvPtr1D( hist[1]->bins, 0 );
for( i = 0; i < total_size; i++ )
{
double v0 = ptr0[i], v1 = ptr1[i];
result0[CV_COMP_CORREL] += v0*v1;
result0[CV_COMP_INTERSECT] += MIN(v0,v1);
if( fabs(v0 + v1) > DBL_EPSILON )
result0[CV_COMP_CHISQR] += (v0 - v1)*(v0 - v1)/(v0 + v1);
s0 += v0;
s1 += v1;
sq0 += v0*v0;
sq1 += v1*v1;
result0[CV_COMP_BHATTACHARYYA] += sqrt(v0*v1);
}
}
else
{
CvSparseMat* sparse0 = (CvSparseMat*)hist[0]->bins;
CvSparseMat* sparse1 = (CvSparseMat*)hist[1]->bins;
CvSparseMatIterator iterator;
CvSparseNode* node;
for( node = cvInitSparseMatIterator( sparse0, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ) )
{
const int* idx = CV_NODE_IDX(sparse0, node);
double v0 = *(float*)CV_NODE_VAL(sparse0, node);
double v1 = (float)cvGetRealND(sparse1, idx);
result0[CV_COMP_CORREL] += v0*v1;
result0[CV_COMP_INTERSECT] += MIN(v0,v1);
if( fabs(v0 + v1) > DBL_EPSILON )
result0[CV_COMP_CHISQR] += (v0 - v1)*(v0 - v1)/(v0 + v1);
s0 += v0;
sq0 += v0*v0;
result0[CV_COMP_BHATTACHARYYA] += sqrt(v0*v1);
}
for( node = cvInitSparseMatIterator( sparse1, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ) )
{
const int* idx = CV_NODE_IDX(sparse1, node);
double v1 = *(float*)CV_NODE_VAL(sparse1, node);
double v0 = (float)cvGetRealND(sparse0, idx);
if( fabs(v0) < DBL_EPSILON )
result0[CV_COMP_CHISQR] += v1;
s1 += v1;
sq1 += v1*v1;
}
}
t = (sq0 - s0*s0/total_size)*(sq1 - s1*s1/total_size);
result0[CV_COMP_CORREL] = fabs(t) > DBL_EPSILON ?
(result0[CV_COMP_CORREL] - s0*s1/total_size)/sqrt(t) : 1;
s1 *= s0;
s0 = result0[CV_COMP_BHATTACHARYYA];
s0 = 1. - s0*(s1 > FLT_EPSILON ? 1./sqrt(s1) : 1.);
result0[CV_COMP_BHATTACHARYYA] = sqrt(MAX(s0,0.));
for( i = 0; i < MAX_METHOD; i++ )
{
double v = result[i], v0 = result0[i];
const char* method_name =
i == CV_COMP_CHISQR ? "Chi-Square" :
i == CV_COMP_CORREL ? "Correlation" :
i == CV_COMP_INTERSECT ? "Intersection" :
i == CV_COMP_BHATTACHARYYA ? "Bhattacharyya" : "Unknown";
if( cvIsNaN(v) || cvIsInf(v) )
{
ts->printf( CvTS::LOG, "The comparison result using the method #%d (%s) is invalid (=%g)\n",
i, method_name, v );
code = CvTS::FAIL_INVALID_OUTPUT;
break;
}
else if( fabs(v0 - v) > FLT_EPSILON*10*MAX(fabs(v0),0.1) )
{
ts->printf( CvTS::LOG, "The comparison result using the method #%d (%s)\n\tis inaccurate (=%g, should be =%g)\n",
i, method_name, v, v0 );
code = CvTS::FAIL_BAD_ACCURACY;
break;
}
}
if( code < 0 )
ts->set_failed_test_info( code );
return code;
}