third_party/opencv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #10757 from savuor:test_hist_renew

Browse Source 
* old types removed

* QueryHist tests: new types

* ThreshHist tests: new types

* CalcHist tests: new types

* CalcBackProject tests: new types

* CalcBackProjectPatch tests: new types

* const ref added
This commit is contained in:
Rostislav Vasilikhin
2018-02-02 21:35:44 +03:00
committed by Alexander Alekhin
parent 403c3c3d03
commit 1055f9d208
1 changed files with 260 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/imgproc/test/test_histograms.cpp
+260 -200
View File
@@ -78,7 +78,7 @@ protected:
int img_type;
int img_max_log_size;
double low, high, range_delta;
CvSize img_size;
Size img_size;
vector<CvHistogram*> hist;
vector<float> _ranges;
@@ -324,19 +324,15 @@ protected:
int validate_test_results( int test_case_idx );
void init_hist( int test_case_idx, int i );
CvMat* indices;
CvMat* values;
CvMat* values0;
Mat indices;
Mat values;
Mat values0;
};
CV_QueryHistTest::CV_QueryHistTest()
{
hist_count = 1;
indices = 0;
values = 0;
values0 = 0;
}
@@ -348,9 +344,6 @@ CV_QueryHistTest::~CV_QueryHistTest()
void CV_QueryHistTest::clear()
{
cvReleaseMat( &indices );
cvReleaseMat( &values );
cvReleaseMat( &values0 );
CV_BaseHistTest::clear();
}
@@ -371,24 +364,22 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
int i, j, iters;
float default_value = 0.f;
RNG& rng = ts->get_rng();
CvMat* bit_mask = 0;
int* idx;
iters = (cvtest::randInt(rng) % MAX(total_size/10,100)) + 1;
iters = MIN( iters, total_size*9/10 + 1 );
indices = cvCreateMat( 1, iters*cdims, CV_32S );
values = cvCreateMat( 1, iters, CV_32F );
values0 = cvCreateMat( 1, iters, CV_32F );
idx = indices->data.i;
indices = Mat(1, iters*cdims, CV_32S);
values = Mat(1, iters, CV_32F );
values0 = Mat( 1, iters, CV_32F );
idx = indices.ptr<int>();
//printf( "total_size = %d, cdims = %d, iters = %d\n", total_size, cdims, iters );
bit_mask = cvCreateMat( 1, (total_size + 7)/8, CV_8U );
cvZero( bit_mask );
Mat bit_mask(1, (total_size + 7)/8, CV_8U, Scalar(0));
#define GET_BIT(n) (bit_mask->data.ptr[(n)/8] & (1 << ((n)&7)))
#define SET_BIT(n) bit_mask->data.ptr[(n)/8] |= (1 << ((n)&7))
#define GET_BIT(n) (bit_mask.data[(n)/8] & (1 << ((n)&7)))
#define SET_BIT(n) bit_mask.data[(n)/8] |= (1 << ((n)&7))
// set random histogram bins' values to the linear indices of the bins
for( i = 0; i < iters; i++ )
@@ -403,13 +394,13 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
if( cvtest::randInt(rng) % 8 || GET_BIT(lin_idx) )
{
values0->data.fl[i] = (float)(lin_idx+1);
values0.at<float>(i) = (float)(lin_idx+1);
SET_BIT(lin_idx);
}
else
// some histogram bins will not be initialized intentionally,
// they should be equal to the default value
values0->data.fl[i] = default_value;
values0.at<float>(i) = default_value;
}
// do the second pass to make values0 consistent with bit_mask
@@ -420,10 +411,8 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
lin_idx = lin_idx*dims[j] + idx[i*cdims + j];
if( GET_BIT(lin_idx) )
values0->data.fl[i] = (float)(lin_idx+1);
values0.at<float>(i) = (float)(lin_idx+1);
}
cvReleaseMat( &bit_mask );
}
return code;
@@ -432,17 +421,17 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
void CV_QueryHistTest::run_func(void)
{
int i, iters = values->cols;
int i, iters = values.cols;
CvArr* h = hist[0]->bins;
const int* idx = indices->data.i;
float* val = values->data.fl;
const int* idx = indices.ptr<int>();
float* val = values.ptr<float>();
float default_value = 0.f;
// stage 1: write bins
if( cdims == 1 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
float v0 = values0.at<float>(i);
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
@@ -458,7 +447,7 @@ void CV_QueryHistTest::run_func(void)
else if( cdims == 2 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
float v0 = values0.at<float>(i);
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
@@ -474,7 +463,7 @@ void CV_QueryHistTest::run_func(void)
else if( cdims == 3 )
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
float v0 = values0.at<float>(i);
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
@@ -490,7 +479,7 @@ void CV_QueryHistTest::run_func(void)
else
for( i = 0; i < iters; i++ )
{
float v0 = values0->data.fl[i];
float v0 = values0.at<float>(i);
if( fabs(v0 - default_value) < FLT_EPSILON )
continue;
if( !(i % 2) )
@@ -538,11 +527,11 @@ void CV_QueryHistTest::run_func(void)
int CV_QueryHistTest::validate_test_results( int /*test_case_idx*/ )
{
int code = cvtest::TS::OK;
int i, j, iters = values->cols;
int i, j, iters = values.cols;
for( i = 0; i < iters; i++ )
{
float v = values->data.fl[i], v0 = values0->data.fl[i];
float v = values.at<float>(i), v0 = values0.at<float>(i);
if( cvIsNaN(v) || cvIsInf(v) )
{
@@ -559,7 +548,7 @@ int CV_QueryHistTest::validate_test_results( int /*test_case_idx*/ )
{
ts->printf( cvtest::TS::LOG, "The bin index = (" );
for( j = 0; j < cdims; j++ )
ts->printf( cvtest::TS::LOG, "%d%s", indices->data.i[i*cdims + j],
ts->printf( cvtest::TS::LOG, "%d%s", indices.at<int>(i*cdims + j),
j < cdims-1 ? ", " : ")\n" );
break;
}
@@ -797,8 +786,8 @@ protected:
int prepare_test_case( int test_case_idx );
void run_func(void);
int validate_test_results( int test_case_idx );
CvMat* indices;
CvMat* values;
Mat indices;
Mat values;
int orig_nz_count;
double threshold;
@@ -806,12 +795,10 @@ protected:
CV_ThreshHistTest::CV_ThreshHistTest()
CV_ThreshHistTest::CV_ThreshHistTest() : threshold(0)
{
hist_count = 1;
gen_random_hist = 1;
threshold = 0;
indices = values = 0;
}
@@ -823,8 +810,6 @@ CV_ThreshHistTest::~CV_ThreshHistTest()
void CV_ThreshHistTest::clear()
{
cvReleaseMat( &indices );
cvReleaseMat( &values );
CV_BaseHistTest::clear();
}
@@ -842,8 +827,9 @@ int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
{
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) );
values = Mat( 1, total_size, CV_32F );
indices = Mat();
memcpy( values.ptr<float>(), cvPtr1D( hist[0]->bins, 0 ), total_size*sizeof(float) );
}
else
{
@@ -854,8 +840,8 @@ int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
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 );
values = Mat( 1, orig_nz_count+1, CV_32F );
indices = Mat( 1, (orig_nz_count+1)*cdims, CV_32S );
for( node = cvInitSparseMatIterator( sparse, &iterator ), i = 0;
node != 0; node = cvGetNextSparseNode( &iterator ), i++ )
@@ -864,9 +850,9 @@ int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
OPENCV_ASSERT( i < orig_nz_count, "CV_ThreshHistTest::prepare_test_case", "Buffer overflow" );
values->data.fl[i] = *(float*)CV_NODE_VAL(sparse,node);
values.at<float>(i) = *(float*)CV_NODE_VAL(sparse,node);
for( k = 0; k < cdims; k++ )
indices->data.i[i*cdims + k] = idx[k];
indices.at<int>(i*cdims + k) = idx[k];
}
OPENCV_ASSERT( i == orig_nz_count, "Unmatched buffer size",
@@ -888,7 +874,7 @@ int CV_ThreshHistTest::validate_test_results( int /*test_case_idx*/ )
{
int code = cvtest::TS::OK;
int i;
float* ptr0 = values->data.fl;
float* ptr0 = values.ptr<float>();
float* ptr = 0;
CvSparseMat* sparse = 0;
@@ -907,8 +893,8 @@ int CV_ThreshHistTest::validate_test_results( int /*test_case_idx*/ )
v = ptr[i];
else
{
v = (float)cvGetRealND( sparse, indices->data.i + i*cdims );
cvClearND( sparse, indices->data.i + i*cdims );
v = (float)cvGetRealND( sparse, indices.ptr<int>() + i*cdims );
cvClearND( sparse, indices.ptr<int>() + i*cdims );
}
if( v0 <= threshold ) v0 = 0.f;
@@ -1128,25 +1114,17 @@ protected:
int prepare_test_case( int test_case_idx );
void run_func(void);
int validate_test_results( int test_case_idx );
IplImage* images[CV_MAX_DIM+1];
int channels[CV_MAX_DIM+1];
vector<Mat> images;
vector<int> channels;
};
CV_CalcHistTest::CV_CalcHistTest()
CV_CalcHistTest::CV_CalcHistTest() : images(CV_MAX_DIM+1), channels(CV_MAX_DIM+1)
{
int i;
hist_count = 2;
gen_random_hist = 0;
init_ranges = 1;
for( i = 0; i <= CV_MAX_DIM; i++ )
{
images[i] = 0;
channels[i] = 0;
}
}
@@ -1158,11 +1136,6 @@ CV_CalcHistTest::~CV_CalcHistTest()
void CV_CalcHistTest::clear()
{
int i;
for( i = 0; i <= CV_MAX_DIM; i++ )
cvReleaseImage( &images[i] );
CV_BaseHistTest::clear();
}
@@ -1181,21 +1154,22 @@ int CV_CalcHistTest::prepare_test_case( int test_case_idx )
if( i < cdims )
{
int nch = 1; //cvtest::randInt(rng) % 3 + 1;
images[i] = cvCreateImage( img_size,
img_type == CV_8U ? IPL_DEPTH_8U : IPL_DEPTH_32F, nch );
images[i] = Mat(img_size, CV_MAKETYPE(img_type, nch));
channels[i] = cvtest::randInt(rng) % nch;
Mat images_i = cvarrToMat(images[i]);
cvtest::randUni( rng, images_i, Scalar::all(low), Scalar::all(high) );
cvtest::randUni( rng, images[i], Scalar::all(low), Scalar::all(high) );
}
else if( i == CV_MAX_DIM && cvtest::randInt(rng) % 2 )
else if( i == CV_MAX_DIM )
{
// create mask
images[i] = cvCreateImage( img_size, IPL_DEPTH_8U, 1 );
Mat images_i = cvarrToMat(images[i]);
if( cvtest::randInt(rng) % 2 )
{
// create mask
images[i] = Mat(img_size, CV_8U);
// make ~25% pixels in the mask non-zero
cvtest::randUni( rng, images_i, Scalar::all(-2), Scalar::all(2) );
// make ~25% pixels in the mask non-zero
cvtest::randUni( rng, images[i], Scalar::all(-2), Scalar::all(2) );
}
else
images[i] = Mat();
}
}
}
@@ -1206,50 +1180,112 @@ int CV_CalcHistTest::prepare_test_case( int test_case_idx )
void CV_CalcHistTest::run_func(void)
{
cvCalcHist( images, hist[0], 0, images[CV_MAX_DIM] );
int size[CV_MAX_DIM];
int hdims = cvGetDims( hist[0]->bins, size);
bool huniform = CV_IS_UNIFORM_HIST(hist[0]);
const float* uranges[CV_MAX_DIM] = {0};
const float** hranges = 0;
if( hist[0]->type & CV_HIST_RANGES_FLAG )
{
hranges = (const float**)hist[0]->thresh2;
if( huniform )
{
for(int i = 0; i < hdims; i++ )
uranges[i] = &hist[0]->thresh[i][0];
hranges = uranges;
}
}
std::vector<cv::Mat> imagesv(cdims);
copy(images.begin(), images.begin() + cdims, imagesv.begin());
Mat mask = images[CV_MAX_DIM];
if( !CV_IS_SPARSE_HIST(hist[0]) )
{
cv::Mat H = cv::cvarrToMat(hist[0]->bins);
if(huniform)
{
vector<int> emptyChannels;
vector<int> hSize(hdims);
for(int i = 0; i < hdims; i++)
hSize[i] = size[i];
vector<float> vranges;
if(hranges)
{
vranges.resize(hdims*2);
for(int i = 0; i < hdims; i++ )
{
vranges[i*2 ] = hist[0]->thresh[i][0];
vranges[i*2+1] = hist[0]->thresh[i][1];
}
}
cv::calcHist(imagesv, emptyChannels, mask, H, hSize, vranges);
}
else
{
cv::calcHist( &imagesv[0], (int)imagesv.size(), 0, mask,
H, cvGetDims(hist[0]->bins), H.size, hranges, huniform );
}
}
else
{
CvSparseMat* sparsemat = (CvSparseMat*)hist[0]->bins;
cvZero( hist[0]->bins );
cv::SparseMat sH;
sparsemat->copyToSparseMat(sH);
cv::calcHist( &imagesv[0], (int)imagesv.size(), 0, mask, sH, sH.dims(),
sH.dims() > 0 ? sH.hdr->size : 0, hranges, huniform, false);
cv::SparseMatConstIterator it = sH.begin();
int nz = (int)sH.nzcount();
for(int i = 0; i < nz; i++, ++it )
{
CV_Assert(it.ptr != NULL);
*(float*)cvPtrND(sparsemat, it.node()->idx, 0, -2) = *(const float*)it.ptr;
}
}
}
static void
cvTsCalcHist( IplImage** _images, CvHistogram* hist, IplImage* _mask, int* channels )
cvTsCalcHist( const vector<Mat>& images, CvHistogram* hist, Mat mask, const vector<int>& channels )
{
int x, y, k, cdims;
int x, y, k;
union
{
float* fl;
uchar* ptr;
const float* fl;
const uchar* ptr;
}
plane[CV_MAX_DIM];
int nch[CV_MAX_DIM];
int dims[CV_MAX_DIM];
int uniform = CV_IS_UNIFORM_HIST(hist);
CvSize img_size = cvGetSize(_images[0]);
CvMat images[CV_MAX_DIM], mask = cvMat(1,1,CV_8U);
int img_depth = _images[0]->depth;
cdims = cvGetDims( hist->bins, dims );
int cdims = cvGetDims( hist->bins, dims );
cvZero( hist->bins );
Size img_size = images[0].size();
int img_depth = images[0].depth();
for( k = 0; k < cdims; k++ )
{
cvGetMat( _images[k], &images[k] );
nch[k] = _images[k]->nChannels;
nch[k] = images[k].channels();
}
if( _mask )
cvGetMat( _mask, &mask );
for( y = 0; y < img_size.height; y++ )
{
const uchar* mptr = _mask ? &CV_MAT_ELEM(mask, uchar, y, 0 ) : 0;
const uchar* mptr = mask.empty() ? 0 : mask.ptr<uchar>(y);
if( img_depth == IPL_DEPTH_8U )
if( img_depth == CV_8U )
for( k = 0; k < cdims; k++ )
plane[k].ptr = &CV_MAT_ELEM(images[k], uchar, y, 0 ) + channels[k];
plane[k].ptr = images[k].ptr<uchar>(y) + channels[k];
else
for( k = 0; k < cdims; k++ )
plane[k].fl = &CV_MAT_ELEM(images[k], float, y, 0 ) + channels[k];
plane[k].fl = images[k].ptr<float>(y) + channels[k];
for( x = 0; x < img_size.width; x++ )
{
@@ -1258,7 +1294,7 @@ cvTsCalcHist( IplImage** _images, CvHistogram* hist, IplImage* _mask, int* chann
if( mptr && !mptr[x] )
continue;
if( img_depth == IPL_DEPTH_8U )
if( img_depth == CV_8U )
for( k = 0; k < cdims; k++ )
val[k] = plane[k].ptr[x*nch[k]];
else
@@ -1339,25 +1375,17 @@ protected:
int prepare_test_case( int test_case_idx );
void run_func(void);
int validate_test_results( int test_case_idx );
IplImage* images[CV_MAX_DIM+3];
int channels[CV_MAX_DIM+3];
vector<Mat> images;
vector<int> channels;
};
CV_CalcBackProjectTest::CV_CalcBackProjectTest()
CV_CalcBackProjectTest::CV_CalcBackProjectTest() : images(CV_MAX_DIM+3), channels(CV_MAX_DIM+3)
{
int i;
hist_count = 1;
gen_random_hist = 0;
init_ranges = 1;
for( i = 0; i < CV_MAX_DIM+3; i++ )
{
images[i] = 0;
channels[i] = 0;
}
}
@@ -1369,11 +1397,6 @@ CV_CalcBackProjectTest::~CV_CalcBackProjectTest()
void CV_CalcBackProjectTest::clear()
{
int i;
for( i = 0; i < CV_MAX_DIM+3; i++ )
cvReleaseImage( &images[i] );
CV_BaseHistTest::clear();
}
@@ -1385,31 +1408,35 @@ int CV_CalcBackProjectTest::prepare_test_case( int test_case_idx )
if( code > 0 )
{
RNG& rng = ts->get_rng();
int i, j, n, img_len = img_size.width*img_size.height;
int i, j, n, img_len = img_size.area();
for( i = 0; i < CV_MAX_DIM + 3; i++ )
{
if( i < cdims )
{
int nch = 1; //cvtest::randInt(rng) % 3 + 1;
images[i] = cvCreateImage( img_size,
img_type == CV_8U ? IPL_DEPTH_8U : IPL_DEPTH_32F, nch );
images[i] = Mat(img_size, CV_MAKETYPE(img_type, nch));
channels[i] = cvtest::randInt(rng) % nch;
Mat images_i = cvarrToMat(images[i]);
cvtest::randUni( rng, images_i, Scalar::all(low), Scalar::all(high) );
cvtest::randUni( rng, images[i], Scalar::all(low), Scalar::all(high) );
}
else if( i == CV_MAX_DIM && cvtest::randInt(rng) % 2 )
else if( i == CV_MAX_DIM )
{
// create mask
images[i] = cvCreateImage( img_size, IPL_DEPTH_8U, 1 );
Mat images_i = cvarrToMat(images[i]);
// make ~25% pixels in the mask non-zero
cvtest::randUni( rng, images_i, Scalar::all(-2), Scalar::all(2) );
if(cvtest::randInt(rng) % 2 )
{
// create mask
images[i] = Mat(img_size, CV_8U);
// make ~25% pixels in the mask non-zero
cvtest::randUni( rng, images[i], Scalar::all(-2), Scalar::all(2) );
}
else
{
images[i] = Mat();
}
}
else if( i > CV_MAX_DIM )
{
images[i] = cvCreateImage( img_size, images[0]->depth, 1 );
images[i] = Mat(img_size, images[0].type());
}
}
@@ -1419,7 +1446,7 @@ int CV_CalcBackProjectTest::prepare_test_case( int test_case_idx )
n = cvtest::randInt(rng) % (img_len/20+1);
for( i = 0; i < cdims; i++ )
{
char* data = images[i]->imageData;
uchar* data = images[i].data;
for( j = 0; j < n; j++ )
{
int idx = cvtest::randInt(rng) % img_len;
@@ -1439,39 +1466,94 @@ int CV_CalcBackProjectTest::prepare_test_case( int test_case_idx )
void CV_CalcBackProjectTest::run_func(void)
{
cvCalcBackProject( images, images[CV_MAX_DIM+1], hist[0] );
int size[CV_MAX_DIM];
int hdims = cvGetDims( hist[0]->bins, size );
bool huniform = CV_IS_UNIFORM_HIST(hist[0]);
const float* uranges[CV_MAX_DIM] = {0};
const float** hranges = 0;
if( hist[0]->type & CV_HIST_RANGES_FLAG )
{
hranges = (const float**)hist[0]->thresh2;
if( huniform )
{
for(int i = 0; i < hdims; i++ )
uranges[i] = &hist[0]->thresh[i][0];
hranges = uranges;
}
}
std::vector<cv::Mat> imagesv(hdims);
copy(images.begin(), images.begin() + hdims, imagesv.begin());
cv::Mat dst = images[CV_MAX_DIM+1];
CV_Assert( dst.size() == imagesv[0].size() && dst.depth() == imagesv[0].depth() );
if( !CV_IS_SPARSE_HIST(hist[0]) )
{
cv::Mat H = cv::cvarrToMat(hist[0]->bins);
if(huniform)
{
vector<int> emptyChannels;
vector<float> vranges;
if(hranges)
{
vranges.resize(hdims*2);
for(int i = 0; i < hdims; i++ )
{
vranges[i*2 ] = hist[0]->thresh[i][0];
vranges[i*2+1] = hist[0]->thresh[i][1];
}
}
cv::calcBackProject(imagesv, emptyChannels, H, dst, vranges, 1);
}
else
{
cv::calcBackProject( &imagesv[0], (int)imagesv.size(),
0, H, dst, hranges, 1, false );
}
}
else
{
cv::SparseMat sH;
((const CvSparseMat*)hist[0]->bins)->copyToSparseMat(sH);
cv::calcBackProject( &imagesv[0], (int)imagesv.size(),
0, sH, dst, hranges, 1, huniform );
}
}
static void
cvTsCalcBackProject( IplImage** images, IplImage* dst, CvHistogram* hist, int* channels )
cvTsCalcBackProject( const vector<Mat>& images, Mat dst, CvHistogram* hist, const vector<int>& channels )
{
int x, y, k, cdims;
union
{
float* fl;
uchar* ptr;
const float* fl;
const uchar* ptr;
}
plane[CV_MAX_DIM];
int nch[CV_MAX_DIM];
int dims[CV_MAX_DIM];
int uniform = CV_IS_UNIFORM_HIST(hist);
CvSize img_size = cvGetSize(images[0]);
int img_depth = images[0]->depth;
Size img_size = images[0].size();
int img_depth = images[0].depth();
cdims = cvGetDims( hist->bins, dims );
for( k = 0; k < cdims; k++ )
nch[k] = images[k]->nChannels;
nch[k] = images[k].channels();
for( y = 0; y < img_size.height; y++ )
{
if( img_depth == IPL_DEPTH_8U )
if( img_depth == CV_8U )
for( k = 0; k < cdims; k++ )
plane[k].ptr = &CV_IMAGE_ELEM(images[k], uchar, y, 0 ) + channels[k];
plane[k].ptr = images[k].ptr<uchar>(y) + channels[k];
else
for( k = 0; k < cdims; k++ )
plane[k].fl = &CV_IMAGE_ELEM(images[k], float, y, 0 ) + channels[k];
plane[k].fl = images[k].ptr<float>(y) + channels[k];
for( x = 0; x < img_size.width; x++ )
{
@@ -1479,7 +1561,7 @@ cvTsCalcBackProject( IplImage** images, IplImage* dst, CvHistogram* hist, int* c
float bin_val = 0;
int idx[CV_MAX_DIM];
if( img_depth == IPL_DEPTH_8U )
if( img_depth == CV_8U )
for( k = 0; k < cdims; k++ )
val[k] = plane[k].ptr[x*nch[k]];
else
@@ -1517,13 +1599,13 @@ cvTsCalcBackProject( IplImage** images, IplImage* dst, CvHistogram* hist, int* c
if( k == cdims )
bin_val = (float)cvGetRealND( hist->bins, idx );
if( img_depth == IPL_DEPTH_8U )
if( img_depth == CV_8U )
{
int t = cvRound(bin_val);
CV_IMAGE_ELEM( dst, uchar, y, x ) = saturate_cast<uchar>(t);
dst.at<uchar>(y, x) = saturate_cast<uchar>(t);
}
else
CV_IMAGE_ELEM( dst, float, y, x ) = bin_val;
dst.at<float>(y, x) = bin_val;
}
}
}
@@ -1534,7 +1616,7 @@ int CV_CalcBackProjectTest::validate_test_results( int /*test_case_idx*/ )
int code = cvtest::TS::OK;
cvTsCalcBackProject( images, images[CV_MAX_DIM+2], hist[0], channels );
Mat a = cvarrToMat(images[CV_MAX_DIM+1]), b = cvarrToMat(images[CV_MAX_DIM+2]);
Mat a = images[CV_MAX_DIM+1], b = images[CV_MAX_DIM+2];
double threshold = a.depth() == CV_8U ? 2 : FLT_EPSILON;
code = cvtest::cmpEps2( ts, a, b, threshold, true, "Back project image" );
@@ -1558,30 +1640,22 @@ protected:
int prepare_test_case( int test_case_idx );
void run_func(void);
int validate_test_results( int test_case_idx );
IplImage* images[CV_MAX_DIM+2];
int channels[CV_MAX_DIM+2];
vector<Mat> images;
vector<int> channels;
CvSize patch_size;
Size patch_size;
double factor;
int method;
};
CV_CalcBackProjectPatchTest::CV_CalcBackProjectPatchTest()
CV_CalcBackProjectPatchTest::CV_CalcBackProjectPatchTest() :
images(CV_MAX_DIM+2), channels(CV_MAX_DIM+2)
{
int i;
hist_count = 1;
gen_random_hist = 0;
init_ranges = 1;
img_max_log_size = 6;
for( i = 0; i < CV_MAX_DIM+2; i++ )
{
images[i] = 0;
channels[i] = 0;
}
}
@@ -1593,11 +1667,6 @@ CV_CalcBackProjectPatchTest::~CV_CalcBackProjectPatchTest()
void CV_CalcBackProjectPatchTest::clear()
{
int i;
for( i = 0; i < CV_MAX_DIM+2; i++ )
cvReleaseImage( &images[i] );
CV_BaseHistTest::clear();
}
@@ -1609,7 +1678,7 @@ int CV_CalcBackProjectPatchTest::prepare_test_case( int test_case_idx )
if( code > 0 )
{
RNG& rng = ts->get_rng();
int i, j, n, img_len = img_size.width*img_size.height;
int i, j, n, img_len = img_size.area();
patch_size.width = cvtest::randInt(rng) % img_size.width + 1;
patch_size.height = cvtest::randInt(rng) % img_size.height + 1;
@@ -1624,30 +1693,24 @@ int CV_CalcBackProjectPatchTest::prepare_test_case( int test_case_idx )
if( i < cdims )
{
int nch = 1; //cvtest::randInt(rng) % 3 + 1;
images[i] = cvCreateImage( img_size,
img_type == CV_8U ? IPL_DEPTH_8U : IPL_DEPTH_32F, nch );
images[i] = Mat(img_size, CV_MAKETYPE(img_type, nch));
channels[i] = cvtest::randInt(rng) % nch;
Mat images_i = cvarrToMat(images[i]);
cvtest::randUni( rng, images_i, Scalar::all(low), Scalar::all(high) );
cvtest::randUni( rng, images[i], Scalar::all(low), Scalar::all(high) );
}
else if( i >= CV_MAX_DIM )
{
images[i] = cvCreateImage(
cvSize(img_size.width - patch_size.width + 1,
img_size.height - patch_size.height + 1),
IPL_DEPTH_32F, 1 );
images[i] = Mat(img_size - patch_size + Size(1, 1), CV_32F);
}
}
cvTsCalcHist( images, hist[0], 0, channels );
cvTsCalcHist( images, hist[0], Mat(), channels );
cvNormalizeHist( hist[0], factor );
// now modify the images a bit
n = cvtest::randInt(rng) % (img_len/10+1);
for( i = 0; i < cdims; i++ )
{
char* data = images[i]->imageData;
uchar* data = images[i].data;
for( j = 0; j < n; j++ )
{
int idx = cvtest::randInt(rng) % img_len;
@@ -1667,53 +1730,46 @@ int CV_CalcBackProjectPatchTest::prepare_test_case( int test_case_idx )
void CV_CalcBackProjectPatchTest::run_func(void)
{
cvCalcBackProjectPatch( images, images[CV_MAX_DIM], patch_size, hist[0], method, factor );
CvMat dst(images[CV_MAX_DIM]);
vector<CvMat > img(cdims);
vector<CvMat*> pimg(cdims);
for(int i = 0; i < cdims; i++)
{
img[i] = CvMat(images[i]);
pimg[i] = &img[i];
}
cvCalcArrBackProjectPatch( (CvArr**)&pimg[0], &dst, patch_size, hist[0], method, factor );
}
static void
cvTsCalcBackProjectPatch( IplImage** images, IplImage* dst, CvSize patch_size,
cvTsCalcBackProjectPatch( const vector<Mat>& images, Mat dst, Size patch_size,
CvHistogram* hist, int method,
double factor, int* channels )
double factor, const vector<int>& channels )
{
CvHistogram* model = 0;
IplImage imgstub[CV_MAX_DIM], *img[CV_MAX_DIM];
IplROI roi;
int i, dims;
int x, y;
CvSize size = cvGetSize(dst);
Size size = dst.size();
dims = cvGetDims( hist->bins );
cvCopyHist( hist, &model );
cvNormalizeHist( hist, factor );
cvZero( dst );
for( i = 0; i < dims; i++ )
{
CvMat stub, *mat;
mat = cvGetMat( images[i], &stub, 0, 0 );
img[i] = cvGetImage( mat, &imgstub[i] );
img[i]->roi = &roi;
}
roi.coi = 0;
vector<Mat> img(images.size());
for( y = 0; y < size.height; y++ )
{
for( x = 0; x < size.width; x++ )
{
double result;
roi.xOffset = x;
roi.yOffset = y;
roi.width = patch_size.width;
roi.height = patch_size.height;
Rect roi(Point(x, y), patch_size);
for(size_t i = 0; i < img.size(); i++)
img[i] = images[i](roi);
cvTsCalcHist( img, model, 0, channels );
cvTsCalcHist( img, model, Mat(), channels );
cvNormalizeHist( model, factor );
result = cvCompareHist( model, hist, method );
CV_IMAGE_ELEM( dst, float, y, x ) = (float)result;
dst.at<float>(y, x) = (float)result;
}
}
@@ -1726,10 +1782,14 @@ int CV_CalcBackProjectPatchTest::validate_test_results( int /*test_case_idx*/ )
int code = cvtest::TS::OK;
double err_level = 5e-3;
cvTsCalcBackProjectPatch( images, images[CV_MAX_DIM+1],
patch_size, hist[0], method, factor, channels );
Mat dst = images[CV_MAX_DIM+1];
vector<Mat> imagesv(cdims);
for(int i = 0; i < cdims; i++)
imagesv[i] = images[i];
cvTsCalcBackProjectPatch( imagesv, dst, patch_size, hist[0],
method, factor, channels );
Mat a = cvarrToMat(images[CV_MAX_DIM]), b = cvarrToMat(images[CV_MAX_DIM+1]);
Mat a = images[CV_MAX_DIM], b = images[CV_MAX_DIM+1];
code = cvtest::cmpEps2( ts, a, b, err_level, true, "BackProjectPatch result" );
if( code < 0 )