ximpgroc module added (structured forests for fast edge detection by Piotr Dollar)

modules/ximpgroc/CMakeLists.txt

+set(the_description "Advanced edge-detection algorithms")
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
+ocv_define_module(ximpgroc opencv_core opencv_imgproc OPTIONAL opencv_highgui)
\ No newline at end of file

modules/ximpgroc/doc/structured_edge_detection/index.rst

+Structured forests for fast edge detection
+******************************************
+
+.. highlight:: cpp
+
+...
+
+StructuredEdgeDetection
+-----------------------
+
+.. ocv:class:: StructuredEdgeDetection : public Algorithm
+
+Class implementing edge detection algorithm from [Dollar2013]_ ::
+
+    /*! \class StructuredEdgeDetection
+    Prediction part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
+    */
+    class CV_EXPORTS_W StructuredEdgeDetection : public Algorithm
+    {
+    public:
+
+        /*!
+        * The function detects edges in src and draw them to dst
+        *
+        * \param src : source image (RGB, float, in [0;1]) to detect edges
+        * \param dst : destination image (grayscale, float, in [0;1])
+        *              where edges are drawn
+        */
+        CV_WRAP virtual void detectEdges(const Mat src, Mat dst) = 0;
+    };
+
+    /*!
+    * The only available constructor loading data from model file
+    *
+    * \param model : name of the file where the model is stored
+    */
+    CV_EXPORTS_W Ptr<StructuredEdgeDetection> createStructuredEdgeDetection(const String &model);
+
+StructuredEdgeDetection::detectEdges
+++++++++++++++++++++++++++++++++++++
+.. ocv:function:: void detectEdges(const Mat src, Mat dst)
+
+The function detects edges in src and draw them to dst. The algorithm underlies this function
+is much more robust to texture presence, than common approaches, e.g. Sobel
+
+    :param src : source image (RGB, float, in [0;1]) to detect edges
+    :param dst : destination image (grayscale, float, in [0;1])
+                 where edges are drawn
+
+.. seealso::
+
+    :ocv:class:`Sobel`,
+    :ocv:class:`Canny`
+
+createStructuredEdgeDetection
++++++++++++++++++++++++++++++
+.. ocv:function:: Ptr<cv::StructuredEdgeDetection> createStructuredEdgeDetection(String model)
+
+The only available constructor
+
+    :param model: model file name
+
+
+Literature
+----------
+
+.. [Dollar2013] Dollár P., Zitnick C. L., "Structured forests for fast edge detection",
+                IEEE International Conference on Computer Vision (ICCV), 2013,
+                pp. 1841-1848. `DOI <http://dx.doi.org/10.1109/ICCV.2013.231>`_
+

modules/ximpgroc/doc/ximpgroc.rst

+********************************************
+ximpgroc. Advanced edge-detection algorithms
+********************************************
+
+.. toctree::
+    :maxdepth: 2
+
+    Structured forests for fast edge detection <structured_edge_detection/index>

modules/ximpgroc/include/opencv2/ximpgroc.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_EDGEDETECTION_HPP__
+#define __OPENCV_EDGEDETECTION_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/ximpgroc/structured_edge_detection.hpp"
+#endif

modules/ximpgroc/include/opencv2/ximpgroc/structured_edge_detection.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__
+#define __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__
+
+/*
+ * structured_edge_detection.hpp
+ *
+ *  Created on: Jun 17, 2014
+ *      Author: Yury Gitman
+ */
+
+#include <opencv2/core.hpp>
+
+/*! \namespace cv
+  Namespace where all the C++ OpenCV functionality resides
+ */
+namespace cv
+{
+
+/*! \class RFFeatureGetter
+  Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
+ */
+class CV_EXPORTS_W RFFeatureGetter : public Algorithm
+{
+public:
+
+    /*!
+     * This functions extracts feature channels from src.
+     * Than StructureEdgeDetection uses this feature space
+     * to detect edges.
+     *
+     * \param src : source image to extract features
+     * \param features : output n-channel floating point feature matrix.
+     *
+     * \param gnrmRad : __rf.options.gradientNormalizationRadius
+     * \param gsmthRad : __rf.options.gradientSmoothingRadius
+     * \param shrink : __rf.options.shrinkNumber
+     * \param outNum : __rf.options.numberOfOutputChannels
+     * \param gradNum : __rf.options.numberOfGradientOrientations
+     */
+    CV_WRAP virtual void getFeatures(const Mat &src, Mat &features,
+                                     const int gnrmRad,
+                                     const int gsmthRad,
+                                     const int shrink,
+                                     const int outNum,
+                                     const int gradNum) const = 0;
+};
+
+/*!
+* ...
+*/
+CV_EXPORTS_W Ptr<RFFeatureGetter> createRFFeatureGetter(void);
+
+
+
+/*! \class StructuredEdgeDetection
+  Prediction part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013].
+ */
+class CV_EXPORTS_W StructuredEdgeDetection : public Algorithm
+{
+public:
+
+    /*!
+     * The function detects edges in src and draw them to dst
+     *
+     * \param src : source image (RGB, float, in [0;1]) to detect edges
+     * \param dst : destination image (grayscale, float, in [0;1])
+     *              where edges are drawn
+     */
+    CV_WRAP virtual void detectEdges(const Mat &src, Mat &dst) const = 0;
+};
+
+/*!
+* The only constructor
+*
+* \param model : name of the file where the model is stored
+* \param howToGetFeatures : optional object inheriting from RFFeatureGetter.
+*                           You need it only if you would like to train your
+*                           own forest, pass NULL otherwise
+*/
+CV_EXPORTS_W Ptr<StructuredEdgeDetection> createStructuredEdgeDetection(const String &model,
+    const RFFeatureGetter *howToGetFeatures = NULL);
+
+}
+
+#endif /* __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__ */
\ No newline at end of file

modules/ximpgroc/samples/structured_edge_detection.cpp

+#include "opencv2/ximpgroc/structured_edge_detection.hpp"
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+
+#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc/types_c.h"
+
+#include <iostream>
+
+const char* keys =
+{
+    "{i || input image name}"
+    "{m || model name}"
+    "{o || output image name}"
+};
+
+int main( int argc, const char** argv )
+{
+    bool printHelp = ( argc == 1 );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "--help" );
+    printHelp = printHelp || ( argc == 2 && std::string(argv[1]) == "-h" );
+
+    if ( printHelp )
+    {
+        printf("\nThis sample demonstrates structured forests for fast edge detection\n"
+               "Call:\n"
+               "    structured_edge_detection -i=in_image_name -m=model_name [-o=out_image_name]\n\n");
+        return 0;
+    }
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    if ( !parser.check() )
+    {
+        parser.printErrors();
+        return -1;
+    }
+
+    std::string modelFilename = parser.get<std::string>("m");
+    std::string inFilename = parser.get<std::string>("i");
+    std::string outFilename = parser.get<std::string>("o");
+
+    cv::Mat image = cv::imread(inFilename, 1);
+    if ( image.empty() )
+    {
+        printf("Cannot read image file: %s\n", inFilename.c_str());
+        return -1;
+    }
+
+    cv::cvtColor(image, image, CV_BGR2RGB);
+    image.convertTo(image, cv::DataType<float>::type, 1/255.0);
+
+    cv::Mat edges(image.size(), image.type());
+
+    cv::Ptr<cv::StructuredEdgeDetection> pDollar =
+        cv::createStructuredEdgeDetection(modelFilename);
+    pDollar->detectEdges(image, edges);
+
+    if ( outFilename == "" )
+    {
+        cv::namedWindow("edges", 1);
+        cv::imshow("edges", edges);
+
+        cv::waitKey(0);
+    }
+    else
+        cv::imwrite(outFilename, 255*edges);
+
+    return 0;
+}

modules/ximpgroc/src/advanced_types.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __ADVANCED_TYPES_HPP__
+#define __ADVANCED_TYPES_HPP__
+
+#include <opencv2/core.hpp>
+
+/********************* Defines *********************/
+
+#ifndef CV_SQR
+#  define CV_SQR(x)  ((x)*(x))
+#endif
+
+#ifndef CV_CUBE
+#  define CV_CUBE(x)  ((x)*(x)*(x))
+#endif
+
+#ifndef CV_INIT_VECTOR
+#  define CV_INIT_VECTOR(vname, type, ...) \
+    static const type vname##_a[] = __VA_ARGS__; \
+    std::vector <type> vname(vname##_a, \
+    vname##_a + sizeof(vname##_a) / sizeof(*vname##_a))
+#endif
+
+/********************* Types *********************/
+
+/*! fictitious type to highlight that function
+ *  can process n-channels arguments */
+typedef cv::Mat NChannelsMat;
+
+/********************* Functions *********************/
+
+namespace cv
+{
+
+template <typename _Tp, typename _Tp2> inline
+    cv::Size_<_Tp> operator * (const _Tp2 &x, const cv::Size_<_Tp> &sz)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(x*sz.width), cv::saturate_cast<_Tp>(x*sz.height));
+}
+
+template <typename _Tp, typename _Tp2> inline
+    cv::Size_<_Tp> operator / (const cv::Size_<_Tp> &sz, const _Tp2 &x)
+{
+    return cv::Size_<_Tp>(cv::saturate_cast<_Tp>(sz.width/x), cv::saturate_cast<_Tp>(sz.height/x));
+}
+
+} // cv
+
+#endif /* __ADVANCED_TYPES_HPP__ */
\ No newline at end of file

modules/ximpgroc/test/structured_edge_detection.cpp

+#include "test_precomp.hpp"
+
+namespace cvtest
+{
+
+TEST(ximpgroc_StructuredEdgeDetection, regression)
+{
+    cv::String dir = "C:/Users/Yury/Projects/opencv/sources/opencv_contrib/modules/ximpgroc/testdata/";//cvtest::TS::ptr()->get_data_path();
+    int nTests = 12;
+    float threshold = 0.01;
+
+    cv::String modelName = dir + "model.yml.gz";
+    cv::Ptr<cv::StructuredEdgeDetection> pDollar =
+        cv::createStructuredEdgeDetection(modelName);
+
+    for (int i = 0; i < nTests; ++i)
+    {
+        cv::String srcName = dir + cv::format( "sources/%02d.png", i + 1);
+        cv::Mat src = cv::imread( srcName, 1 );
+
+        cv::String previousResultName = dir + cv::format( "results/%02d.png", i + 1 );
+        cv::Mat previousResult = cv::imread( previousResultName, 0 );
+        previousResult.convertTo( previousResult, cv::DataType<float>::type, 1/255.0 );
+
+        cv::cvtColor( src, src, CV_BGR2RGB );
+        src.convertTo( src, cv::DataType<float>::type, 1/255.0 );
+
+        cv::Mat currentResult( src.size(), src.type() );
+        pDollar->detectEdges( src, currentResult );
+
+        cv::Mat sqrError = ( currentResult - previousResult )
+            .mul( currentResult - previousResult );
+        cv::Scalar mse = cv::sum(sqrError) / cv::Scalar::all( sqrError.total() );
+
+        EXPECT_LE( mse[0], threshold );
+    }
+}
+
+}
\ No newline at end of file

modules/ximpgroc/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("ximpgroc")

modules/ximpgroc/test/test_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgproc/types_c.h"
+#include "opencv2/highgui.hpp"
+#include "opencv2/ximpgroc.hpp"
+#include "opencv2/ts.hpp"
+#include <iostream>
+
+#endif