modules/legacy/test/test_stereomatching.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                        Intel License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
  14 // Third party copyrights are property of their respective owners.
  15 //
  16 // Redistribution and use in source and binary forms, with or without modification,
  17 // are permitted provided that the following conditions are met:
  18 //
  19 //   * Redistribution's of source code must retain the above copyright notice,
  20 //     this list of conditions and the following disclaimer.
  21 //
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,
  23 //     this list of conditions and the following disclaimer in the documentation
  24 //     and/or other materials provided with the distribution.
  25 //
  26 //   * The name of Intel Corporation may not be used to endorse or promote products
  27 //     derived from this software without specific prior written permission.
  28 //
  29 // This software is provided by the copyright holders and contributors "as is" and
  30 // any express or implied warranties, including, but not limited to, the implied
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  32 // In no event shall the Intel Corporation or contributors be liable for any direct,
  33 // indirect, incidental, special, exemplary, or consequential damages
  34 // (including, but not limited to, procurement of substitute goods or services;
  35 // loss of use, data, or profits; or business interruption) however caused
  36 // and on any theory of liability, whether in contract, strict liability,
  37 // or tort (including negligence or otherwise) arising in any way out of
  38 // the use of this software, even if advised of the possibility of such damage.
  39 //
  40 //M*/
  41
  42 /*
  43   This is a regression test for stereo matching algorithms. This test gets some quality metrics
  44   discribed in "A Taxonomy and Evaluation of Dense Two-Frame Stereo Correspondence Algorithms".
  45   Daniel Scharstein, Richard Szeliski
  46 */
  47
  48 #include "test_precomp.hpp"
  49 #include <limits>
  50 #include <cstdio>
  51
  52 using namespace std;
  53 using namespace cv;
  54
  55 const float EVAL_BAD_THRESH = 1.f;
  56 const int EVAL_TEXTURELESS_WIDTH = 3;
  57 const float EVAL_TEXTURELESS_THRESH = 4.f;
  58 const float EVAL_DISP_THRESH = 1.f;
  59 const float EVAL_DISP_GAP = 2.f;
  60 const int EVAL_DISCONT_WIDTH = 9;
  61 const int EVAL_IGNORE_BORDER = 10;
  62
  63 const int ERROR_KINDS_COUNT = 6;
  64
  65 //============================== quality measuring functions =================================================
  66
  67 /*
  68   Calculate textureless regions of image (regions where the squared horizontal intensity gradient averaged over
  69   a square window of size=evalTexturelessWidth is below a threshold=evalTexturelessThresh) and textured regions.
  70 */
  71 void computeTextureBasedMasks( const Mat& _img, Mat* texturelessMask, Mat* texturedMask,
  72              int texturelessWidth = EVAL_TEXTURELESS_WIDTH, float texturelessThresh = EVAL_TEXTURELESS_THRESH )
  73 {
  74     if( !texturelessMask && !texturedMask )
  75         return;
  76     if( _img.empty() )
  77         CV_Error( CV_StsBadArg, "img is empty" );
  78
  79     Mat img = _img;
  80     if( _img.channels() > 1)
  81     {
  82         Mat tmp; cvtColor( _img, tmp, CV_BGR2GRAY ); img = tmp;
  83     }
  84     Mat dxI; Sobel( img, dxI, CV_32FC1, 1, 0, 3 );
  85     Mat dxI2; pow( dxI / 8.f/*normalize*/, 2, dxI2 );
  86     Mat avgDxI2; boxFilter( dxI2, avgDxI2, CV_32FC1, Size(texturelessWidth,texturelessWidth) );
  87
  88     if( texturelessMask )
  89         *texturelessMask = avgDxI2 < texturelessThresh;
  90     if( texturedMask )
  91         *texturedMask = avgDxI2 >= texturelessThresh;
  92 }
  93
  94 void checkTypeAndSizeOfDisp( const Mat& dispMap, const Size* sz )
  95 {
  96     if( dispMap.empty() )
  97         CV_Error( CV_StsBadArg, "dispMap is empty" );
  98     if( dispMap.type() != CV_32FC1 )
  99         CV_Error( CV_StsBadArg, "dispMap must have CV_32FC1 type" );
 100     if( sz && (dispMap.rows != sz->height || dispMap.cols != sz->width) )
 101         CV_Error( CV_StsBadArg, "dispMap has incorrect size" );
 102 }
 103
 104 void checkTypeAndSizeOfMask( const Mat& mask, Size sz )
 105 {
 106     if( mask.empty() )
 107         CV_Error( CV_StsBadArg, "mask is empty" );
 108     if( mask.type() != CV_8UC1 )
 109         CV_Error( CV_StsBadArg, "mask must have CV_8UC1 type" );
 110     if( mask.rows != sz.height || mask.cols != sz.width )
 111         CV_Error( CV_StsBadArg, "mask has incorrect size" );
 112 }
 113
 114 void checkDispMapsAndUnknDispMasks( const Mat& leftDispMap, const Mat& rightDispMap,
 115                                     const Mat& leftUnknDispMask, const Mat& rightUnknDispMask )
 116 {
 117     // check type and size of disparity maps
 118     checkTypeAndSizeOfDisp( leftDispMap, 0 );
 119     if( !rightDispMap.empty() )
 120     {
 121         Size sz = leftDispMap.size();
 122         checkTypeAndSizeOfDisp( rightDispMap, &sz );
 123     }
 124
 125     // check size and type of unknown disparity maps
 126     if( !leftUnknDispMask.empty() )
 127         checkTypeAndSizeOfMask( leftUnknDispMask, leftDispMap.size() );
 128     if( !rightUnknDispMask.empty() )
 129         checkTypeAndSizeOfMask( rightUnknDispMask, rightDispMap.size() );
 130
 131     // check values of disparity maps (known disparity values musy be positive)
 132     double leftMinVal = 0, rightMinVal = 0;
 133     if( leftUnknDispMask.empty() )
 134         minMaxLoc( leftDispMap, &leftMinVal );
 135     else
 136         minMaxLoc( leftDispMap, &leftMinVal, 0, 0, 0, ~leftUnknDispMask );
 137     if( !rightDispMap.empty() )
 138     {
 139         if( rightUnknDispMask.empty() )
 140             minMaxLoc( rightDispMap, &rightMinVal );
 141         else
 142             minMaxLoc( rightDispMap, &rightMinVal, 0, 0, 0, ~rightUnknDispMask );
 143     }
 144     if( leftMinVal < 0 || rightMinVal < 0)
 145         CV_Error( CV_StsBadArg, "known disparity values must be positive" );
 146 }
 147
 148 /*
 149   Calculate occluded regions of reference image (left image) (regions that are occluded in the matching image (right image),
 150   i.e., where the forward-mapped disparity lands at a location with a larger (nearer) disparity) and non occluded regions.
 151 */
 152 void computeOcclusionBasedMasks( const Mat& leftDisp, const Mat& _rightDisp,
 153                              Mat* occludedMask, Mat* nonOccludedMask,
 154                              const Mat& leftUnknDispMask = Mat(), const Mat& rightUnknDispMask = Mat(),
 155                              float dispThresh = EVAL_DISP_THRESH )
 156 {
 157     if( !occludedMask && !nonOccludedMask )
 158         return;
 159     checkDispMapsAndUnknDispMasks( leftDisp, _rightDisp, leftUnknDispMask, rightUnknDispMask );
 160
 161     Mat rightDisp;
 162     if( _rightDisp.empty() )
 163     {
 164         if( !rightUnknDispMask.empty() )
 165            CV_Error( CV_StsBadArg, "rightUnknDispMask must be empty if _rightDisp is empty" );
 166         rightDisp.create(leftDisp.size(), CV_32FC1);
 167         rightDisp.setTo(Scalar::all(0) );
 168         for( int leftY = 0; leftY < leftDisp.rows; leftY++ )
 169         {
 170             for( int leftX = 0; leftX < leftDisp.cols; leftX++ )
 171             {
 172                 if( !leftUnknDispMask.empty() && leftUnknDispMask.at<uchar>(leftY,leftX) )
 173                     continue;
 174                 float leftDispVal = leftDisp.at<float>(leftY, leftX);
 175                 int rightX = leftX - cvRound(leftDispVal), rightY = leftY;
 176                 if( rightX >= 0)
 177                     rightDisp.at<float>(rightY,rightX) = max(rightDisp.at<float>(rightY,rightX), leftDispVal);
 178             }
 179         }
 180     }
 181     else
 182         _rightDisp.copyTo(rightDisp);
 183
 184     if( occludedMask )
 185     {
 186         occludedMask->create(leftDisp.size(), CV_8UC1);
 187         occludedMask->setTo(Scalar::all(0) );
 188     }
 189     if( nonOccludedMask )
 190     {
 191         nonOccludedMask->create(leftDisp.size(), CV_8UC1);
 192         nonOccludedMask->setTo(Scalar::all(0) );
 193     }
 194     for( int leftY = 0; leftY < leftDisp.rows; leftY++ )
 195     {
 196         for( int leftX = 0; leftX < leftDisp.cols; leftX++ )
 197         {
 198             if( !leftUnknDispMask.empty() && leftUnknDispMask.at<uchar>(leftY,leftX) )
 199                 continue;
 200             float leftDispVal = leftDisp.at<float>(leftY, leftX);
 201             int rightX = leftX - cvRound(leftDispVal), rightY = leftY;
 202             if( rightX < 0 && occludedMask )
 203                 occludedMask->at<uchar>(leftY, leftX) = 255;
 204             else
 205             {
 206                 if( !rightUnknDispMask.empty() && rightUnknDispMask.at<uchar>(rightY,rightX) )
 207                     continue;
 208                 float rightDispVal = rightDisp.at<float>(rightY, rightX);
 209                 if( rightDispVal > leftDispVal + dispThresh )
 210                 {
 211                     if( occludedMask )
 212                         occludedMask->at<uchar>(leftY, leftX) = 255;
 213                 }
 214                 else
 215                 {
 216                     if( nonOccludedMask )
 217                         nonOccludedMask->at<uchar>(leftY, leftX) = 255;
 218                 }
 219             }
 220         }
 221     }
 222 }
 223
 224 /*
 225   Calculate depth discontinuty regions: pixels whose neiboring disparities differ by more than
 226   dispGap, dilated by window of width discontWidth.
 227 */
 228 void computeDepthDiscontMask( const Mat& disp, Mat& depthDiscontMask, const Mat& unknDispMask = Mat(),
 229                                  float dispGap = EVAL_DISP_GAP, int discontWidth = EVAL_DISCONT_WIDTH )
 230 {
 231     if( disp.empty() )
 232         CV_Error( CV_StsBadArg, "disp is empty" );
 233     if( disp.type() != CV_32FC1 )
 234         CV_Error( CV_StsBadArg, "disp must have CV_32FC1 type" );
 235     if( !unknDispMask.empty() )
 236         checkTypeAndSizeOfMask( unknDispMask, disp.size() );
 237
 238     Mat curDisp; disp.copyTo( curDisp );
 239     if( !unknDispMask.empty() )
 240         curDisp.setTo( Scalar(numeric_limits<float>::min()), unknDispMask );
 241     Mat maxNeighbDisp; dilate( curDisp, maxNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)) );
 242     if( !unknDispMask.empty() )
 243         curDisp.setTo( Scalar(numeric_limits<float>::max()), unknDispMask );
 244     Mat minNeighbDisp; erode( curDisp, minNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)) );
 245     depthDiscontMask = max( (Mat)(maxNeighbDisp-disp), (Mat)(disp-minNeighbDisp) ) > dispGap;
 246     if( !unknDispMask.empty() )
 247         depthDiscontMask &= ~unknDispMask;
 248     dilate( depthDiscontMask, depthDiscontMask, Mat(discontWidth, discontWidth, CV_8UC1, Scalar(1)) );
 249 }
 250
 251 /*
 252    Get evaluation masks excluding a border.
 253 */
 254 Mat getBorderedMask( Size maskSize, int border = EVAL_IGNORE_BORDER )
 255 {
 256     CV_Assert( border >= 0 );
 257     Mat mask(maskSize, CV_8UC1, Scalar(0));
 258     int w = maskSize.width - 2*border, h = maskSize.height - 2*border;
 259     if( w < 0 ||  h < 0 )
 260         mask.setTo(Scalar(0));
 261     else
 262         mask( Rect(Point(border,border),Size(w,h)) ).setTo(Scalar(255));
 263     return mask;
 264 }
 265
 266 /*
 267   Calculate root-mean-squared error between the computed disparity map (computedDisp) and ground truth map (groundTruthDisp).
 268 */
 269 float dispRMS( const Mat& computedDisp, const Mat& groundTruthDisp, const Mat& mask )
 270 {
 271     checkTypeAndSizeOfDisp( groundTruthDisp, 0 );
 272     Size sz = groundTruthDisp.size();
 273     checkTypeAndSizeOfDisp( computedDisp, &sz );
 274
 275     int pointsCount = sz.height*sz.width;
 276     if( !mask.empty() )
 277     {
 278         checkTypeAndSizeOfMask( mask, sz );
 279         pointsCount = countNonZero(mask);
 280     }
 281     return 1.f/sqrt((float)pointsCount) * (float)cvtest::norm(computedDisp, groundTruthDisp, NORM_L2, mask);
 282 }
 283
 284 /*
 285   Calculate fraction of bad matching pixels.
 286 */
 287 float badMatchPxlsFraction( const Mat& computedDisp, const Mat& groundTruthDisp, const Mat& mask,
 288                             float _badThresh = EVAL_BAD_THRESH )
 289 {
 290     int badThresh = cvRound(_badThresh);
 291     checkTypeAndSizeOfDisp( groundTruthDisp, 0 );
 292     Size sz = groundTruthDisp.size();
 293     checkTypeAndSizeOfDisp( computedDisp, &sz );
 294
 295     Mat badPxlsMap;
 296     absdiff( computedDisp, groundTruthDisp, badPxlsMap );
 297     badPxlsMap = badPxlsMap > badThresh;
 298     int pointsCount = sz.height*sz.width;
 299     if( !mask.empty() )
 300     {
 301         checkTypeAndSizeOfMask( mask, sz );
 302         badPxlsMap = badPxlsMap & mask;
 303         pointsCount = countNonZero(mask);
 304     }
 305     return 1.f/pointsCount * countNonZero(badPxlsMap);
 306 }
 307
 308 //===================== regression test for stereo matching algorithms ==============================
 309
 310 const string ALGORITHMS_DIR = "stereomatching/algorithms/";
 311 const string DATASETS_DIR = "stereomatching/datasets/";
 312 const string DATASETS_FILE = "datasets.xml";
 313
 314 const string RUN_PARAMS_FILE = "_params.xml";
 315 const string RESULT_FILE = "_res.xml";
 316
 317 const string LEFT_IMG_NAME = "im2.png";
 318 const string RIGHT_IMG_NAME = "im6.png";
 319 const string TRUE_LEFT_DISP_NAME = "disp2.png";
 320 const string TRUE_RIGHT_DISP_NAME = "disp6.png";
 321
 322 string ERROR_PREFIXES[] = { "borderedAll",
 323                             "borderedNoOccl",
 324                             "borderedOccl",
 325                             "borderedTextured",
 326                             "borderedTextureless",
 327                             "borderedDepthDiscont" }; // size of ERROR_KINDS_COUNT
 328
 329
 330 const string RMS_STR = "RMS";
 331 const string BAD_PXLS_FRACTION_STR = "BadPxlsFraction";
 332
 333 class QualityEvalParams
 334 {
 335 public:
 336     QualityEvalParams() { setDefaults(); }
 337     QualityEvalParams( int _ignoreBorder )
 338     {
 339         setDefaults();
 340         ignoreBorder = _ignoreBorder;
 341     }
 342     void setDefaults()
 343     {
 344         badThresh = EVAL_BAD_THRESH;
 345         texturelessWidth = EVAL_TEXTURELESS_WIDTH;
 346         texturelessThresh = EVAL_TEXTURELESS_THRESH;
 347         dispThresh = EVAL_DISP_THRESH;
 348         dispGap = EVAL_DISP_GAP;
 349         discontWidth = EVAL_DISCONT_WIDTH;
 350         ignoreBorder = EVAL_IGNORE_BORDER;
 351     }
 352     float badThresh;
 353     int texturelessWidth;
 354     float texturelessThresh;
 355     float dispThresh;
 356     float dispGap;
 357     int discontWidth;
 358     int ignoreBorder;
 359 };
 360
 361 class CV_StereoMatchingTest : public cvtest::BaseTest
 362 {
 363 public:
 364     CV_StereoMatchingTest()
 365     { rmsEps.resize( ERROR_KINDS_COUNT, 0.01f );  fracEps.resize( ERROR_KINDS_COUNT, 1.e-6f ); }
 366 protected:
 367     // assumed that left image is a reference image
 368     virtual int runStereoMatchingAlgorithm( const Mat& leftImg, const Mat& rightImg,
 369                    Mat& leftDisp, Mat& rightDisp, int caseIdx ) = 0; // return ignored border width
 370
 371     int readDatasetsParams( FileStorage& fs );
 372     virtual int readRunParams( FileStorage& fs );
 373     void writeErrors( const string& errName, const vector<float>& errors, FileStorage* fs = 0 );
 374     void readErrors( FileNode& fn, const string& errName, vector<float>& errors );
 375     int compareErrors( const vector<float>& calcErrors, const vector<float>& validErrors,
 376                        const vector<float>& eps, const string& errName );
 377     int processStereoMatchingResults( FileStorage& fs, int caseIdx, bool isWrite,
 378                   const Mat& leftImg, const Mat& rightImg,
 379                   const Mat& trueLeftDisp, const Mat& trueRightDisp,
 380                   const Mat& leftDisp, const Mat& rightDisp,
 381                   const QualityEvalParams& qualityEvalParams  );
 382     void run( int );
 383
 384     vector<float> rmsEps;
 385     vector<float> fracEps;
 386
 387     struct DatasetParams
 388     {
 389         int dispScaleFactor;
 390         int dispUnknVal;
 391     };
 392     map<string, DatasetParams> datasetsParams;
 393
 394     vector<string> caseNames;
 395     vector<string> caseDatasets;
 396 };
 397
 398 void CV_StereoMatchingTest::run(int)
 399 {
 400     string dataPath = ts->get_data_path();
 401     string algorithmName = name;
 402     assert( !algorithmName.empty() );
 403     if( dataPath.empty() )
 404     {
 405         ts->printf( cvtest::TS::LOG, "dataPath is empty" );
 406         ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ARG_CHECK );
 407         return;
 408     }
 409
 410     FileStorage datasetsFS( dataPath + DATASETS_DIR + DATASETS_FILE, FileStorage::READ );
 411     int code = readDatasetsParams( datasetsFS );
 412     if( code != cvtest::TS::OK )
 413     {
 414         ts->set_failed_test_info( code );
 415         return;
 416     }
 417     FileStorage runParamsFS( dataPath + ALGORITHMS_DIR + algorithmName + RUN_PARAMS_FILE, FileStorage::READ );
 418     code = readRunParams( runParamsFS );
 419     if( code != cvtest::TS::OK )
 420     {
 421         ts->set_failed_test_info( code );
 422         return;
 423     }
 424
 425     string fullResultFilename = dataPath + ALGORITHMS_DIR + algorithmName + RESULT_FILE;
 426     FileStorage resFS( fullResultFilename, FileStorage::READ );
 427     bool isWrite = true; // write or compare results
 428     if( resFS.isOpened() )
 429         isWrite = false;
 430     else
 431     {
 432         resFS.open( fullResultFilename, FileStorage::WRITE );
 433         if( !resFS.isOpened() )
 434         {
 435             ts->printf( cvtest::TS::LOG, "file %s can not be read or written\n", fullResultFilename.c_str() );
 436             ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ARG_CHECK );
 437             return;
 438         }
 439         resFS << "stereo_matching" << "{";
 440     }
 441
 442     int progress = 0, caseCount = (int)caseNames.size();
 443     for( int ci = 0; ci < caseCount; ci++)
 444     {
 445         progress = update_progress( progress, ci, caseCount, 0 );
 446         printf("progress: %d%%\n", progress);
 447         fflush(stdout);
 448         string datasetName = caseDatasets[ci];
 449         string datasetFullDirName = dataPath + DATASETS_DIR + datasetName + "/";
 450         Mat leftImg = imread(datasetFullDirName + LEFT_IMG_NAME);
 451         Mat rightImg = imread(datasetFullDirName + RIGHT_IMG_NAME);
 452         Mat trueLeftDisp = imread(datasetFullDirName + TRUE_LEFT_DISP_NAME, 0);
 453         Mat trueRightDisp = imread(datasetFullDirName + TRUE_RIGHT_DISP_NAME, 0);
 454
 455         if( leftImg.empty() || rightImg.empty() || trueLeftDisp.empty() )
 456         {
 457             ts->printf( cvtest::TS::LOG, "images or left ground-truth disparities of dataset %s can not be read", datasetName.c_str() );
 458             code = cvtest::TS::FAIL_INVALID_TEST_DATA;
 459             continue;
 460         }
 461         int dispScaleFactor = datasetsParams[datasetName].dispScaleFactor;
 462         Mat tmp; trueLeftDisp.convertTo( tmp, CV_32FC1, 1.f/dispScaleFactor ); trueLeftDisp = tmp; tmp.release();
 463         if( !trueRightDisp.empty() )
 464             trueRightDisp.convertTo( tmp, CV_32FC1, 1.f/dispScaleFactor ); trueRightDisp = tmp; tmp.release();
 465
 466         Mat leftDisp, rightDisp;
 467         int ignBorder = max(runStereoMatchingAlgorithm(leftImg, rightImg, leftDisp, rightDisp, ci), EVAL_IGNORE_BORDER);
 468         leftDisp.convertTo( tmp, CV_32FC1 ); leftDisp = tmp; tmp.release();
 469         rightDisp.convertTo( tmp, CV_32FC1 ); rightDisp = tmp; tmp.release();
 470
 471         int tempCode = processStereoMatchingResults( resFS, ci, isWrite,
 472                    leftImg, rightImg, trueLeftDisp, trueRightDisp, leftDisp, rightDisp, QualityEvalParams(ignBorder));
 473         code = tempCode==cvtest::TS::OK ? code : tempCode;
 474     }
 475
 476     if( isWrite )
 477         resFS << "}"; // "stereo_matching"
 478
 479     ts->set_failed_test_info( code );
 480 }
 481
 482 void calcErrors( const Mat& leftImg, const Mat& /*rightImg*/,
 483                  const Mat& trueLeftDisp, const Mat& trueRightDisp,
 484                  const Mat& trueLeftUnknDispMask, const Mat& trueRightUnknDispMask,
 485                  const Mat& calcLeftDisp, const Mat& /*calcRightDisp*/,
 486                  vector<float>& rms, vector<float>& badPxlsFractions,
 487                  const QualityEvalParams& qualityEvalParams )
 488 {
 489     Mat texturelessMask, texturedMask;
 490     computeTextureBasedMasks( leftImg, &texturelessMask, &texturedMask,
 491                               qualityEvalParams.texturelessWidth, qualityEvalParams.texturelessThresh );
 492     Mat occludedMask, nonOccludedMask;
 493     computeOcclusionBasedMasks( trueLeftDisp, trueRightDisp, &occludedMask, &nonOccludedMask,
 494                                 trueLeftUnknDispMask, trueRightUnknDispMask, qualityEvalParams.dispThresh);
 495     Mat depthDiscontMask;
 496     computeDepthDiscontMask( trueLeftDisp, depthDiscontMask, trueLeftUnknDispMask,
 497                              qualityEvalParams.dispGap, qualityEvalParams.discontWidth);
 498
 499     Mat borderedKnownMask = getBorderedMask( leftImg.size(), qualityEvalParams.ignoreBorder ) & ~trueLeftUnknDispMask;
 500
 501     nonOccludedMask &= borderedKnownMask;
 502     occludedMask &= borderedKnownMask;
 503     texturedMask &= nonOccludedMask; // & borderedKnownMask
 504     texturelessMask &= nonOccludedMask; // & borderedKnownMask
 505     depthDiscontMask &= nonOccludedMask; // & borderedKnownMask
 506
 507     rms.resize(ERROR_KINDS_COUNT);
 508     rms[0] = dispRMS( calcLeftDisp, trueLeftDisp, borderedKnownMask );
 509     rms[1] = dispRMS( calcLeftDisp, trueLeftDisp, nonOccludedMask );
 510     rms[2] = dispRMS( calcLeftDisp, trueLeftDisp, occludedMask );
 511     rms[3] = dispRMS( calcLeftDisp, trueLeftDisp, texturedMask );
 512     rms[4] = dispRMS( calcLeftDisp, trueLeftDisp, texturelessMask );
 513     rms[5] = dispRMS( calcLeftDisp, trueLeftDisp, depthDiscontMask );
 514
 515     badPxlsFractions.resize(ERROR_KINDS_COUNT);
 516     badPxlsFractions[0] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, borderedKnownMask, qualityEvalParams.badThresh );
 517     badPxlsFractions[1] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, nonOccludedMask, qualityEvalParams.badThresh );
 518     badPxlsFractions[2] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, occludedMask, qualityEvalParams.badThresh );
 519     badPxlsFractions[3] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, texturedMask, qualityEvalParams.badThresh );
 520     badPxlsFractions[4] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, texturelessMask, qualityEvalParams.badThresh );
 521     badPxlsFractions[5] = badMatchPxlsFraction( calcLeftDisp, trueLeftDisp, depthDiscontMask, qualityEvalParams.badThresh );
 522 }
 523
 524 int CV_StereoMatchingTest::processStereoMatchingResults( FileStorage& fs, int caseIdx, bool isWrite,
 525               const Mat& leftImg, const Mat& rightImg,
 526               const Mat& trueLeftDisp, const Mat& trueRightDisp,
 527               const Mat& leftDisp, const Mat& rightDisp,
 528               const QualityEvalParams& qualityEvalParams )
 529 {
 530     // rightDisp is not used in current test virsion
 531     int code = cvtest::TS::OK;
 532     assert( fs.isOpened() );
 533     assert( trueLeftDisp.type() == CV_32FC1 && trueRightDisp.type() == CV_32FC1 );
 534     assert( leftDisp.type() == CV_32FC1 && rightDisp.type() == CV_32FC1 );
 535
 536     // get masks for unknown ground truth disparity values
 537     Mat leftUnknMask, rightUnknMask;
 538     DatasetParams params = datasetsParams[caseDatasets[caseIdx]];
 539     absdiff( trueLeftDisp, Scalar(params.dispUnknVal), leftUnknMask );
 540     leftUnknMask = leftUnknMask < numeric_limits<float>::epsilon();
 541     assert(leftUnknMask.type() == CV_8UC1);
 542     if( !trueRightDisp.empty() )
 543     {
 544         absdiff( trueRightDisp, Scalar(params.dispUnknVal), rightUnknMask );
 545         rightUnknMask = rightUnknMask < numeric_limits<float>::epsilon();
 546         assert(leftUnknMask.type() == CV_8UC1);
 547     }
 548
 549     // calculate errors
 550     vector<float> rmss, badPxlsFractions;
 551     calcErrors( leftImg, rightImg, trueLeftDisp, trueRightDisp, leftUnknMask, rightUnknMask,
 552                 leftDisp, rightDisp, rmss, badPxlsFractions, qualityEvalParams );
 553
 554     if( isWrite )
 555     {
 556         fs << caseNames[caseIdx] << "{";
 557         cvWriteComment( fs.fs, RMS_STR.c_str(), 0 );
 558         writeErrors( RMS_STR, rmss, &fs );
 559         cvWriteComment( fs.fs, BAD_PXLS_FRACTION_STR.c_str(), 0 );
 560         writeErrors( BAD_PXLS_FRACTION_STR, badPxlsFractions, &fs );
 561         fs << "}"; // datasetName
 562     }
 563     else // compare
 564     {
 565         ts->printf( cvtest::TS::LOG, "\nquality of case named %s\n", caseNames[caseIdx].c_str() );
 566         ts->printf( cvtest::TS::LOG, "%s\n", RMS_STR.c_str() );
 567         writeErrors( RMS_STR, rmss );
 568         ts->printf( cvtest::TS::LOG, "%s\n", BAD_PXLS_FRACTION_STR.c_str() );
 569         writeErrors( BAD_PXLS_FRACTION_STR, badPxlsFractions );
 570
 571         FileNode fn = fs.getFirstTopLevelNode()[caseNames[caseIdx]];
 572         vector<float> validRmss, validBadPxlsFractions;
 573
 574         readErrors( fn, RMS_STR, validRmss );
 575         readErrors( fn, BAD_PXLS_FRACTION_STR, validBadPxlsFractions );
 576         int tempCode = compareErrors( rmss, validRmss, rmsEps, RMS_STR );
 577         code = tempCode==cvtest::TS::OK ? code : tempCode;
 578         tempCode = compareErrors( badPxlsFractions, validBadPxlsFractions, fracEps, BAD_PXLS_FRACTION_STR );
 579         code = tempCode==cvtest::TS::OK ? code : tempCode;
 580     }
 581     return code;
 582 }
 583
 584 int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs )
 585 {
 586     if( !fs.isOpened() )
 587     {
 588         ts->printf( cvtest::TS::LOG, "datasetsParams can not be read " );
 589         return cvtest::TS::FAIL_INVALID_TEST_DATA;
 590     }
 591     datasetsParams.clear();
 592     FileNode fn = fs.getFirstTopLevelNode();
 593     assert(fn.isSeq());
 594     for( int i = 0; i < (int)fn.size(); i+=3 )
 595     {
 596         String nm = fn[i];
 597         DatasetParams params;
 598         String sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str());
 599         String uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str());
 600         datasetsParams[nm] = params;
 601     }
 602     return cvtest::TS::OK;
 603 }
 604
 605 int CV_StereoMatchingTest::readRunParams( FileStorage& fs )
 606 {
 607     if( !fs.isOpened() )
 608     {
 609         ts->printf( cvtest::TS::LOG, "runParams can not be read " );
 610         return cvtest::TS::FAIL_INVALID_TEST_DATA;
 611     }
 612     caseNames.clear();;
 613     caseDatasets.clear();
 614     return cvtest::TS::OK;
 615 }
 616
 617 void CV_StereoMatchingTest::writeErrors( const string& errName, const vector<float>& errors, FileStorage* fs )
 618 {
 619     assert( (int)errors.size() == ERROR_KINDS_COUNT );
 620     vector<float>::const_iterator it = errors.begin();
 621     if( fs )
 622         for( int i = 0; i < ERROR_KINDS_COUNT; i++, ++it )
 623             *fs << ERROR_PREFIXES[i] + errName << *it;
 624     else
 625         for( int i = 0; i < ERROR_KINDS_COUNT; i++, ++it )
 626             ts->printf( cvtest::TS::LOG, "%s = %f\n", string(ERROR_PREFIXES[i]+errName).c_str(), *it );
 627 }
 628
 629 void CV_StereoMatchingTest::readErrors( FileNode& fn, const string& errName, vector<float>& errors )
 630 {
 631     errors.resize( ERROR_KINDS_COUNT );
 632     vector<float>::iterator it = errors.begin();
 633     for( int i = 0; i < ERROR_KINDS_COUNT; i++, ++it )
 634         fn[ERROR_PREFIXES[i]+errName] >> *it;
 635 }
 636
 637 int CV_StereoMatchingTest::compareErrors( const vector<float>& calcErrors, const vector<float>& validErrors,
 638                    const vector<float>& eps, const string& errName )
 639 {
 640     assert( (int)calcErrors.size() == ERROR_KINDS_COUNT );
 641     assert( (int)validErrors.size() == ERROR_KINDS_COUNT );
 642     assert( (int)eps.size() == ERROR_KINDS_COUNT );
 643     vector<float>::const_iterator calcIt = calcErrors.begin(),
 644                                   validIt = validErrors.begin(),
 645                                   epsIt = eps.begin();
 646     bool ok = true;
 647     for( int i = 0; i < ERROR_KINDS_COUNT; i++, ++calcIt, ++validIt, ++epsIt )
 648         if( *calcIt - *validIt > *epsIt )
 649         {
 650             ts->printf( cvtest::TS::LOG, "bad accuracy of %s (valid=%f; calc=%f)\n", string(ERROR_PREFIXES[i]+errName).c_str(), *validIt, *calcIt );
 651             ok = false;
 652         }
 653     return ok ? cvtest::TS::OK : cvtest::TS::FAIL_BAD_ACCURACY;
 654 }
 655
 656 //----------------------------------- StereoGC test -----------------------------------------------------
 657
 658 class CV_StereoGCTest : public CV_StereoMatchingTest
 659 {
 660 public:
 661     CV_StereoGCTest()
 662     {
 663         name = "stereogc";
 664         fill(rmsEps.begin(), rmsEps.end(), 3.f);
 665         fracEps[0] = 0.05f; // all
 666         fracEps[1] = 0.05f; // noOccl
 667         fracEps[2] = 0.25f; // occl
 668         fracEps[3] = 0.05f; // textured
 669         fracEps[4] = 0.10f; // textureless
 670         fracEps[5] = 0.10f; // borderedDepthDiscont
 671     }
 672 protected:
 673     struct RunParams
 674     {
 675         int ndisp;
 676         int iterCount;
 677     };
 678     vector<RunParams> caseRunParams;
 679
 680     virtual int readRunParams( FileStorage& fs )
 681     {
 682         int code = CV_StereoMatchingTest::readRunParams(fs);
 683         FileNode fn = fs.getFirstTopLevelNode();
 684         assert(fn.isSeq());
 685         for( int i = 0; i < (int)fn.size(); i+=4 )
 686         {
 687             String caseName = fn[i], datasetName = fn[i+1];
 688             RunParams params;
 689             String ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str());
 690             String iterCount = fn[i+3]; params.iterCount = atoi(iterCount.c_str());
 691             caseNames.push_back( caseName );
 692             caseDatasets.push_back( datasetName );
 693             caseRunParams.push_back( params );
 694         }
 695         return code;
 696     }
 697
 698     virtual int runStereoMatchingAlgorithm( const Mat& _leftImg, const Mat& _rightImg,
 699                    Mat& leftDisp, Mat& rightDisp, int caseIdx )
 700     {
 701         RunParams params = caseRunParams[caseIdx];
 702         assert( _leftImg.type() == CV_8UC3 && _rightImg.type() == CV_8UC3 );
 703         Mat leftImg, rightImg, tmp;
 704         cvtColor( _leftImg, leftImg, CV_BGR2GRAY );
 705         cvtColor( _rightImg, rightImg, CV_BGR2GRAY );
 706
 707         leftDisp.create( leftImg.size(), CV_16SC1 );
 708         rightDisp.create( rightImg.size(), CV_16SC1 );
 709
 710         CvMat _limg = leftImg, _rimg = rightImg, _ldisp = leftDisp, _rdisp = rightDisp;
 711         CvStereoGCState *state = cvCreateStereoGCState( params.ndisp, params.iterCount );
 712         cvFindStereoCorrespondenceGC( &_limg, &_rimg, &_ldisp, &_rdisp, state );
 713         cvReleaseStereoGCState( &state );
 714
 715         leftDisp = - leftDisp;
 716         return 0;
 717     }
 718
 719 };
 720
 721
 722 TEST(Legacy_StereoGC, regression) { CV_StereoGCTest test; test.safe_run(); }