{

float rho;

float angle;

{

hough_cmp_gt(const int* _aux) : aux(_aux) {}

inline bool operator()(int l1, int l2) const

{

return aux[l1] > aux[l2] || (aux[l1] == aux[l2] && l1 < l2);

}

const int* aux;

int threshold, std::vector<Vec2f>& lines, int linesMax,

double min_theta, double max_theta )

{

int i, j;

float irho = 1 / rho;

CV_Assert( img.type() == CV_8UC1 );

const uchar* image = img.ptr();

int step = (int)img.step;

int width = img.cols;

int height = img.rows;

if (max_theta < min_theta ) {

CV_Error( CV_StsBadArg, "max_theta must be greater than min_theta" );

}

int numangle = cvRound((max_theta - min_theta) / theta);

int numrho = cvRound(((width + height) * 2 + 1) / rho);

#if defined HAVE_IPP && IPP_VERSION_X100 >= 810 && !IPP_DISABLE_HOUGH

CV_IPP_CHECK()

{

IppiSize srcSize = { width, height };

IppPointPolar delta = { rho, theta };

IppPointPolar dstRoi[2] = {{(Ipp32f) -(width + height), (Ipp32f) min_theta},{(Ipp32f) (width + height), (Ipp32f) max_theta}};

int bufferSize;

int nz = countNonZero(img);

int ipp_linesMax = std::min(linesMax, nz*numangle/threshold);

int linesCount = 0;

lines.resize(ipp_linesMax);

IppStatus ok = ippiHoughLineGetSize_8u_C1R(srcSize, delta, ipp_linesMax, &bufferSize);

Ipp8u* buffer = ippsMalloc_8u_L(bufferSize);

if (ok >= 0) {ok = CV_INSTRUMENT_FUN_IPP(ippiHoughLine_Region_8u32f_C1R, image, step, srcSize, (IppPointPolar*) &lines[0], dstRoi, ipp_linesMax, &linesCount, delta, threshold, buffer);};

ippsFree(buffer);

if (ok >= 0)

{

lines.resize(linesCount);

CV_IMPL_ADD(CV_IMPL_IPP);

return;

}

lines.clear();

setIppErrorStatus();

}

#endif

AutoBuffer<int> _accum((numangle+2) * (numrho+2));

std::vector<int> _sort_buf;

AutoBuffer<float> _tabSin(numangle);

AutoBuffer<float> _tabCos(numangle);

int *accum = _accum;

float *tabSin = _tabSin, *tabCos = _tabCos;

memset( accum, 0, sizeof(accum[0]) * (numangle+2) * (numrho+2) );

float ang = static_cast<float>(min_theta);

for(int n = 0; n < numangle; ang += theta, n++ )

{

tabSin[n] = (float)(sin((double)ang) * irho);

tabCos[n] = (float)(cos((double)ang) * irho);

}

// stage 1. fill accumulator

for( i = 0; i < height; i++ )

for( j = 0; j < width; j++ )

{

if( image[i * step + j] != 0 )

for(int n = 0; n < numangle; n++ )

{

int r = cvRound( j * tabCos[n] + i * tabSin[n] );

r += (numrho - 1) / 2;

accum[(n+1) * (numrho+2) + r+1]++;

}

}

// stage 2. find local maximums

for(int r = 0; r < numrho; r++ )

for(int n = 0; n < numangle; n++ )

{

int base = (n+1) * (numrho+2) + r+1;

if( accum[base] > threshold &&

accum[base] > accum[base - 1] && accum[base] >= accum[base + 1] &&

accum[base] > accum[base - numrho - 2] && accum[base] >= accum[base + numrho + 2] )

_sort_buf.push_back(base);

}

// stage 3. sort the detected lines by accumulator value

std::sort(_sort_buf.begin(), _sort_buf.end(), hough_cmp_gt(accum));

// stage 4. store the first min(total,linesMax) lines to the output buffer

linesMax = std::min(linesMax, (int)_sort_buf.size());

double scale = 1./(numrho+2);

for( i = 0; i < linesMax; i++ )

{

LinePolar line;

int idx = _sort_buf[i];

int n = cvFloor(idx*scale) - 1;

int r = idx - (n+1)*(numrho+2) - 1;

line.rho = (r - (numrho - 1)*0.5f) * rho;

line.angle = static_cast<float>(min_theta) + n * theta;

lines.push_back(Vec2f(line.rho, line.angle));

}

{

hough_index() : value(0), rho(0.f), theta(0.f) {}

hough_index(int _val, float _rho, float _theta)

: value(_val), rho(_rho), theta(_theta) {}

int value;

float rho, theta;

float rho, float theta, int threshold,

int srn, int stn,

std::vector<Vec2f>& lines, int linesMax,

double min_theta, double max_theta )

{

#define _POINT(row, column)\

(image_src[(row)*step+(column)])

int index, i;

int ri, ti, ti1, ti0;

int row, col;

float r, t; /* Current rho and theta */

float rv; /* Some temporary rho value */

int fn = 0;

float xc, yc;

const float d2r = (float)(CV_PI / 180);

int sfn = srn * stn;

int fi;

int count;

int cmax = 0;

std::vector<hough_index> lst;

CV_Assert( img.type() == CV_8UC1 );

CV_Assert( linesMax > 0 );

threshold = MIN( threshold, 255 );

const uchar* image_src = img.ptr();

int step = (int)img.step;

int w = img.cols;

int h = img.rows;

float irho = 1 / rho;

float itheta = 1 / theta;

float srho = rho / srn;

float stheta = theta / stn;

float isrho = 1 / srho;

float istheta = 1 / stheta;

int rn = cvFloor( std::sqrt( (double)w * w + (double)h * h ) * irho );

int tn = cvFloor( 2 * CV_PI * itheta );

lst.push_back(hough_index(threshold, -1.f, 0.f));

// Precalculate sin table

std::vector<float> _sinTable( 5 * tn * stn );

float* sinTable = &_sinTable[0];

for( index = 0; index < 5 * tn * stn; index++ )

sinTable[index] = (float)cos( stheta * index * 0.2f );

std::vector<uchar> _caccum(rn * tn, (uchar)0);

uchar* caccum = &_caccum[0];

// Counting all feature pixels

for( row = 0; row < h; row++ )

for( col = 0; col < w; col++ )

fn += _POINT( row, col ) != 0;

std::vector<int> _x(fn), _y(fn);

int* x = &_x[0], *y = &_y[0];

// Full Hough Transform (it's accumulator update part)

fi = 0;

for( row = 0; row < h; row++ )

{

for( col = 0; col < w; col++ )

{

if( _POINT( row, col ))

{

int halftn;

float r0;

float scale_factor;

int iprev = -1;

float phi, phi1;

float theta_it; // Value of theta for iterating

// Remember the feature point

x[fi] = col;

y[fi] = row;

fi++;

yc = (float) row + 0.5f;

xc = (float) col + 0.5f;

/* Update the accumulator */

t = (float) fabs( cvFastArctan( yc, xc ) * d2r );

r = (float) std::sqrt( (double)xc * xc + (double)yc * yc );

r0 = r * irho;

ti0 = cvFloor( (t + CV_PI*0.5) * itheta );

caccum[ti0]++;

theta_it = rho / r;

theta_it = theta_it < theta ? theta_it : theta;

scale_factor = theta_it * itheta;

halftn = cvFloor( CV_PI / theta_it );

for( ti1 = 1, phi = theta_it - (float)(CV_PI*0.5), phi1 = (theta_it + t) * itheta;

ti1 < halftn; ti1++, phi += theta_it, phi1 += scale_factor )

{

rv = r0 * std::cos( phi );

i = (int)rv * tn;

i += cvFloor( phi1 );

assert( i >= 0 );

assert( i < rn * tn );

caccum[i] = (uchar) (caccum[i] + ((i ^ iprev) != 0));

iprev = i;

if( cmax < caccum[i] )

cmax = caccum[i];

}

}

}

}

// Starting additional analysis

count = 0;

for( ri = 0; ri < rn; ri++ )

{

for( ti = 0; ti < tn; ti++ )

{

if( caccum[ri * tn + ti] > threshold )

count++;

}

}

if( count * 100 > rn * tn )

{

HoughLinesStandard( img, rho, theta, threshold, lines, linesMax, min_theta, max_theta );

return;

}

std::vector<uchar> _buffer(srn * stn + 2);

uchar* buffer = &_buffer[0];

uchar* mcaccum = buffer + 1;

count = 0;

for( ri = 0; ri < rn; ri++ )

{

for( ti = 0; ti < tn; ti++ )

{

if( caccum[ri * tn + ti] > threshold )

{

count++;

memset( mcaccum, 0, sfn * sizeof( uchar ));

for( index = 0; index < fn; index++ )

{

int ti2;

float r0;

yc = (float) y[index] + 0.5f;

xc = (float) x[index] + 0.5f;

// Update the accumulator

t = (float) fabs( cvFastArctan( yc, xc ) * d2r );

r = (float) std::sqrt( (double)xc * xc + (double)yc * yc ) * isrho;

ti0 = cvFloor( (t + CV_PI * 0.5) * istheta );

ti2 = (ti * stn - ti0) * 5;

r0 = (float) ri *srn;

for( ti1 = 0; ti1 < stn; ti1++, ti2 += 5 )

{

rv = r * sinTable[(int) (std::abs( ti2 ))] - r0;

i = cvFloor( rv ) * stn + ti1;

i = CV_IMAX( i, -1 );

i = CV_IMIN( i, sfn );

mcaccum[i]++;

assert( i >= -1 );

assert( i <= sfn );

}

}

// Find peaks in maccum...

for( index = 0; index < sfn; index++ )

{

i = 0;

int pos = (int)(lst.size() - 1);

if( pos < 0 || lst[pos].value < mcaccum[index] )

{

hough_index vi(mcaccum[index],

index / stn * srho + ri * rho,

index % stn * stheta + ti * theta - (float)(CV_PI*0.5));

lst.push_back(vi);

for( ; pos >= 0; pos-- )

{

if( lst[pos].value > vi.value )

break;

lst[pos+1] = lst[pos];

}

lst[pos+1] = vi;

if( (int)lst.size() > linesMax )

lst.pop_back();

}

}

}

}

}

for( size_t idx = 0; idx < lst.size(); idx++ )

{

if( lst[idx].rho < 0 )

continue;

lines.push_back(Vec2f(lst[idx].rho, lst[idx].theta));

}

float rho, float theta, int threshold,

int lineLength, int lineGap,

std::vector<Vec4i>& lines, int linesMax )

{

Point pt;

float irho = 1 / rho;

RNG rng((uint64)-1);

CV_Assert( image.type() == CV_8UC1 );

int width = image.cols;

int height = image.rows;

int numangle = cvRound(CV_PI / theta);

int numrho = cvRound(((width + height) * 2 + 1) / rho);

#if defined HAVE_IPP && IPP_VERSION_X100 >= 810 && !IPP_DISABLE_HOUGH

CV_IPP_CHECK()

{

IppiSize srcSize = { width, height };

IppPointPolar delta = { rho, theta };

IppiHoughProbSpec* pSpec;

int bufferSize, specSize;

int ipp_linesMax = std::min(linesMax, numangle*numrho);

int linesCount = 0;

lines.resize(ipp_linesMax);

IppStatus ok = ippiHoughProbLineGetSize_8u_C1R(srcSize, delta, &specSize, &bufferSize);

Ipp8u* buffer = ippsMalloc_8u_L(bufferSize);

pSpec = (IppiHoughProbSpec*) ippsMalloc_8u_L(specSize);

if (ok >= 0) ok = ippiHoughProbLineInit_8u32f_C1R(srcSize, delta, ippAlgHintNone, pSpec);

if (ok >= 0) {ok = CV_INSTRUMENT_FUN_IPP(ippiHoughProbLine_8u32f_C1R, image.data, (int)image.step, srcSize, threshold, lineLength, lineGap, (IppiPoint*) &lines[0], ipp_linesMax, &linesCount, buffer, pSpec);};

ippsFree(pSpec);

ippsFree(buffer);

if (ok >= 0)

{

lines.resize(linesCount);

CV_IMPL_ADD(CV_IMPL_IPP);

return;

}

lines.clear();

setIppErrorStatus();

}

#endif

Mat accum = Mat::zeros( numangle, numrho, CV_32SC1 );

Mat mask( height, width, CV_8UC1 );

std::vector<float> trigtab(numangle*2);

for( int n = 0; n < numangle; n++ )

{

trigtab[n*2] = (float)(cos((double)n*theta) * irho);

trigtab[n*2+1] = (float)(sin((double)n*theta) * irho);

}

const float* ttab = &trigtab[0];

uchar* mdata0 = mask.ptr();

std::vector<Point> nzloc;

// stage 1. collect non-zero image points

for( pt.y = 0; pt.y < height; pt.y++ )

{

const uchar* data = image.ptr(pt.y);

uchar* mdata = mask.ptr(pt.y);

for( pt.x = 0; pt.x < width; pt.x++ )

{

if( data[pt.x] )

{

mdata[pt.x] = (uchar)1;

nzloc.push_back(pt);

}

else

mdata[pt.x] = 0;

}

}

int count = (int)nzloc.size();

// stage 2. process all the points in random order

for( ; count > 0; count-- )

{

// choose random point out of the remaining ones

int idx = rng.uniform(0, count);

int max_val = threshold-1, max_n = 0;

Point point = nzloc[idx];

Point line_end[2];

float a, b;

int* adata = accum.ptr<int>();

int i = point.y, j = point.x, k, x0, y0, dx0, dy0, xflag;

int good_line;

const int shift = 16;

// "remove" it by overriding it with the last element

nzloc[idx] = nzloc[count-1];

// check if it has been excluded already (i.e. belongs to some other line)

if( !mdata0[i*width + j] )

continue;

// update accumulator, find the most probable line

for( int n = 0; n < numangle; n++, adata += numrho )

{

int r = cvRound( j * ttab[n*2] + i * ttab[n*2+1] );

r += (numrho - 1) / 2;

int val = ++adata[r];

if( max_val < val )

{

max_val = val;

max_n = n;

}

}

// if it is too "weak" candidate, continue with another point

if( max_val < threshold )

continue;

// from the current point walk in each direction

// along the found line and extract the line segment

a = -ttab[max_n*2+1];

b = ttab[max_n*2];

x0 = j;

y0 = i;

if( fabs(a) > fabs(b) )

{

xflag = 1;

dx0 = a > 0 ? 1 : -1;

dy0 = cvRound( b*(1 << shift)/fabs(a) );

y0 = (y0 << shift) + (1 << (shift-1));

}

else

{

xflag = 0;

dy0 = b > 0 ? 1 : -1;

dx0 = cvRound( a*(1 << shift)/fabs(b) );

x0 = (x0 << shift) + (1 << (shift-1));

}

for( k = 0; k < 2; k++ )

{

int gap = 0, x = x0, y = y0, dx = dx0, dy = dy0;

if( k > 0 )

dx = -dx, dy = -dy;

// walk along the line using fixed-point arithmetics,

// stop at the image border or in case of too big gap

for( ;; x += dx, y += dy )

{

uchar* mdata;

int i1, j1;

if( xflag )

{

j1 = x;

i1 = y >> shift;

}

else

{

j1 = x >> shift;

i1 = y;

}

if( j1 < 0 || j1 >= width || i1 < 0 || i1 >= height )

break;

mdata = mdata0 + i1*width + j1;

// for each non-zero point:

// update line end,

// clear the mask element

// reset the gap

if( *mdata )

{

gap = 0;

line_end[k].y = i1;

line_end[k].x = j1;

}

else if( ++gap > lineGap )

break;

}

}

good_line = std::abs(line_end[1].x - line_end[0].x) >= lineLength ||

std::abs(line_end[1].y - line_end[0].y) >= lineLength;

for( k = 0; k < 2; k++ )

{

int x = x0, y = y0, dx = dx0, dy = dy0;

if( k > 0 )

dx = -dx, dy = -dy;

// walk along the line using fixed-point arithmetics,

// stop at the image border or in case of too big gap

for( ;; x += dx, y += dy )

{

uchar* mdata;

int i1, j1;

if( xflag )

{

j1 = x;

i1 = y >> shift;

}

else

{

j1 = x >> shift;

i1 = y;

}

mdata = mdata0 + i1*width + j1;

// for each non-zero point:

// update line end,

// clear the mask element

// reset the gap

if( *mdata )

{

if( good_line )

{

adata = accum.ptr<int>();

for( int n = 0; n < numangle; n++, adata += numrho )

{

int r = cvRound( j1 * ttab[n*2] + i1 * ttab[n*2+1] );

r += (numrho - 1) / 2;

adata[r]--;

}

}

*mdata = 0;

}

if( i1 == line_end[k].y && j1 == line_end[k].x )

break;

}

}

if( good_line )

{

Vec4i lr(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);

lines.push_back(lr);

if( (int)lines.size() >= linesMax )

return;

}

}

{

UMat src = _src.getUMat();

_pointsList.create(1, (int) src.total(), CV_32SC1);

UMat pointsList = _pointsList.getUMat();

UMat counters = _counters.getUMat();

ocl::Device dev = ocl::Device::getDefault();

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] = { (size_t)workgroup_size, 1 };

size_t globalThreads[2] = { (size_t)workgroup_size, (size_t)src.rows };

return pointListKernel.run(2, globalThreads, localThreads, false);

{

UMat pointsList = _pointsList.getUMat();

_accum.create(numangle + 2, numrho + 2, CV_32SC1);

UMat accum = _accum.getUMat();

ocl::Device dev = ocl::Device::getDefault();

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];

size_t local_memory_needed = (numrho + 2)*sizeof(int);

if (local_memory_needed > dev.localMemSize())

{

accum.setTo(Scalar::all(0));

fillAccumKernel.create("fill_accum_global", ocl::imgproc::hough_lines_oclsrc,

format("-D FILL_ACCUM_GLOBAL"));

if (fillAccumKernel.empty())

return false;

globalThreads[0] = workgroup_size; globalThreads[1] = numangle;

fillAccumKernel.args(ocl::KernelArg::ReadOnlyNoSize(pointsList), ocl::KernelArg::WriteOnlyNoSize(accum),

total_points, irho, (float) theta, numrho, numangle);

return fillAccumKernel.run(2, globalThreads, NULL, false);

}

else

{

fillAccumKernel.create("fill_accum_local", ocl::imgproc::hough_lines_oclsrc,

format("-D FILL_ACCUM_LOCAL -D LOCAL_SIZE=%d -D BUFFER_SIZE=%d", workgroup_size, numrho + 2));

if (fillAccumKernel.empty())

return false;

localThreads[0] = workgroup_size; localThreads[1] = 1;

globalThreads[0] = workgroup_size; globalThreads[1] = numangle+2;

fillAccumKernel.args(ocl::KernelArg::ReadOnlyNoSize(pointsList), ocl::KernelArg::WriteOnlyNoSize(accum),

total_points, irho, (float) theta, numrho, numangle);

return fillAccumKernel.run(2, globalThreads, localThreads, false);

}

double min_theta, double max_theta)

{

CV_Assert(_src.type() == CV_8UC1);

if (max_theta < 0 || max_theta > CV_PI ) {

CV_Error( Error::StsBadArg, "max_theta must fall between 0 and pi" );

}

if (min_theta < 0 || min_theta > max_theta ) {

CV_Error( Error::StsBadArg, "min_theta must fall between 0 and max_theta" );

}

if (!(rho > 0 && theta > 0)) {

CV_Error( Error::StsBadArg, "rho and theta must be greater 0" );

}

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));

if (!ocl_makePointsList(src, pointsList, counters))

return false;

int total_points = counters.getMat(ACCESS_READ).at<int>(0, 0);

if (total_points <= 0)

{

_lines.assign(UMat(0,0,CV_32FC2));

return true;

}

UMat accum;

if (!ocl_fillAccum(pointsList, accum, total_points, rho, theta, numrho, numangle))

return false;

const int pixPerWI = 8;

ocl::Kernel getLinesKernel("get_lines", ocl::imgproc::hough_lines_oclsrc,

format("-D GET_LINES"));

if (getLinesKernel.empty())

return false;

int linesMax = threshold > 0 ? min(total_points*numangle/threshold, OCL_MAX_LINES) : OCL_MAX_LINES;

UMat lines(linesMax, 1, CV_32FC2);

getLinesKernel.args(ocl::KernelArg::ReadOnly(accum), ocl::KernelArg::WriteOnlyNoSize(lines),

ocl::KernelArg::PtrWriteOnly(counters), linesMax, threshold, (float) rho, (float) theta);

size_t globalThreads[2] = { ((size_t)numrho + pixPerWI - 1)/pixPerWI, (size_t)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_32FC2));

return true;

double minLineLength, double maxGap)

{

CV_Assert(_src.type() == CV_8UC1);

if (!(rho > 0 && theta > 0)) {

CV_Error( Error::StsBadArg, "rho and theta must be greater 0" );

}

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;

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;

int linesMax = threshold > 0 ? min(total_points*numangle/threshold, OCL_MAX_LINES) : OCL_MAX_LINES;

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] = { (size_t)numrho, (size_t)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;

double rho, double theta, int threshold,

double srn, double stn, double min_theta, double max_theta )

{

CV_INSTRUMENT_REGION()

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();

std::vector<Vec2f> lines;

if( srn == 0 && stn == 0 )

HoughLinesStandard(image, (float)rho, (float)theta, threshold, lines, INT_MAX, min_theta, max_theta );

else

HoughLinesSDiv(image, (float)rho, (float)theta, threshold, cvRound(srn), cvRound(stn), lines, INT_MAX, min_theta, max_theta);

Mat(lines).copyTo(_lines);

double rho, double theta, int threshold,

double minLineLength, double maxGap )

{

CV_INSTRUMENT_REGION()

CV_OCL_RUN(_image.isUMat() && _lines.isUMat(),

ocl_HoughLinesP(_image, _lines, rho, theta, threshold, minLineLength, maxGap));

Mat image = _image.getMat();

std::vector<Vec4i> lines;

HoughLinesProbabilistic(image, (float)rho, (float)theta, threshold, cvRound(minLineLength), cvRound(maxGap), lines, INT_MAX);

Mat(lines).copyTo(_lines);

{

EstimatedCircle(Vec3f _c, int _accum) :

c(_c), accum(_accum) {}

Vec3f c;

int accum;

{

// Compare everything so the order is completely deterministic

// Larger accum first

if (left.accum > right.accum)

return true;

else if (left.accum < right.accum)

return false;

// Larger radius first

else if (left.c[2] > right.c[2])

return true;

else if (left.c[2] < right.c[2])

return false;

// Smaller X

else if (left.c[0] < right.c[0])

return true;

else if (left.c[0] > right.c[0])

return false;

// Smaller Y

else if (left.c[1] < right.c[1])

return true;

else if (left.c[1] > right.c[1])

return false;

// Identical - neither object is less than the other

else

return false;

{

NZPointList(const NZPointList& other); // non-copyable

NZPointList(int reserveSize = 256)

{

reserve(reserveSize);

}

{

NZPointSet(const NZPointSet& other); // non-copyable

Mat_<uchar> positions;

NZPointSet(int rows, int cols) :

positions(rows, cols, (uchar)0)

{

}

void insert(const Point& pt)

{

positions(pt) = 1;

}

void insert(const NZPointSet& from)

{

cv::bitwise_or(from.positions, positions, positions);

}

void toList(NZPointList& list) const

{

for (int y = 0; y < positions.rows; y++)

{

const uchar *ptr = positions.ptr<uchar>(y, 0);

for (int x = 0; x < positions.cols; x++)

{

if (ptr[x])

{

list.push_back(Point(x, y));

}

}

}

}

{

HoughCirclesAccumInvoker(const Mat &_edges, const Mat &_dx, const Mat &_dy, int _minRadius, int _maxRadius, float _idp,

std::vector<Mat>& _accumVec, NZPointSet& _nz, Mutex& _mtx) :

edges(_edges), dx(_dx), dy(_dy), minRadius(_minRadius), maxRadius(_maxRadius), idp(_idp),

accumVec(_accumVec), nz(_nz), mutex(_mtx)

{

acols = cvCeil(edges.cols * idp), arows = cvCeil(edges.rows * idp);

astep = acols + 2;

}

~HoughCirclesAccumInvoker() { }

void operator()(const Range &boundaries) const

{

Mat accumLocal = Mat(arows + 2, acols + 2, CV_32SC1, Scalar::all(0));

int *adataLocal = accumLocal.ptr<int>();

NZPointSet nzLocal(nz.positions.rows, nz.positions.cols);