additional improvements and documentation of class

Author: sturkmen72

modules/ximgproc/include/opencv2/ximgproc/edge_drawing.hpp

@@ -41,35 +41,72 @@ class CV_EXPORTS_W EdgeDrawing : public Algorithm
         LSD = 3
     };
 
+    struct CV_EXPORTS_W_SIMPLE Params
+    {
+        CV_WRAP Params();
+        //! Parameter Free mode will be activated when this value is true.
+        CV_PROP_RW bool PFmode;
+        //! indicates the operator used for gradient calculation.The following operation flags are available(cv::ximgproc::EdgeDrawing::GradientOperator)
+        CV_PROP_RW int EdgeDetectionOperator;
+        //! threshold value used to create gradient image.
+        CV_PROP_RW int GradientThresholdValue;
+        //! threshold value used to create gradient image.
+        CV_PROP_RW int AnchorThresholdValue;
+        CV_PROP_RW int ScanInterval;
+        //! minimun connected pixels length processed to create an edge segment.
+        CV_PROP_RW int MinPathLength;
+        //! sigma value for internal GaussianBlur() function.
+        CV_PROP_RW float Sigma;
+        CV_PROP_RW bool SumFlag;
+        //! when this value is true NFA (Number of False Alarms) algorithm will be used for line and ellipse validation.
+        CV_PROP_RW bool NFAValidation;
+        //! minimun line length to detect.
+        CV_PROP_RW int MinLineLength;
+        CV_PROP_RW double MaxDistanceBetweenTwoLines;
+        CV_PROP_RW double LineFitErrorThreshold;
+        CV_PROP_RW double MaxErrorThreshold;
+
+        void read(const FileNode& fn);
+        void write(FileStorage& fs) const;
+    };
+
+    /** @brief Detects edges and prepares them to detect lines and ellipses.
+
+    @param src input image
+    */
     CV_WRAP virtual void detectEdges(InputArray src) = 0;
     CV_WRAP virtual void getEdgeImage(OutputArray dst) = 0;
     CV_WRAP virtual void getGradientImage(OutputArray dst) = 0;
 
     CV_WRAP virtual std::vector<std::vector<Point> > getSegments() = 0;
 
-    CV_WRAP virtual void detectLines(OutputArray lines, bool validate = true,
-                                     int MinLineLength = -1, double LineError = 1.0,
-                                     double MaxDistanceBetweenTwoLines = 6.0, double MaxError = 1.3) = 0;
-    CV_WRAP virtual void detectEllipses(OutputArray ellipses, bool validate = true) = 0;
+    /** @brief Detects lines.
+
+    @param lines  output Vec<4f> contains start point and end point of detected lines.
+    @note you should call detectEdges() method before call this.
+    */
+    CV_WRAP virtual void detectLines(OutputArray lines) = 0;
+
+    /** @brief Detects circles and ellipses.
 
+    @param ellipses  output Vec<6d> contains center point and perimeter for circles.
+    @note you should call detectEdges() method before call this.
+    */
+    CV_WRAP virtual void detectEllipses(OutputArray ellipses) = 0;
+
+    CV_WRAP Params params;
+
+    /** @brief sets parameters.
+
+    this function is meant to be used for parameter setting in other languages than c++.
+    */
+    CV_WRAP void setParams(EdgeDrawing::Params parameters);
     virtual ~EdgeDrawing() { }
 };
 
 /** @brief Creates a smart pointer to a EdgeDrawing object and initializes it
-
-@param EdgeDetectionOperator The following operation flags are available (cv::ximgproc::EdgeDrawing::GradientOperator)
-@param GradientThresholdValue threshold value used to create gradient image. if this value is 0 then
-                              parameter free (EDPF) used internally.
-@param AnchorThresholdValue threshold value used to find anchor points.
-@param ScanningInterval
-@param MinPathLength Segments shorter than this value will be discarded.
-@param Sigma sigma value used internal GaussianBlur() function.
-@param SumFlag
 */
-CV_EXPORTS_W Ptr<EdgeDrawing> createEdgeDrawing(int EdgeDetectionOperator = EdgeDrawing::SOBEL,
-    int GradientThresholdValue = 20, int AnchorThresholdValue = 0, int ScanningInterval = 1,
-    int MinPathLength = 10, double Sigma = 1.0, bool SumFlag = true);
-
+CV_EXPORTS_W Ptr<EdgeDrawing> createEdgeDrawing();
 //! @}
 
 }

modules/ximgproc/misc/python/pyopencv_ximgproc.hpp

@@ -0,0 +1,3 @@
+#ifdef HAVE_OPENCV_XIMGPROC
+typedef cv::ximgproc::EdgeDrawing::Params EdgeDrawing_Params;
+#endif

modules/ximgproc/samples/edge_drawing.py

@@ -32,30 +32,40 @@ def main():
     lsrc = src.copy()
     esrc = src.copy()
 
-    ed = cv.ximgproc.createEdgeDrawing(cv.ximgproc.EdgeDrawing_SOBEL, 36, 8)
+    ed = cv.ximgproc.createEdgeDrawing()
+
+    # you can change parameters (refer the documentation to see all parameters)
+    EDParams = cv.ximgproc_EdgeDrawing_Params()
+    EDParams.MinPathLength = 50     # try changing this value between 5 to 1000
+    EDParams.PFmode = False         # defaut value try to swich it to True
+    EDParams.MinLineLength = 10     # try changing this value between 5 to 100
+    EDParams.NFAValidation = True   # defaut value try to swich it to False
+
+    ed.setParams(EDParams)
 
     # Detect edges
     # you should call this before detectLines() and detectEllipses()
     ed.detectEdges(gray)
-
-    lines = ed.detectLines(False)
     segments = ed.getSegments()
+    lines = ed.detectLines()
+    ellipses = ed.detectEllipses()
 
+    #Draw detected edge segments
     for i in range(len(segments)):
         color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
         cv.polylines(ssrc, [segments[i]], False, color, 1, cv.LINE_8)
 
-    cv.imshow("detected edges", ssrc)
+    cv.imshow("detected edge segments", ssrc)
 
-    if lines is not None: # Check if lines have been found and only then iterate over these and add them to the image
+    #Draw detected lines
+    if lines is not None: # Check if the lines have been found and only then iterate over these and add them to the image
         lines = np.uint16(np.around(lines))
         for i in range(len(lines)):
             cv.line(lsrc, (lines[i][0][0], lines[i][0][1]), (lines[i][0][2], lines[i][0][3]), (0, 0, 255), 1, cv.LINE_AA)
 
     cv.imshow("detected lines", lsrc)
 
-    ellipses = ed.detectEllipses()
-
+    #Draw detected circles and ellipses
     if ellipses is not None: # Check if circles and ellipses have been found and only then iterate over these and add them to the image
         ellipses = np.uint16(np.around(ellipses))
         for i in range(len(ellipses)):

modules/ximgproc/samples/fld_lines.cpp

@@ -73,7 +73,11 @@ int main(int argc, char** argv)
 
     waitKey(1);
 
-    Ptr<EdgeDrawing> ed = createEdgeDrawing(EdgeDrawing::SOBEL, 36, 8);
+    Ptr<EdgeDrawing> ed = createEdgeDrawing();
+    ed->params.EdgeDetectionOperator = EdgeDrawing::SOBEL;
+    ed->params.GradientThresholdValue = 38;
+    ed->params.AnchorThresholdValue = 8;
+
     vector<Vec6d> ellipses;
 
     for (int run_count = 0; run_count < 5; run_count++) {
@@ -86,13 +90,13 @@ int main(int argc, char** argv)
         ed->detectEdges(image);
 
         // Detect lines
-        ed->detectLines(lines, false);
+        ed->detectLines(lines);
         double duration_ms = double(getTickCount() - start) * 1000 / freq;
         cout << "Elapsed time for EdgeDrawing detectLines " << duration_ms << " ms." << endl;
 
         start = getTickCount();
         // Detect circles and ellipses
-        ed->detectEllipses(ellipses, true);
+        ed->detectEllipses(ellipses);
         duration_ms = double(getTickCount() - start) * 1000 / freq;
         cout << "Elapsed time for EdgeDrawing detectEllipses " << duration_ms << " ms." << endl;
     }