Merge pull request #326 from MMp131316:MatchingOperations

modules/README.md

@@ -52,4 +52,4 @@ $ cmake -D OPENCV_EXTRA_MODULES_PATH=<opencv_contrib>/modules -D BUILD_opencv_re
 
 22. **opencv_xphoto**: Additional photo processing algorithms: Color balance / Denoising / Inpainting.
 
-23. **opencv_stereo**: Stereo Correspondence done with different descriptors: Census / CS-Census / MCT / BRIEF / MV / RT.
+23. **opencv_stereo**: Stereo Correspondence done with different descriptors: Census / CS-Census / MCT / BRIEF / MV.

modules/stereo/perf/perf_bm.cpp

+/*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*/
+
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::stereo;
+using namespace perf;
+
+typedef std::tr1::tuple<Size, MatType, MatDepth> s_bm_test_t;
+typedef perf::TestBaseWithParam<s_bm_test_t> s_bm;
+
+PERF_TEST_P( s_bm, sgm_perf,
+            testing::Combine(
+            testing::Values( cv::Size(512, 283),  cv::Size(320, 240)),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_8UC1,CV_8U,CV_16S )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+
+    Mat left(sz, matType);
+    Mat right(sz, matType);
+    Mat out1(sz, sdepth);
+    Ptr<StereoBinarySGBM> sgbm = StereoBinarySGBM::create(0, 16, 5);
+    sgbm->setBinaryKernelType(CV_DENSE_CENSUS);
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.1)
+        .iterations(20);
+    TEST_CYCLE()
+    {
+        sgbm->compute(left, right, out1);
+    }
+    SANITY_CHECK(out1);
+}
+PERF_TEST_P( s_bm, bm_perf,
+            testing::Combine(
+            testing::Values( cv::Size(512, 383),  cv::Size(320, 240) ),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_8UC1,CV_8U )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+
+    Mat left(sz, matType);
+    Mat right(sz, matType);
+    Mat out1(sz, sdepth);
+    Ptr<StereoBinaryBM> sbm = StereoBinaryBM::create(16, 9);
+    // we set the corresponding parameters
+    sbm->setPreFilterCap(31);
+    sbm->setMinDisparity(0);
+    sbm->setTextureThreshold(10);
+    sbm->setUniquenessRatio(0);
+    sbm->setSpeckleWindowSize(400);
+    sbm->setDisp12MaxDiff(0);
+    sbm->setAgregationWindowSize(11);
+    // the user can choose between the average speckle removal algorithm or
+    // the classical version that was implemented in OpenCV
+    sbm->setSpekleRemovalTechnique(CV_SPECKLE_REMOVAL_AVG_ALGORITHM);
+    sbm->setUsePrefilter(false);
+
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.1)
+        .iterations(20);
+    TEST_CYCLE()
+    {
+        sbm->compute(left, right, out1);
+    }
+    SANITY_CHECK(out1);
+}

modules/stereo/perf/perf_descriptor.cpp

+/*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*/
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::stereo;
+using namespace perf;
+
+typedef std::tr1::tuple<Size, MatType, MatDepth> descript_params_t;
+typedef perf::TestBaseWithParam<descript_params_t> descript_params;
+
+PERF_TEST_P( descript_params, census_sparse_descriptor,
+            testing::Combine(
+            testing::Values(  TYPICAL_MAT_SIZES ),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_32SC4,CV_32S )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+    Mat left(sz, matType);
+    Mat out1(sz, sdepth);
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.01);
+    TEST_CYCLE()
+    {
+        censusTransform(left,9,out1,CV_SPARSE_CENSUS);
+    }
+    SANITY_CHECK(out1);
+}
+PERF_TEST_P( descript_params, star_census_transform,
+            testing::Combine(
+            testing::Values( TYPICAL_MAT_SIZES ),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_32SC4,CV_32S )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+    Mat left(sz, matType);
+    Mat out1(sz, sdepth);
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.01);
+    TEST_CYCLE()
+    {
+        starCensusTransform(left,9,out1);
+    }
+    SANITY_CHECK(out1);
+}
+PERF_TEST_P( descript_params, modified_census_transform,
+            testing::Combine(
+            testing::Values( TYPICAL_MAT_SIZES ),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_32SC4,CV_32S )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+
+    Mat left(sz, matType);
+    Mat out1(sz, sdepth);
+
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.01);
+    TEST_CYCLE()
+    {
+        modifiedCensusTransform(left,9,out1,CV_MODIFIED_CENSUS_TRANSFORM);
+    }
+    SANITY_CHECK(out1);
+}
+PERF_TEST_P( descript_params, center_symetric_census,
+            testing::Combine(
+            testing::Values( TYPICAL_MAT_SIZES ),
+            testing::Values( CV_8UC1,CV_8U ),
+            testing::Values( CV_32SC4,CV_32S )
+            )
+            )
+{
+    Size sz = std::tr1::get<0>(GetParam());
+    int matType = std::tr1::get<1>(GetParam());
+    int sdepth = std::tr1::get<2>(GetParam());
+
+    Mat left(sz, matType);
+    Mat out1(sz, sdepth);
+
+    declare.in(left, WARMUP_RNG)
+        .out(out1)
+        .time(0.01);
+    TEST_CYCLE()
+    {
+        symetricCensusTransform(left,7,out1,CV_CS_CENSUS);
+    }
+    SANITY_CHECK(out1);
+}

modules/stereo/perf/perf_main.cpp

+/*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*/
+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(stereo)

modules/stereo/perf/perf_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_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include <iostream>
+#include "opencv2/ts.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/stereo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include "opencv2/core/cvdef.h"
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/calib3d.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+#ifdef GTEST_CREATE_SHARED_LIBRARY
+#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
+#endif
+
+#endif

modules/stereo/samples/sample.cpp

+#include "opencv2/stereo.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+using namespace cv::stereo;
+
+enum { STEREO_BINARY_BM, STEREO_BINARY_SGM };
+static cv::CommandLineParser parse_argument_values(int argc, char **argv, string &left, string &right, int &kernel_size, int &number_of_disparities,
+                                                   int &aggregation_window, int &P1, int &P2, float &scale, int &algo, int &binary_descriptor_type, int &success);
+int main(int argc, char** argv)
+{
+    string left, right;
+    int kernel_size = 0, number_of_disparities = 0, aggregation_window = 0, P1 = 0, P2 = 0;
+    float scale = 4;
+    int algo = STEREO_BINARY_BM;
+    int binary_descriptor_type = 0;
+    int success;
+    // here we extract the values that were added as arguments
+    // we also test to see if they are provided correcly
+    cv::CommandLineParser parser =
+        parse_argument_values(argc, argv, left, right,
+        kernel_size,
+        number_of_disparities,
+        aggregation_window,
+        P1, P2,
+        scale,
+        algo, binary_descriptor_type,success);
+    if (!parser.check() || !success)
+    {
+        parser.printMessage();
+        return 1;
+    }
+    // verify if the user inputs the correct number of parameters
+    Mat image1, image2;
+    // we read  a pair of images from the disk
+    image1 = imread(left, CV_8UC1);
+    image2 = imread(right, CV_8UC1);
+    // verify if they are loaded correctly
+    if (image1.empty() || image2.empty())
+    {
+        cout << " --(!) Error reading images \n";
+
+        parser.printMessage();
+        return 1;
+    }
+    // we display the parsed parameters
+    const char *b[7] = { "CV_DENSE_CENSUS", "CV_SPARSE_CENSUS", "CV_CS_CENSUS", "CV_MODIFIED_CS_CENSUS",
+        "CV_MODIFIED_CENSUS_TRANSFORM", "CV_MEAN_VARIATION", "CV_STAR_KERNEL" };
+    cout << "Program Name: " << argv[0];
+    cout << "\nPath to left image " << left << " \n" << "Path to right image " << right << "\n";
+    cout << "\nkernel size " << kernel_size << "\n"
+        << "numberOfDisparities " << number_of_disparities << "\n"
+        << "aggregationWindow " << aggregation_window << "\n"
+        << "scallingFactor " << scale << "\n" << "Descriptor name : " << b[binary_descriptor_type] << "\n";
+
+    Mat imgDisparity16S2 = Mat(image1.rows, image1.cols, CV_16S);
+    Mat imgDisparity8U2 = Mat(image1.rows, image1.cols, CV_8UC1);
+    imshow("Original Left image", image1);
+
+    if (algo == STEREO_BINARY_BM)
+    {
+        Ptr<StereoBinaryBM> sbm = StereoBinaryBM::create(number_of_disparities, kernel_size);
+        // we set the corresponding parameters
+        sbm->setPreFilterCap(31);
+        sbm->setMinDisparity(0);
+        sbm->setTextureThreshold(10);
+        sbm->setUniquenessRatio(0);
+        sbm->setSpeckleWindowSize(400); // speckle size
+        sbm->setSpeckleRange(200);
+        sbm->setDisp12MaxDiff(0);
+        sbm->setScalleFactor((int)scale); // the scaling factor
+        sbm->setBinaryKernelType(binary_descriptor_type); // binary descriptor kernel
+        sbm->setAgregationWindowSize(aggregation_window);
+        // the user can choose between the average speckle removal algorithm or
+        // the classical version that was implemented in OpenCV
+        sbm->setSpekleRemovalTechnique(CV_SPECKLE_REMOVAL_AVG_ALGORITHM);
+        sbm->setUsePrefilter(false);
+        //-- calculate the disparity image
+        sbm->compute(image1, image2, imgDisparity8U2);
+        imshow("Disparity", imgDisparity8U2);
+    }
+    else if (algo == STEREO_BINARY_SGM)
+    {
+        // we set the corresponding parameters
+        Ptr<StereoBinarySGBM> sgbm = StereoBinarySGBM::create(0, number_of_disparities, kernel_size);
+        // setting the penalties for sgbm
+        sgbm->setP1(P1);
+        sgbm->setP2(P2);
+        sgbm->setMinDisparity(0);
+        sgbm->setUniquenessRatio(5);
+        sgbm->setSpeckleWindowSize(400);
+        sgbm->setSpeckleRange(0);
+        sgbm->setDisp12MaxDiff(1);
+        sgbm->setBinaryKernelType(binary_descriptor_type);
+        sgbm->setSpekleRemovalTechnique(CV_SPECKLE_REMOVAL_AVG_ALGORITHM);
+        sgbm->setSubPixelInterpolationMethod(CV_SIMETRICV_INTERPOLATION);
+        sgbm->compute(image1, image2, imgDisparity16S2);
+        /*Alternative for scalling
+        imgDisparity16S2.convertTo(imgDisparity8U2, CV_8UC1, scale);
+        */
+        double minVal; double maxVal;
+        minMaxLoc(imgDisparity16S2, &minVal, &maxVal);
+        imgDisparity16S2.convertTo(imgDisparity8U2, CV_8UC1, 255 / (maxVal - minVal));
+        //show the disparity image
+        imshow("Windowsgm", imgDisparity8U2);
+    }
+    waitKey(0);
+    return 0;
+}
+static cv::CommandLineParser parse_argument_values(int argc, char **argv, string &left, string &right, int &kernel_size, int &number_of_disparities,
+                                                   int &aggregation_window, int &P1, int &P2, float &scale, int &algo, int &binary_descriptor_type, int &success)
+{
+    static const char* keys =
+        "{ @left                |         | }"
+        "{ @right               |         | }"
+        "{ k kernel_size        |    9    | }"
+        "{ d disparity          |    128   | }"
+        "{ w aggregation_window |    9     | }"
+        "{ P1                   |   100    | }"
+        "{ P2                   |   1000   | }"
+        "{ b binary_descriptor  |     4    | Index of the descriptor type:\n 0 - CV_DENSE_CENSUS,\n 1 - CV_SPARSE_CENSUS,\n 2 - CV_CS_CENSUS,\n 3 - CV_MODIFIED_CS_CENSUS,\n 4 - CV_MODIFIED_CENSUS_TRANSFORM,\n 5 - CV_MEAN_VARIATION,\n 6 - CV_STAR_KERNEL}"
+        "{ s scale              |    1.01593    | }"
+        "{ a algorithm          | sgm     | }"
+        ;
+    cv::CommandLineParser parser( argc, argv, keys );
+
+    left = parser.get<string>(0);
+    right = parser.get<string>(1);
+    kernel_size = parser.get<int>("kernel_size");
+    number_of_disparities = parser.get<int>("disparity");
+    aggregation_window = parser.get<int>("aggregation_window");
+    P1 = parser.get<int>("P1");
+    P2 = parser.get<int>("P2");
+    binary_descriptor_type = parser.get<int>("binary_descriptor");
+    scale = parser.get<float>("scale");
+    algo = parser.get<string>("algorithm") == "sgm" ? STEREO_BINARY_SGM : STEREO_BINARY_BM;
+
+    parser.about("\nDemo stereo matching converting L and R images into disparity images using BM and SGBM\n");
+
+    success = 1;
+    //TEST if the provided parameters are correct
+    if(binary_descriptor_type == CV_DENSE_CENSUS && kernel_size > 5)
+    {
+        cout << "For the dense census transform the maximum kernel size should be 5\n";
+        success = 0;
+    }
+    if((binary_descriptor_type == CV_MEAN_VARIATION || binary_descriptor_type == CV_MODIFIED_CENSUS_TRANSFORM || binary_descriptor_type == CV_STAR_KERNEL) && kernel_size != 9)
+    {
+        cout <<" For Mean variation and the modified census transform the kernel size should be equal to 9\n";
+        success = 0;
+    }
+    if((binary_descriptor_type == CV_CS_CENSUS || binary_descriptor_type == CV_MODIFIED_CS_CENSUS) && kernel_size > 7)
+    {
+        cout << " The kernel size should be smaller or equal to 7 for the CS census and modified center symetric census\n";
+        success = 0;
+    }
+    if(binary_descriptor_type == CV_SPARSE_CENSUS && kernel_size > 11)
+    {
+        cout << "The kernel size for the sparse census must be smaller or equal to 11\n";
+        success = 0;
+    }
+    if(number_of_disparities < 10)
+    {
+        cout << "Number of disparities should be greater than 10\n";
+        success = 0;
+    }
+    if(aggregation_window < 3)
+    {
+        cout << "Aggregation window should be > 3";
+        success = 0;
+    }
+    if(scale < 1)
+    {
+        cout << "The scale should be a positive number \n";
+        success = 0;
+    }
+    if(P1 != 0)
+    {
+        if(P2 / P1 < 2)
+        {
+            cout << "You should probably choose a greater P2 penalty\n";
+            success = 0;
+        }
+    }
+    else
+    {
+        cout << " Penalties should be greater than 0\n";
+        success = 0;
+    }
+    return parser;
+}

modules/stereo/src/precomp.hpp

@@ -56,4 +56,3 @@
 #include <cmath>
 
 #endif
-

modules/stereo/test/test_block_matching.cpp

+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 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*/
+
+#include "test_precomp.hpp"
+#include <limits.h>
+
+using namespace cv;
+using namespace cv::stereo;
+using namespace std;
+
+class CV_BlockMatchingTest : public cvtest::BaseTest
+{
+public:
+    CV_BlockMatchingTest();
+    ~CV_BlockMatchingTest();
+protected:
+    void run(int /* idx */);
+};
+
+CV_BlockMatchingTest::CV_BlockMatchingTest(){}
+CV_BlockMatchingTest::~CV_BlockMatchingTest(){}
+
+static double errorLevel(const Mat &ideal, Mat &actual)
+{
+    uint8_t *date, *harta;
+    harta = actual.data;
+    date = ideal.data;
+    int stride, h;
+    stride = (int)ideal.step;
+    h = ideal.rows;
+    int error = 0;
+    for (int i = 0; i < ideal.rows; i++)
+    {
+        for (int j = 0; j < ideal.cols; j++)
+        {
+            if (date[i * stride + j] != 0)
+                if (abs(date[i * stride + j] - harta[i * stride + j]) > 2 * 16)
+                {
+                    error += 1;
+                }
+        }
+    }
+    return ((double)((error * 100) * 1.0) / (stride * h));
+}
+void CV_BlockMatchingTest::run(int )
+{
+    Mat image1, image2, gt;
+    //some test images can be found in the test data folder
+    //in order for the tests to build succesfully please replace
+    //ts->get_data_path() + "testdata/imL2l.bmp with the path from your disk
+    //for example if your images are on D:\\ , please write D:\\testdata\\imL2l.bmp
+    image1 = imread(ts->get_data_path() + "testdata/imL2l.bmp", CV_8UC1);
+    image2 = imread(ts->get_data_path() + "testdata/imL2.bmp", CV_8UC1);
+    gt = imread(ts->get_data_path() + "testdata/groundtruth.bmp", CV_8UC1);
+
+    if(image1.empty() || image2.empty() || gt.empty())
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input data \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+        return;
+    }
+    if(image1.rows != image2.rows || image1.cols != image2.cols || gt.cols != gt.cols || gt.rows != gt.rows)
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input / output dimension \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+        return;
+    }
+
+    RNG range;
+    //set the parameters
+    int binary_descriptor_type = range.uniform(0,8);
+    int kernel_size, aggregation_window;
+    if(binary_descriptor_type == 0)
+        kernel_size = 5;
+    else if(binary_descriptor_type == 2 || binary_descriptor_type == 3)
+        kernel_size = 7;
+    else if(binary_descriptor_type == 1)
+        kernel_size = 11;
+    else
+        kernel_size = 9;
+    if(binary_descriptor_type == 3)
+        aggregation_window = 13;
+    else
+        aggregation_window = 11;
+    Mat test = Mat(image1.rows, image1.cols, CV_8UC1);
+    Ptr<StereoBinaryBM> sbm = StereoBinaryBM::create(16, kernel_size);
+    //we set the corresponding parameters
+    sbm->setPreFilterCap(31);
+    sbm->setMinDisparity(0);
+    sbm->setTextureThreshold(10);
+    sbm->setUniquenessRatio(0);
+    sbm->setSpeckleWindowSize(400);//speckle size
+    sbm->setSpeckleRange(200);
+    sbm->setDisp12MaxDiff(0);
+    sbm->setScalleFactor(16);//the scaling factor
+    sbm->setBinaryKernelType(binary_descriptor_type);//binary descriptor kernel
+    sbm->setAgregationWindowSize(aggregation_window);
+    //speckle removal algorithm the user can choose between the average speckle removal algorithm
+    //or the classical version that was implemented in open cv
+    sbm->setSpekleRemovalTechnique(CV_SPECKLE_REMOVAL_AVG_ALGORITHM);
+    sbm->setUsePrefilter(false);//pre-filter or not the images prior to making the transformations
+    //-- calculate the disparity image
+    sbm->compute(image1, image2, test);
+    if(test.empty())
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input / output dimension \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+        return;
+    }
+    if(errorLevel(gt,test) > 20)
+    {
+        ts->printf( cvtest::TS::LOG,
+            "Too big error\n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        return;
+    }
+}
+
+class CV_SGBlockMatchingTest : public cvtest::BaseTest
+{
+public:
+    CV_SGBlockMatchingTest();
+    ~CV_SGBlockMatchingTest();
+protected:
+    void run(int /* idx */);
+};
+
+CV_SGBlockMatchingTest::CV_SGBlockMatchingTest(){}
+CV_SGBlockMatchingTest::~CV_SGBlockMatchingTest(){}
+
+void CV_SGBlockMatchingTest::run(int )
+{
+    Mat image1, image2, gt;
+   //some test images can be found in the test data folder
+    image1 = imread(ts->get_data_path() + "testdata/imL2l.bmp", CV_8UC1);
+    image2 = imread(ts->get_data_path() + "testdata/imL2.bmp", CV_8UC1);
+    gt = imread(ts->get_data_path() + "testdata/groundtruth.bmp", CV_8UC1);
+
+
+    if(image1.empty() || image2.empty() || gt.empty())
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input data \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+        return;
+    }
+    if(image1.rows != image2.rows || image1.cols != image2.cols || gt.cols != gt.cols || gt.rows != gt.rows)
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input / output dimension \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+        return;
+    }
+
+    RNG range;
+    //set the parameters
+    int binary_descriptor_type = range.uniform(0,8);
+    int kernel_size;
+    if(binary_descriptor_type == 0)
+        kernel_size = 5;
+    else if(binary_descriptor_type == 2 || binary_descriptor_type == 3)
+        kernel_size = 7;
+    else if(binary_descriptor_type == 1)
+        kernel_size = 11;
+    else
+        kernel_size = 9;
+
+    Mat test = Mat(image1.rows, image1.cols, CV_8UC1);
+    Mat imgDisparity16S2 = Mat(image1.rows, image1.cols, CV_16S);
+    Ptr<StereoBinarySGBM> sgbm = StereoBinarySGBM::create(0, 16, kernel_size);
+    //setting the penalties for sgbm
+    sgbm->setP1(10);
+    sgbm->setP2(100);
+    sgbm->setMinDisparity(0);
+    sgbm->setNumDisparities(16);//set disparity number
+    sgbm->setUniquenessRatio(1);
+    sgbm->setSpeckleWindowSize(400);
+    sgbm->setSpeckleRange(200);
+    sgbm->setDisp12MaxDiff(1);
+    sgbm->setBinaryKernelType(binary_descriptor_type);//set the binary descriptor
+    sgbm->setSpekleRemovalTechnique(CV_SPECKLE_REMOVAL_AVG_ALGORITHM); //the avg speckle removal algorithm
+    sgbm->setSubPixelInterpolationMethod(CV_SIMETRICV_INTERPOLATION);// the SIMETRIC V interpolation method
+    sgbm->compute(image1, image2, imgDisparity16S2);
+    double minVal; double maxVal;
+    minMaxLoc(imgDisparity16S2, &minVal, &maxVal);
+
+    imgDisparity16S2.convertTo(test, CV_8UC1, 255 / (maxVal - minVal));
+
+    if(test.empty())
+    {
+        ts->printf(cvtest::TS::LOG, "Wrong input / output dimension \n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
+        return;
+    }
+    double error = errorLevel(gt,test);
+    if(error > 10)
+    {
+        ts->printf( cvtest::TS::LOG,
+            "Too big error\n");
+        ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        return;
+    }
+}
+TEST(block_matching_simple_test, accuracy) { CV_BlockMatchingTest test; test.safe_run(); }
+TEST(SG_block_matching_simple_test, accuracy) { CV_SGBlockMatchingTest test; test.safe_run(); }

modules/stereo/test/test_precomp.hpp

@@ -12,8 +12,6 @@
 #include <iostream>
 #include "opencv2/ts.hpp"
 #include "opencv2/imgcodecs.hpp"
-
-
 #include "opencv2/stereo.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/features2d.hpp"
@@ -22,10 +20,9 @@
 #include "opencv2/core/cvdef.h"
 #include "opencv2/core.hpp"
 #include "opencv2/highgui.hpp"
+#include "opencv2/calib3d.hpp"
 
 #include <algorithm>
 #include <cmath>
 
-
-
 #endif