new API for StereoMatchers

modules/calib3d/include/opencv2/calib3d/calib3d.hpp

@@ -669,18 +669,35 @@ CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2,
 CV_EXPORTS_W void correctMatches( InputArray F, InputArray points1, InputArray points2,
                                   OutputArray newPoints1, OutputArray newPoints2 );
 
-template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
 
-/*!
- Block Matching Stereo Correspondence Algorithm
+class CV_EXPORTS_W StereoMatcher : public Algorithm
+{
+public:
+    CV_WRAP virtual void compute( InputArray left, InputArray right,
+                                  OutputArray disparity ) = 0;
+};
+
+enum { STEREO_DISP_SCALE=16, STEREO_PREFILTER_NORMALIZED_RESPONSE = 0, STEREO_PREFILTER_XSOBEL = 1,
+    STEREOBM_BASIC_PRESET=0, STEREOBM_FISH_EYE_PRESET=1, STEREOBM_NARROW_PRESET=2 };
 
- The class implements BM stereo correspondence algorithm by K. Konolige.
-*/
+CV_EXPORTS Ptr<StereoMatcher> createStereoBM(int preset, int numDisparities=0, int SADWindowSize=21);
+    
+CV_EXPORTS Ptr<StereoMatcher> createStereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
+                                               int P1=0, int P2=0, int disp12MaxDiff=0,
+                                               int preFilterCap=0, int uniquenessRatio=0,
+                                               int speckleWindowSize=0, int speckleRange=0,
+                                               bool fullDP=false);
+
+template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();
+
+// to be moved to "compat" module
 class CV_EXPORTS_W StereoBM
 {
 public:
     enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1,
-        BASIC_PRESET=0, FISH_EYE_PRESET=1, NARROW_PRESET=2 };
+        BASIC_PRESET=STEREOBM_BASIC_PRESET,
+        FISH_EYE_PRESET=STEREOBM_FISH_EYE_PRESET,
+        NARROW_PRESET=STEREOBM_NARROW_PRESET };
 
     //! the default constructor
     CV_WRAP StereoBM();
@@ -697,11 +714,7 @@ public:
 };
 
 
-/*!
- Semi-Global Block Matching Stereo Correspondence Algorithm
-
- The class implements the original SGBM stereo correspondence algorithm by H. Hirschmuller and some its modification.
- */
+// to be moved to "compat" module
 class CV_EXPORTS_W StereoSGBM
 {
 public:
@@ -736,7 +749,7 @@ public:
     CV_PROP_RW bool fullDP;
 
 protected:
-    Mat buffer;
+    Ptr<StereoMatcher> sm;
 };
 
 //! filters off speckles (small regions of incorrectly computed disparity)

modules/calib3d/src/compat_stereo.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, Intel Corporation, all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, 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 "precomp.hpp"
+
+CvStereoBMState* cvCreateStereoBMState( int /*preset*/, int numberOfDisparities )
+{
+    CvStereoBMState* state = (CvStereoBMState*)cvAlloc( sizeof(*state) );
+    if( !state )
+        return 0;
+
+    state->preFilterType = CV_STEREO_BM_XSOBEL; //CV_STEREO_BM_NORMALIZED_RESPONSE;
+    state->preFilterSize = 9;
+    state->preFilterCap = 31;
+    state->SADWindowSize = 15;
+    state->minDisparity = 0;
+    state->numberOfDisparities = numberOfDisparities > 0 ? numberOfDisparities : 64;
+    state->textureThreshold = 10;
+    state->uniquenessRatio = 15;
+    state->speckleRange = state->speckleWindowSize = 0;
+    state->trySmallerWindows = 0;
+    state->roi1 = state->roi2 = cvRect(0,0,0,0);
+    state->disp12MaxDiff = -1;
+
+    state->preFilteredImg0 = state->preFilteredImg1 = state->slidingSumBuf =
+    state->disp = state->cost = 0;
+
+    return state;
+}
+
+void cvReleaseStereoBMState( CvStereoBMState** state )
+{
+    if( !state )
+        CV_Error( CV_StsNullPtr, "" );
+
+    if( !*state )
+        return;
+
+    cvReleaseMat( &(*state)->preFilteredImg0 );
+    cvReleaseMat( &(*state)->preFilteredImg1 );
+    cvReleaseMat( &(*state)->slidingSumBuf );
+    cvReleaseMat( &(*state)->disp );
+    cvReleaseMat( &(*state)->cost );
+    cvFree( state );
+}
+
+template<> void cv::Ptr<CvStereoBMState>::delete_obj()
+{ cvReleaseStereoBMState(&obj); }
+
+
+void cvFindStereoCorrespondenceBM( const CvArr* leftarr, const CvArr* rightarr,
+                                   CvArr* disparr, CvStereoBMState* state )
+{
+    cv::Mat left = cv::cvarrToMat(leftarr), right = cv::cvarrToMat(rightarr);
+    const cv::Mat disp = cv::cvarrToMat(disparr);
+
+    CV_Assert( state != 0 );
+
+    cv::Ptr<cv::StereoMatcher> sm = cv::createStereoBM(cv::STEREOBM_BASIC_PRESET,
+                                                       state->numberOfDisparities,
+                                                       state->SADWindowSize);
+    sm->set("preFilterType", state->preFilterType);
+    sm->set("preFilterSize", state->preFilterSize);
+    sm->set("preFilterCap", state->preFilterCap);
+    sm->set("SADWindowSize", state->SADWindowSize);
+    sm->set("numDisparities", state->numberOfDisparities > 0 ? state->numberOfDisparities : 64);
+    sm->set("textureThreshold", state->textureThreshold);
+    sm->set("uniquenessRatio", state->uniquenessRatio);
+    sm->set("speckleRange", state->speckleRange);
+    sm->set("speckleWindowSize", state->speckleWindowSize);
+    sm->set("disp12MaxDiff", state->disp12MaxDiff);
+
+    sm->compute(left, right, disp);
+}
+
+CvRect cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity,
+                              int numberOfDisparities, int SADWindowSize )
+{
+    return (CvRect)cv::getValidDisparityROI( roi1, roi2, minDisparity,
+                                            numberOfDisparities, SADWindowSize );
+}
+
+void cvValidateDisparity( CvArr* _disp, const CvArr* _cost, int minDisparity,
+                         int numberOfDisparities, int disp12MaxDiff )
+{
+    cv::Mat disp = cv::cvarrToMat(_disp), cost = cv::cvarrToMat(_cost);
+    cv::validateDisparity( disp, cost, minDisparity, numberOfDisparities, disp12MaxDiff );
+}
+
+namespace cv
+{
+
+StereoBM::StereoBM()
+{ init(STEREOBM_BASIC_PRESET); }
+
+StereoBM::StereoBM(int _preset, int _ndisparities, int _SADWindowSize)
+{ init(_preset, _ndisparities, _SADWindowSize); }
+
+void StereoBM::init(int _preset, int _ndisparities, int _SADWindowSize)
+{
+    state = cvCreateStereoBMState(_preset, _ndisparities);
+    state->SADWindowSize = _SADWindowSize;
+}
+
+void StereoBM::operator()( InputArray _left, InputArray _right,
+                          OutputArray _disparity, int disptype )
+{
+    Mat left = _left.getMat(), right = _right.getMat();
+    CV_Assert( disptype == CV_16S || disptype == CV_32F );
+    _disparity.create(left.size(), disptype);
+    Mat disp = _disparity.getMat();
+
+    CvMat left_c = left, right_c = right, disp_c = disp;
+    cvFindStereoCorrespondenceBM(&left_c, &right_c, &disp_c, state);
+}
+
+
+StereoSGBM::StereoSGBM()
+{
+    minDisparity = numberOfDisparities = 0;
+    SADWindowSize = 0;
+    P1 = P2 = 0;
+    disp12MaxDiff = 0;
+    preFilterCap = 0;
+    uniquenessRatio = 0;
+    speckleWindowSize = 0;
+    speckleRange = 0;
+    fullDP = false;
+
+    sm = createStereoSGBM(0, 0, 0);
+}
+
+StereoSGBM::StereoSGBM( int _minDisparity, int _numDisparities, int _SADWindowSize,
+                       int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
+                       int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
+                       bool _fullDP )
+{
+    minDisparity = _minDisparity;
+    numberOfDisparities = _numDisparities;
+    SADWindowSize = _SADWindowSize;
+    P1 = _P1;
+    P2 = _P2;
+    disp12MaxDiff = _disp12MaxDiff;
+    preFilterCap = _preFilterCap;
+    uniquenessRatio = _uniquenessRatio;
+    speckleWindowSize = _speckleWindowSize;
+    speckleRange = _speckleRange;
+    fullDP = _fullDP;
+
+    sm = createStereoSGBM(0, 0, 0);
+}
+
+StereoSGBM::~StereoSGBM()
+{
+}
+
+void StereoSGBM::operator ()( InputArray _left, InputArray _right,
+                             OutputArray _disp )
+{
+    sm->set("minDisparity", minDisparity);
+    sm->set("numDisparities", numberOfDisparities);
+    sm->set("SADWindowSize", SADWindowSize);
+    sm->set("P1", P1);
+    sm->set("P2", P2);
+    sm->set("disp12MaxDiff", disp12MaxDiff);
+    sm->set("preFilterCap", preFilterCap);
+    sm->set("uniquenessRatio", uniquenessRatio);
+    sm->set("speckleWindowSize", speckleWindowSize);
+    sm->set("speckleRange", speckleRange);
+    sm->set("fullDP", fullDP);
+
+    sm->compute(_left, _right, _disp);
+}
+
+}
+
+
+

modules/calib3d/src/stereosgbm.cpp

@@ -12,6 +12,7 @@
 //
 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
@@ -61,9 +62,12 @@ typedef short DispType;
 
 enum { NR = 16, NR2 = NR/2 };
 
-StereoSGBM::StereoSGBM()
+
+struct StereoSGBMParams
 {
-    minDisparity = numberOfDisparities = 0;
+    StereoSGBMParams()
+    {
+        minDisparity = numDisparities = 0;
         SADWindowSize = 0;
         P1 = P2 = 0;
         disp12MaxDiff = 0;
@@ -72,16 +76,15 @@ StereoSGBM::StereoSGBM()
         speckleWindowSize = 0;
         speckleRange = 0;
         fullDP = false;
-}
-
+    }
 
-StereoSGBM::StereoSGBM( int _minDisparity, int _numDisparities, int _SADWindowSize,
+    StereoSGBMParams( int _minDisparity, int _numDisparities, int _SADWindowSize,
                       int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
                       int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
                       bool _fullDP )
-{
+    {
         minDisparity = _minDisparity;
-    numberOfDisparities = _numDisparities;
+        numDisparities = _numDisparities;
         SADWindowSize = _SADWindowSize;
         P1 = _P1;
         P2 = _P2;
@@ -91,12 +94,20 @@ StereoSGBM::StereoSGBM( int _minDisparity, int _numDisparities, int _SADWindowSi
         speckleWindowSize = _speckleWindowSize;
         speckleRange = _speckleRange;
         fullDP = _fullDP;
-}
-
+    }
 
-StereoSGBM::~StereoSGBM()
-{
-}
+    int minDisparity;
+    int numDisparities;
+    int SADWindowSize;
+    int preFilterCap;
+    int uniquenessRatio;
+    int P1;
+    int P2;
+    int speckleWindowSize;
+    int speckleRange;
+    int disp12MaxDiff;
+    bool fullDP;
+};
 
 /*
  For each pixel row1[x], max(-maxD, 0) <= minX <= x < maxX <= width - max(0, -minD),
@@ -289,7 +300,7 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
  final after all the tiles are processed.
 
  the disparity in disp1buf is written with sub-pixel accuracy
- (4 fractional bits, see CvStereoSGBM::DISP_SCALE),
+ (4 fractional bits, see StereoSGBM::DISP_SCALE),
  using quadratic interpolation, while the disparity in disp2buf
  is written as is, without interpolation.
 
@@ -297,7 +308,7 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
  It contains the minimum current cost, used to find the best disparity, corresponding to the minimal cost.
  */
 static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
-                                 Mat& disp1, const StereoSGBM& params,
+                                 Mat& disp1, const StereoSGBMParams& params,
                                  Mat& buffer )
 {
 #if CV_SSE2
@@ -321,7 +332,7 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
     const int DISP_SCALE = StereoSGBM::DISP_SCALE;
     const CostType MAX_COST = SHRT_MAX;
 
-    int minD = params.minDisparity, maxD = minD + params.numberOfDisparities;
+    int minD = params.minDisparity, maxD = minD + params.numDisparities;
     Size SADWindowSize;
     SADWindowSize.width = SADWindowSize.height = params.SADWindowSize > 0 ? params.SADWindowSize : 5;
     int ftzero = std::max(params.preFilterCap, 15) | 1;
@@ -817,26 +828,80 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
     }
 }
 
-typedef cv::Point_<short> Point2s;
 
-void StereoSGBM::operator ()( InputArray _left, InputArray _right,
-                             OutputArray _disp )
+class StereoSGBMImpl : public StereoMatcher
 {
-    Mat left = _left.getMat(), right = _right.getMat();
+public:
+    StereoSGBMImpl()
+    {
+        params = StereoSGBMParams();
+    }
+
+    StereoSGBMImpl( int _minDisparity, int _numDisparities, int _SADWindowSize,
+                    int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
+                    int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
+                    bool _fullDP )
+    {
+        params = StereoSGBMParams( _minDisparity, _numDisparities, _SADWindowSize,
+                                   _P1, _P2, _disp12MaxDiff, _preFilterCap,
+                                   _uniquenessRatio, _speckleWindowSize, _speckleRange,
+                                   _fullDP );
+    }
+
+    void compute( InputArray leftarr, InputArray rightarr, OutputArray disparr )
+    {
+        Mat left = leftarr.getMat(), right = rightarr.getMat();
         CV_Assert( left.size() == right.size() && left.type() == right.type() &&
-              left.depth() == DataType<PixType>::depth );
+                   left.depth() == CV_8U );
 
-    _disp.create( left.size(), CV_16S );
-    Mat disp = _disp.getMat();
+        disparr.create( left.size(), CV_16S );
+        Mat disp = disparr.getMat();
 
-    computeDisparitySGBM( left, right, disp, *this, buffer );
+        computeDisparitySGBM( left, right, disp, params, buffer );
         medianBlur(disp, disp, 3);
 
-    if( speckleWindowSize > 0 )
-        filterSpeckles(disp, (minDisparity - 1)*DISP_SCALE, speckleWindowSize, DISP_SCALE*speckleRange, buffer);
+        if( params.speckleWindowSize > 0 )
+            filterSpeckles(disp, (params.minDisparity - 1)*STEREO_DISP_SCALE, params.speckleWindowSize,
+                           STEREO_DISP_SCALE*params.speckleRange, buffer);
+    }
+
+    AlgorithmInfo* info() const;
+
+    StereoSGBMParams params;
+    Mat buffer;
+};
+
+
+Ptr<StereoMatcher> createStereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,
+                                    int P1, int P2, int disp12MaxDiff,
+                                    int preFilterCap, int uniquenessRatio,
+                                    int speckleWindowSize, int speckleRange,
+                                    bool fullDP)
+{
+    return new StereoSGBMImpl(minDisparity, numDisparities, SADWindowSize,
+                              P1, P2, disp12MaxDiff,
+                              preFilterCap, uniquenessRatio,
+                              speckleWindowSize, speckleRange,
+                              fullDP);
 }
 
 
+#define add_param(n) \
+    obj.info()->addParam(obj, #n, obj.params.n)
+
+CV_INIT_ALGORITHM(StereoSGBMImpl, "StereoMatcher.SGBM",
+                  add_param(minDisparity);
+                  add_param(numDisparities);
+                  add_param(SADWindowSize);
+                  add_param(preFilterCap);
+                  add_param(uniquenessRatio);
+                  add_param(P1);
+                  add_param(P2);
+                  add_param(speckleWindowSize);
+                  add_param(speckleRange);
+                  add_param(disp12MaxDiff);
+                  add_param(fullDP));
+
 Rect getValidDisparityROI( Rect roi1, Rect roi2,
                           int minDisparity,
                           int numberOfDisparities,
@@ -855,13 +920,11 @@ Rect getValidDisparityROI( Rect roi1, Rect roi2,
     return r.width > 0 && r.height > 0 ? r : Rect();
 }
 
-}
+typedef cv::Point_<short> Point2s;
 
-namespace
+template <typename T>
+void filterSpecklesImpl(cv::Mat& img, int newVal, int maxSpeckleSize, int maxDiff, cv::Mat& _buf)
 {
-    template <typename T>
-    void filterSpecklesImpl(cv::Mat& img, int newVal, int maxSpeckleSize, int maxDiff, cv::Mat& _buf)
-    {
     using namespace cv;
 
     int width = img.cols, height = img.rows, npixels = width*height;
@@ -954,7 +1017,8 @@ namespace
             }
         }
     }
-    }
+}
+
 }
 
 void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSize,
@@ -1054,16 +1118,3 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
     }
 }
 
-CvRect cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity,
-                               int numberOfDisparities, int SADWindowSize )
-{
-    return (CvRect)cv::getValidDisparityROI( roi1, roi2, minDisparity,
-                                             numberOfDisparities, SADWindowSize );
-}
-
-void cvValidateDisparity( CvArr* _disp, const CvArr* _cost, int minDisparity,
-                          int numberOfDisparities, int disp12MaxDiff )
-{
-    cv::Mat disp = cv::cvarrToMat(_disp), cost = cv::cvarrToMat(_cost);
-    cv::validateDisparity( disp, cost, minDisparity, numberOfDisparities, disp12MaxDiff );
-}