generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

added buffered version of pyrDown and pyrUp

Browse Source 
added stream support to downsample, upsample, pyrUp and pyrDown
This commit is contained in:
Vladislav Vinogradov
2011-08-01 08:15:31 +00:00
parent cf42f3088d
commit e746b3e8ae
5 changed files with 377 additions and 1015 deletions
Download Patch File Download Diff File Expand all files Collapse all files

775
modules/gpu/test/test_features2d.cpp
View File

@@ -560,778 +560,3 @@ INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher, testing::Combine(
testing::Values(57, 64, 83, 128, 179, 256, 304)));
#endif // HAVE_CUDA
//struct CV_GpuBFMTest : CV_GpuTestBase
//{
// void run_gpu_test();
//
// void generateData(GpuMat& query, GpuMat& train, int dim, int depth);
//
// virtual void test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher) = 0;
//
// static const int queryDescCount = 300; // must be even number because we split train data in some cases in two
// static const int countFactor = 4; // do not change it
//};
//
//void CV_GpuBFMTest::run_gpu_test()
//{
// BruteForceMatcher_GPU_base::DistType dists[] = {BruteForceMatcher_GPU_base::L1Dist, BruteForceMatcher_GPU_base::L2Dist, BruteForceMatcher_GPU_base::HammingDist};
// const char* dists_str[] = {"L1Dist", "L2Dist", "HammingDist"};
// int dists_count = sizeof(dists) / sizeof(dists[0]);
//
// RNG rng = ts->get_rng();
//
// int dims[] = {rng.uniform(30, 60), 64, rng.uniform(70, 110), 128, rng.uniform(130, 250), 256, rng.uniform(260, 350)};
// int dims_count = sizeof(dims) / sizeof(dims[0]);
//
// for (int dist = 0; dist < dists_count; ++dist)
// {
// int depth_end = dists[dist] == BruteForceMatcher_GPU_base::HammingDist ? CV_32S : CV_32F;
//
// for (int depth = CV_8U; depth <= depth_end; ++depth)
// {
// for (int dim = 0; dim < dims_count; ++dim)
// {
// PRINT_ARGS("dist=%s depth=%s dim=%d", dists_str[dist], getTypeName(depth), dims[dim]);
//
// BruteForceMatcher_GPU_base matcher(dists[dist]);
//
// GpuMat query, train;
// generateData(query, train, dim, depth);
//
// test(query, train, matcher);
// }
// }
// }
//}
//
//void CV_GpuBFMTest::generateData(GpuMat& queryGPU, GpuMat& trainGPU, int dim, int depth)
//{
// RNG& rng = ts->get_rng();
//
// Mat queryBuf, trainBuf;
//
// // Generate query descriptors randomly.
// // Descriptor vector elements are integer values.
// queryBuf.create(queryDescCount, dim, CV_32SC1);
// rng.fill(queryBuf, RNG::UNIFORM, Scalar::all(0), Scalar(3));
// queryBuf.convertTo(queryBuf, CV_32FC1);
//
// // Generate train decriptors as follows:
// // copy each query descriptor to train set countFactor times
// // and perturb some one element of the copied descriptors in
// // in ascending order. General boundaries of the perturbation
// // are (0.f, 1.f).
// trainBuf.create(queryDescCount * countFactor, dim, CV_32FC1);
// float step = 1.f / countFactor;
// for (int qIdx = 0; qIdx < queryDescCount; qIdx++)
// {
// Mat queryDescriptor = queryBuf.row(qIdx);
// for (int c = 0; c < countFactor; c++)
// {
// int tIdx = qIdx * countFactor + c;
// Mat trainDescriptor = trainBuf.row(tIdx);
// queryDescriptor.copyTo(trainDescriptor);
// int elem = rng(dim);
// float diff = rng.uniform(step * c, step * (c + 1));
// trainDescriptor.at<float>(0, elem) += diff;
// }
// }
//
// Mat query, train;
// queryBuf.convertTo(query, depth);
// trainBuf.convertTo(train, depth);
//
// queryGPU.upload(query);
// trainGPU.upload(train);
//}
//
//#define GPU_BFM_TEST(test_name)
// struct CV_GpuBFM_ ##test_name ## _Test : CV_GpuBFMTest
// {
// void test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher);
// };
// TEST(BruteForceMatcher, test_name) { CV_GpuBFM_ ##test_name ## _Test test; test.safe_run(); }
// void CV_GpuBFM_ ##test_name ## _Test::test(const GpuMat& query, const GpuMat& train, BruteForceMatcher_GPU_base& matcher)
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//// match
//
//GPU_BFM_TEST(match)
//{
// vector<DMatch> matches;
//
// matcher.match(query, train, matches);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// for (size_t i = 0; i < matches.size(); i++)
// {
// DMatch match = matches[i];
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
// badCount++;
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
//GPU_BFM_TEST(match_add)
//{
// vector<DMatch> matches;
//
// // make add() twice to test such case
// matcher.add(vector<GpuMat>(1, train.rowRange(0, train.rows/2)));
// matcher.add(vector<GpuMat>(1, train.rowRange(train.rows/2, train.rows)));
//
// // prepare masks (make first nearest match illegal)
// vector<GpuMat> masks(2);
// for (int mi = 0; mi < 2; mi++)
// {
// masks[mi] = GpuMat(query.rows, train.rows/2, CV_8UC1, Scalar::all(1));
// for (int di = 0; di < queryDescCount/2; di++)
// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
// }
//
// matcher.match(query, matches, masks);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// for (size_t i = 0; i < matches.size(); i++)
// {
// DMatch match = matches[i];
// int shift = matcher.isMaskSupported() ? 1 : 0;
// {
// if (i < queryDescCount / 2)
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + shift) || (match.imgIdx != 0))
// badCount++;
// }
// else
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + shift) || (match.imgIdx != 1))
// badCount++;
// }
// }
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//// knnMatch
//
//GPU_BFM_TEST(knnMatch)
//{
// const int knn = 3;
//
// vector< vector<DMatch> > matches;
//
// matcher.knnMatch(query, train, matches, knn);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// for (size_t i = 0; i < matches.size(); i++)
// {
// if ((int)matches[i].size() != knn)
// badCount++;
// else
// {
// int localBadCount = 0;
// for (int k = 0; k < knn; k++)
// {
// DMatch match = matches[i][k];
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
// localBadCount++;
// }
// badCount += localBadCount > 0 ? 1 : 0;
// }
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
//GPU_BFM_TEST(knnMatch_add)
//{
// const int knn = 2;
// vector<vector<DMatch> > matches;
//
// // make add() twice to test such case
// matcher.add(vector<GpuMat>(1,train.rowRange(0, train.rows / 2)));
// matcher.add(vector<GpuMat>(1,train.rowRange(train.rows / 2, train.rows)));
//
// // prepare masks (make first nearest match illegal)
// vector<GpuMat> masks(2);
// for (int mi = 0; mi < 2; mi++ )
// {
// masks[mi] = GpuMat(query.rows, train.rows / 2, CV_8UC1, Scalar::all(1));
// for (int di = 0; di < queryDescCount / 2; di++)
// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
// }
//
// matcher.knnMatch(query, matches, knn, masks);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// int shift = matcher.isMaskSupported() ? 1 : 0;
// for (size_t i = 0; i < matches.size(); i++)
// {
// if ((int)matches[i].size() != knn)
// badCount++;
// else
// {
// int localBadCount = 0;
// for (int k = 0; k < knn; k++)
// {
// DMatch match = matches[i][k];
// {
// if (i < queryDescCount / 2)
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
// localBadCount++;
// }
// else
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
// localBadCount++;
// }
// }
// }
// badCount += localBadCount > 0 ? 1 : 0;
// }
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//// radiusMatch
//
//GPU_BFM_TEST(radiusMatch)
//{
// CHECK_RETURN(support(GLOBAL_ATOMICS), TS::SKIPPED);
//
// const float radius = 1.f / countFactor;
//
// vector< vector<DMatch> > matches;
//
// matcher.radiusMatch(query, train, matches, radius);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// for (size_t i = 0; i < matches.size(); i++)
// {
// if ((int)matches[i].size() != 1)
// badCount++;
// else
// {
// DMatch match = matches[i][0];
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
// badCount++;
// }
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
//GPU_BFM_TEST(radiusMatch_add)
//{
// CHECK_RETURN(support(GLOBAL_ATOMICS), TS::SKIPPED);
//
// int n = 3;
// const float radius = 1.f / countFactor * n;
// vector< vector<DMatch> > matches;
//
// // make add() twice to test such case
// matcher.add(vector<GpuMat>(1,train.rowRange(0, train.rows / 2)));
// matcher.add(vector<GpuMat>(1,train.rowRange(train.rows / 2, train.rows)));
//
// // prepare masks (make first nearest match illegal)
// vector<GpuMat> masks(2);
// for (int mi = 0; mi < 2; mi++)
// {
// masks[mi] = GpuMat(query.rows, train.rows / 2, CV_8UC1, Scalar::all(1));
// for (int di = 0; di < queryDescCount / 2; di++)
// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
// }
//
// matcher.radiusMatch(query, matches, radius, masks);
//
// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
//
// int badCount = 0;
// int shift = matcher.isMaskSupported() ? 1 : 0;
// int needMatchCount = matcher.isMaskSupported() ? n-1 : n;
// for (size_t i = 0; i < matches.size(); i++)
// {
// if ((int)matches[i].size() != needMatchCount)
// badCount++;
// else
// {
// int localBadCount = 0;
// for (int k = 0; k < needMatchCount; k++)
// {
// DMatch match = matches[i][k];
// {
// if (i < queryDescCount / 2)
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
// localBadCount++;
// }
// else
// {
// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
// localBadCount++;
// }
// }
// }
// badCount += localBadCount > 0 ? 1 : 0;
// }
// }
//
// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
////struct CV_GpuBruteForceMatcherTest : CV_GpuTestBase
////{
//// void run_gpu_test();
////
//// void emptyDataTest();
//// void dataTest(int dim);
////
//// void generateData(GpuMat& query, GpuMat& train, int dim);
////
//// void matchTest(const GpuMat& query, const GpuMat& train);
//// void knnMatchTest(const GpuMat& query, const GpuMat& train);
//// void radiusMatchTest(const GpuMat& query, const GpuMat& train);
////
//// BruteForceMatcher_GPU< L2<float> > dmatcher;
////
//// static const int queryDescCount = 300; // must be even number because we split train data in some cases in two
//// static const int countFactor = 4; // do not change it
////};
////
////void CV_GpuBruteForceMatcherTest::emptyDataTest()
////{
//// GpuMat queryDescriptors, trainDescriptors, mask;
//// vector<GpuMat> trainDescriptorCollection, masks;
//// vector<DMatch> matches;
//// vector< vector<DMatch> > vmatches;
////
//// try
//// {
//// dmatcher.match(queryDescriptors, trainDescriptors, matches, mask);
//// }
//// catch(...)
//// {
//// PRINTLN("match() on empty descriptors must not generate exception (1)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.knnMatch(queryDescriptors, trainDescriptors, vmatches, 2, mask);
//// }
//// catch(...)
//// {
//// PRINTLN("knnMatch() on empty descriptors must not generate exception (1)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.radiusMatch(queryDescriptors, trainDescriptors, vmatches, 10.f, mask);
//// }
//// catch(...)
//// {
//// PRINTLN("radiusMatch() on empty descriptors must not generate exception (1)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.add(trainDescriptorCollection);
//// }
//// catch(...)
//// {
//// PRINTLN("add() on empty descriptors must not generate exception");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.match(queryDescriptors, matches, masks);
//// }
//// catch(...)
//// {
//// PRINTLN("match() on empty descriptors must not generate exception (2)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.knnMatch(queryDescriptors, vmatches, 2, masks);
//// }
//// catch(...)
//// {
//// PRINTLN("knnMatch() on empty descriptors must not generate exception (2)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
//// try
//// {
//// dmatcher.radiusMatch( queryDescriptors, vmatches, 10.f, masks );
//// }
//// catch(...)
//// {
//// PRINTLN("radiusMatch() on empty descriptors must not generate exception (2)");
//// ts->set_failed_test_info(TS::FAIL_EXCEPTION);
//// }
////
////}
////
////void CV_GpuBruteForceMatcherTest::generateData(GpuMat& queryGPU, GpuMat& trainGPU, int dim)
////{
//// Mat query, train;
//// RNG& rng = ts->get_rng();
////
//// // Generate query descriptors randomly.
//// // Descriptor vector elements are integer values.
//// Mat buf(queryDescCount, dim, CV_32SC1);
//// rng.fill(buf, RNG::UNIFORM, Scalar::all(0), Scalar(3));
//// buf.convertTo(query, CV_32FC1);
////
//// // Generate train decriptors as follows:
//// // copy each query descriptor to train set countFactor times
//// // and perturb some one element of the copied descriptors in
//// // in ascending order. General boundaries of the perturbation
//// // are (0.f, 1.f).
//// train.create( query.rows*countFactor, query.cols, CV_32FC1 );
//// float step = 1.f / countFactor;
//// for (int qIdx = 0; qIdx < query.rows; qIdx++)
//// {
//// Mat queryDescriptor = query.row(qIdx);
//// for (int c = 0; c < countFactor; c++)
//// {
//// int tIdx = qIdx * countFactor + c;
//// Mat trainDescriptor = train.row(tIdx);
//// queryDescriptor.copyTo(trainDescriptor);
//// int elem = rng(dim);
//// float diff = rng.uniform(step * c, step * (c + 1));
//// trainDescriptor.at<float>(0, elem) += diff;
//// }
//// }
////
//// queryGPU.upload(query);
//// trainGPU.upload(train);
////}
////
////void CV_GpuBruteForceMatcherTest::matchTest(const GpuMat& query, const GpuMat& train)
////{
//// dmatcher.clear();
////
//// // test const version of match()
//// {
//// vector<DMatch> matches;
//// dmatcher.match(query, train, matches);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// DMatch match = matches[i];
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
//// badCount++;
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////
//// // test version of match() with add()
//// {
//// vector<DMatch> matches;
////
//// // make add() twice to test such case
//// dmatcher.add(vector<GpuMat>(1, train.rowRange(0, train.rows/2)));
//// dmatcher.add(vector<GpuMat>(1, train.rowRange(train.rows/2, train.rows)));
////
//// // prepare masks (make first nearest match illegal)
//// vector<GpuMat> masks(2);
//// for (int mi = 0; mi < 2; mi++)
//// {
//// masks[mi] = GpuMat(query.rows, train.rows/2, CV_8UC1, Scalar::all(1));
//// for (int di = 0; di < queryDescCount/2; di++)
//// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
//// }
////
//// dmatcher.match(query, matches, masks);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// DMatch match = matches[i];
//// int shift = dmatcher.isMaskSupported() ? 1 : 0;
//// {
//// if (i < queryDescCount / 2)
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + shift) || (match.imgIdx != 0))
//// badCount++;
//// }
//// else
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + shift) || (match.imgIdx != 1))
//// badCount++;
//// }
//// }
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////}
////
////void CV_GpuBruteForceMatcherTest::knnMatchTest(const GpuMat& query, const GpuMat& train)
////{
//// dmatcher.clear();
////
//// // test const version of knnMatch()
//// {
//// const int knn = 3;
////
//// vector< vector<DMatch> > matches;
//// dmatcher.knnMatch(query, train, matches, knn);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// if ((int)matches[i].size() != knn)
//// badCount++;
//// else
//// {
//// int localBadCount = 0;
//// for (int k = 0; k < knn; k++)
//// {
//// DMatch match = matches[i][k];
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
//// localBadCount++;
//// }
//// badCount += localBadCount > 0 ? 1 : 0;
//// }
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////
//// // test version of knnMatch() with add()
//// {
//// const int knn = 2;
//// vector<vector<DMatch> > matches;
////
//// // make add() twice to test such case
//// dmatcher.add(vector<GpuMat>(1,train.rowRange(0, train.rows / 2)));
//// dmatcher.add(vector<GpuMat>(1,train.rowRange(train.rows / 2, train.rows)));
////
//// // prepare masks (make first nearest match illegal)
//// vector<GpuMat> masks(2);
//// for (int mi = 0; mi < 2; mi++ )
//// {
//// masks[mi] = GpuMat(query.rows, train.rows / 2, CV_8UC1, Scalar::all(1));
//// for (int di = 0; di < queryDescCount / 2; di++)
//// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
//// }
////
//// dmatcher.knnMatch(query, matches, knn, masks);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// int shift = dmatcher.isMaskSupported() ? 1 : 0;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// if ((int)matches[i].size() != knn)
//// badCount++;
//// else
//// {
//// int localBadCount = 0;
//// for (int k = 0; k < knn; k++)
//// {
//// DMatch match = matches[i][k];
//// {
//// if (i < queryDescCount / 2)
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
//// localBadCount++;
//// }
//// else
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
//// localBadCount++;
//// }
//// }
//// }
//// badCount += localBadCount > 0 ? 1 : 0;
//// }
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////}
////
////void CV_GpuBruteForceMatcherTest::radiusMatchTest(const GpuMat& query, const GpuMat& train)
////{
//// CHECK_RETURN(support(GLOBAL_ATOMICS), TS::SKIPPED);
////
//// dmatcher.clear();
////
//// // test const version of match()
//// {
//// const float radius = 1.f / countFactor;
////
//// vector< vector<DMatch> > matches;
//// dmatcher.radiusMatch(query, train, matches, radius);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// if ((int)matches[i].size() != 1)
//// badCount++;
//// else
//// {
//// DMatch match = matches[i][0];
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
//// badCount++;
//// }
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////
//// // test version of match() with add()
//// {
//// int n = 3;
//// const float radius = 1.f / countFactor * n;
//// vector< vector<DMatch> > matches;
////
//// // make add() twice to test such case
//// dmatcher.add(vector<GpuMat>(1,train.rowRange(0, train.rows / 2)));
//// dmatcher.add(vector<GpuMat>(1,train.rowRange(train.rows / 2, train.rows)));
////
//// // prepare masks (make first nearest match illegal)
//// vector<GpuMat> masks(2);
//// for (int mi = 0; mi < 2; mi++)
//// {
//// masks[mi] = GpuMat(query.rows, train.rows / 2, CV_8UC1, Scalar::all(1));
//// for (int di = 0; di < queryDescCount / 2; di++)
//// masks[mi].col(di * countFactor).setTo(Scalar::all(0));
//// }
////
//// dmatcher.radiusMatch(query, matches, radius, masks);
////
//// CHECK((int)matches.size() == queryDescCount, TS::FAIL_INVALID_OUTPUT);
////
//// int badCount = 0;
//// int shift = dmatcher.isMaskSupported() ? 1 : 0;
//// int needMatchCount = dmatcher.isMaskSupported() ? n-1 : n;
//// for (size_t i = 0; i < matches.size(); i++)
//// {
//// if ((int)matches[i].size() != needMatchCount)
//// badCount++;
//// else
//// {
//// int localBadCount = 0;
//// for (int k = 0; k < needMatchCount; k++)
//// {
//// DMatch match = matches[i][k];
//// {
//// if (i < queryDescCount / 2)
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
//// localBadCount++;
//// }
//// else
//// {
//// if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
//// localBadCount++;
//// }
//// }
//// }
//// badCount += localBadCount > 0 ? 1 : 0;
//// }
//// }
////
//// CHECK(badCount == 0, TS::FAIL_INVALID_OUTPUT);
//// }
////}
////
////void CV_GpuBruteForceMatcherTest::dataTest(int dim)
////{
//// GpuMat query, train;
//// generateData(query, train, dim);
////
//// matchTest(query, train);
//// knnMatchTest(query, train);
//// radiusMatchTest(query, train);
////
//// dmatcher.clear();
////}
////
////void CV_GpuBruteForceMatcherTest::run_gpu_test()
////{
//// emptyDataTest();
////
//// dataTest(50);
//// dataTest(64);
//// dataTest(100);
//// dataTest(128);
//// dataTest(200);
//// dataTest(256);
//// dataTest(300);
////}
////
////TEST(BruteForceMatcher, accuracy) { CV_GpuBruteForceMatcherTest test; test.safe_run(); }