opencv
diff --git a/‎doc/js_tutorials/js_assets/js_intelligent_scissors.html
Copy file name to clipboard
+127Lines changed: 127 additions & 0 deletions b/‎doc/js_tutorials/js_assets/js_intelligent_scissors.html
Copy file name to clipboard
+127Lines changed: 127 additions & 0 deletions
diff --git a/‎doc/js_tutorials/js_imgproc/js_intelligent_scissors/js_intelligent_scissors.markdown
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions b/‎doc/js_tutorials/js_imgproc/js_intelligent_scissors/js_intelligent_scissors.markdown
Copy file name to clipboard
+14Lines changed: 14 additions & 0 deletions
diff --git a/‎doc/js_tutorials/js_imgproc/js_table_of_contents_imgproc.markdown
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎doc/js_tutorials/js_imgproc/js_table_of_contents_imgproc.markdown
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎doc/opencv.bib
Copy file name to clipboard
+7Lines changed: 7 additions & 0 deletions b/‎doc/opencv.bib
Copy file name to clipboard
+7Lines changed: 7 additions & 0 deletions
diff --git a/‎modules/imgproc/include/opencv2/imgproc.hpp
Copy file name to clipboard
+16-3Lines changed: 16 additions & 3 deletions b/‎modules/imgproc/include/opencv2/imgproc.hpp
Copy file name to clipboard
+16-3Lines changed: 16 additions & 3 deletions
diff --git a/‎modules/imgproc/include/opencv2/imgproc/segmentation.hpp
Copy file name to clipboard
+141Lines changed: 141 additions & 0 deletions b/‎modules/imgproc/include/opencv2/imgproc/segmentation.hpp
Copy file name to clipboard
+141Lines changed: 141 additions & 0 deletions
@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Intelligent Scissors Example</title>
+<link href="js_example_style.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<h2>Intelligent Scissors Example</h2>
+<p>
+    Click <b>Start</b> button to launch the code below.<br>
+    Then click on image to pick source point. After that you can hover mouse pointer over canvas to specify target point candidate.<br>
+    You can change the code in the &lt;textarea&gt; to investigate more. You can choose another image (need to "Stop" first).
+</p>
+<div>
+<div class="control"><button id="tryIt" disabled>Start</button> <button id="stopIt" disabled>Stop</button></div>
+<textarea class="code" rows="20" cols="100" id="codeEditor" spellcheck="false">
+</textarea>
+<p class="err" id="errorMessage"></p>
+</div>
+<div id="inputParams">
+  <div class="caption">canvasInput <input type="file" id="fileInput" name="file" accept="image/*" /></div>
+  <canvas id="canvasInput"></canvas>
+</div>
+<div id="result" style="display:none">
+  <canvas id="canvasOutput"></canvas>
+</div>
+
+<script src="utils.js" type="text/javascript"></script>
+
+<script id="codeSnippet" type="text/code-snippet">
+let src = cv.imread('canvasInput');
+//cv.resize(src, src, new cv.Size(1024, 1024));
+cv.imshow('canvasOutput', src);
+
+let tool = new cv.segmentation_IntelligentScissorsMB();
+tool.setEdgeFeatureCannyParameters(32, 100);
+tool.setGradientMagnitudeMaxLimit(200);
+tool.applyImage(src);
+
+let hasMap = false;
+
+let canvas = document.getElementById('canvasOutput');
+canvas.addEventListener('click', e => {
+    let startX = e.offsetX, startY = e.offsetY; console.log(startX, startY);
+    if (startX < src.cols && startY < src.rows)
+    {
+        console.time('buildMap');
+        tool.buildMap(new cv.Point(startX, startY));
+        console.timeEnd('buildMap');
+        hasMap = true;
+    }
+});
+canvas.addEventListener('mousemove', e => {
+    let x = e.offsetX, y = e.offsetY; //console.log(x, y);
+    let dst = src.clone();
+    if (hasMap && x >= 0 && x < src.cols && y >= 0 && y < src.rows)
+    {
+        let contour = new cv.Mat();
+        tool.getContour(new cv.Point(x, y), contour);
+        let contours = new cv.MatVector();
+        contours.push_back(contour);
+        let color = new cv.Scalar(0, 255, 0, 255);  // RGBA
+        cv.polylines(dst, contours, false, color, 1, cv.LINE_8);
+        contours.delete(); contour.delete();
+    }
+    cv.imshow('canvasOutput', dst);
+    dst.delete();
+});
+canvas.addEventListener('dispose', e => {
+    src.delete();
+    tool.delete();
+});
+</script>
+
+<script type="text/javascript">
+let utils = new Utils('errorMessage');
+
+utils.loadCode('codeSnippet', 'codeEditor');
+utils.loadImageToCanvas('lena.jpg', 'canvasInput');
+utils.addFileInputHandler('fileInput', 'canvasInput');
+
+let disposeEvent = new Event('dispose');
+
+let tryIt = document.getElementById('tryIt');
+let stopIt = document.getElementById('stopIt');
+
+tryIt.addEventListener('click', () => {
+    let e_input = document.getElementById('inputParams');
+    e_input.style.display = 'none';
+
+    let e_result = document.getElementById("result")
+    e_result.style.display = '';
+
+    var e = document.getElementById("canvasOutput");
+    var e_new = e.cloneNode(true);
+    e.parentNode.replaceChild(e_new, e);  // reset event handlers
+
+    stopIt.removeAttribute('disabled');
+    tryIt.setAttribute('disabled', '');
+
+    utils.executeCode('codeEditor');
+});
+
+stopIt.addEventListener('click', () => {
+    let e_input = document.getElementById('inputParams');
+    e_input.style.display = '';
+
+    let e_result = document.getElementById("result")
+    e_result.style.display = 'none';
+
+    var e = document.getElementById("canvasOutput");
+    e.dispatchEvent(disposeEvent);
+
+    var e_new = e.cloneNode(true);
+    e.parentNode.replaceChild(e_new, e);  // reset event handlers
+
+    tryIt.removeAttribute('disabled');
+    stopIt.setAttribute('disabled', '');
+});
+
+utils.loadOpenCv(() => {
+    tryIt.removeAttribute('disabled');
+});
+</script>
+</body>
+</html>
@@ -0,0 +1,14 @@
+Intelligent Scissors Demo {#tutorial_js_intelligent_scissors}
+=========================
+
+Goal
+----
+
+- Here you can check how to use IntelligentScissors tool for image segmentation task.
+- Available methods and parameters: @ref cv::segmentation::IntelligentScissorsMB
+
+\htmlonly
+<iframe src="../../js_intelligent_scissors.html" width="100%"
+        onload="this.style.height=this.contentDocument.body.scrollHeight +'px';">
+</iframe>
+\endhtmlonly
@@ -77,3 +77,7 @@ Image Processing {#tutorial_js_table_of_contents_imgproc}
 -   @subpage tutorial_js_imgproc_camera
 
     Learn image processing for video capture.
+
+-   @subpage tutorial_js_intelligent_scissors
+
+    Learn how to use IntelligentScissors tool for image segmentation task.
@@ -768,6 +768,13 @@ @incollection{Mitzel09
   pages = {432--441},
   publisher = {Springer}
 }
+@INPROCEEDINGS{Mortensen95intelligentscissors,
+  author = {Eric N. Mortensen and William A. Barrett},
+  title = {Intelligent Scissors for Image Composition},
+  booktitle = {In Computer Graphics, SIGGRAPH Proceedings},
+  year = {1995},
+  pages = {191--198}
+}
 @inproceedings{Muja2009,
   author = {Muja, Marius and Lowe, David G},
   title = {Fast Approximate Nearest Neighbors with Automatic Algorithm Configuration},
 
@@ -185,6 +185,7 @@ location of points on the plane, building special graphs (such as NNG,RNG), and
     @defgroup imgproc_motion Motion Analysis and Object Tracking
     @defgroup imgproc_feature Feature Detection
     @defgroup imgproc_object Object Detection
+    @defgroup imgproc_segmentation Image Segmentation
     @defgroup imgproc_c C API
     @defgroup imgproc_hal Hardware Acceleration Layer
     @{
@@ -3227,6 +3228,9 @@ CV_EXPORTS_AS(EMD) float wrapperEMD( InputArray signature1, InputArray signature
 
 //! @} imgproc_hist
 
+//! @addtogroup imgproc_segmentation
+//! @{
+
 /** @example samples/cpp/watershed.cpp
 An example using the watershed algorithm
 */
@@ -3254,11 +3258,11 @@ function.
 size as image .
 
 @sa findContours
-
-@ingroup imgproc_misc
  */
 CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );
 
+//! @} imgproc_segmentation
+
 //! @addtogroup imgproc_filter
 //! @{
 
@@ -3304,7 +3308,7 @@ CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
 
 //! @}
 
-//! @addtogroup imgproc_misc
+//! @addtogroup imgproc_segmentation
 //! @{
 
 /** @example samples/cpp/grabcut.cpp
@@ -3334,6 +3338,11 @@ CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
                            InputOutputArray bgdModel, InputOutputArray fgdModel,
                            int iterCount, int mode = GC_EVAL );
 
+//! @} imgproc_segmentation
+
+//! @addtogroup imgproc_misc
+//! @{
+
 /** @example samples/cpp/distrans.cpp
 An example on using the distance transform
 */
@@ -4876,4 +4885,8 @@ Point LineIterator::pos() const
 
 } // cv
 
+
+#include "./imgproc/segmentation.hpp"
+
+
 #endif
@@ -0,0 +1,141 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+
+#ifndef OPENCV_IMGPROC_SEGMENTATION_HPP
+#define OPENCV_IMGPROC_SEGMENTATION_HPP
+
+#include "opencv2/imgproc.hpp"
+
+namespace cv {
+
+namespace segmentation {
+
+//! @addtogroup imgproc_segmentation
+//! @{
+
+
+/** @brief Intelligent Scissors image segmentation
+ *
+ * This class is used to find the path (contour) between two points
+ * which can be used for image segmentation.
+ *
+ * Usage example:
+ * @snippet snippets/imgproc_segmentation.cpp usage_example_intelligent_scissors
+ *
+ * Reference: <a href="https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.3811&rep=rep1&type=pdf">"Intelligent Scissors for Image Composition"</a>
+ * algorithm designed by Eric N. Mortensen and William A. Barrett, Brigham Young University
+ * @cite Mortensen95intelligentscissors
+ */
+class CV_EXPORTS_W_SIMPLE IntelligentScissorsMB
+{
+public:
+    CV_WRAP
+    IntelligentScissorsMB();
+
+    /** @brief Specify weights of feature functions
+     *
+     * Consider keeping weights normalized (sum of weights equals to 1.0)
+     * Discrete dynamic programming (DP) goal is minimization of costs between pixels.
+     *
+     * @param weight_non_edge Specify cost of non-edge pixels (default: 0.43f)
+     * @param weight_gradient_direction Specify cost of gradient direction function (default: 0.43f)
+     * @param weight_gradient_magnitude Specify cost of gradient magnitude function (default: 0.14f)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setWeights(float weight_non_edge, float weight_gradient_direction, float weight_gradient_magnitude);
+
+    /** @brief Specify gradient magnitude max value threshold
+     *
+     * Zero limit value is used to disable gradient magnitude thresholding (default behavior, as described in original article).
+     * Otherwize pixels with `gradient magnitude >= threshold` have zero cost.
+     *
+     * @note Thresholding should be used for images with irregular regions (to avoid stuck on parameters from high-contract areas, like embedded logos).
+     *
+     * @param gradient_magnitude_threshold_max Specify gradient magnitude max value threshold (default: 0, disabled)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setGradientMagnitudeMaxLimit(float gradient_magnitude_threshold_max = 0.0f);
+
+    /** @brief Switch to "Laplacian Zero-Crossing" edge feature extractor and specify its parameters
+     *
+     * This feature extractor is used by default according to article.
+     *
+     * Implementation has additional filtering for regions with low-amplitude noise.
+     * This filtering is enabled through parameter of minimal gradient amplitude (use some small value 4, 8, 16).
+     *
+     * @note Current implementation of this feature extractor is based on processing of grayscale images (color image is converted to grayscale image first).
+     *
+     * @note Canny edge detector is a bit slower, but provides better results (especially on color images): use setEdgeFeatureCannyParameters().
+     *
+     * @param gradient_magnitude_min_value Minimal gradient magnitude value for edge pixels (default: 0, check is disabled)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setEdgeFeatureZeroCrossingParameters(float gradient_magnitude_min_value = 0.0f);
+
+    /** @brief Switch edge feature extractor to use Canny edge detector
+     *
+     * @note "Laplacian Zero-Crossing" feature extractor is used by default (following to original article)
+     *
+     * @sa Canny
+     */
+    CV_WRAP
+    IntelligentScissorsMB& setEdgeFeatureCannyParameters(
+            double threshold1, double threshold2,
+            int apertureSize = 3, bool L2gradient = false
+    );
+
+    /** @brief Specify input image and extract image features
+     *
+     * @param image input image. Type is #CV_8UC1 / #CV_8UC3
+     */
+    CV_WRAP
+    IntelligentScissorsMB& applyImage(InputArray image);
+
+    /** @brief Specify custom features of imput image
+     *
+     * Customized advanced variant of applyImage() call.
+     *
+     * @param non_edge Specify cost of non-edge pixels. Type is CV_8UC1. Expected values are `{0, 1}`.
+     * @param gradient_direction Specify gradient direction feature. Type is CV_32FC2. Values are expected to be normalized: `x^2 + y^2 == 1`
+     * @param gradient_magnitude Specify cost of gradient magnitude function: Type is CV_32FC1. Values should be in range `[0, 1]`.
+     * @param image **Optional parameter**. Must be specified if subset of features is specified (non-specified features are calculated internally)
+     */
+    CV_WRAP
+    IntelligentScissorsMB& applyImageFeatures(
+            InputArray non_edge, InputArray gradient_direction, InputArray gradient_magnitude,
+            InputArray image = noArray()
+    );
+
+    /** @brief Prepares a map of optimal paths for the given source point on the image
+     *
+     * @note applyImage() / applyImageFeatures() must be called before this call
+     *
+     * @param sourcePt The source point used to find the paths
+     */
+    CV_WRAP void buildMap(const Point& sourcePt);
+
+    /** @brief Extracts optimal contour for the given target point on the image
+     *
+     * @note buildMap() must be called before this call
+     *
+     * @param targetPt The target point
+     * @param[out] contour The list of pixels which contains optimal path between the source and the target points of the image. Type is CV_32SC2 (compatible with `std::vector<Point>`)
+     * @param backward Flag to indicate reverse order of retrived pixels (use "true" value to fetch points from the target to the source point)
+     */
+    CV_WRAP void getContour(const Point& targetPt, OutputArray contour, bool backward = false) const;
+
+#ifndef CV_DOXYGEN
+    struct Impl;
+    inline Impl* getImpl() const { return impl.get(); }
+protected:
+    std::shared_ptr<Impl> impl;
+#endif
+};
+
+//! @}
+
+}  // namespace segmentation
+}  // namespace cv
+
+#endif // OPENCV_IMGPROC_SEGMENTATION_HPP