add FastHoughTransform test

shimat · shimat · commit 5b51f6128481 · 2018-11-12T10:44:00.000+09:00
diff --git a/src/OpenCvSharpExtern/ximgproc_FastHoughTransform.h b/src/OpenCvSharpExtern/ximgproc_FastHoughTransform.h
@@ -9,10 +9,10 @@ CVAPI(void) ximgproc_FastHoughTransform(cv::_InputArray *src, cv::_OutputArray *
     cv::ximgproc::FastHoughTransform(*src, *dst, dstMatDepth, angleRange, op, makeSkew);
 }
 
-CVAPI(CvVec4i) ximgproc_HoughPoint2Line(CvPoint houghPoint, cv::_InputArray *srcImgInfo,
+CVAPI(CvVec4i) ximgproc_HoughPoint2Line(MyCvPoint houghPoint, cv::_InputArray *srcImgInfo,
     int angleRange, int makeSkew, int rules)
 {
-    return c(cv::ximgproc::HoughPoint2Line(houghPoint, *srcImgInfo, angleRange, makeSkew, rules));
+    return c(cv::ximgproc::HoughPoint2Line(cpp(houghPoint), *srcImgInfo, angleRange, makeSkew, rules));
 }
 
 #endif
diff --git a/test/OpenCvSharp.Tests/ximgproc/FastHoughTransformTest.cs b/test/OpenCvSharp.Tests/ximgproc/FastHoughTransformTest.cs
@@ -1,4 +1,6 @@
 ﻿using System;
+using System.Collections.Generic;
+using System.Linq;
 using OpenCvSharp.XImgProc;
 using Xunit;
 
@@ -38,6 +40,105 @@ private static void Rescale(Mat src, Mat dst,
                                    (double)maxHeight / src.Rows), 1.0);
             Cv2.Resize(src, dst, new Size(), scale, scale, InterpolationFlags.Linear);
         }
+
+        /// <summary>
+        /// https://github.com/opencv/opencv_contrib/blob/master/modules/ximgproc/samples/fast_hough_transform.cpp
+        /// </summary>
+        [Fact]
+        public void FHTSample()
+        {
+            const string imPath = @"_data\image\building.jpg";
+            using (var image = new Mat(imPath, ImreadModes.GrayScale))
+            using (var hough = new Mat())
+            using (var canny = new Mat())
+            {
+                Cv2.Canny(image, canny, 50, 200, 3);
+
+                CvXImgProc.FastHoughTransform(canny, hough, MatType.CV_32S/*C1*/, AngleRangeOption.ARO_315_135, HoughOP.FHT_ADD, HoughDeskewOption.DESKEW);
+
+                var lines = new List<Vec4i>();
+                GetLocalExtr(lines, canny, hough, 255f * 0.3f * Math.Min(canny.Rows, canny.Cols), 50);
+
+                var cannyColor = new Mat();
+                Cv2.CvtColor(canny, cannyColor, ColorConversionCodes.GRAY2BGR);
+                for (var i = 0; i < lines.Count; i++)
+                {
+                    var line = lines[i];
+                    Cv2.Line(cannyColor, new Point(line.Item0, line.Item1), new Point(line.Item2, line.Item3), Scalar.Red);
+                }
+                //cannyColor.SaveImage("cannycolor.png");
+
+                ShowImagesWhenDebugMode(image, canny, cannyColor);
+            }
+
+            bool GetLocalExtr(List<Vec4i> lines, Mat src, Mat fht, float minWeight, int maxCount)
+            {
+                const int MAX_LEN = 10_000;
+                var weightedPoints = new List<KeyValuePair<int, Point>>();
+                for (var y = 0; y < fht.Rows; ++y)
+                {
+                    if (weightedPoints.Count > MAX_LEN)
+                        break;
+
+                    var fhtMat = new MatOfInt(fht);
+                    var fhtIndexer = fhtMat.GetIndexer();
+
+                    var pLineY = Math.Max(y - 1, 0);
+                    var cLineY = y;
+                    var nLineY = Math.Min(y + 1, fht.Rows - 1);
+
+                    for (var x = 0; x < fht.Cols; ++x)
+                    {
+                        if (weightedPoints.Count > MAX_LEN)
+                            break;
+
+                        var value = fhtIndexer[cLineY, x];
+                        if (value >= minWeight)
+                        {
+                            var isLocalMax = 0;
+                            var start = Math.Max(x - 1, 0);
+                            var end = Math.Min(x + 1, fht.Cols - 1);
+                            for (var xx = start; xx < end; ++xx)
+                            {
+                                var pLine = fhtIndexer[pLineY, xx];
+                                var cLine = fhtIndexer[cLineY, xx];
+                                var nLine = fhtIndexer[nLineY, xx];
+                                if (!incIfGreater(value, pLine, ref isLocalMax) ||
+                                    !incIfGreater(value, cLine, ref isLocalMax) ||
+                                    !incIfGreater(value, nLine, ref isLocalMax))
+                                {
+                                    isLocalMax = 0;
+                                    break;
+                                }
+                            }
+                            if (isLocalMax > 0)
+                                weightedPoints.Add(new KeyValuePair<int, Point>(value, new Point(x, y)));
+                        }
+                    }
+                }
+
+                if (weightedPoints.Count == 0)
+                    return true;
+
+                // Sort WeightedPoints
+                weightedPoints = weightedPoints.OrderByDescending(x => x.Key).ToList();
+                weightedPoints = weightedPoints.Take(maxCount).ToList();
+
+                for (var i = 0; i < weightedPoints.Count; i++)
+                    lines.Add(CvXImgProc.HoughPoint2Line(weightedPoints[i].Value, src));
+
+                return true;
+            }
+
+            bool incIfGreater(int a, int b, ref int value)
+            {
+                if (/*value == 0 || */a < b)
+                    return false;
+                if (a > b)
+                    ++(value);
+                return true;
+            }
+        }
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,10 @@ CVAPI(void) ximgproc_FastHoughTransform(cv::_InputArray src, cv::_OutputArray `
`9`	`9`	`cv::ximgproc::FastHoughTransform(src, dst, dstMatDepth, angleRange, op, makeSkew);`
`10`	`10`	`}`
`11`	`11`
`12`		`-CVAPI(CvVec4i) ximgproc_HoughPoint2Line(CvPoint houghPoint, cv::_InputArray *srcImgInfo,`
	`12`	`+CVAPI(CvVec4i) ximgproc_HoughPoint2Line(MyCvPoint houghPoint, cv::_InputArray *srcImgInfo,`
`13`	`13`	`int angleRange, int makeSkew, int rules)`
`14`	`14`	`{`
`15`		`- return c(cv::ximgproc::HoughPoint2Line(houghPoint, *srcImgInfo, angleRange, makeSkew, rules));`
	`15`	`+ return c(cv::ximgproc::HoughPoint2Line(cpp(houghPoint), *srcImgInfo, angleRange, makeSkew, rules));`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`#endif`