int CV_ThreshHistTest::validate_test_results( int /*test_case_idx*/ )
{
int code = CvTS::OK;
int i;
float* ptr0 = values->data.fl;
float* ptr = 0;
CvSparseMat* sparse = 0;
if( hist_type == CV_HIST_ARRAY )
ptr = (float*)cvPtr1D( hist[0]->bins, 0 );
else
sparse = (CvSparseMat*)hist[0]->bins;
if( code > 0 )
{
for( i = 0; i < orig_nz_count; i++ )
{
float v0 = ptr0[i], v;
if( hist_type == CV_HIST_ARRAY )
v = ptr[i];
else
{
v = (float)cvGetRealND( sparse, indices->data.i + i*cdims );
cvClearND( sparse, indices->data.i + i*cdims );
}
if( v0 <= threshold ) v0 = 0.f;
if( cvIsNaN(v) || cvIsInf(v) )
{
ts->printf( CvTS::LOG, "The %d-th bin is invalid (=%g)\n", i, v );
code = CvTS::FAIL_INVALID_OUTPUT;
break;
}
else if( fabs(v0 - v) > FLT_EPSILON*10*fabs(v0) )
{
ts->printf( CvTS::LOG, "The %d-th bin is incorrect (=%g, should be =%g)\n", i, v, v0 );
code = CvTS::FAIL_BAD_ACCURACY;
break;
}
}
}
if( code > 0 && hist_type == CV_HIST_SPARSE )
{
if( sparse->heap->active_count > 0 )
{
ts->printf( CvTS::LOG,
"There some extra histogram bins in the sparse histogram after the thresholding\n" );
code = CvTS::FAIL_INVALID_OUTPUT;
}
}
if( code < 0 )
ts->set_failed_test_info( code );
return code;
}
void CvAdaptiveSkinDetector::Histogram::mergeWith(CvAdaptiveSkinDetector::Histogram *source, double weight)
{
float myweight = (float)(1-weight);
float maxVal1 = 0, maxVal2 = 0, *f1, *f2, ff1, ff2;
cvGetMinMaxHistValue(source->fHistogram, NULL, &maxVal2);
if (maxVal2 > 0 )
{
cvGetMinMaxHistValue(fHistogram, NULL, &maxVal1);
if (maxVal1 <= 0)
{
for (int i = 0; i < HistogramSize; i++)
{
f1 = (float*)cvPtr1D(fHistogram->bins, i);
f2 = (float*)cvPtr1D(source->fHistogram->bins, i);
(*f1) = (*f2);
}
}
else
{
for (int i = 0; i < HistogramSize; i++)
{
f1 = (float*)cvPtr1D(fHistogram->bins, i);
f2 = (float*)cvPtr1D(source->fHistogram->bins, i);
ff1 = ((*f1)/maxVal1)*myweight;
if (ff1 < 0)
ff1 = -ff1;
ff2 = (float)(((*f2)/maxVal2)*weight);
if (ff2 < 0)
ff2 = -ff2;
(*f1) = (ff1 + ff2);
}
}
}
};
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;
}
static double
icvGetThreshVal_Otsu( const CvHistogram* hist )
{
double max_val = 0;
CV_FUNCNAME( "icvGetThreshVal_Otsu" );
__BEGIN__;
int i, count;
const float* h;
double sum = 0, mu = 0;
bool uniform = false;
double low = 0, high = 0, delta = 0;
float* nu_thresh = 0;
double mu1 = 0, q1 = 0;
double max_sigma = 0;
if( !CV_IS_HIST(hist) || CV_IS_SPARSE_HIST(hist) || hist->mat.dims != 1 )
CV_ERROR( CV_StsBadArg,
"The histogram in Otsu method must be a valid dense 1D histogram" );
count = hist->mat.dim[0].size;
h = (float*)cvPtr1D( hist->bins, 0 );
if( !CV_HIST_HAS_RANGES(hist) || CV_IS_UNIFORM_HIST(hist) )
{
if( CV_HIST_HAS_RANGES(hist) )
{
low = hist->thresh[0][0];
high = hist->thresh[0][1];
}
else
{
low = 0;
high = count;
}
delta = (high-low)/count;
low += delta*0.5;
uniform = true;
}
else
nu_thresh = hist->thresh2[0];
for( i = 0; i < count; i++ )
{
sum += h[i];
if( uniform )
mu += (i*delta + low)*h[i];
else
mu += (nu_thresh[i*2] + nu_thresh[i*2+1])*0.5*h[i];
}
sum = fabs(sum) > FLT_EPSILON ? 1./sum : 0;
mu *= sum;
mu1 = 0;
q1 = 0;
for( i = 0; i < count; i++ )
{
double p_i, q2, mu2, val_i, sigma;
p_i = h[i]*sum;
mu1 *= q1;
q1 += p_i;
q2 = 1. - q1;
if( MIN(q1,q2) < FLT_EPSILON || MAX(q1,q2) > 1. - FLT_EPSILON )
continue;
if( uniform )
val_i = i*delta + low;
else
val_i = (nu_thresh[i*2] + nu_thresh[i*2+1])*0.5;
mu1 = (mu1 + val_i*p_i)/q1;
mu2 = (mu - q1*mu1)/q2;
sigma = q1*q2*(mu1 - mu2)*(mu1 - mu2);
if( sigma > max_sigma )
{
max_sigma = sigma;
max_val = val_i;
}
}
__END__;
return max_val;
}
void CV_QueryHistTest::run_func(void)
{
int i, iters = values->cols;
CvArr* h = hist[0]->bins;
const int* idx = indices->data.i;
float* val = values->data.fl;
float default_value = 0.f;
// stage 1: write bins
if( cdims == 1 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
{
if( !(i % 4) )
cvSetReal1D( h, idx[i], v0 );
else
*(float*)cvPtr1D( h, idx[i] ) = v0;
}
else
cvSetRealND( h, idx+i, v0 );
}
else if( cdims == 2 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
{
if( !(i % 4) )
cvSetReal2D( h, idx[i*2], idx[i*2+1], v0 );
else
*(float*)cvPtr2D( h, idx[i*2], idx[i*2+1] ) = v0;
}
else
cvSetRealND( h, idx+i*2, v0 );
}
else if( cdims == 3 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
{
if( !(i % 4) )
cvSetReal3D( h, idx[i*3], idx[i*3+1], idx[i*3+2], v0 );
else
*(float*)cvPtr3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] ) = v0;
}
else
cvSetRealND( h, idx+i*3, v0 );
}
else
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
cvSetRealND( h, idx+i*cdims, v0 );
else
*(float*)cvPtrND( h, idx+i*cdims ) = v0;
}
// stage 2: read bins
if( cdims == 1 )
for( i = 0; i < iters; i++ )
{
if( !(i % 2) )
val[i] = *(float*)cvPtr1D( h, idx[i] );
else
val[i] = (float)cvGetReal1D( h, idx[i] );
}
else if( cdims == 2 )
for( i = 0; i < iters; i++ )
{
if( !(i % 2) )
val[i] = *(float*)cvPtr2D( h, idx[i*2], idx[i*2+1] );
else
val[i] = (float)cvGetReal2D( h, idx[i*2], idx[i*2+1] );
}
else if( cdims == 3 )
for( i = 0; i < iters; i++ )
{
if( !(i % 2) )
val[i] = *(float*)cvPtr3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] );
else
val[i] = (float)cvGetReal3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] );
}
else
for( i = 0; i < iters; i++ )
{
if( !(i % 2) )
val[i] = *(float*)cvPtrND( h, idx+i*cdims );
else
val[i] = (float)cvGetRealND( h, idx+i*cdims );
}
}
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;
}
