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;
+};
 
- The class implements BM stereo correspondence algorithm by K. Konolige.
-*/
+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 };
+
+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,42 +62,52 @@ typedef short DispType;
 
 enum { NR = 16, NR2 = NR/2 };
 
-StereoSGBM::StereoSGBM()
-{
-    minDisparity = numberOfDisparities = 0;
-    SADWindowSize = 0;
-    P1 = P2 = 0;
-    disp12MaxDiff = 0;
-    preFilterCap = 0;
-    uniquenessRatio = 0;
-    speckleWindowSize = 0;
-    speckleRange = 0;
-    fullDP = false;
-}
-
 
-StereoSGBM::StereoSGBM( int _minDisparity, int _numDisparities, int _SADWindowSize,
-                   int _P1, int _P2, int _disp12MaxDiff, int _preFilterCap,
-                   int _uniquenessRatio, int _speckleWindowSize, int _speckleRange,
-                   bool _fullDP )
+struct StereoSGBMParams
 {
-    minDisparity = _minDisparity;
-    numberOfDisparities = _numDisparities;
-    SADWindowSize = _SADWindowSize;
-    P1 = _P1;
-    P2 = _P2;
-    disp12MaxDiff = _disp12MaxDiff;
-    preFilterCap = _preFilterCap;
-    uniquenessRatio = _uniquenessRatio;
-    speckleWindowSize = _speckleWindowSize;
-    speckleRange = _speckleRange;
-    fullDP = _fullDP;
-}
+    StereoSGBMParams()
+    {
+        minDisparity = numDisparities = 0;
+        SADWindowSize = 0;
+        P1 = P2 = 0;
+        disp12MaxDiff = 0;
+        preFilterCap = 0;
+        uniquenessRatio = 0;
+        speckleWindowSize = 0;
+        speckleRange = 0;
+        fullDP = false;
+    }
 
+    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;
+        numDisparities = _numDisparities;
+        SADWindowSize = _SADWindowSize;
+        P1 = _P1;
+        P2 = _P2;
+        disp12MaxDiff = _disp12MaxDiff;
+        preFilterCap = _preFilterCap;
+        uniquenessRatio = _uniquenessRatio;
+        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();
-    CV_Assert( left.size() == right.size() && left.type() == right.type() &&
-              left.depth() == DataType<PixType>::depth );
+public:
+    StereoSGBMImpl()
+    {
+        params = StereoSGBMParams();
+    }
 
-    _disp.create( left.size(), CV_16S );
-    Mat disp = _disp.getMat();
+    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() == CV_8U );
 
-    computeDisparitySGBM( left, right, disp, *this, buffer );
-    medianBlur(disp, disp, 3);
+        disparr.create( left.size(), CV_16S );
+        Mat disp = disparr.getMat();
 
-    if( speckleWindowSize > 0 )
-        filterSpeckles(disp, (minDisparity - 1)*DISP_SCALE, speckleWindowSize, DISP_SCALE*speckleRange, buffer);
+        computeDisparitySGBM( left, right, disp, params, buffer );
+        medianBlur(disp, disp, 3);
+
+        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,108 +920,107 @@ 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;
+    size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar));
+    if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
+        _buf.create(1, (int)bufSize, CV_8U);
+
+    uchar* buf = _buf.data;
+    int i, j, dstep = (int)(img.step/sizeof(T));
+    int* labels = (int*)buf;
+    buf += npixels*sizeof(labels[0]);
+    Point2s* wbuf = (Point2s*)buf;
+    buf += npixels*sizeof(wbuf[0]);
+    uchar* rtype = (uchar*)buf;
+    int curlabel = 0;
+
+    // clear out label assignments
+    memset(labels, 0, npixels*sizeof(labels[0]));
+
+    for( i = 0; i < height; i++ )
     {
-        using namespace cv;
-
-        int width = img.cols, height = img.rows, npixels = width*height;
-        size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar));
-        if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
-            _buf.create(1, (int)bufSize, CV_8U);
-
-        uchar* buf = _buf.data;
-        int i, j, dstep = (int)(img.step/sizeof(T));
-        int* labels = (int*)buf;
-        buf += npixels*sizeof(labels[0]);
-        Point2s* wbuf = (Point2s*)buf;
-        buf += npixels*sizeof(wbuf[0]);
-        uchar* rtype = (uchar*)buf;
-        int curlabel = 0;
-
-        // clear out label assignments
-        memset(labels, 0, npixels*sizeof(labels[0]));
-
-        for( i = 0; i < height; i++ )
-        {
-            T* ds = img.ptr<T>(i);
-            int* ls = labels + width*i;
+        T* ds = img.ptr<T>(i);
+        int* ls = labels + width*i;
 
-            for( j = 0; j < width; j++ )
+        for( j = 0; j < width; j++ )
+        {
+            if( ds[j] != newVal )   // not a bad disparity
             {
-                if( ds[j] != newVal )   // not a bad disparity
+                if( ls[j] )     // has a label, check for bad label
                 {
-                    if( ls[j] )     // has a label, check for bad label
-                    {
-                        if( rtype[ls[j]] ) // small region, zero out disparity
-                            ds[j] = (T)newVal;
-                    }
-                    // no label, assign and propagate
-                    else
+                    if( rtype[ls[j]] ) // small region, zero out disparity
+                        ds[j] = (T)newVal;
+                }
+                // no label, assign and propagate
+                else
+                {
+                    Point2s* ws = wbuf; // initialize wavefront
+                    Point2s p((short)j, (short)i);  // current pixel
+                    curlabel++; // next label
+                    int count = 0;  // current region size
+                    ls[j] = curlabel;
+
+                    // wavefront propagation
+                    while( ws >= wbuf ) // wavefront not empty
                     {
-                        Point2s* ws = wbuf; // initialize wavefront
-                        Point2s p((short)j, (short)i);  // current pixel
-                        curlabel++; // next label
-                        int count = 0;  // current region size
-                        ls[j] = curlabel;
-
-                        // wavefront propagation
-                        while( ws >= wbuf ) // wavefront not empty
-                        {
-                            count++;
-                            // put neighbors onto wavefront
-                            T* dpp = &img.at<T>(p.y, p.x);
-                            T dp = *dpp;
-                            int* lpp = labels + width*p.y + p.x;
-
-                            if( p.x < width-1 && !lpp[+1] && dpp[+1] != newVal && std::abs(dp - dpp[+1]) <= maxDiff )
-                            {
-                                lpp[+1] = curlabel;
-                                *ws++ = Point2s(p.x+1, p.y);
-                            }
-
-                            if( p.x > 0 && !lpp[-1] && dpp[-1] != newVal && std::abs(dp - dpp[-1]) <= maxDiff )
-                            {
-                                lpp[-1] = curlabel;
-                                *ws++ = Point2s(p.x-1, p.y);
-                            }
+                        count++;
+                        // put neighbors onto wavefront
+                        T* dpp = &img.at<T>(p.y, p.x);
+                        T dp = *dpp;
+                        int* lpp = labels + width*p.y + p.x;
 
-                            if( p.y < height-1 && !lpp[+width] && dpp[+dstep] != newVal && std::abs(dp - dpp[+dstep]) <= maxDiff )
-                            {
-                                lpp[+width] = curlabel;
-                                *ws++ = Point2s(p.x, p.y+1);
-                            }
+                        if( p.x < width-1 && !lpp[+1] && dpp[+1] != newVal && std::abs(dp - dpp[+1]) <= maxDiff )
+                        {
+                            lpp[+1] = curlabel;
+                            *ws++ = Point2s(p.x+1, p.y);
+                        }
 
-                            if( p.y > 0 && !lpp[-width] && dpp[-dstep] != newVal && std::abs(dp - dpp[-dstep]) <= maxDiff )
-                            {
-                                lpp[-width] = curlabel;
-                                *ws++ = Point2s(p.x, p.y-1);
-                            }
+                        if( p.x > 0 && !lpp[-1] && dpp[-1] != newVal && std::abs(dp - dpp[-1]) <= maxDiff )
+                        {
+                            lpp[-1] = curlabel;
+                            *ws++ = Point2s(p.x-1, p.y);
+                        }
 
-                            // pop most recent and propagate
-                            // NB: could try least recent, maybe better convergence
-                            p = *--ws;
+                        if( p.y < height-1 && !lpp[+width] && dpp[+dstep] != newVal && std::abs(dp - dpp[+dstep]) <= maxDiff )
+                        {
+                            lpp[+width] = curlabel;
+                            *ws++ = Point2s(p.x, p.y+1);
                         }
 
-                        // assign label type
-                        if( count <= maxSpeckleSize )   // speckle region
+                        if( p.y > 0 && !lpp[-width] && dpp[-dstep] != newVal && std::abs(dp - dpp[-dstep]) <= maxDiff )
                         {
-                            rtype[ls[j]] = 1;   // small region label
-                            ds[j] = (T)newVal;
+                            lpp[-width] = curlabel;
+                            *ws++ = Point2s(p.x, p.y-1);
                         }
-                        else
-                            rtype[ls[j]] = 0;   // large region label
+
+                        // pop most recent and propagate
+                        // NB: could try least recent, maybe better convergence
+                        p = *--ws;
+                    }
+
+                    // assign label type
+                    if( count <= maxSpeckleSize )   // speckle region
+                    {
+                        rtype[ls[j]] = 1;   // small region label
+                        ds[j] = (T)newVal;
                     }
+                    else
+                        rtype[ls[j]] = 0;   // large region label
                 }
             }
         }
     }
 }
 
+}
+
 void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSize,
                          double _maxDiff, InputOutputArray __buf )
 {
@@ -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 );
-}