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)); }
CvSparseNode * cvGetNextSparseNode_wrap(CvSparseMatIterator * mat_iterator ){ return cvGetNextSparseNode(/*CvSparseMatIterator*//***/mat_iterator); }
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; }