Merge pull request #3465 from 747:hough-segment-fix

asmorkalov · web-flow · commit 853144ef93c4 · 2023-04-11T16:35:18.000+03:00
Add `threshold` parameter to cuda::HoughSegmentDetector
diff --git a/modules/cudaimgproc/include/opencv2/cudaimgproc.hpp b/modules/cudaimgproc/include/opencv2/cudaimgproc.hpp
@@ -425,6 +425,9 @@ class CV_EXPORTS_W HoughSegmentDetector : public Algorithm
 
     CV_WRAP virtual void setMaxLines(int maxLines) = 0;
     CV_WRAP virtual int getMaxLines() const = 0;
+
+    CV_WRAP virtual void setThreshold(int threshold) = 0;
+    CV_WRAP virtual int getThreshold() const = 0;
 };
 
 /** @brief Creates implementation for cuda::HoughSegmentDetector .
@@ -434,8 +437,10 @@ class CV_EXPORTS_W HoughSegmentDetector : public Algorithm
 @param minLineLength Minimum line length. Line segments shorter than that are rejected.
 @param maxLineGap Maximum allowed gap between points on the same line to link them.
 @param maxLines Maximum number of output lines.
+@param threshold %Accumulator threshold parameter. Only those lines are returned that get enough
+votes ( \f$>\texttt{threshold}\f$ ).
  */
-CV_EXPORTS_W Ptr<HoughSegmentDetector> createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines = 4096);
+CV_EXPORTS_W Ptr<HoughSegmentDetector> createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines = 4096, int threshold = -1);
 
 //////////////////////////////////////
 // HoughCircles
diff --git a/modules/cudaimgproc/src/cuda/hough_segments.cu b/modules/cudaimgproc/src/cuda/hough_segments.cu
@@ -55,6 +55,7 @@ namespace cv { namespace cuda { namespace device
                                                 int4* out, const int maxSize,
                                                 const float rho, const float theta,
                                                 const int lineGap, const int lineLength,
+                                                const int threshold,
                                                 const int rows, const int cols,
                                                 int* counterPtr)
         {
@@ -65,8 +66,9 @@ namespace cv { namespace cuda { namespace device
                 return;
 
             const int curVotes = accum(n + 1, r + 1);
+            const int threshold_ = (threshold > 0) ? threshold : lineLength;
 
-            if (curVotes >= lineLength &&
+            if (curVotes >= threshold_ &&
                 curVotes > accum(n, r) &&
                 curVotes > accum(n, r + 1) &&
                 curVotes > accum(n, r + 2) &&
@@ -213,7 +215,7 @@ namespace cv { namespace cuda { namespace device
             }
         }
 
-        int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int* counterPtr, cudaStream_t stream)
+        int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int threshold, int* counterPtr, cudaStream_t stream)
         {
             cudaSafeCall( cudaMemsetAsync(counterPtr, 0, sizeof(int), stream) );
 
@@ -225,11 +227,11 @@ namespace cv { namespace cuda { namespace device
             mask.locateROI(wholeSize, ofs);
             if (ofs.x || ofs.y) {
                 cv::cudev::TextureOff<uchar> texMask(wholeSize.height, wholeSize.width, mask.datastart, mask.step, ofs.y, ofs.x);
-                houghLinesProbabilistic<cv::cudev::TextureOffPtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, mask.rows, mask.cols, counterPtr);
+                houghLinesProbabilistic<cv::cudev::TextureOffPtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, threshold, mask.rows, mask.cols, counterPtr);
             }
             else {
                 cv::cudev::Texture<uchar> texMask(mask);
-                houghLinesProbabilistic<cv::cudev::TexturePtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, mask.rows, mask.cols, counterPtr);
+                houghLinesProbabilistic<cv::cudev::TexturePtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, threshold, mask.rows, mask.cols, counterPtr);
             }
 
             cudaSafeCall( cudaGetLastError() );
diff --git a/modules/cudaimgproc/src/hough_segments.cpp b/modules/cudaimgproc/src/hough_segments.cpp
@@ -47,7 +47,7 @@ using namespace cv::cuda;
 
 #if !defined (HAVE_CUDA) || defined (CUDA_DISABLER)
 
-Ptr<cuda::HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float, float, int, int, int) { throw_no_cuda(); return Ptr<HoughSegmentDetector>(); }
+Ptr<cuda::HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float, float, int, int, int, int) { throw_no_cuda(); return Ptr<HoughSegmentDetector>(); }
 
 #else /* !defined (HAVE_CUDA) */
 
@@ -65,7 +65,7 @@ namespace cv { namespace cuda { namespace device
 
     namespace hough_segments
     {
-        int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int* counterPtr, cudaStream_t stream);
+        int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int threshold, int* counterPtr, cudaStream_t stream);
     }
 }}}
 
@@ -74,7 +74,7 @@ namespace
     class HoughSegmentDetectorImpl : public HoughSegmentDetector
     {
     public:
-        HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines);
+        HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold);
         ~HoughSegmentDetectorImpl();
 
         void detect(InputArray src, OutputArray lines, Stream& stream);
@@ -94,6 +94,9 @@ namespace
         void setMaxLines(int maxLines) { maxLines_ = maxLines; }
         int getMaxLines() const { return maxLines_; }
 
+        void setThreshold(int threshold) { threshold_ = threshold; }
+        int getThreshold() const { return threshold_; }
+
         void write(FileStorage& fs) const
         {
             writeFormat(fs);
@@ -102,7 +105,8 @@ namespace
             << "theta" << theta_
             << "minLineLength" << minLineLength_
             << "maxLineGap" << maxLineGap_
-            << "maxLines" << maxLines_;
+            << "maxLines" << maxLines_
+            << "threshold" << threshold_;
         }
 
         void read(const FileNode& fn)
@@ -113,6 +117,7 @@ namespace
             minLineLength_ = (int)fn["minLineLength"];
             maxLineGap_ = (int)fn["maxLineGap"];
             maxLines_ = (int)fn["maxLines"];
+            threshold_ = (int)fn["threshold"];
         }
 
     private:
@@ -121,6 +126,7 @@ namespace
         int minLineLength_;
         int maxLineGap_;
         int maxLines_;
+        int threshold_;
 
         GpuMat accum_;
         GpuMat list_;
@@ -129,8 +135,8 @@ namespace
         int* counterPtr_;
     };
 
-    HoughSegmentDetectorImpl::HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines) :
-        rho_(rho), theta_(theta), minLineLength_(minLineLength), maxLineGap_(maxLineGap), maxLines_(maxLines)
+    HoughSegmentDetectorImpl::HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold) :
+        rho_(rho), theta_(theta), minLineLength_(minLineLength), maxLineGap_(maxLineGap), maxLines_(maxLines), threshold_(threshold)
     {
         cudaSafeCall(cudaMalloc(&counterPtr_, sizeof(int)));
     }
@@ -178,7 +184,7 @@ namespace
 
         ensureSizeIsEnough(1, maxLines_, CV_32SC4, result_);
 
-        int linesCount = houghLinesProbabilistic_gpu(src, accum_, result_.ptr<int4>(), maxLines_, rho_, theta_, maxLineGap_, minLineLength_, counterPtr_, cudaStream);
+        int linesCount = houghLinesProbabilistic_gpu(src, accum_, result_.ptr<int4>(), maxLines_, rho_, theta_, maxLineGap_, minLineLength_, threshold_, counterPtr_, cudaStream);
 
         if (linesCount == 0)
         {
@@ -191,9 +197,9 @@ namespace
     }
 }
 
-Ptr<HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines)
+Ptr<HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold)
 {
-    return makePtr<HoughSegmentDetectorImpl>(rho, theta, minLineLength, maxLineGap, maxLines);
+    return makePtr<HoughSegmentDetectorImpl>(rho, theta, minLineLength, maxLineGap, maxLines, threshold);
 }
 
 #endif /* !defined (HAVE_CUDA) */

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ namespace cv { namespace cuda { namespace device`
`55`	`55`	`int4* out, const int maxSize,`
`56`	`56`	`const float rho, const float theta,`
`57`	`57`	`const int lineGap, const int lineLength,`
	`58`	`+ const int threshold,`
`58`	`59`	`const int rows, const int cols,`
`59`	`60`	`int* counterPtr)`
`60`	`61`	`{`
`@@ -65,8 +66,9 @@ namespace cv { namespace cuda { namespace device`
`65`	`66`	`return;`
`66`	`67`
`67`	`68`	`const int curVotes = accum(n + 1, r + 1);`
	`69`	`+ const int threshold_ = (threshold > 0) ? threshold : lineLength;`
`68`	`70`
`69`		`- if (curVotes >= lineLength &&`
	`71`	`+ if (curVotes >= threshold_ &&`
`70`	`72`	`curVotes > accum(n, r) &&`
`71`	`73`	`curVotes > accum(n, r + 1) &&`
`72`	`74`	`curVotes > accum(n, r + 2) &&`
`@@ -213,7 +215,7 @@ namespace cv { namespace cuda { namespace device`
`213`	`215`	`}`
`214`	`216`	`}`
`215`	`217`
`216`		`- int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int* counterPtr, cudaStream_t stream)`
	`218`	`+ int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int threshold, int* counterPtr, cudaStream_t stream)`
`217`	`219`	`{`
`218`	`220`	`cudaSafeCall( cudaMemsetAsync(counterPtr, 0, sizeof(int), stream) );`
`219`	`221`
`@@ -225,11 +227,11 @@ namespace cv { namespace cuda { namespace device`
`225`	`227`	`mask.locateROI(wholeSize, ofs);`
`226`	`228`	`if (ofs.x \|\| ofs.y) {`
`227`	`229`	`cv::cudev::TextureOff<uchar> texMask(wholeSize.height, wholeSize.width, mask.datastart, mask.step, ofs.y, ofs.x);`
`228`		`- houghLinesProbabilistic<cv::cudev::TextureOffPtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, mask.rows, mask.cols, counterPtr);`
	`230`	`+ houghLinesProbabilistic<cv::cudev::TextureOffPtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, threshold, mask.rows, mask.cols, counterPtr);`
`229`	`231`	`}`
`230`	`232`	`else {`
`231`	`233`	`cv::cudev::Texture<uchar> texMask(mask);`
`232`		`- houghLinesProbabilistic<cv::cudev::TexturePtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, mask.rows, mask.cols, counterPtr);`
	`234`	`+ houghLinesProbabilistic<cv::cudev::TexturePtr<uchar>><<<grid, block, 0, stream>>>(texMask, accum, out, maxSize, rho, theta, lineGap, lineLength, threshold, mask.rows, mask.cols, counterPtr);`
`233`	`235`	`}`
`234`	`236`
`235`	`237`	`cudaSafeCall( cudaGetLastError() );`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ using namespace cv::cuda;`
`47`	`47`
`48`	`48`	`#if !defined (HAVE_CUDA) \|\| defined (CUDA_DISABLER)`
`49`	`49`
`50`		`-Ptr<cuda::HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float, float, int, int, int) { throw_no_cuda(); return Ptr<HoughSegmentDetector>(); }`
	`50`	`+Ptr<cuda::HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float, float, int, int, int, int) { throw_no_cuda(); return Ptr<HoughSegmentDetector>(); }`
`51`	`51`
`52`	`52`	`#else /* !defined (HAVE_CUDA) */`
`53`	`53`
`@@ -65,7 +65,7 @@ namespace cv { namespace cuda { namespace device`
`65`	`65`
`66`	`66`	`namespace hough_segments`
`67`	`67`	`{`
`68`		`- int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int* counterPtr, cudaStream_t stream);`
	`68`	`+ int houghLinesProbabilistic_gpu(GpuMat &mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength, int threshold, int* counterPtr, cudaStream_t stream);`
`69`	`69`	`}`
`70`	`70`	`}}}`
`71`	`71`
`@@ -74,7 +74,7 @@ namespace`
`74`	`74`	`class HoughSegmentDetectorImpl : public HoughSegmentDetector`
`75`	`75`	`{`
`76`	`76`	`public:`
`77`		`- HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines);`
	`77`	`+ HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold);`
`78`	`78`	`~HoughSegmentDetectorImpl();`
`79`	`79`
`80`	`80`	`void detect(InputArray src, OutputArray lines, Stream& stream);`
`@@ -94,6 +94,9 @@ namespace`
`94`	`94`	`void setMaxLines(int maxLines) { maxLines_ = maxLines; }`
`95`	`95`	`int getMaxLines() const { return maxLines_; }`
`96`	`96`
	`97`	`+ void setThreshold(int threshold) { threshold_ = threshold; }`
	`98`	`+ int getThreshold() const { return threshold_; }`
	`99`	`+`
`97`	`100`	`void write(FileStorage& fs) const`
`98`	`101`	`{`
`99`	`102`	`writeFormat(fs);`
`@@ -102,7 +105,8 @@ namespace`
`102`	`105`	`<< "theta" << theta_`
`103`	`106`	`<< "minLineLength" << minLineLength_`
`104`	`107`	`<< "maxLineGap" << maxLineGap_`
`105`		`- << "maxLines" << maxLines_;`
	`108`	`+ << "maxLines" << maxLines_`
	`109`	`+ << "threshold" << threshold_;`
`106`	`110`	`}`
`107`	`111`
`108`	`112`	`void read(const FileNode& fn)`
`@@ -113,6 +117,7 @@ namespace`
`113`	`117`	`minLineLength_ = (int)fn["minLineLength"];`
`114`	`118`	`maxLineGap_ = (int)fn["maxLineGap"];`
`115`	`119`	`maxLines_ = (int)fn["maxLines"];`
	`120`	`+ threshold_ = (int)fn["threshold"];`
`116`	`121`	`}`
`117`	`122`
`118`	`123`	`private:`
`@@ -121,6 +126,7 @@ namespace`
`121`	`126`	`int minLineLength_;`
`122`	`127`	`int maxLineGap_;`
`123`	`128`	`int maxLines_;`
	`129`	`+ int threshold_;`
`124`	`130`
`125`	`131`	`GpuMat accum_;`
`126`	`132`	`GpuMat list_;`
`@@ -129,8 +135,8 @@ namespace`
`129`	`135`	`int* counterPtr_;`
`130`	`136`	`};`
`131`	`137`
`132`		`- HoughSegmentDetectorImpl::HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines) :`
`133`		`- rho_(rho), theta_(theta), minLineLength_(minLineLength), maxLineGap_(maxLineGap), maxLines_(maxLines)`
	`138`	`+ HoughSegmentDetectorImpl::HoughSegmentDetectorImpl(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold) :`
	`139`	`+ rho_(rho), theta_(theta), minLineLength_(minLineLength), maxLineGap_(maxLineGap), maxLines_(maxLines), threshold_(threshold)`
`134`	`140`	`{`
`135`	`141`	`cudaSafeCall(cudaMalloc(&counterPtr_, sizeof(int)));`
`136`	`142`	`}`
`@@ -178,7 +184,7 @@ namespace`
`178`	`184`
`179`	`185`	`ensureSizeIsEnough(1, maxLines_, CV_32SC4, result_);`
`180`	`186`
`181`		`- int linesCount = houghLinesProbabilistic_gpu(src, accum_, result_.ptr<int4>(), maxLines_, rho_, theta_, maxLineGap_, minLineLength_, counterPtr_, cudaStream);`
	`187`	`+ int linesCount = houghLinesProbabilistic_gpu(src, accum_, result_.ptr<int4>(), maxLines_, rho_, theta_, maxLineGap_, minLineLength_, threshold_, counterPtr_, cudaStream);`
`182`	`188`
`183`	`189`	`if (linesCount == 0)`
`184`	`190`	`{`
`@@ -191,9 +197,9 @@ namespace`
`191`	`197`	`}`
`192`	`198`	`}`
`193`	`199`
`194`		`-Ptr<HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines)`
	`200`	`+Ptr<HoughSegmentDetector> cv::cuda::createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold)`
`195`	`201`	`{`
`196`		`- return makePtr<HoughSegmentDetectorImpl>(rho, theta, minLineLength, maxLineGap, maxLines);`
	`202`	`+ return makePtr<HoughSegmentDetectorImpl>(rho, theta, minLineLength, maxLineGap, maxLines, threshold);`
`197`	`203`	`}`
`198`	`204`
`199`	`205`	`#endif /* !defined (HAVE_CUDA) */`