edge_filter.hpp

/*





*  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





*  (3 - clause BSD License)





*





*  Redistribution and use in source and binary forms, with or without modification,





*  are permitted provided that the following conditions are met :





*





*  * Redistributions of source code must retain the above copyright notice,





*  this list of conditions and the following disclaimer.





*





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





*





*  * Neither the names of the copyright holders nor the names of the contributors





*  may 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 copyright holders 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.





*/








#ifndef __OPENCV_EDGEFILTER_HPP__




#define __OPENCV_EDGEFILTER_HPP__




#ifdef __cplusplus








#include <opencv2/core.hpp>








namespace

cv



{



namespace
ximgproc


{











enum
EdgeAwareFiltersList


{



DTF_NC,



DTF_IC,



DTF_RF,







GUIDED_FILTER,



AM_FILTER


};











class
CV_EXPORTS_W DTFilter :
public
Algorithm


{



public:







CV_WRAP
virtual
void
filter(InputArray src, OutputArray dst,
int
dDepth = -1) = 0;


};






CV_EXPORTS_W


Ptr<DTFilter> createDTFilter(InputArray guide,
double
sigmaSpatial,
double
sigmaColor,
int
mode = DTF_NC,
int
numIters = 3);






CV_EXPORTS_W



void
dtFilter(InputArray guide, InputArray src, OutputArray dst,
double
sigmaSpatial,
double
sigmaColor,
int
mode = DTF_NC,
int
numIters = 3);











class
CV_EXPORTS_W GuidedFilter :
public
Algorithm


{



public:







CV_WRAP
virtual
void
filter(InputArray src, OutputArray dst,
int
dDepth = -1) = 0;


};






CV_EXPORTS_W Ptr<GuidedFilter> createGuidedFilter(InputArray guide,
int
radius,
double
eps);






CV_EXPORTS_W
void
guidedFilter(InputArray guide, InputArray src, OutputArray dst,
int
radius,
double
eps,
int
dDepth = -1);











class
CV_EXPORTS_W AdaptiveManifoldFilter :
public
Algorithm


{



public:



CV_WRAP
virtual
void
filter(InputArray src, OutputArray dst, InputArray joint = noArray()) = 0;







CV_WRAP
virtual
void
collectGarbage() = 0;







CV_WRAP
static
Ptr<AdaptiveManifoldFilter> create();







virtual
double
getSigmaS()
const
= 0;



virtual
void
setSigmaS(double
val) = 0;



virtual
double
getSigmaR()
const
= 0;



virtual
void
setSigmaR(double
val) = 0;



virtual
int
getTreeHeight()
const
= 0;



virtual
void
setTreeHeight(int
val) = 0;



virtual
int
getPCAIterations()
const
= 0;



virtual
void
setPCAIterations(int
val) = 0;



virtual
bool
getAdjustOutliers()
const
= 0;



virtual
void
setAdjustOutliers(bool
val) = 0;



virtual
bool
getUseRNG()
const
= 0;



virtual
void
setUseRNG(bool
val) = 0;


};






CV_EXPORTS_W Ptr<AdaptiveManifoldFilter> createAMFilter(double
sigma_s,
double
sigma_r,
bool
adjust_outliers =
false);






CV_EXPORTS_W
void
amFilter(InputArray joint, InputArray src, OutputArray dst,
double
sigma_s,
double
sigma_r,
bool
adjust_outliers =
false);










CV_EXPORTS_W



void
jointBilateralFilter(InputArray joint, InputArray src, OutputArray dst,
int
d,
double
sigmaColor,
double
sigmaSpace,
int
borderType =
BORDER_DEFAULT);






CV_EXPORTS_W



void
bilateralTextureFilter(InputArray src, OutputArray dst,
int
fr = 3,
int
numIter = 1,
double
sigmaAlpha = -1.,
double
sigmaAvg = -1.);










CV_EXPORTS_W



void
rollingGuidanceFilter(InputArray src, OutputArray dst,
int
d = -1,
double
sigmaColor = 25,
double
sigmaSpace = 3,
int
numOfIter = 4,
int
borderType =
BORDER_DEFAULT);











class
CV_EXPORTS_W FastBilateralSolverFilter :
public
Algorithm


{



public:



CV_WRAP
virtual
void
filter(InputArray src, InputArray confidence, OutputArray dst) = 0;


};






CV_EXPORTS_W Ptr<FastBilateralSolverFilter> createFastBilateralSolverFilter(InputArray guide,
double
sigma_spatial,
double
sigma_luma,
double
sigma_chroma,
double
lambda = 128.0,
int
num_iter = 25,
double
max_tol = 1e-5);














CV_EXPORTS_W
void
fastBilateralSolverFilter(InputArray guide, InputArray src, InputArray confidence, OutputArray dst,
double
sigma_spatial = 8,
double
sigma_luma = 8,
double
sigma_chroma = 8,
double
lambda = 128.0,
int
num_iter = 25,
double
max_tol = 1e-5);











class
CV_EXPORTS_W FastGlobalSmootherFilter :
public
Algorithm


{



public:



CV_WRAP
virtual
void
filter(InputArray src, OutputArray dst) = 0;


};






CV_EXPORTS_W Ptr<FastGlobalSmootherFilter> createFastGlobalSmootherFilter(InputArray guide,
double
lambda,
double
sigma_color,
double
lambda_attenuation=0.25,
int
num_iter=3);






CV_EXPORTS_W
void
fastGlobalSmootherFilter(InputArray guide, InputArray src, OutputArray dst,
double
lambda,
double
sigma_color,
double
lambda_attenuation=0.25,
int
num_iter=3);






CV_EXPORTS_W
void
l0Smooth(InputArray src, OutputArray dst,
double
lambda = 0.02,
double
kappa = 2.0);


}


}



#endif




#endif