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

added assertion on Compute Capability >= 1.1 to BruteForceMatcher_GPU_base::radiusMatch

Browse Source
This commit is contained in:
Vladislav Vinogradov 2010-12-06 14:51:47 +00:00
parent 50167f6c26
commit fadd19b976
3 changed files with 16 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/gpu/src/brute_force_matcher.cpp
View File

@ -493,6 +493,10 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& queryDescs,
} }
}; };
int major, minor;
getComputeCapability(getDevice(), major, minor);
CV_Assert(100 * major + 10 * minor >= 110); // works onle on device with CC >= 1.1
const int nQuery = queryDescs.rows; const int nQuery = queryDescs.rows;
const int nTrain = trainDescs.rows; const int nTrain = trainDescs.rows;

4
modules/gpu/src/cuda/brute_force_matcher.cu
View File

@ -1104,6 +1104,8 @@ namespace cv { namespace gpu { namespace bfmatcher
__global__ void radiusMatch(PtrStep_<T> queryDescs_, DevMem2D_<T> trainDescs_, __global__ void radiusMatch(PtrStep_<T> queryDescs_, DevMem2D_<T> trainDescs_,
float maxDistance, Mask mask, DevMem2Di trainIdx_, unsigned int* nMatches, PtrStepf distance) float maxDistance, Mask mask, DevMem2Di trainIdx_, unsigned int* nMatches, PtrStepf distance)
{ {
#if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
__shared__ float sdiff[BLOCK_DIM_X * BLOCK_DIM_Y]; __shared__ float sdiff[BLOCK_DIM_X * BLOCK_DIM_Y];
float* sdiff_row = sdiff + BLOCK_DIM_X * threadIdx.y; float* sdiff_row = sdiff + BLOCK_DIM_X * threadIdx.y;
@ -1135,6 +1137,8 @@ namespace cv { namespace gpu { namespace bfmatcher
} }
} }
} }
#endif
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

16
tests/gpu/src/brute_force_matcher.cpp
View File

@ -67,7 +67,7 @@ protected:
const int desc_len = rng.uniform(40, 300); const int desc_len = rng.uniform(40, 300);
Mat queryCPU(rng.uniform(100, 300), desc_len, CV_32F); Mat queryCPU(rng.uniform(100, 300), desc_len, CV_32F);
rng.fill(queryCPU, cv::RNG::UNIFORM, cv::Scalar::all(0.0), cv::Scalar::all(1.0)); rng.fill(queryCPU, cv::RNG::UNIFORM, cv::Scalar::all(0.0), cv::Scalar::all(10.0));
GpuMat queryGPU(queryCPU); GpuMat queryGPU(queryCPU);
const int nTrains = rng.uniform(1, 5); const int nTrains = rng.uniform(1, 5);
@ -81,7 +81,7 @@ protected:
for (int i = 0; i < nTrains; ++i) for (int i = 0; i < nTrains; ++i)
{ {
Mat train(rng.uniform(100, 300), desc_len, CV_32F); Mat train(rng.uniform(100, 300), desc_len, CV_32F);
rng.fill(train, cv::RNG::UNIFORM, cv::Scalar::all(0.0), cv::Scalar::all(1.0)); rng.fill(train, cv::RNG::UNIFORM, cv::Scalar::all(0.0), cv::Scalar::all(10.0));
trainsCPU[i] = train; trainsCPU[i] = train;
trainsGPU[i].upload(train); trainsGPU[i].upload(train);
@ -89,7 +89,7 @@ protected:
bool with_mask = rng.uniform(0, 10) < 5; bool with_mask = rng.uniform(0, 10) < 5;
if (with_mask) if (with_mask)
{ {
Mat mask(queryCPU.rows, train.rows, CV_8U, Scalar::all(1)); Mat mask(queryCPU.rows, train.rows, CV_8U);
rng.fill(mask, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(200)); rng.fill(mask, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(200));
masksCPU[i] = mask; masksCPU[i] = mask;
@ -111,8 +111,8 @@ protected:
const int knn = rng.uniform(3, 10); const int knn = rng.uniform(3, 10);
matcherCPU.knnMatch(queryCPU, knnMatchesCPU, knn, masksCPU); matcherCPU.knnMatch(queryCPU, knnMatchesCPU, knn, masksCPU, true);
matcherGPU.knnMatch(queryGPU, knnMatchesGPU, knn, masksGPU); matcherGPU.knnMatch(queryGPU, knnMatchesGPU, knn, masksGPU, true);
if (!compareMatches(knnMatchesCPU, knnMatchesGPU)) if (!compareMatches(knnMatchesCPU, knnMatchesGPU))
{ {
@ -120,10 +120,10 @@ protected:
return; return;
} }
const float maxDistance = rng.uniform(0.01f, 0.3f); const float maxDistance = rng.uniform(25.0f, 65.0f);
matcherCPU.radiusMatch(queryCPU, radiusMatchesCPU, maxDistance, masksCPU); matcherCPU.radiusMatch(queryCPU, radiusMatchesCPU, maxDistance, masksCPU, true);
matcherGPU.radiusMatch(queryGPU, radiusMatchesGPU, maxDistance, masksGPU); matcherGPU.radiusMatch(queryGPU, radiusMatchesGPU, maxDistance, masksGPU, true);
if (!compareMatches(radiusMatchesCPU, radiusMatchesGPU)) if (!compareMatches(radiusMatchesCPU, radiusMatchesGPU))
{ {