opencv/opencv_contrib
1
0
Fork 0
mirror of https://github.com/opencv/opencv_contrib.git synced 2025-10-19 11:21:39 +08:00
Code Issues Releases Wiki Activity
Files
master
opencv_contrib/modules/cudastereo/test/test_stereo.cpp
Alexander Smorkalov 3fa3b52191 Fixed array initialization in cuda::stereoBM.
2021-12-20 16:01:02 +03:00

1048 lines
38 KiB
C++
Raw Permalink Blame History

/*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 "test_precomp.hpp"
#ifdef HAVE_CUDA
namespace opencv_test { namespace {
//////////////////////////////////////////////////////////////////////////
// StereoBM
struct StereoBM : testing::TestWithParam<cv::cuda::DeviceInfo>
{
cv::cuda::DeviceInfo devInfo;
virtual void SetUp()
{
devInfo = GetParam();
cv::cuda::setDevice(devInfo.deviceID());
}
};
CUDA_TEST_P(StereoBM, Regression)
{
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
cv::Mat disp_gold = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::StereoBM> bm = cv::cuda::createStereoBM(128, 19);
cv::cuda::GpuMat disp;
bm->compute(loadMat(left_image), loadMat(right_image), disp);
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
CUDA_TEST_P(StereoBM, PrefilterXSobelRegression)
{
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
cv::Mat disp_gold = readImage("stereobm/aloe-disp-prefilter-xsobel.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::StereoBM> bm = cv::cuda::createStereoBM(128, 19);
cv::cuda::GpuMat disp;
bm->setPreFilterType(cv::StereoBM::PREFILTER_XSOBEL);
bm->compute(loadMat(left_image), loadMat(right_image), disp);
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
CUDA_TEST_P(StereoBM, PrefilterNormRegression)
{
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
cv::Mat disp_gold = readImage("stereobm/aloe-disp-prefilter-norm.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::StereoBM> bm = cv::cuda::createStereoBM(128, 19);
cv::cuda::GpuMat disp;
bm->setPreFilterType(cv::StereoBM::PREFILTER_NORMALIZED_RESPONSE);
bm->setPreFilterSize(9);
bm->compute(loadMat(left_image), loadMat(right_image), disp);
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
CUDA_TEST_P(StereoBM, Streams)
{
cv::cuda::Stream stream;
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
cv::Mat disp_gold = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::cuda::StereoBM> bm = cv::cuda::createStereoBM(128, 19);
cv::cuda::GpuMat disp;
bm->compute(loadMat(left_image), loadMat(right_image), disp, stream);
stream.waitForCompletion();
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
CUDA_TEST_P(StereoBM, Uniqueness_Regression)
{
cv::Mat left_image = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
cv::Mat disp_gold = readImage("stereobm/aloe-disp-uniqueness15.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::StereoBM> bm = cv::cuda::createStereoBM(128, 19);
cv::cuda::GpuMat disp;
bm->setUniquenessRatio(15);
bm->compute(loadMat(left_image), loadMat(right_image), disp);
EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
}
INSTANTIATE_TEST_CASE_P(CUDA_Stereo, StereoBM, ALL_DEVICES);
//////////////////////////////////////////////////////////////////////////
// StereoBeliefPropagation
struct StereoBeliefPropagation : testing::TestWithParam<cv::cuda::DeviceInfo>
{
cv::cuda::DeviceInfo devInfo;
virtual void SetUp()
{
devInfo = GetParam();
cv::cuda::setDevice(devInfo.deviceID());
}
};
CUDA_TEST_P(StereoBeliefPropagation, Regression)
{
cv::Mat left_image = readImage("stereobp/aloe-L.png");
cv::Mat right_image = readImage("stereobp/aloe-R.png");
cv::Mat disp_gold = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::cuda::StereoBeliefPropagation> bp = cv::cuda::createStereoBeliefPropagation(64, 8, 2, CV_16S);
bp->setMaxDataTerm(25.0);
bp->setDataWeight(0.1);
bp->setMaxDiscTerm(15.0);
bp->setDiscSingleJump(1.0);
cv::cuda::GpuMat disp;
bp->compute(loadMat(left_image), loadMat(right_image), disp);
cv::Mat h_disp(disp);
h_disp.convertTo(h_disp, disp_gold.depth());
EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
}
INSTANTIATE_TEST_CASE_P(CUDA_Stereo, StereoBeliefPropagation, ALL_DEVICES);
//////////////////////////////////////////////////////////////////////////
// StereoConstantSpaceBP
struct StereoConstantSpaceBP : testing::TestWithParam<cv::cuda::DeviceInfo>
{
cv::cuda::DeviceInfo devInfo;
virtual void SetUp()
{
devInfo = GetParam();
cv::cuda::setDevice(devInfo.deviceID());
}
};
CUDA_TEST_P(StereoConstantSpaceBP, Regression)
{
cv::Mat left_image = readImage("csstereobp/aloe-L.png");
cv::Mat right_image = readImage("csstereobp/aloe-R.png");
cv::Mat disp_gold;
if (supportFeature(devInfo, cv::cuda::FEATURE_SET_COMPUTE_20))
disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
else
disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
ASSERT_FALSE(left_image.empty());
ASSERT_FALSE(right_image.empty());
ASSERT_FALSE(disp_gold.empty());
cv::Ptr<cv::cuda::StereoConstantSpaceBP> csbp = cv::cuda::createStereoConstantSpaceBP(128, 16, 4, 4);
cv::cuda::GpuMat disp;
csbp->compute(loadMat(left_image), loadMat(right_image), disp);
cv::Mat h_disp(disp);
h_disp.convertTo(h_disp, disp_gold.depth());
EXPECT_MAT_SIMILAR(disp_gold, h_disp, 1e-4);
}
INSTANTIATE_TEST_CASE_P(CUDA_Stereo, StereoConstantSpaceBP, ALL_DEVICES);
////////////////////////////////////////////////////////////////////////////////
// reprojectImageTo3D
PARAM_TEST_CASE(ReprojectImageTo3D, cv::cuda::DeviceInfo, cv::Size, MatDepth, UseRoi)
{
cv::cuda::DeviceInfo devInfo;
cv::Size size;
int depth;
bool useRoi;
virtual void SetUp()
{
devInfo = GET_PARAM(0);
size = GET_PARAM(1);
depth = GET_PARAM(2);
useRoi = GET_PARAM(3);
cv::cuda::setDevice(devInfo.deviceID());
}
};
CUDA_TEST_P(ReprojectImageTo3D, Accuracy)
{
cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
cv::cuda::GpuMat dst;
cv::cuda::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
cv::Mat dst_gold;
cv::reprojectImageTo3D(disp, dst_gold, Q, false);
EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
}
INSTANTIATE_TEST_CASE_P(CUDA_Stereo, ReprojectImageTo3D, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatDepth(CV_8U), MatDepth(CV_16S)),
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
// StereoSGM
/*
This is a regression test for stereo matching algorithms. This test gets some quality metrics
described in "A Taxonomy and Evaluation of Dense Two-Frame Stereo Correspondence Algorithms".
Daniel Scharstein, Richard Szeliski
*/
const float EVAL_BAD_THRESH = 1.f;
const int EVAL_TEXTURELESS_WIDTH = 3;
const float EVAL_TEXTURELESS_THRESH = 4.f;
const float EVAL_DISP_THRESH = 1.f;
const float EVAL_DISP_GAP = 2.f;
const int EVAL_DISCONT_WIDTH = 9;
const int EVAL_IGNORE_BORDER = 10;
const int ERROR_KINDS_COUNT = 6;
//============================== quality measuring functions =================================================
/*
Calculate textureless regions of image (regions where the squared horizontal intensity gradient averaged over
a square window of size=evalTexturelessWidth is below a threshold=evalTexturelessThresh) and textured regions.
*/
void computeTextureBasedMasks(const Mat& _img, Mat* texturelessMask, Mat* texturedMask,
int texturelessWidth = EVAL_TEXTURELESS_WIDTH, float texturelessThresh = EVAL_TEXTURELESS_THRESH)
{
if (!texturelessMask && !texturedMask)
return;
if (_img.empty())
CV_Error(Error::StsBadArg, "img is empty");
Mat img = _img;
if (_img.channels() > 1)
{
Mat tmp; cvtColor(_img, tmp, COLOR_BGR2GRAY); img = tmp;
}
Mat dxI; Sobel(img, dxI, CV_32FC1, 1, 0, 3);
Mat dxI2; pow(dxI / 8.f/*normalize*/, 2, dxI2);
Mat avgDxI2; boxFilter(dxI2, avgDxI2, CV_32FC1, Size(texturelessWidth, texturelessWidth));
if (texturelessMask)
*texturelessMask = avgDxI2 < texturelessThresh;
if (texturedMask)
*texturedMask = avgDxI2 >= texturelessThresh;
}
void checkTypeAndSizeOfDisp(const Mat& dispMap, const Size* sz)
{
if (dispMap.empty())
CV_Error(Error::StsBadArg, "dispMap is empty");
if (dispMap.type() != CV_32FC1)
CV_Error(Error::StsBadArg, "dispMap must have CV_32FC1 type");
if (sz && (dispMap.rows != sz->height || dispMap.cols != sz->width))
CV_Error(Error::StsBadArg, "dispMap has incorrect size");
}
void checkTypeAndSizeOfMask(const Mat& mask, Size sz)
{
if (mask.empty())
CV_Error(Error::StsBadArg, "mask is empty");
if (mask.type() != CV_8UC1)
CV_Error(Error::StsBadArg, "mask must have CV_8UC1 type");
if (mask.rows != sz.height || mask.cols != sz.width)
CV_Error(Error::StsBadArg, "mask has incorrect size");
}
void checkDispMapsAndUnknDispMasks(const Mat& leftDispMap, const Mat& rightDispMap,
const Mat& leftUnknDispMask, const Mat& rightUnknDispMask)
{
// check type and size of disparity maps
checkTypeAndSizeOfDisp(leftDispMap, 0);
if (!rightDispMap.empty())
{
Size sz = leftDispMap.size();
checkTypeAndSizeOfDisp(rightDispMap, &sz);
}
// check size and type of unknown disparity maps
if (!leftUnknDispMask.empty())
checkTypeAndSizeOfMask(leftUnknDispMask, leftDispMap.size());
if (!rightUnknDispMask.empty())
checkTypeAndSizeOfMask(rightUnknDispMask, rightDispMap.size());
// check values of disparity maps (known disparity values musy be positive)
double leftMinVal = 0, rightMinVal = 0;
if (leftUnknDispMask.empty())
minMaxLoc(leftDispMap, &leftMinVal);
else
minMaxLoc(leftDispMap, &leftMinVal, 0, 0, 0, ~leftUnknDispMask);
if (!rightDispMap.empty())
{
if (rightUnknDispMask.empty())
minMaxLoc(rightDispMap, &rightMinVal);
else
minMaxLoc(rightDispMap, &rightMinVal, 0, 0, 0, ~rightUnknDispMask);
}
if (leftMinVal < 0 || rightMinVal < 0)
CV_Error(Error::StsBadArg, "known disparity values must be positive");
}
/*
Calculate occluded regions of reference image (left image) (regions that are occluded in the matching image (right image),
i.e., where the forward-mapped disparity lands at a location with a larger (nearer) disparity) and non occluded regions.
*/
void computeOcclusionBasedMasks(const Mat& leftDisp, const Mat& _rightDisp,
Mat* occludedMask, Mat* nonOccludedMask,
const Mat& leftUnknDispMask = Mat(), const Mat& rightUnknDispMask = Mat(),
float dispThresh = EVAL_DISP_THRESH)
{
if (!occludedMask && !nonOccludedMask)
return;
checkDispMapsAndUnknDispMasks(leftDisp, _rightDisp, leftUnknDispMask, rightUnknDispMask);
Mat rightDisp;
if (_rightDisp.empty())
{
if (!rightUnknDispMask.empty())
CV_Error(Error::StsBadArg, "rightUnknDispMask must be empty if _rightDisp is empty");
rightDisp.create(leftDisp.size(), CV_32FC1);
rightDisp.setTo(Scalar::all(0));
for (int leftY = 0; leftY < leftDisp.rows; leftY++)
{
for (int leftX = 0; leftX < leftDisp.cols; leftX++)
{
if (!leftUnknDispMask.empty() && leftUnknDispMask.at<uchar>(leftY, leftX))
continue;
float leftDispVal = leftDisp.at<float>(leftY, leftX);
int rightX = leftX - cvRound(leftDispVal), rightY = leftY;
if (rightX >= 0)
rightDisp.at<float>(rightY, rightX) = max(rightDisp.at<float>(rightY, rightX), leftDispVal);
}
}
}
else
_rightDisp.copyTo(rightDisp);
if (occludedMask)
{
occludedMask->create(leftDisp.size(), CV_8UC1);
occludedMask->setTo(Scalar::all(0));
}
if (nonOccludedMask)
{
nonOccludedMask->create(leftDisp.size(), CV_8UC1);
nonOccludedMask->setTo(Scalar::all(0));
}
for (int leftY = 0; leftY < leftDisp.rows; leftY++)
{
for (int leftX = 0; leftX < leftDisp.cols; leftX++)
{
if (!leftUnknDispMask.empty() && leftUnknDispMask.at<uchar>(leftY, leftX))
continue;
float leftDispVal = leftDisp.at<float>(leftY, leftX);
int rightX = leftX - cvRound(leftDispVal), rightY = leftY;
if (rightX < 0 && occludedMask)
occludedMask->at<uchar>(leftY, leftX) = 255;
else
{
if (!rightUnknDispMask.empty() && rightUnknDispMask.at<uchar>(rightY, rightX))
continue;
float rightDispVal = rightDisp.at<float>(rightY, rightX);
if (rightDispVal > leftDispVal + dispThresh)
{
if (occludedMask)
occludedMask->at<uchar>(leftY, leftX) = 255;
}
else
{
if (nonOccludedMask)
nonOccludedMask->at<uchar>(leftY, leftX) = 255;
}
}
}
}
}
/*
Calculate depth discontinuty regions: pixels whose neiboring disparities differ by more than
dispGap, dilated by window of width discontWidth.
*/
void computeDepthDiscontMask(const Mat& disp, Mat& depthDiscontMask, const Mat& unknDispMask = Mat(),
float dispGap = EVAL_DISP_GAP, int discontWidth = EVAL_DISCONT_WIDTH)
{
if (disp.empty())
CV_Error(Error::StsBadArg, "disp is empty");
if (disp.type() != CV_32FC1)
CV_Error(Error::StsBadArg, "disp must have CV_32FC1 type");
if (!unknDispMask.empty())
checkTypeAndSizeOfMask(unknDispMask, disp.size());
Mat curDisp; disp.copyTo(curDisp);
if (!unknDispMask.empty())
curDisp.setTo(Scalar(std::numeric_limits<float>::min()), unknDispMask);
Mat maxNeighbDisp; dilate(curDisp, maxNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)));
if (!unknDispMask.empty())
curDisp.setTo(Scalar(std::numeric_limits<float>::max()), unknDispMask);
Mat minNeighbDisp; erode(curDisp, minNeighbDisp, Mat(3, 3, CV_8UC1, Scalar(1)));
depthDiscontMask = max((Mat)(maxNeighbDisp - disp), (Mat)(disp - minNeighbDisp)) > dispGap;
if (!unknDispMask.empty())
depthDiscontMask &= ~unknDispMask;
dilate(depthDiscontMask, depthDiscontMask, Mat(discontWidth, discontWidth, CV_8UC1, Scalar(1)));
}
/*
Get evaluation masks excluding a border.
*/
Mat getBorderedMask(Size maskSize, int border = EVAL_IGNORE_BORDER)
{
CV_Assert(border >= 0);
Mat mask(maskSize, CV_8UC1, Scalar(0));
int w = maskSize.width - 2 * border, h = maskSize.height - 2 * border;
if (w < 0 || h < 0)
mask.setTo(Scalar(0));
else
mask(Rect(Point(border, border), Size(w, h))).setTo(Scalar(255));
return mask;
}
/*
Calculate root-mean-squared error between the computed disparity map (computedDisp) and ground truth map (groundTruthDisp).
*/
float dispRMS(const Mat& computedDisp, const Mat& groundTruthDisp, const Mat& mask)
{
checkTypeAndSizeOfDisp(groundTruthDisp, 0);
Size sz = groundTruthDisp.size();
checkTypeAndSizeOfDisp(computedDisp, &sz);
int pointsCount = sz.height*sz.width;
if (!mask.empty())
{
checkTypeAndSizeOfMask(mask, sz);
pointsCount = countNonZero(mask);
}
return 1.f / sqrt((float)pointsCount) * (float)cvtest::norm(computedDisp, groundTruthDisp, NORM_L2, mask);
}
/*
Calculate fraction of bad matching pixels.
*/
float badMatchPxlsFraction(const Mat& computedDisp, const Mat& groundTruthDisp, const Mat& mask,
float _badThresh = EVAL_BAD_THRESH)
{
int badThresh = cvRound(_badThresh);
checkTypeAndSizeOfDisp(groundTruthDisp, 0);
Size sz = groundTruthDisp.size();
checkTypeAndSizeOfDisp(computedDisp, &sz);
Mat badPxlsMap;
absdiff(computedDisp, groundTruthDisp, badPxlsMap);
badPxlsMap = badPxlsMap > badThresh;
int pointsCount = sz.height*sz.width;
if (!mask.empty())
{
checkTypeAndSizeOfMask(mask, sz);
badPxlsMap = badPxlsMap & mask;
pointsCount = countNonZero(mask);
}
return 1.f / pointsCount * countNonZero(badPxlsMap);
}
//===================== regression test for stereo matching algorithms ==============================
const string ALGORITHMS_DIR = "stereomatching/algorithms/";
const string DATASETS_DIR = "stereomatching/datasets/";
const string DATASETS_FILE = "datasets.xml";
const string RUN_PARAMS_FILE = "_params.xml";
const string RESULT_FILE = "_res.xml";
const string LEFT_IMG_NAME = "im2.png";
const string RIGHT_IMG_NAME = "im6.png";
const string TRUE_LEFT_DISP_NAME = "disp2.png";
const string TRUE_RIGHT_DISP_NAME = "disp6.png";
string ERROR_PREFIXES[] = { "borderedAll",
"borderedNoOccl",
"borderedOccl",
"borderedTextured",
"borderedTextureless",
"borderedDepthDiscont" }; // size of ERROR_KINDS_COUNT
string ROI_PREFIXES[] = { "roiX",
"roiY",
"roiWidth",
"roiHeight" };
const string RMS_STR = "RMS";
const string BAD_PXLS_FRACTION_STR = "BadPxlsFraction";
const string ROI_STR = "ValidDisparityROI";
class QualityEvalParams
{
public:
QualityEvalParams()
{
setDefaults();
}
QualityEvalParams(int _ignoreBorder)
{
setDefaults();
ignoreBorder = _ignoreBorder;
}
void setDefaults()
{
badThresh = EVAL_BAD_THRESH;
texturelessWidth = EVAL_TEXTURELESS_WIDTH;
texturelessThresh = EVAL_TEXTURELESS_THRESH;
dispThresh = EVAL_DISP_THRESH;
dispGap = EVAL_DISP_GAP;
discontWidth = EVAL_DISCONT_WIDTH;
ignoreBorder = EVAL_IGNORE_BORDER;
}
float badThresh;
int texturelessWidth;
float texturelessThresh;
float dispThresh;
float dispGap;
int discontWidth;
int ignoreBorder;
};
class CV_StereoMatchingTest : public cvtest::BaseTest
{
public:
CV_StereoMatchingTest()
{
rmsEps.resize(ERROR_KINDS_COUNT, 0.01f); fracEps.resize(ERROR_KINDS_COUNT, 1.e-6f);
}
protected:
// assumed that left image is a reference image
virtual int runStereoMatchingAlgorithm(const Mat& leftImg, const Mat& rightImg,
Rect& calcROI, Mat& leftDisp, Mat& rightDisp, int caseIdx) = 0; // return ignored border width
int readDatasetsParams(FileStorage& fs);
virtual int readRunParams(FileStorage& fs);
void writeErrors(const string& errName, const vector<float>& errors, FileStorage* fs = 0);
void writeROI(const Rect& calcROI, FileStorage* fs = 0);
void readErrors(FileNode& fn, const string& errName, vector<float>& errors);
void readROI(FileNode& fn, Rect& trueROI);
int compareErrors(const vector<float>& calcErrors, const vector<float>& validErrors,
const vector<float>& eps, const string& errName);
int compareROI(const Rect& calcROI, const Rect& validROI);
int processStereoMatchingResults(FileStorage& fs, int caseIdx, bool isWrite,
const Mat& leftImg, const Mat& rightImg,
const Rect& calcROI,
const Mat& trueLeftDisp, const Mat& trueRightDisp,
const Mat& leftDisp, const Mat& rightDisp,
const QualityEvalParams& qualityEvalParams);
void run(int);
vector<float> rmsEps;
vector<float> fracEps;
struct DatasetParams
{
int dispScaleFactor;
int dispUnknVal;
};
map<string, DatasetParams> datasetsParams;
vector<string> caseNames;
vector<string> caseDatasets;
};
void CV_StereoMatchingTest::run(int)
{
addDataSearchSubDirectory("cv");
string algorithmName = name;
assert(!algorithmName.empty());
FileStorage datasetsFS(findDataFile(DATASETS_DIR + DATASETS_FILE), FileStorage::READ);
int code = readDatasetsParams(datasetsFS);
if (code != cvtest::TS::OK)
{
ts->set_failed_test_info(code);
return;
}
FileStorage runParamsFS(findDataFile(ALGORITHMS_DIR + algorithmName + RUN_PARAMS_FILE), FileStorage::READ);
code = readRunParams(runParamsFS);
if (code != cvtest::TS::OK)
{
ts->set_failed_test_info(code);
return;
}
string fullResultFilename = findDataDirectory(ALGORITHMS_DIR) + algorithmName + RESULT_FILE;
FileStorage resFS(fullResultFilename, FileStorage::READ);
bool isWrite = true; // write or compare results
if (resFS.isOpened())
isWrite = false;
else
{
resFS.open(fullResultFilename, FileStorage::WRITE);
if (!resFS.isOpened())
{
ts->printf(cvtest::TS::LOG, "file %s can not be read or written\n", fullResultFilename.c_str());
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ARG_CHECK);
return;
}
resFS << "stereo_matching" << "{";
}
int progress = 0, caseCount = (int)caseNames.size();
for (int ci = 0; ci < caseCount; ci++)
{
progress = update_progress(progress, ci, caseCount, 0);
printf("progress: %d%%\n", progress);
fflush(stdout);
string datasetName = caseDatasets[ci];
string datasetFullDirName = findDataDirectory(DATASETS_DIR) + datasetName + "/";
Mat leftImg = imread(datasetFullDirName + LEFT_IMG_NAME);
Mat rightImg = imread(datasetFullDirName + RIGHT_IMG_NAME);
Mat trueLeftDisp = imread(datasetFullDirName + TRUE_LEFT_DISP_NAME, 0);
Mat trueRightDisp = imread(datasetFullDirName + TRUE_RIGHT_DISP_NAME, 0);
Rect calcROI;
if (leftImg.empty() || rightImg.empty() || trueLeftDisp.empty())
{
ts->printf(cvtest::TS::LOG, "images or left ground-truth disparities of dataset %s can not be read", datasetName.c_str());
code = cvtest::TS::FAIL_INVALID_TEST_DATA;
continue;
}
int dispScaleFactor = datasetsParams[datasetName].dispScaleFactor;
Mat tmp;
trueLeftDisp.convertTo(tmp, CV_32FC1, 1.f / dispScaleFactor);
trueLeftDisp = tmp;
tmp.release();
if (!trueRightDisp.empty())
{
trueRightDisp.convertTo(tmp, CV_32FC1, 1.f / dispScaleFactor);
trueRightDisp = tmp;
tmp.release();
}
Mat leftDisp, rightDisp;
int ignBorder = max(runStereoMatchingAlgorithm(leftImg, rightImg, calcROI, leftDisp, rightDisp, ci), EVAL_IGNORE_BORDER);
leftDisp.convertTo(tmp, CV_32FC1);
leftDisp = tmp;
tmp.release();
rightDisp.convertTo(tmp, CV_32FC1);
rightDisp = tmp;
tmp.release();
int tempCode = processStereoMatchingResults(resFS, ci, isWrite,
leftImg, rightImg, calcROI, trueLeftDisp, trueRightDisp, leftDisp, rightDisp, QualityEvalParams(ignBorder));
code = tempCode == cvtest::TS::OK ? code : tempCode;
}
if (isWrite)
resFS << "}"; // "stereo_matching"
ts->set_failed_test_info(code);
}
void calcErrors(const Mat& leftImg, const Mat& /*rightImg*/,
const Mat& trueLeftDisp, const Mat& trueRightDisp,
const Mat& trueLeftUnknDispMask, const Mat& trueRightUnknDispMask,
const Mat& calcLeftDisp, const Mat& /*calcRightDisp*/,
vector<float>& rms, vector<float>& badPxlsFractions,
const QualityEvalParams& qualityEvalParams)
{
Mat texturelessMask, texturedMask;
computeTextureBasedMasks(leftImg, &texturelessMask, &texturedMask,
qualityEvalParams.texturelessWidth, qualityEvalParams.texturelessThresh);
Mat occludedMask, nonOccludedMask;
computeOcclusionBasedMasks(trueLeftDisp, trueRightDisp, &occludedMask, &nonOccludedMask,
trueLeftUnknDispMask, trueRightUnknDispMask, qualityEvalParams.dispThresh);
Mat depthDiscontMask;
computeDepthDiscontMask(trueLeftDisp, depthDiscontMask, trueLeftUnknDispMask,
qualityEvalParams.dispGap, qualityEvalParams.discontWidth);
Mat borderedKnownMask = getBorderedMask(leftImg.size(), qualityEvalParams.ignoreBorder) & ~trueLeftUnknDispMask;
nonOccludedMask &= borderedKnownMask;
occludedMask &= borderedKnownMask;
texturedMask &= nonOccludedMask; // & borderedKnownMask
texturelessMask &= nonOccludedMask; // & borderedKnownMask
depthDiscontMask &= nonOccludedMask; // & borderedKnownMask
rms.resize(ERROR_KINDS_COUNT);
rms[0] = dispRMS(calcLeftDisp, trueLeftDisp, borderedKnownMask);
rms[1] = dispRMS(calcLeftDisp, trueLeftDisp, nonOccludedMask);
rms[2] = dispRMS(calcLeftDisp, trueLeftDisp, occludedMask);
rms[3] = dispRMS(calcLeftDisp, trueLeftDisp, texturedMask);
rms[4] = dispRMS(calcLeftDisp, trueLeftDisp, texturelessMask);
rms[5] = dispRMS(calcLeftDisp, trueLeftDisp, depthDiscontMask);
badPxlsFractions.resize(ERROR_KINDS_COUNT);
badPxlsFractions[0] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, borderedKnownMask, qualityEvalParams.badThresh);
badPxlsFractions[1] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, nonOccludedMask, qualityEvalParams.badThresh);
badPxlsFractions[2] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, occludedMask, qualityEvalParams.badThresh);
badPxlsFractions[3] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, texturedMask, qualityEvalParams.badThresh);
badPxlsFractions[4] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, texturelessMask, qualityEvalParams.badThresh);
badPxlsFractions[5] = badMatchPxlsFraction(calcLeftDisp, trueLeftDisp, depthDiscontMask, qualityEvalParams.badThresh);
}
int CV_StereoMatchingTest::processStereoMatchingResults(FileStorage& fs, int caseIdx, bool isWrite,
const Mat& leftImg, const Mat& rightImg,
const Rect& calcROI,
const Mat& trueLeftDisp, const Mat& trueRightDisp,
const Mat& leftDisp, const Mat& rightDisp,
const QualityEvalParams& qualityEvalParams)
{
// rightDisp is not used in current test virsion
int code = cvtest::TS::OK;
assert(fs.isOpened());
assert(trueLeftDisp.type() == CV_32FC1);
assert(trueRightDisp.empty() || trueRightDisp.type() == CV_32FC1);
assert(leftDisp.type() == CV_32FC1 && (rightDisp.empty() || rightDisp.type() == CV_32FC1));
// get masks for unknown ground truth disparity values
Mat leftUnknMask, rightUnknMask;
DatasetParams params = datasetsParams[caseDatasets[caseIdx]];
absdiff(trueLeftDisp, Scalar(params.dispUnknVal), leftUnknMask);
leftUnknMask = leftUnknMask < std::numeric_limits<float>::epsilon();
assert(leftUnknMask.type() == CV_8UC1);
if (!trueRightDisp.empty())
{
absdiff(trueRightDisp, Scalar(params.dispUnknVal), rightUnknMask);
rightUnknMask = rightUnknMask < std::numeric_limits<float>::epsilon();
assert(rightUnknMask.type() == CV_8UC1);
}
// calculate errors
vector<float> rmss, badPxlsFractions;
calcErrors(leftImg, rightImg, trueLeftDisp, trueRightDisp, leftUnknMask, rightUnknMask,
leftDisp, rightDisp, rmss, badPxlsFractions, qualityEvalParams);
if (isWrite)
{
fs << caseNames[caseIdx] << "{";
fs.writeComment(RMS_STR, 0);
writeErrors(RMS_STR, rmss, &fs);
fs.writeComment(BAD_PXLS_FRACTION_STR, 0);
writeErrors(BAD_PXLS_FRACTION_STR, badPxlsFractions, &fs);
fs.writeComment(ROI_STR, 0);
writeROI(calcROI, &fs);
fs << "}"; // datasetName
}
else // compare
{
ts->printf(cvtest::TS::LOG, "\nquality of case named %s\n", caseNames[caseIdx].c_str());
ts->printf(cvtest::TS::LOG, "%s\n", RMS_STR.c_str());
writeErrors(RMS_STR, rmss);
ts->printf(cvtest::TS::LOG, "%s\n", BAD_PXLS_FRACTION_STR.c_str());
writeErrors(BAD_PXLS_FRACTION_STR, badPxlsFractions);
ts->printf(cvtest::TS::LOG, "%s\n", ROI_STR.c_str());
writeROI(calcROI);
FileNode fn = fs.getFirstTopLevelNode()[caseNames[caseIdx]];
vector<float> validRmss, validBadPxlsFractions;
Rect validROI;
readErrors(fn, RMS_STR, validRmss);
readErrors(fn, BAD_PXLS_FRACTION_STR, validBadPxlsFractions);
readROI(fn, validROI);
int tempCode = compareErrors(rmss, validRmss, rmsEps, RMS_STR);
code = tempCode == cvtest::TS::OK ? code : tempCode;
tempCode = compareErrors(badPxlsFractions, validBadPxlsFractions, fracEps, BAD_PXLS_FRACTION_STR);
code = tempCode == cvtest::TS::OK ? code : tempCode;
tempCode = compareROI(calcROI, validROI);
code = tempCode == cvtest::TS::OK ? code : tempCode;
}
return code;
}
int CV_StereoMatchingTest::readDatasetsParams(FileStorage& fs)
{
if (!fs.isOpened())
{
ts->printf(cvtest::TS::LOG, "datasetsParams can not be read ");
return cvtest::TS::FAIL_INVALID_TEST_DATA;
}
datasetsParams.clear();
FileNode fn = fs.getFirstTopLevelNode();
assert(fn.isSeq());
for (int i = 0; i < (int)fn.size(); i += 3)
{
String _name = fn[i];
DatasetParams params;
String sf = fn[i + 1]; params.dispScaleFactor = atoi(sf.c_str());
String uv = fn[i + 2]; params.dispUnknVal = atoi(uv.c_str());
datasetsParams[_name] = params;
}
return cvtest::TS::OK;
}
int CV_StereoMatchingTest::readRunParams(FileStorage& fs)
{
if (!fs.isOpened())
{
ts->printf(cvtest::TS::LOG, "runParams can not be read ");
return cvtest::TS::FAIL_INVALID_TEST_DATA;
}
caseNames.clear();;
caseDatasets.clear();
return cvtest::TS::OK;
}
void CV_StereoMatchingTest::writeErrors(const string& errName, const vector<float>& errors, FileStorage* fs)
{
assert((int)errors.size() == ERROR_KINDS_COUNT);
vector<float>::const_iterator it = errors.begin();
if (fs)
for (int i = 0; i < ERROR_KINDS_COUNT; i++, ++it)
*fs << ERROR_PREFIXES[i] + errName << *it;
else
for (int i = 0; i < ERROR_KINDS_COUNT; i++, ++it)
ts->printf(cvtest::TS::LOG, "%s = %f\n", string(ERROR_PREFIXES[i] + errName).c_str(), *it);
}
void CV_StereoMatchingTest::writeROI(const Rect& calcROI, FileStorage* fs)
{
if (fs)
{
*fs << ROI_PREFIXES[0] << calcROI.x;
*fs << ROI_PREFIXES[1] << calcROI.y;
*fs << ROI_PREFIXES[2] << calcROI.width;
*fs << ROI_PREFIXES[3] << calcROI.height;
}
else
{
ts->printf(cvtest::TS::LOG, "%s = %d\n", ROI_PREFIXES[0].c_str(), calcROI.x);
ts->printf(cvtest::TS::LOG, "%s = %d\n", ROI_PREFIXES[1].c_str(), calcROI.y);
ts->printf(cvtest::TS::LOG, "%s = %d\n", ROI_PREFIXES[2].c_str(), calcROI.width);
ts->printf(cvtest::TS::LOG, "%s = %d\n", ROI_PREFIXES[3].c_str(), calcROI.height);
}
}
void CV_StereoMatchingTest::readErrors(FileNode& fn, const string& errName, vector<float>& errors)
{
errors.resize(ERROR_KINDS_COUNT);
vector<float>::iterator it = errors.begin();
for (int i = 0; i < ERROR_KINDS_COUNT; i++, ++it)
fn[ERROR_PREFIXES[i] + errName] >> *it;
}
void CV_StereoMatchingTest::readROI(FileNode& fn, Rect& validROI)
{
fn[ROI_PREFIXES[0]] >> validROI.x;
fn[ROI_PREFIXES[1]] >> validROI.y;
fn[ROI_PREFIXES[2]] >> validROI.width;
fn[ROI_PREFIXES[3]] >> validROI.height;
}
int CV_StereoMatchingTest::compareErrors(const vector<float>& calcErrors, const vector<float>& validErrors,
const vector<float>& eps, const string& errName)
{
assert((int)calcErrors.size() == ERROR_KINDS_COUNT);
assert((int)validErrors.size() == ERROR_KINDS_COUNT);
assert((int)eps.size() == ERROR_KINDS_COUNT);
vector<float>::const_iterator calcIt = calcErrors.begin(),
validIt = validErrors.begin(),
epsIt = eps.begin();
bool ok = true;
for (int i = 0; i < ERROR_KINDS_COUNT; i++, ++calcIt, ++validIt, ++epsIt)
if (*calcIt - *validIt > *epsIt)
{
ts->printf(cvtest::TS::LOG, "bad accuracy of %s (valid=%f; calc=%f)\n", string(ERROR_PREFIXES[i] + errName).c_str(), *validIt, *calcIt);
ok = false;
}
return ok ? cvtest::TS::OK : cvtest::TS::FAIL_BAD_ACCURACY;
}
int CV_StereoMatchingTest::compareROI(const Rect& calcROI, const Rect& validROI)
{
int compare[4][2] = {
{ calcROI.x, validROI.x },
{ calcROI.y, validROI.y },
{ calcROI.width, validROI.width },
{ calcROI.height, validROI.height },
};
bool ok = true;
for (int i = 0; i < 4; i++)
{
if (compare[i][0] != compare[i][1])
{
ts->printf(cvtest::TS::LOG, "bad accuracy of %s (valid=%d; calc=%d)\n", ROI_PREFIXES[i].c_str(), compare[i][1], compare[i][0]);
ok = false;
}
}
return ok ? cvtest::TS::OK : cvtest::TS::FAIL_BAD_ACCURACY;
}
//----------------------------------- StereoSGM test -----------------------------------------------------
class CV_Cuda_StereoSGMTest : public CV_StereoMatchingTest
{
public:
CV_Cuda_StereoSGMTest()
{
name = "cuda_stereosgm";
fill(rmsEps.begin(), rmsEps.end(), 0.25f);
fill(fracEps.begin(), fracEps.end(), 0.01f);
}
protected:
struct RunParams
{
int ndisp;
int mode;
};
vector<RunParams> caseRunParams;
virtual int readRunParams(FileStorage& fs)
{
int code = CV_StereoMatchingTest::readRunParams(fs);
FileNode fn = fs.getFirstTopLevelNode();
assert(fn.isSeq());
for (int i = 0; i < (int)fn.size(); i += 4)
{
String caseName = fn[i], datasetName = fn[i + 1];
RunParams params;
String ndisp = fn[i + 2]; params.ndisp = atoi(ndisp.c_str());
String mode = fn[i + 3]; params.mode = atoi(mode.c_str());
caseNames.push_back(caseName);
caseDatasets.push_back(datasetName);
caseRunParams.push_back(params);
}
return code;
}
virtual int runStereoMatchingAlgorithm(const Mat& leftImg, const Mat& rightImg,
Rect& calcROI, Mat& leftDisp, Mat& /*rightDisp*/, int caseIdx)
{
RunParams params = caseRunParams[caseIdx];
assert(params.ndisp % 16 == 0);
Ptr<StereoMatcher> sgm = createStereoSGM(0, params.ndisp, 10, 120, 5, params.mode);
cv::Mat G1, G2;
cv::cvtColor(leftImg, G1, cv::COLOR_RGB2GRAY);
cv::cvtColor(rightImg, G2, cv::COLOR_RGB2GRAY);
cv::cuda::GpuMat d_leftImg, d_rightImg, d_leftDisp;
d_leftImg.upload(G1);
d_rightImg.upload(G2);
sgm->compute(d_leftImg, d_rightImg, d_leftDisp);
d_leftDisp.download(leftDisp);
CV_Assert(leftDisp.type() == CV_16SC1);
leftDisp.convertTo(leftDisp, CV_32FC1, 1.0 / StereoMatcher::DISP_SCALE);
calcROI.x = calcROI.y = 0;
calcROI.width = leftImg.cols;
calcROI.height = leftImg.rows;
return 0;
}
};
TEST(CudaStereo_StereoSGM, regression) { CV_Cuda_StereoSGMTest test; test.safe_run(); }
}} // namespace
#endif // HAVE_CUDA
Reference in New Issue View Git Blame Copy Permalink