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;
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;
}
void CV_QueryHistTest::clear()
{
- cvReleaseMat( &indices );
- cvReleaseMat( &values );
- cvReleaseMat( &values0 );
CV_BaseHistTest::clear();
}
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++ )
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
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;
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) )
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) )
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) )
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) )
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) )
{
{
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;
}
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;
-CV_ThreshHistTest::CV_ThreshHistTest()
+CV_ThreshHistTest::CV_ThreshHistTest() : threshold(0)
{
hist_count = 1;
gen_random_hist = 1;
- threshold = 0;
- indices = values = 0;
}
void CV_ThreshHistTest::clear()
{
- cvReleaseMat( &indices );
- cvReleaseMat( &values );
CV_BaseHistTest::clear();
}
{
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
{
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++ )
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",
{
int code = cvtest::TS::OK;
int i;
- float* ptr0 = values->data.fl;
+ float* ptr0 = values.ptr<float>();
float* ptr = 0;
CvSparseMat* sparse = 0;
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;
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;
- }
}
void CV_CalcHistTest::clear()
{
- int i;
-
- for( i = 0; i <= CV_MAX_DIM; i++ )
- cvReleaseImage( &images[i] );
-
CV_BaseHistTest::clear();
}
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();
}
}
}
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++ )
{
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
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;
- }
}
void CV_CalcBackProjectTest::clear()
{
- int i;
-
- for( i = 0; i < CV_MAX_DIM+3; i++ )
- cvReleaseImage( &images[i] );
-
CV_BaseHistTest::clear();
}
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());
}
}
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;
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++ )
{
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
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;
}
}
}
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" );
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;
- }
}
void CV_CalcBackProjectPatchTest::clear()
{
- int i;
-
- for( i = 0; i < CV_MAX_DIM+2; i++ )
- cvReleaseImage( &images[i] );
-
CV_BaseHistTest::clear();
}
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;
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;
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;
}
}
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 )
projects / platform / upstream / opencv.git / commitdiff