}
}
}
+
+#ifdef HAVE_OPENCL
+
static bool ocl_makePointsList(InputArray _src, OutputArray _pointsList, InputOutputArray _counters)
{
UMat src = _src.getUMat();
UMat counters = _counters.getUMat();
ocl::Device dev = ocl::Device::getDefault();
- const int pixelsPerWI = 16;
- int workgroup_size = min((int) dev.maxWorkGroupSize(), (src.cols + pixelsPerWI - 1)/pixelsPerWI);
- ocl::Kernel pointListKernel("make_point_list", ocl::imgproc::hough_lines_oclsrc,
+ const int pixPerWI = 16;
+ int workgroup_size = min((int) dev.maxWorkGroupSize(), (src.cols + pixPerWI - 1)/pixPerWI);
+ ocl::Kernel pointListKernel("make_point_list", ocl::imgproc::hough_lines_oclsrc,
format("-D MAKE_POINTS_LIST -D GROUP_SIZE=%d -D LOCAL_SIZE=%d", workgroup_size, src.cols));
if (pointListKernel.empty())
return false;
pointListKernel.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnlyNoSize(pointsList),
ocl::KernelArg::PtrWriteOnly(counters));
-
+
size_t localThreads[2] = { workgroup_size, 1 };
size_t globalThreads[2] = { workgroup_size, src.rows };
float irho = (float) (1 / rho);
int workgroup_size = min((int) dev.maxWorkGroupSize(), total_points);
-
+
ocl::Kernel fillAccumKernel;
size_t localThreads[2];
size_t globalThreads[2];
- int local_memory_needed = (numrho + 2)*sizeof(int);
+ size_t local_memory_needed = (numrho + 2)*sizeof(int);
if (local_memory_needed > dev.localMemSize())
{
accum.setTo(Scalar::all(0));
}
}
-static bool ocl_HoughLines(InputArray _src, OutputArray _lines, double rho, double theta, int threshold,
+static bool ocl_HoughLines(InputArray _src, OutputArray _lines, double rho, double theta, int threshold,
double min_theta, double max_theta)
{
CV_Assert(_src.type() == CV_8UC1);
UMat src = _src.getUMat();
int numangle = cvRound((max_theta - min_theta) / theta);
int numrho = cvRound(((src.cols + src.rows) * 2 + 1) / rho);
-
+
UMat pointsList;
UMat counters(1, 2, CV_32SC1, Scalar::all(0));
size_t globalThreads[2] = { (numrho + pixPerWI - 1)/pixPerWI, numangle };
if (!getLinesKernel.run(2, globalThreads, NULL, false))
return false;
-
+
int total_lines = min(counters.getMat(ACCESS_READ).at<int>(0, 1), linesMax);
if (total_lines > 0)
_lines.assign(lines.rowRange(Range(0, total_lines)));
return true;
}
-static bool ocl_HoughLinesP(InputArray _src, OutputArray _lines, double rho, double theta, int threshold,
+static bool ocl_HoughLinesP(InputArray _src, OutputArray _lines, double rho, double theta, int threshold,
double minLineLength, double maxGap)
{
CV_Assert(_src.type() == CV_8UC1);
-
+
UMat src = _src.getUMat();
+ int numangle = cvRound(CV_PI / theta);
+ int numrho = cvRound(((src.cols + src.rows) * 2 + 1) / rho);
+
+ UMat pointsList;
+ UMat counters(1, 2, CV_32SC1, Scalar::all(0));
+
+ if (!ocl_makePointsList(src, pointsList, counters))
+ return false;
- return false;
+ int total_points = counters.getMat(ACCESS_READ).at<int>(0, 0);
+ if (total_points <= 0)
+ {
+ _lines.assign(UMat(0,0,CV_32SC4));
+ return true;
+ }
+
+ UMat accum;
+ if (!ocl_fillAccum(pointsList, accum, total_points, rho, theta, numrho, numangle))
+ return false;
+
+ ocl::Kernel getLinesKernel("get_lines", ocl::imgproc::hough_lines_oclsrc,
+ format("-D GET_LINES_PROBABOLISTIC"));
+ if (getLinesKernel.empty())
+ return false;
+
+ // TODO: investigate other strategies to choose linesMax
+ int linesMax = min(total_points*numangle/threshold, 4096);
+ UMat lines(linesMax, 1, CV_32SC4);
+
+ getLinesKernel.args(ocl::KernelArg::ReadOnly(accum), ocl::KernelArg::ReadOnly(src),
+ ocl::KernelArg::WriteOnlyNoSize(lines), ocl::KernelArg::PtrWriteOnly(counters),
+ linesMax, threshold, (int) minLineLength, (int) maxGap, (float) rho, (float) theta);
+
+ size_t globalThreads[2] = { numrho, numangle };
+ if (!getLinesKernel.run(2, globalThreads, NULL, false))
+ return false;
+
+ int total_lines = min(counters.getMat(ACCESS_READ).at<int>(0, 1), linesMax);
+ if (total_lines > 0)
+ _lines.assign(lines.rowRange(Range(0, total_lines)));
+ else
+ _lines.assign(UMat(0,0,CV_32SC4));
+
+ return true;
}
+#endif /* HAVE_OPENCL */
+
}
void cv::HoughLines( InputArray _image, OutputArray _lines,
double rho, double theta, int threshold,
double srn, double stn, double min_theta, double max_theta )
{
- CV_OCL_RUN(srn == 0 && stn == 0 && _image.isUMat() && _lines.isUMat(),
+ CV_OCL_RUN(srn == 0 && stn == 0 && _image.isUMat() && _lines.isUMat(),
ocl_HoughLines(_image, _lines, rho, theta, threshold, min_theta, max_theta));
Mat image = _image.getMat();
double rho, double theta, int threshold,
double minLineLength, double maxGap )
{
- CV_OCL_RUN(_image.isUMat() && _lines.isUMat(), ocl_HoughLinesP(_image, _lines, rho, theta, threshold, minLineLength, maxGap));
+ CV_OCL_RUN(_image.isUMat() && _lines.isUMat(),
+ ocl_HoughLinesP(_image, _lines, rho, theta, threshold, minLineLength, maxGap));
Mat image = _image.getMat();
std::vector<Vec4i> lines;
{
int x = get_local_id(0);
int y = get_group_id(1);
-
+
__local int l_index, l_offset;
__local int l_points[LOCAL_SIZE];
__global const uchar * src = src_ptr + mad24(y, src_step, src_offset);
}
barrier(CLK_LOCAL_MEM_FENCE);
-
+
if (x == 0)
l_offset = atomic_add(global_offset, l_index);
barrier(CLK_LOCAL_MEM_FENCE);
-
+
list += l_offset;
for (int i=x; i < l_index; i+=GROUP_SIZE)
{
#elif defined FILL_ACCUM_GLOBAL
__kernel void fill_accum_global(__global const uchar * list_ptr, int list_step, int list_offset,
- __global uchar * accum_ptr, int accum_step, int accum_offset, int accum_rows, int accum_cols,
- int total_points, float irho, float theta, int numrho, int numangle)
+ __global uchar * accum_ptr, int accum_step, int accum_offset, int accum_rows, int accum_cols,
+ int total_points, float irho, float theta, int numrho, int numangle)
{
int theta_idx = get_global_id(1);
int count_idx = get_global_id(0);
{
int theta_idx = get_group_id(1);
int count_idx = get_local_id(0);
-
+
if (theta_idx > 0 && theta_idx < numangle + 1)
{
float cosVal;
#define ACCUM(ptr) *((__global int*)(ptr))
__kernel void get_lines(__global uchar * accum_ptr, int accum_step, int accum_offset, int accum_rows, int accum_cols,
- __global uchar * lines_ptr, int lines_step, int lines_offset, __global int* lines_index_ptr,
+ __global uchar * lines_ptr, int lines_step, int lines_offset, __global int* lines_index_ptr,
int linesMax, int threshold, float rho, float theta)
{
int x0 = get_global_id(0);
__global uchar* accum = accum_ptr + mad24(y+1, accum_step, mad24(x0+1, (int) sizeof(int), accum_offset));
__global float2* lines = (__global float2*)(lines_ptr + lines_offset);
__global int* lines_index = lines_index_ptr + 1;
-
+
for (int x=x0; x<accum_cols-2; x+=gl_size)
{
int curVote = ACCUM(accum);
}
}
+#elif GET_LINES_PROBABOLISTIC
+
+#define ACCUM(ptr) *((__global int*)(ptr))
+
+__kernel void get_lines(__global const uchar * accum_ptr, int accum_step, int accum_offset, int accum_rows, int accum_cols,
+ __global const uchar * src_ptr, int src_step, int src_offset, int src_rows, int src_cols,
+ __global uchar * lines_ptr, int lines_step, int lines_offset, __global int* lines_index_ptr,
+ int linesMax, int threshold, int lineLength, int lineGap, float rho, float theta)
+{
+ int x = get_global_id(0);
+ int y = get_global_id(1);
+
+ __global uchar* accum = accum_ptr + mad24(y+1, accum_step, mad24(x+1, (int) sizeof(int), accum_offset));
+ __global int4* lines = (__global int4*)(lines_ptr + lines_offset);
+ __global int* lines_index = lines_index_ptr + 1;
+
+ int curVote = ACCUM(accum);
+
+ if (curVote >= threshold &&
+ curVote > ACCUM(accum - accum_step - sizeof(int)) &&
+ curVote > ACCUM(accum - accum_step) &&
+ curVote > ACCUM(accum - accum_step + sizeof(int)) &&
+ curVote > ACCUM(accum - sizeof(int)) &&
+ curVote > ACCUM(accum + sizeof(int)) &&
+ curVote > ACCUM(accum + accum_step - sizeof(int)) &&
+ curVote > ACCUM(accum + accum_step) &&
+ curVote > ACCUM(accum + accum_step + sizeof(int)))
+ {
+ const float radius = (x - (accum_cols - 2 - 1) * 0.5f) * rho;
+ const float angle = y * theta;
+
+ float cosa;
+ float sina = sincos(angle, &cosa);
+
+ float2 p0 = (float2)(cosa * radius, sina * radius);
+ float2 dir = (float2)(-sina, cosa);
+
+ float2 pb[4] = { (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1) };
+ float a;
+
+ if (dir.x != 0)
+ {
+ a = -p0.x / dir.x;
+ pb[0].x = 0;
+ pb[0].y = p0.y + a * dir.y;
+
+ a = (src_cols - 1 - p0.x) / dir.x;
+ pb[1].x = src_cols - 1;
+ pb[1].y = p0.y + a * dir.y;
+ }
+ if (dir.y != 0)
+ {
+ a = -p0.y / dir.y;
+ pb[2].x = p0.x + a * dir.x;
+ pb[2].y = 0;
+
+ a = (src_rows - 1 - p0.y) / dir.y;
+ pb[3].x = p0.x + a * dir.x;
+ pb[3].y = src_rows - 1;
+ }
+
+ if (pb[0].x == 0 && (pb[0].y >= 0 && pb[0].y < src_rows))
+ {
+ p0 = pb[0];
+ if (dir.x < 0)
+ dir = -dir;
+ }
+ else if (pb[1].x == src_cols - 1 && (pb[0].y >= 0 && pb[0].y < src_rows))
+ {
+ p0 = pb[1];
+ if (dir.x > 0)
+ dir = -dir;
+ }
+ else if (pb[2].y == 0 && (pb[2].x >= 0 && pb[2].x < src_cols))
+ {
+ p0 = pb[2];
+ if (dir.y < 0)
+ dir = -dir;
+ }
+ else if (pb[3].y == src_rows - 1 && (pb[3].x >= 0 && pb[3].x < src_cols))
+ {
+ p0 = pb[3];
+ if (dir.y > 0)
+ dir = -dir;
+ }
+
+ float2 d;
+ if (fabs(dir.x) > fabs(dir.y))
+ {
+ d.x = dir.x > 0 ? 1 : -1;
+ d.y = dir.y / fabs(dir.x);
+ }
+ else
+ {
+ d.x = dir.x / fabs(dir.y);
+ d.y = dir.y > 0 ? 1 : -1;
+ }
+
+ float2 line_end[2];
+ int gap;
+ bool inLine = false;
+
+ float2 p1 = p0;
+ if (p1.x < 0 || p1.x >= src_cols || p1.y < 0 || p1.y >= src_rows)
+ return;
+
+ for (;;)
+ {
+ if (*(src_ptr + mad24(p1.y, src_step, p1.x + src_offset)))
+ {
+ gap = 0;
+
+ if (!inLine)
+ {
+ line_end[0] = p1;
+ line_end[1] = p1;
+ inLine = true;
+ }
+ else
+ {
+ line_end[1] = p1;
+ }
+ }
+ else if (inLine)
+ {
+ if (++gap > lineGap)
+ {
+ bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength ||
+ fabs(line_end[1].y - line_end[0].y) >= lineLength;
+
+ if (good_line)
+ {
+ int index = atomic_inc(lines_index);
+ if (index < linesMax)
+ lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+ }
+
+ gap = 0;
+ inLine = false;
+ }
+ }
+
+ p1 = p1 + d;
+ if (p1.x < 0 || p1.x >= src_cols || p1.y < 0 || p1.y >= src_rows)
+ {
+ if (inLine)
+ {
+ bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength ||
+ fabs(line_end[1].y - line_end[0].y) >= lineLength;
+
+ if (good_line)
+ {
+ int index = atomic_inc(lines_index);
+ if (index < linesMax)
+ lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+ }
+
+ }
+ break;
+ }
+ }
+
+ }
+}
+
#endif
\ No newline at end of file
struct Vec2fComparator
{
- bool operator()(const cv::Vec2f& a, const cv::Vec2f b) const
+ bool operator()(const Vec2f& a, const Vec2f b) const
{
if(a[0] != b[0]) return a[0] < b[0];
else return a[1] < b[1];
}
};
-PARAM_TEST_CASE(HoughLinesTestBase, double, double, int)
+/////////////////////////////// HoughLines ////////////////////////////////////
+
+PARAM_TEST_CASE(HoughLines, double, double, int)
{
- double rhoStep;
- double thetaStep;
+ double rhoStep, thetaStep;
int threshold;
Size src_size;
line(src, Point(100, 0), Point(100, 200), Scalar::all(255), 1);
line(src, Point(200, 0), Point(200, 200), Scalar::all(255), 1);
line(src, Point(400, 0), Point(400, 200), Scalar::all(255), 1);
-
+
src.copyTo(usrc);
}
virtual void Near(double eps = 0.)
{
EXPECT_EQ(dst.size(), udst.size());
-
+
if (dst.total() > 0)
{
Mat lines_cpu, lines_gpu;
}
};
-typedef HoughLinesTestBase HoughLines;
-
OCL_TEST_P(HoughLines, RealImage)
{
readRealTestData();
}
}
+/////////////////////////////// HoughLinesP ///////////////////////////////////
+
+PARAM_TEST_CASE(HoughLinesP, int, double, double)
+{
+ double rhoStep, thetaStep, minLineLength, maxGap;
+ int threshold;
+
+ Size src_size;
+ Mat src, dst;
+ UMat usrc, udst;
+
+ virtual void SetUp()
+ {
+ rhoStep = 1.0;
+ thetaStep = CV_PI / 180;
+ threshold = GET_PARAM(0);
+ minLineLength = GET_PARAM(1);
+ maxGap = GET_PARAM(2);
+ }
+
+ virtual void readRealTestData()
+ {
+ Mat img = readImage("shared/pic5.png", IMREAD_GRAYSCALE);
+ Canny(img, src, 50, 200, 3);
+
+ src.copyTo(usrc);
+ }
+
+ virtual void Near(double eps = 0.)
+ {
+ Mat lines_gpu = udst.getMat(ACCESS_READ);
+
+ if (dst.total() > 0 && lines_gpu.total() > 0)
+ {
+ Mat result_cpu(src.size(), CV_8UC1, Scalar::all(0));
+ Mat result_gpu(src.size(), CV_8UC1, Scalar::all(0));
+
+ MatConstIterator_<Vec4i> it = dst.begin<Vec4i>(), end = dst.end<Vec4i>();
+ for ( ; it != end; it++)
+ {
+ Vec4i p = *it;
+ line(result_cpu, Point(p[0], p[1]), Point(p[2], p[3]), Scalar(255));
+ }
+
+ it = lines_gpu.begin<Vec4i>(), end = lines_gpu.end<Vec4i>();
+ for ( ; it != end; it++)
+ {
+ Vec4i p = *it;
+ line(result_gpu, Point(p[0], p[1]), Point(p[2], p[3]), Scalar(255));
+ }
+
+ EXPECT_MAT_SIMILAR(result_cpu, result_gpu, eps);
+ }
+ }
+};
+
+
+OCL_TEST_P(HoughLinesP, RealImage)
+{
+ readRealTestData();
+
+ OCL_OFF(cv::HoughLinesP(src, dst, rhoStep, thetaStep, threshold, minLineLength, maxGap));
+ OCL_ON(cv::HoughLinesP(usrc, udst, rhoStep, thetaStep, threshold, minLineLength, maxGap));
+
+ Near(0.2);
+}
+
OCL_INSTANTIATE_TEST_CASE_P(Imgproc, HoughLines, Combine(Values(1, 0.5), // rhoStep
Values(CV_PI / 180.0, CV_PI / 360.0), // thetaStep
Values(80, 150))); // threshold
+OCL_INSTANTIATE_TEST_CASE_P(Imgproc, HoughLinesP, Combine(Values(100, 150), // threshold
+ Values(50, 100), // minLineLength
+ Values(5, 10))); // maxLineGap
+
} } // namespace cvtest::ocl
#endif // HAVE_OPENCL
\ No newline at end of file
projects / platform / upstream / opencv.git / commitdiff