stereo.hpp

/*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.




// 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*/








#ifndef __OPENCV_STEREO_HPP__




#define __OPENCV_STEREO_HPP__








#include "opencv2/core.hpp"




#include "opencv2/stereo/descriptor.hpp"




#include <opencv2/stereo/quasi_dense_stereo.hpp>








namespace

cv



{



namespace
stereo



{







class

StereoMatcher
:
public
Algorithm




{



public:



enum
{ DISP_SHIFT = 4,



DISP_SCALE = (1 << DISP_SHIFT)



};







virtual
void
compute( InputArray left, InputArray right,



OutputArray
disparity ) = 0;







virtual
int
getMinDisparity()
const
= 0;



virtual
void
setMinDisparity(int
minDisparity) = 0;







virtual
int
getNumDisparities()
const
= 0;



virtual
void
setNumDisparities(int
numDisparities) = 0;







virtual
int
getBlockSize()
const
= 0;



virtual
void
setBlockSize(int
blockSize) = 0;







virtual
int
getSpeckleWindowSize()
const
= 0;



virtual
void
setSpeckleWindowSize(int
speckleWindowSize) = 0;







virtual
int
getSpeckleRange()
const
= 0;



virtual
void
setSpeckleRange(int
speckleRange) = 0;







virtual
int
getDisp12MaxDiff()
const
= 0;



virtual
void
setDisp12MaxDiff(int
disp12MaxDiff) = 0;







};



enum
{



CV_SPECKLE_REMOVAL_ALGORITHM, CV_SPECKLE_REMOVAL_AVG_ALGORITHM



};



enum{



CV_QUADRATIC_INTERPOLATION, CV_SIMETRICV_INTERPOLATION



};



class

StereoBinaryBM
:
public
StereoMatcher




{



public:



enum
{ PREFILTER_NORMALIZED_RESPONSE = 0,



PREFILTER_XSOBEL              = 1



};







virtual
int
getPreFilterType()
const
= 0;



virtual
void
setPreFilterType(int
preFilterType) = 0;







virtual
int
getPreFilterSize()
const
= 0;



virtual
void
setPreFilterSize(int
preFilterSize) = 0;







virtual
int
getPreFilterCap()
const
= 0;



virtual
void
setPreFilterCap(int
preFilterCap) = 0;







virtual
int
getTextureThreshold()
const
= 0;



virtual
void
setTextureThreshold(int
textureThreshold) = 0;







virtual
int
getUniquenessRatio()
const
= 0;



virtual
void
setUniquenessRatio(int
uniquenessRatio) = 0;







virtual
int
getSmallerBlockSize()
const
= 0;



virtual
void
setSmallerBlockSize(int
blockSize) = 0;







virtual
int
getScalleFactor()
const
= 0 ;



virtual
void
setScalleFactor(int
factor) = 0;







virtual
int
getSpekleRemovalTechnique()
const
= 0 ;



virtual
void
setSpekleRemovalTechnique(int
factor) = 0;







virtual
bool
getUsePrefilter()
const
= 0 ;



virtual
void
setUsePrefilter(bool
factor) = 0;







virtual
int
getBinaryKernelType()
const
= 0;



virtual
void
setBinaryKernelType(int
value) = 0;







virtual
int
getAgregationWindowSize()
const
= 0;



virtual
void
setAgregationWindowSize(int
value) = 0;



CV_EXPORTS
static
Ptr< cv::stereo::StereoBinaryBM >
create(int
numDisparities = 0,
int
blockSize = 9);



};







class

StereoBinarySGBM
:
public
StereoMatcher




{



public:



enum




{



MODE_SGBM = 0,



MODE_HH   = 1



};







virtual
int
getPreFilterCap()
const
= 0;



virtual
void
setPreFilterCap(int
preFilterCap) = 0;







virtual
int
getUniquenessRatio()
const
= 0;



virtual
void
setUniquenessRatio(int
uniquenessRatio) = 0;







virtual
int
getP1()
const
= 0;



virtual
void
setP1(int
P1) = 0;







virtual
int
getP2()
const
= 0;



virtual
void
setP2(int
P2) = 0;







virtual
int
getMode()
const
= 0;



virtual
void
setMode(int
mode) = 0;







virtual
int
getSpekleRemovalTechnique()
const
= 0 ;



virtual
void
setSpekleRemovalTechnique(int
factor) = 0;







virtual
int
getBinaryKernelType()
const
= 0;



virtual
void
setBinaryKernelType(int
value) = 0;







virtual
int
getSubPixelInterpolationMethod()
const
= 0;



virtual
void
setSubPixelInterpolationMethod(int
value) = 0;







CV_EXPORTS
static
Ptr<cv::stereo::StereoBinarySGBM>
create(int
minDisparity,
int
numDisparities,
int
blockSize,



int
P1 = 100,
int
P2 = 1000,
int
disp12MaxDiff = 1,



int
preFilterCap = 0,
int
uniquenessRatio = 5,



int
speckleWindowSize = 400,
int
speckleRange = 200,



int
mode = StereoBinarySGBM::MODE_SGBM);



};



}//stereo



}
// cv








#endif