mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-29 05:29:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

implemented brute force convolve for small kernel sizes

Browse Source
This commit is contained in:
Vladislav Vinogradov 2011-10-10 11:58:47 +00:00
parent ee768d4605
commit f38596b783
4 changed files with 160 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
modules/gpu/perf/perf_imgproc.cpp
View File

@ -737,7 +737,7 @@ PERF_TEST_P(DevInfo_Size, dft, testing::Combine(testing::ValuesIn(devices()),
PERF_TEST_P(DevInfo_Int_Int, convolve, testing::Combine(testing::ValuesIn(devices()),
testing::Values(512, 1024, 1536, 2048, 2560, 3072, 3584),
testing::Values(27, 32, 64)))
testing::Values(3, 9, 27, 32, 64)))
{
DeviceInfo devInfo = std::tr1::get<0>(GetParam());
int image_size = std::tr1::get<1>(GetParam());
@ -745,13 +745,12 @@ PERF_TEST_P(DevInfo_Int_Int, convolve, testing::Combine(testing::ValuesIn(device
setDevice(devInfo.deviceID());
Mat image_host(image_size, image_size, CV_32FC1);
Mat templ_host(templ_size, templ_size, CV_32FC1);
GpuMat image = createContinuous(image_size, image_size, CV_32FC1);
GpuMat templ = createContinuous(templ_size, templ_size, CV_32FC1);
declare.in(image_host, templ_host, WARMUP_RNG);
image.setTo(Scalar(1.0));
templ.setTo(Scalar(1.0));
GpuMat image(image_host);
GpuMat templ(templ_host);
GpuMat dst;
ConvolveBuf buf;

78
modules/gpu/src/cuda/imgproc.cu
View File

@ -951,6 +951,84 @@ namespace cv { namespace gpu { namespace imgproc
}
//////////////////////////////////////////////////////////////////////////
// convolve
#define CONVOLVE_MAX_KERNEL_SIZE 17
__constant__ float c_convolveKernel[CONVOLVE_MAX_KERNEL_SIZE * CONVOLVE_MAX_KERNEL_SIZE];
__global__ void convolve(const DevMem2Df src, PtrStepf dst, int kWidth, int kHeight)
{
__shared__ float smem[16 + 2 * 8][16 + 2 * 8];
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
// x | x 0 | 0
// -----------
// x | x 0 | 0
// 0 | 0 0 | 0
// -----------
// 0 | 0 0 | 0
smem[threadIdx.y][threadIdx.x] = src.ptr(min(max(y - 8, 0), src.rows - 1))[min(max(x - 8, 0), src.cols - 1)];
// 0 | 0 x | x
// -----------
// 0 | 0 x | x
// 0 | 0 0 | 0
// -----------
// 0 | 0 0 | 0
smem[threadIdx.y][threadIdx.x + 16] = src.ptr(min(max(y - 8, 0), src.rows - 1))[min(x + 8, src.cols - 1)];
// 0 | 0 0 | 0
// -----------
// 0 | 0 0 | 0
// x | x 0 | 0
// -----------
// x | x 0 | 0
smem[threadIdx.y + 16][threadIdx.x] = src.ptr(min(y + 8, src.rows - 1))[min(max(x - 8, 0), src.cols - 1)];
// 0 | 0 0 | 0
// -----------
// 0 | 0 0 | 0
// 0 | 0 x | x
// -----------
// 0 | 0 x | x
smem[threadIdx.y + 16][threadIdx.x + 16] = src.ptr(min(y + 8, src.rows - 1))[min(x + 8, src.cols - 1)];
__syncthreads();
if (x < src.cols && y < src.rows)
{
float res = 0;
for (int i = 0; i < kHeight; ++i)
{
for (int j = 0; j < kWidth; ++j)
{
res += smem[threadIdx.y + 8 - kHeight / 2 + i][threadIdx.x + 8 - kWidth / 2 + j] * c_convolveKernel[i * kWidth + j];
}
}
dst.ptr(y)[x] = res;
}
}
void convolve_gpu(const DevMem2Df& src, const PtrStepf& dst, int kWidth, int kHeight, float* kernel)
{
cudaSafeCall(cudaMemcpyToSymbol(c_convolveKernel, kernel, kWidth * kHeight * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
const dim3 block(16, 16);
const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
convolve<<<grid, block>>>(src, dst, kWidth, kHeight);
cudaSafeCall(cudaGetLastError());
cudaSafeCall(cudaDeviceSynchronize());
}
}}}

22
modules/gpu/src/imgproc.cpp
View File

@ -1576,6 +1576,10 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
convolve(image, templ, result, ccorr, buf);
}
namespace cv { namespace gpu { namespace imgproc
{
void convolve_gpu(const DevMem2Df& src, const PtrStepf& dst, int kWidth, int kHeight, float* kernel);
}}}
void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
bool ccorr, ConvolveBuf& buf)
@ -1586,6 +1590,24 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
CV_Assert(image.type() == CV_32F);
CV_Assert(templ.type() == CV_32F);
if (templ.cols < 13 && templ.rows < 13)
{
result.create(image.size(), CV_32F);
GpuMat contKernel;
if (templ.isContinuous())
contKernel = templ;
else
{
contKernel = createContinuous(templ.size(), templ.type());
templ.copyTo(contKernel);
}
imgproc::convolve_gpu(image, result, templ.cols, templ.rows, contKernel.ptr<float>());
return;
}
buf.create(image.size(), templ.size());
result.create(buf.result_size, CV_32F);

55
modules/gpu/test/test_imgproc.cpp
View File

@ -4221,4 +4221,59 @@ INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(
testing::Values(3, 5),
testing::Values(false, true)));
////////////////////////////////////////////////////////
// convolve
struct Convolve: testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
{
cv::gpu::DeviceInfo devInfo;
int ksize;
cv::Size size;
cv::Mat src;
cv::Mat kernel;
cv::Mat dst_gold;
virtual void SetUp()
{
devInfo = std::tr1::get<0>(GetParam());
ksize = std::tr1::get<1>(GetParam());
cv::gpu::setDevice(devInfo.deviceID());
cv::RNG& rng = cvtest::TS::ptr()->get_rng();
size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
src = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 255.0, false);
kernel = cvtest::randomMat(rng, cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0, false);
cv::filter2D(src, dst_gold, CV_32F, kernel, cv::Point(-1, -1), 0, cv::BORDER_REPLICATE);
}
};
TEST_P(Convolve, Accuracy)
{
PRINT_PARAM(devInfo);
PRINT_PARAM(ksize);
cv::Mat dst;
ASSERT_NO_THROW(
cv::gpu::GpuMat d_dst;
cv::gpu::convolve(cv::gpu::GpuMat(src), cv::gpu::GpuMat(kernel), d_dst);
d_dst.download(dst);
);
EXPECT_MAT_NEAR(dst, dst_gold, 1e-2);
}
INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(
testing::ValuesIn(devices()),
testing::Values(3, 5, 7, 9, 11)));
#endif // HAVE_CUDA