Efficient way to generate a three-channel LUT mask - c++

Question

I have some code to create an HSV mask that looks approximately like this (taken from this Japanese-language page):
void colorExtraction(const cv::gpu::GpuMat &src,
cv::gpu::GpuMat *dst)
{
cv::Mat lut(256, 1, CV_8UC3);
for (int i = 0; i < 256; i++)
{
cv::Vec3b thisHSV;
thisHSV[0] = inHRange(i) ? 255 : 0;
thisHSV[1] = inSRange(i) ? 255 : 0;
thisHSV[2] = inVRange(i) ? 255 : 0;
lut.at<cv::Vec3b>(i) = thisHSV;
}
/* apply LUT to input image */
cv::gpu::GpuMat extracted(src.size(), CV_8UC3);
cv::gpu::LUT(src, lut, extracted);
/* divide image into each channel */
std::vector<cv::gpu::GpuMat> channels;
cv::gpu::split(extracted, channels);
/* create mask */
cv::gpu::bitwise_and(channels[0], channels[1], *dst);
cv::gpu::bitwise_and(*dst, channels[2], *dst);
}
This works, but despite the operations being mostly in the GPU, it is slower than I would like, perhaps due to a number of intermediate GpuMats. I suspect there might be a nice way to fold this all up into just one or two calls, but I don't know what it could be. Writing my own CUDA kernel is, of course, an option, but I want to check to see if I don't need to reinvent the wheel.

Answer 1

To self-answer, I ended up coding my own kernel to do the LUT(), split(), and two bitwise_and()s in a single call:
__global__ void colorExtractionKernel(cv::gpu::PtrStepSz<uchar3> const src,
cv::gpu::PtrStepSz<unsigned char> dst,
cv::gpu::PtrStepSz<uchar3> const lut)
{
unsigned int row = blockIdx.y * blockDim.y + threadIdx.y;
unsigned int col = blockIdx.x * blockDim.x + threadIdx.x;
// Extract post-LUT hsv flags
uchar3 srcHSV = src(row, col);
unsigned char h = lut(srcHSV.x, 0).x;
unsigned char s = lut(srcHSV.y, 0).y;
unsigned char v = lut(srcHSV.z, 0).z;
// Result pixel is the AND of the pixels
dst(row, col) = (h & s & v);
}
void colorExtraction_cuda(const cv::gpu::GpuMat &src, // input HSV image
cv::gpu::GpuMat &dst, // specified color extracted binarized image
cv::Mat const &lut) // Look-up thresholds
{
cudaStream_t thisStream;
gpuErrChk(cudaStreamCreate(&thisStream));
dim3 Threads(32, 16);
dim3 Blocks((src.cols + Threads.x - 1)/Threads.x, (src.rows + Threads.y - 1)/Threads.y);
cv::gpu::GpuMat gpuLut(lut);
colorExtractionKernel<<<Blocks, Threads, 0, thisStream>>>(src, dst, gpuLut);
gpuErrChk(cudaStreamSynchronize(thisStream));
gpuErrChk(cudaStreamDestroy(thisStream));
gpuErrChk(cudaGetLastError());
}