diff options
Diffstat (limited to 'thirdparty/linux/include/opencv2/ximgproc')
14 files changed, 2250 insertions, 0 deletions
diff --git a/thirdparty/linux/include/opencv2/ximgproc/deriche_filter.hpp b/thirdparty/linux/include/opencv2/ximgproc/deriche_filter.hpp new file mode 100644 index 0000000..2371feb --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/deriche_filter.hpp @@ -0,0 +1,77 @@ +/* + * 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_DERICHEFILTER_HPP__ +#define __OPENCV_DERICHEFILTER_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv { +namespace ximgproc { + +//! @addtogroup ximgproc_filters +//! @{ + +/** +* @brief Applies Y Deriche filter to an image. +* +* For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf +* +* @param _op Source 8-bit or 16bit image, 1-channel or 3-channel image. +* @param _dst result CV_32FC image with same number of channel than _op. +* @param alphaDerive double see paper +* @param alphaMean double see paper +* +*/ +CV_EXPORTS void GradientDericheY(InputArray _op, OutputArray _dst, double alphaDerive,double alphaMean); +/** +* @brief Applies X Deriche filter to an image. +* +* For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf +* +* @param _op Source 8-bit or 16bit image, 1-channel or 3-channel image. +* @param _dst result CV_32FC image with same number of channel than _op. +* @param alphaDerive double see paper +* @param alphaMean double see paper +* +*/ +CV_EXPORTS void GradientDericheX(InputArray _op, OutputArray _dst, double alphaDerive,double alphaMean); + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/disparity_filter.hpp b/thirdparty/linux/include/opencv2/ximgproc/disparity_filter.hpp new file mode 100644 index 0000000..b738436 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/disparity_filter.hpp @@ -0,0 +1,210 @@ +/* + * 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_DISPARITYFILTER_HPP__ +#define __OPENCV_DISPARITYFILTER_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> +#include <opencv2/calib3d.hpp> + +namespace cv { +namespace ximgproc { + +//! @addtogroup ximgproc_filters +//! @{ + +/** @brief Main interface for all disparity map filters. + */ +class CV_EXPORTS_W DisparityFilter : public Algorithm +{ +public: + + /** @brief Apply filtering to the disparity map. + + @param disparity_map_left disparity map of the left view, 1 channel, CV_16S type. Implicitly assumes that disparity + values are scaled by 16 (one-pixel disparity corresponds to the value of 16 in the disparity map). Disparity map + can have any resolution, it will be automatically resized to fit left_view resolution. + + @param left_view left view of the original stereo-pair to guide the filtering process, 8-bit single-channel + or three-channel image. + + @param filtered_disparity_map output disparity map. + + @param disparity_map_right optional argument, some implementations might also use the disparity map + of the right view to compute confidence maps, for instance. + + @param ROI region of the disparity map to filter. Optional, usually it should be set automatically. + + @param right_view optional argument, some implementations might also use the right view of the original + stereo-pair. + */ + CV_WRAP virtual void filter(InputArray disparity_map_left, InputArray left_view, OutputArray filtered_disparity_map, InputArray disparity_map_right = Mat(), Rect ROI = Rect(), InputArray right_view = Mat()) = 0; +}; + +/** @brief Disparity map filter based on Weighted Least Squares filter (in form of Fast Global Smoother that +is a lot faster than traditional Weighted Least Squares filter implementations) and optional use of +left-right-consistency-based confidence to refine the results in half-occlusions and uniform areas. + */ +class CV_EXPORTS_W DisparityWLSFilter : public DisparityFilter +{ +public: + /** filter parameters */ + + /** @brief Lambda is a parameter defining the amount of regularization during filtering. Larger values force + filtered disparity map edges to adhere more to source image edges. Typical value is 8000. + */ + CV_WRAP virtual double getLambda() = 0; + /** @see getLambda */ + CV_WRAP virtual void setLambda(double _lambda) = 0; + /** @brief SigmaColor is a parameter defining how sensitive the filtering process is to source image edges. + Large values can lead to disparity leakage through low-contrast edges. Small values can make the filter too + sensitive to noise and textures in the source image. Typical values range from 0.8 to 2.0. + */ + CV_WRAP virtual double getSigmaColor() = 0; + /** @see getSigmaColor */ + CV_WRAP virtual void setSigmaColor(double _sigma_color) = 0; + + /** confidence-related parameters */ + + /** @brief LRCthresh is a threshold of disparity difference used in left-right-consistency check during + confidence map computation. The default value of 24 (1.5 pixels) is virtually always good enough. + */ + CV_WRAP virtual int getLRCthresh() = 0; + /** @see getLRCthresh */ + CV_WRAP virtual void setLRCthresh(int _LRC_thresh) = 0; + /** @brief DepthDiscontinuityRadius is a parameter used in confidence computation. It defines the size of + low-confidence regions around depth discontinuities. + */ + CV_WRAP virtual int getDepthDiscontinuityRadius() = 0; + /** @see getDepthDiscontinuityRadius */ + CV_WRAP virtual void setDepthDiscontinuityRadius(int _disc_radius) = 0; + /** @brief Get the confidence map that was used in the last filter call. It is a CV_32F one-channel image + with values ranging from 0.0 (totally untrusted regions of the raw disparity map) to 255.0 (regions containing + correct disparity values with a high degree of confidence). + */ + CV_WRAP virtual Mat getConfidenceMap() = 0; + /** @brief Get the ROI used in the last filter call + */ + CV_WRAP virtual Rect getROI() = 0; +}; + +/** @brief Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant +filter parameters automatically based on the matcher instance. Currently supports only StereoBM and StereoSGBM. + +@param matcher_left stereo matcher instance that will be used with the filter +*/ +CV_EXPORTS_W +Ptr<DisparityWLSFilter> createDisparityWLSFilter(Ptr<StereoMatcher> matcher_left); + +/** @brief Convenience method to set up the matcher for computing the right-view disparity map +that is required in case of filtering with confidence. + +@param matcher_left main stereo matcher instance that will be used with the filter +*/ +CV_EXPORTS_W +Ptr<StereoMatcher> createRightMatcher(Ptr<StereoMatcher> matcher_left); + +/** @brief More generic factory method, create instance of DisparityWLSFilter and execute basic +initialization routines. When using this method you will need to set-up the ROI, matchers and +other parameters by yourself. + +@param use_confidence filtering with confidence requires two disparity maps (for the left and right views) and is +approximately two times slower. However, quality is typically significantly better. +*/ +CV_EXPORTS_W +Ptr<DisparityWLSFilter> createDisparityWLSFilterGeneric(bool use_confidence); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +/** @brief Function for reading ground truth disparity maps. Supports basic Middlebury +and MPI-Sintel formats. Note that the resulting disparity map is scaled by 16. + +@param src_path path to the image, containing ground-truth disparity map + +@param dst output disparity map, CV_16S depth + +@result returns zero if successfully read the ground truth + */ +CV_EXPORTS +int readGT(String src_path,OutputArray dst); + +/** @brief Function for computing mean square error for disparity maps + +@param GT ground truth disparity map + +@param src disparity map to evaluate + +@param ROI region of interest + +@result returns mean square error between GT and src + */ +CV_EXPORTS +double computeMSE(InputArray GT, InputArray src, Rect ROI); + +/** @brief Function for computing the percent of "bad" pixels in the disparity map +(pixels where error is higher than a specified threshold) + +@param GT ground truth disparity map + +@param src disparity map to evaluate + +@param ROI region of interest + +@param thresh threshold used to determine "bad" pixels + +@result returns mean square error between GT and src + */ +CV_EXPORTS +double computeBadPixelPercent(InputArray GT, InputArray src, Rect ROI, int thresh=24/*1.5 pixels*/); + +/** @brief Function for creating a disparity map visualization (clamped CV_8U image) + +@param src input disparity map (CV_16S depth) + +@param dst output visualization + +@param scale disparity map will be multiplied by this value for visualization + */ +CV_EXPORTS +void getDisparityVis(InputArray src,OutputArray dst,double scale=1.0); + +//! @} +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/edge_filter.hpp b/thirdparty/linux/include/opencv2/ximgproc/edge_filter.hpp new file mode 100644 index 0000000..65cff9e --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/edge_filter.hpp @@ -0,0 +1,454 @@ +/* + * 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 +{ + +//! @addtogroup ximgproc_filters +//! @{ + +enum EdgeAwareFiltersList +{ + DTF_NC, + DTF_IC, + DTF_RF, + + GUIDED_FILTER, + AM_FILTER +}; + + +/** @brief Interface for realizations of Domain Transform filter. + +For more details about this filter see @cite Gastal11 . + */ +class CV_EXPORTS_W DTFilter : public Algorithm +{ +public: + + /** @brief Produce domain transform filtering operation on source image. + + @param src filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels. + + @param dst destination image. + + @param dDepth optional depth of the output image. dDepth can be set to -1, which will be equivalent + to src.depth(). + */ + CV_WRAP virtual void filter(InputArray src, OutputArray dst, int dDepth = -1) = 0; +}; + +/** @brief Factory method, create instance of DTFilter and produce initialization routines. + +@param guide guided image (used to build transformed distance, which describes edge structure of +guided image). + +@param sigmaSpatial \f${\sigma}_H\f$ parameter in the original article, it's similar to the sigma in the +coordinate space into bilateralFilter. + +@param sigmaColor \f${\sigma}_r\f$ parameter in the original article, it's similar to the sigma in the +color space into bilateralFilter. + +@param mode one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for +filtering 2D signals in the article. + +@param numIters optional number of iterations used for filtering, 3 is quite enough. + +For more details about Domain Transform filter parameters, see the original article @cite Gastal11 and +[Domain Transform filter homepage](http://www.inf.ufrgs.br/~eslgastal/DomainTransform/). + */ +CV_EXPORTS_W +Ptr<DTFilter> createDTFilter(InputArray guide, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3); + +/** @brief Simple one-line Domain Transform filter call. If you have multiple images to filter with the same +guided image then use DTFilter interface to avoid extra computations on initialization stage. + +@param guide guided image (also called as joint image) with unsigned 8-bit or floating-point 32-bit +depth and up to 4 channels. +@param src filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels. +@param dst +@param sigmaSpatial \f${\sigma}_H\f$ parameter in the original article, it's similar to the sigma in the +coordinate space into bilateralFilter. +@param sigmaColor \f${\sigma}_r\f$ parameter in the original article, it's similar to the sigma in the +color space into bilateralFilter. +@param mode one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for +filtering 2D signals in the article. +@param numIters optional number of iterations used for filtering, 3 is quite enough. +@sa bilateralFilter, guidedFilter, amFilter + */ +CV_EXPORTS_W +void dtFilter(InputArray guide, InputArray src, OutputArray dst, double sigmaSpatial, double sigmaColor, int mode = DTF_NC, int numIters = 3); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +/** @brief Interface for realizations of Guided Filter. + +For more details about this filter see @cite Kaiming10 . + */ +class CV_EXPORTS_W GuidedFilter : public Algorithm +{ +public: + + /** @brief Apply Guided Filter to the filtering image. + + @param src filtering image with any numbers of channels. + + @param dst output image. + + @param dDepth optional depth of the output image. dDepth can be set to -1, which will be equivalent + to src.depth(). + */ + CV_WRAP virtual void filter(InputArray src, OutputArray dst, int dDepth = -1) = 0; +}; + +/** @brief Factory method, create instance of GuidedFilter and produce initialization routines. + +@param guide guided image (or array of images) with up to 3 channels, if it have more then 3 +channels then only first 3 channels will be used. + +@param radius radius of Guided Filter. + +@param eps regularization term of Guided Filter. \f${eps}^2\f$ is similar to the sigma in the color +space into bilateralFilter. + +For more details about Guided Filter parameters, see the original article @cite Kaiming10 . + */ +CV_EXPORTS_W Ptr<GuidedFilter> createGuidedFilter(InputArray guide, int radius, double eps); + +/** @brief Simple one-line Guided Filter call. + +If you have multiple images to filter with the same guided image then use GuidedFilter interface to +avoid extra computations on initialization stage. + +@param guide guided image (or array of images) with up to 3 channels, if it have more then 3 +channels then only first 3 channels will be used. + +@param src filtering image with any numbers of channels. + +@param dst output image. + +@param radius radius of Guided Filter. + +@param eps regularization term of Guided Filter. \f${eps}^2\f$ is similar to the sigma in the color +space into bilateralFilter. + +@param dDepth optional depth of the output image. + +@sa bilateralFilter, dtFilter, amFilter */ +CV_EXPORTS_W void guidedFilter(InputArray guide, InputArray src, OutputArray dst, int radius, double eps, int dDepth = -1); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +/** @brief Interface for Adaptive Manifold Filter realizations. + +For more details about this filter see @cite Gastal12 and References_. + +Below listed optional parameters which may be set up with Algorithm::set function. +- member double sigma_s = 16.0 +Spatial standard deviation. +- member double sigma_r = 0.2 +Color space standard deviation. +- member int tree_height = -1 +Height of the manifold tree (default = -1 : automatically computed). +- member int num_pca_iterations = 1 +Number of iterations to computed the eigenvector. +- member bool adjust_outliers = false +Specify adjust outliers using Eq. 9 or not. +- member bool use_RNG = true +Specify use random number generator to compute eigenvector or not. + */ +class CV_EXPORTS_W AdaptiveManifoldFilter : public Algorithm +{ +public: + /** @brief Apply high-dimensional filtering using adaptive manifolds. + + @param src filtering image with any numbers of channels. + + @param dst output image. + + @param joint optional joint (also called as guided) image with any numbers of channels. + */ + 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(); + + /** @see setSigmaS */ + virtual double getSigmaS() const = 0; + /** @copybrief getSigmaS @see getSigmaS */ + virtual void setSigmaS(double val) = 0; + /** @see setSigmaR */ + virtual double getSigmaR() const = 0; + /** @copybrief getSigmaR @see getSigmaR */ + virtual void setSigmaR(double val) = 0; + /** @see setTreeHeight */ + virtual int getTreeHeight() const = 0; + /** @copybrief getTreeHeight @see getTreeHeight */ + virtual void setTreeHeight(int val) = 0; + /** @see setPCAIterations */ + virtual int getPCAIterations() const = 0; + /** @copybrief getPCAIterations @see getPCAIterations */ + virtual void setPCAIterations(int val) = 0; + /** @see setAdjustOutliers */ + virtual bool getAdjustOutliers() const = 0; + /** @copybrief getAdjustOutliers @see getAdjustOutliers */ + virtual void setAdjustOutliers(bool val) = 0; + /** @see setUseRNG */ + virtual bool getUseRNG() const = 0; + /** @copybrief getUseRNG @see getUseRNG */ + virtual void setUseRNG(bool val) = 0; +}; + +/** @brief Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines. + +@param sigma_s spatial standard deviation. + +@param sigma_r color space standard deviation, it is similar to the sigma in the color space into +bilateralFilter. + +@param adjust_outliers optional, specify perform outliers adjust operation or not, (Eq. 9) in the +original paper. + +For more details about Adaptive Manifold Filter parameters, see the original article @cite Gastal12 . + +@note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] +color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same +sigmas in bilateralFilter and dtFilter functions. +*/ +CV_EXPORTS_W Ptr<AdaptiveManifoldFilter> createAMFilter(double sigma_s, double sigma_r, bool adjust_outliers = false); + +/** @brief Simple one-line Adaptive Manifold Filter call. + +@param joint joint (also called as guided) image or array of images with any numbers of channels. + +@param src filtering image with any numbers of channels. + +@param dst output image. + +@param sigma_s spatial standard deviation. + +@param sigma_r color space standard deviation, it is similar to the sigma in the color space into +bilateralFilter. + +@param adjust_outliers optional, specify perform outliers adjust operation or not, (Eq. 9) in the +original paper. + +@note Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] +color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same +sigmas in bilateralFilter and dtFilter functions. @sa bilateralFilter, dtFilter, guidedFilter +*/ +CV_EXPORTS_W void amFilter(InputArray joint, InputArray src, OutputArray dst, double sigma_s, double sigma_r, bool adjust_outliers = false); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +/** @brief Applies the joint bilateral filter to an image. + +@param joint Joint 8-bit or floating-point, 1-channel or 3-channel image. + +@param src Source 8-bit or floating-point, 1-channel or 3-channel image with the same depth as joint +image. + +@param dst Destination image of the same size and type as src . + +@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, +it is computed from sigmaSpace . + +@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that +farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in +larger areas of semi-equal color. + +@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that +farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). +When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is +proportional to sigmaSpace . + +@param borderType + +@note bilateralFilter and jointBilateralFilter use L1 norm to compute difference between colors. + +@sa bilateralFilter, amFilter +*/ +CV_EXPORTS_W +void jointBilateralFilter(InputArray joint, InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType = BORDER_DEFAULT); + +/** @brief Applies the bilateral texture filter to an image. It performs structure-preserving texture filter. +For more details about this filter see @cite Cho2014. + +@param src Source image whose depth is 8-bit UINT or 32-bit FLOAT + +@param dst Destination image of the same size and type as src. + +@param fr Radius of kernel to be used for filtering. It should be positive integer + +@param numIter Number of iterations of algorithm, It should be positive integer + +@param sigmaAlpha Controls the sharpness of the weight transition from edges to smooth/texture regions, where +a bigger value means sharper transition. When the value is negative, it is automatically calculated. + +@param sigmaAvg Range blur parameter for texture blurring. Larger value makes result to be more blurred. When the +value is negative, it is automatically calculated as described in the paper. + +@sa rollingGuidanceFilter, bilateralFilter +*/ +CV_EXPORTS_W +void bilateralTextureFilter(InputArray src, OutputArray dst, int fr = 3, int numIter = 1, double sigmaAlpha = -1., double sigmaAvg = -1.); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +/** @brief Applies the rolling guidance filter to an image. + +For more details, please see @cite zhang2014rolling + +@param src Source 8-bit or floating-point, 1-channel or 3-channel image. + +@param dst Destination image of the same size and type as src. + +@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, +it is computed from sigmaSpace . + +@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that +farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in +larger areas of semi-equal color. + +@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that +farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). +When d\>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is +proportional to sigmaSpace . + +@param numOfIter Number of iterations of joint edge-preserving filtering applied on the source image. + +@param borderType + +@note rollingGuidanceFilter uses jointBilateralFilter as the edge-preserving filter. + +@sa jointBilateralFilter, bilateralFilter, amFilter +*/ +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); + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + + +/** @brief Interface for implementations of Fast Global Smoother filter. + +For more details about this filter see @cite Min2014 and @cite Farbman2008 . +*/ +class CV_EXPORTS_W FastGlobalSmootherFilter : public Algorithm +{ +public: + /** @brief Apply smoothing operation to the source image. + + @param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels. + + @param dst destination image. + */ + CV_WRAP virtual void filter(InputArray src, OutputArray dst) = 0; +}; + +/** @brief Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines. + +@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels. + +@param lambda parameter defining the amount of regularization + +@param sigma_color parameter, that is similar to color space sigma in bilateralFilter. + +@param lambda_attenuation internal parameter, defining how much lambda decreases after each iteration. Normally, +it should be 0.25. Setting it to 1.0 may lead to streaking artifacts. + +@param num_iter number of iterations used for filtering, 3 is usually enough. + +For more details about Fast Global Smoother parameters, see the original paper @cite Min2014. However, please note that +there are several differences. Lambda attenuation described in the paper is implemented a bit differently so do not +expect the results to be identical to those from the paper; sigma_color values from the paper should be multiplied by 255.0 to +achieve the same effect. Also, in case of image filtering where source and guide image are the same, authors +propose to dynamically update the guide image after each iteration. To maximize the performance this feature +was not implemented here. +*/ +CV_EXPORTS_W Ptr<FastGlobalSmootherFilter> createFastGlobalSmootherFilter(InputArray guide, double lambda, double sigma_color, double lambda_attenuation=0.25, int num_iter=3); + +/** @brief Simple one-line Fast Global Smoother filter call. If you have multiple images to filter with the same +guide then use FastGlobalSmootherFilter interface to avoid extra computations. + +@param guide image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels. + +@param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels. + +@param dst destination image. + +@param lambda parameter defining the amount of regularization + +@param sigma_color parameter, that is similar to color space sigma in bilateralFilter. + +@param lambda_attenuation internal parameter, defining how much lambda decreases after each iteration. Normally, +it should be 0.25. Setting it to 1.0 may lead to streaking artifacts. + +@param num_iter number of iterations used for filtering, 3 is usually enough. +*/ +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); + +/** @brief Global image smoothing via L0 gradient minimization. + +@param src source image for filtering with unsigned 8-bit or signed 16-bit or floating-point depth. + +@param dst destination image. + +@param lambda parameter defining the smooth term weight. + +@param kappa parameter defining the increasing factor of the weight of the gradient data term. + +For more details about L0 Smoother, see the original paper @cite xu2011image. +*/ +CV_EXPORTS_W void l0Smooth(InputArray src, OutputArray dst, double lambda = 0.02, double kappa = 2.0); +//! @} +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/estimated_covariance.hpp b/thirdparty/linux/include/opencv2/ximgproc/estimated_covariance.hpp new file mode 100644 index 0000000..e4f5ddf --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/estimated_covariance.hpp @@ -0,0 +1,82 @@ +/* +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) + +Copyright (C) 2000-2015, Intel Corporation, all rights reserved. +Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. +Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved. +Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved. +Copyright (C) 2015, OpenCV Foundation, all rights reserved. +Copyright (C) 2015, Itseez 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: + + * 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. + +Algorithmic details of this algorithm can be found at: + * O. Green, Y. Birk, "A Computationally Efficient Algorithm for the 2D Covariance Method", ACM/IEEE International Conference on High Performance Computing, Networking, Storage and Analysis, Denver, Colorado, 2013 +A previous and less efficient version of the algorithm can be found: + * O. Green, L. David, A. Galperin, Y. Birk, "Efficient parallel computation of the estimated covariance matrix", arXiv, 2013 + + +*/ +#ifndef __OPENCV_ESTIMATECOVARIANCE_HPP__ +#define __OPENCV_ESTIMATECOVARIANCE_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +/** @brief Computes the estimated covariance matrix of an image using the sliding +window forumlation. + +@param src The source image. Input image must be of a complex type. +@param dst The destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols). +@param windowRows The number of rows in the window. +@param windowCols The number of cols in the window. +The window size parameters control the accuracy of the estimation. +The sliding window moves over the entire image from the top-left corner +to the bottom right corner. Each location of the window represents a sample. +If the window is the size of the image, then this gives the exact covariance matrix. +For all other cases, the sizes of the window will impact the number of samples +and the number of elements in the estimated covariance matrix. +*/ + +CV_EXPORTS_W void covarianceEstimation(InputArray src, OutputArray dst, int windowRows, int windowCols); + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/fast_hough_transform.hpp b/thirdparty/linux/include/opencv2/ximgproc/fast_hough_transform.hpp new file mode 100644 index 0000000..cdfb032 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/fast_hough_transform.hpp @@ -0,0 +1,164 @@ +/*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) 2015, Smart Engines Ltd, all rights reserved. +// Copyright (C) 2015, Institute for Information Transmission Problems of the Russian Academy of Sciences (Kharkevich Institute), all rights reserved. +// Copyright (C) 2015, Dmitry Nikolaev, Simon Karpenko, Michail Aliev, Elena Kuznetsova, 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_FAST_HOUGH_TRANSFORM_HPP__ +#define __OPENCV_FAST_HOUGH_TRANSFORM_HPP__ +#ifdef __cplusplus + +#include "opencv2/core.hpp" + + +namespace cv { namespace ximgproc { + +/** +* @brief Specifies the part of Hough space to calculate +* @details The enum specifies the part of Hough space to calculate. Each +* member specifies primarily direction of lines (horizontal or vertical) +* and the direction of angle changes. +* Direction of angle changes is from multiples of 90 to odd multiples of 45. +* The image considered to be written top-down and left-to-right. +* Angles are started from vertical line and go clockwise. +* Separate quarters and halves are written in orientation they should be in +* full Hough space. +*/ +enum AngleRangeOption +{ + ARO_0_45 = 0, //< Vertical primarily direction and clockwise angle changes + ARO_45_90 = 1, //< Horizontal primarily direction and counterclockwise angle changes + ARO_90_135 = 2, //< Horizontal primarily direction and clockwise angle changes + ARO_315_0 = 3, //< Vertical primarily direction and counterclockwise angle changes + ARO_315_45 = 4, //< Vertical primarily direction + ARO_45_135 = 5, //< Horizontal primarily direction + ARO_315_135 = 6, //< Full set of directions + ARO_CTR_HOR = 7, //< 90 +/- atan(0.5), interval approximately from 64.5 to 116.5 degrees. + //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5). + ARO_CTR_VER = 8 //< +/- atan(0.5), interval approximately from 333.5(-26.5) to 26.5 degrees + //< It is used for calculating Fast Hough Transform for images skewed by atan(0.5). +}; + +/** + * @brief Specifies binary operations. + * @details The enum specifies binary operations, that is such ones which involve + * two operands. Formally, a binary operation @f$ f @f$ on a set @f$ S @f$ + * is a binary relation that maps elements of the Cartesian product + * @f$ S \times S @f$ to @f$ S @f$: +* @f[ f: S \times S \to S @f] + * @ingroup MinUtils_MathOper + */ +enum HoughOp +{ + FHT_MIN = 0, //< Binary minimum operation. The constant specifies the binary minimum operation + //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \min(x, y) @f] + FHT_MAX = 1, //< Binary maximum operation. The constant specifies the binary maximum operation + //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \max(x, y) @f] + FHT_ADD = 2, //< Binary addition operation. The constant specifies the binary addition operation + //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = x + y @f] + FHT_AVE = 3 //< Binary average operation. The constant specifies the binary average operation + //< @f$ f @f$ that is defined as follows: @f[ f(x, y) = \frac{x + y}{2} @f] +}; + +/** +* @brief Specifies to do or not to do skewing of Hough transform image +* @details The enum specifies to do or not to do skewing of Hough transform image +* so it would be no cycling in Hough transform image through borders of image. +*/ +enum HoughDeskewOption +{ + HDO_RAW = 0, //< Use raw cyclic image + HDO_DESKEW = 1 //< Prepare deskewed image +}; + +/** + * @brief Specifies the degree of rules validation. + * @details The enum specifies the degree of rules validation. This can be used, + * for example, to choose a proper way of input arguments validation. + */ +typedef enum { + RO_STRICT = 0x00, ///< Validate each rule in a proper way. + RO_IGNORE_BORDERS = 0x01, ///< Skip validations of image borders. +} RulesOption; + +/** +* @brief Calculates 2D Fast Hough transform of an image. +* @param dst The destination image, result of transformation. +* @param src The source (input) image. +* @param dstMatDepth The depth of destination image +* @param op The operation to be applied, see cv::HoughOp +* @param angleRange The part of Hough space to calculate, see cv::AngleRangeOption +* @param makeSkew Specifies to do or not to do image skewing, see cv::HoughDeskewOption +* +* The function calculates the fast Hough transform for full, half or quarter +* range of angles. +*/ +CV_EXPORTS void FastHoughTransform( InputArray src, + OutputArray dst, + int dstMatDepth, + int angleRange = ARO_315_135, + int op = FHT_ADD, + int makeSkew = HDO_DESKEW ); + +/** +* @brief Calculates coordinates of line segment corresponded by point in Hough space. +* @param houghPoint Point in Hough space. +* @param srcImgInfo The source (input) image of Hough transform. +* @param angleRange The part of Hough space where point is situated, see cv::AngleRangeOption +* @param makeSkew Specifies to do or not to do image skewing, see cv::HoughDeskewOption +* @param rules Specifies strictness of line segment calculating, see cv::RulesOption +* @retval [Vec4i] Coordinates of line segment corresponded by point in Hough space. +* @remarks If rules parameter set to RO_STRICT + then returned line cut along the border of source image. +* @remarks If rules parameter set to RO_WEAK then in case of point, which belongs + the incorrect part of Hough image, returned line will not intersect source image. +* +* The function calculates coordinates of line segment corresponded by point in Hough space. +*/ +CV_EXPORTS Vec4i HoughPoint2Line(const Point &houghPoint, + InputArray srcImgInfo, + int angleRange = ARO_315_135, + int makeSkew = HDO_DESKEW, + int rules = RO_IGNORE_BORDERS ); + +} }// namespace cv::ximgproc + +#endif //__cplusplus +#endif //__OPENCV_FAST_HOUGH_TRANSFORM_HPP__ diff --git a/thirdparty/linux/include/opencv2/ximgproc/fast_line_detector.hpp b/thirdparty/linux/include/opencv2/ximgproc/fast_line_detector.hpp new file mode 100644 index 0000000..1df5558 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/fast_line_detector.hpp @@ -0,0 +1,81 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +#ifndef __OPENCV_FAST_LINE_DETECTOR_HPP__ +#define __OPENCV_FAST_LINE_DETECTOR_HPP__ + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +//! @addtogroup ximgproc_fast_line_detector +//! @{ + +/** @brief Class implementing the FLD (Fast Line Detector) algorithm described +in @cite Lee14 . +*/ + +//! @include samples/fld_lines.cpp + +class CV_EXPORTS_W FastLineDetector : public Algorithm +{ +public: + /** @example fld_lines.cpp + An example using the FastLineDetector + */ + /** @brief Finds lines in the input image. + This is the output of the default parameters of the algorithm on the above + shown image. + +  + + @param _image A grayscale (CV_8UC1) input image. If only a roi needs to be + selected, use: `fld_ptr-\>detect(image(roi), lines, ...); + lines += Scalar(roi.x, roi.y, roi.x, roi.y);` + @param _lines A vector of Vec4f elements specifying the beginning + and ending point of a line. Where Vec4f is (x1, y1, x2, y2), point + 1 is the start, point 2 - end. Returned lines are directed so that the + brighter side is on their left. + */ + CV_WRAP virtual void detect(InputArray _image, OutputArray _lines) = 0; + + /** @brief Draws the line segments on a given image. + @param _image The image, where the lines will be drawn. Should be bigger + or equal to the image, where the lines were found. + @param lines A vector of the lines that needed to be drawn. + @param draw_arrow If true, arrow heads will be drawn. + */ + CV_WRAP virtual void drawSegments(InputOutputArray _image, InputArray lines, + bool draw_arrow = false) = 0; + + virtual ~FastLineDetector() { } +}; + +/** @brief Creates a smart pointer to a FastLineDetector object and initializes it + +@param _length_threshold 10 - Segment shorter than this will be discarded +@param _distance_threshold 1.41421356 - A point placed from a hypothesis line + segment farther than this will be + regarded as an outlier +@param _canny_th1 50 - First threshold for + hysteresis procedure in Canny() +@param _canny_th2 50 - Second threshold for + hysteresis procedure in Canny() +@param _canny_aperture_size 3 - Aperturesize for the sobel + operator in Canny() +@param _do_merge false - If true, incremental merging of segments + will be perfomred +*/ +CV_EXPORTS_W Ptr<FastLineDetector> createFastLineDetector( + int _length_threshold = 10, float _distance_threshold = 1.414213562f, + double _canny_th1 = 50.0, double _canny_th2 = 50.0, int _canny_aperture_size = 3, + bool _do_merge = false); + +//! @} ximgproc_fast_line_detector +} +} +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/lsc.hpp b/thirdparty/linux/include/opencv2/ximgproc/lsc.hpp new file mode 100644 index 0000000..e6f5bae --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/lsc.hpp @@ -0,0 +1,157 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2014, 2015 + * Zhengqin Li <li-zq12 at mails dot tsinghua dot edu dot cn> + * Jiansheng Chen <jschenthu at mail dot tsinghua dot edu dot cn> + * Tsinghua University + * + * 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 name of the copyright holders nor the names of its + * 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 THE + * COPYRIGHT OWNER 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. + *********************************************************************/ + +/* + + "Superpixel Segmentation using Linear Spectral Clustering" + Zhengqin Li, Jiansheng Chen, IEEE Conference on Computer Vision and Pattern + Recognition (CVPR), Jun. 2015 + + OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com> + */ + +#ifndef __OPENCV_LSC_HPP__ +#define __OPENCV_LSC_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +//! @addtogroup ximgproc_superpixel +//! @{ + +/** @brief Class implementing the LSC (Linear Spectral Clustering) superpixels +algorithm described in @cite LiCVPR2015LSC. + +LSC (Linear Spectral Clustering) produces compact and uniform superpixels with low +computational costs. Basically, a normalized cuts formulation of the superpixel +segmentation is adopted based on a similarity metric that measures the color +similarity and space proximity between image pixels. LSC is of linear computational +complexity and high memory efficiency and is able to preserve global properties of images + + */ + +class CV_EXPORTS_W SuperpixelLSC : public Algorithm +{ +public: + + /** @brief Calculates the actual amount of superpixels on a given segmentation computed + and stored in SuperpixelLSC object. + */ + CV_WRAP virtual int getNumberOfSuperpixels() const = 0; + + /** @brief Calculates the superpixel segmentation on a given image with the initialized + parameters in the SuperpixelLSC object. + + This function can be called again without the need of initializing the algorithm with + createSuperpixelLSC(). This save the computational cost of allocating memory for all the + structures of the algorithm. + + @param num_iterations Number of iterations. Higher number improves the result. + + The function computes the superpixels segmentation of an image with the parameters initialized + with the function createSuperpixelLSC(). The algorithms starts from a grid of superpixels and + then refines the boundaries by proposing updates of edges boundaries. + + */ + CV_WRAP virtual void iterate( int num_iterations = 10 ) = 0; + + /** @brief Returns the segmentation labeling of the image. + + Each label represents a superpixel, and each pixel is assigned to one superpixel label. + + @param labels_out Return: A CV_32SC1 integer array containing the labels of the superpixel + segmentation. The labels are in the range [0, getNumberOfSuperpixels()]. + + The function returns an image with the labels of the superpixel segmentation. The labels are in + the range [0, getNumberOfSuperpixels()]. + */ + CV_WRAP virtual void getLabels( OutputArray labels_out ) const = 0; + + /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelLSC object. + + @param image Return: CV_8U1 image mask where -1 indicates that the pixel is a superpixel border, + and 0 otherwise. + + @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border + are masked. + + The function return the boundaries of the superpixel segmentation. + */ + CV_WRAP virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const = 0; + + /** @brief Enforce label connectivity. + + @param min_element_size The minimum element size in percents that should be absorbed into a bigger + superpixel. Given resulted average superpixel size valid value should be in 0-100 range, 25 means + that less then a quarter sized superpixel should be absorbed, this is default. + + The function merge component that is too small, assigning the previously found adjacent label + to this component. Calling this function may change the final number of superpixels. + */ + CV_WRAP virtual void enforceLabelConnectivity( int min_element_size = 20 ) = 0; + + +}; + +/** @brief Class implementing the LSC (Linear Spectral Clustering) superpixels + +@param image Image to segment +@param region_size Chooses an average superpixel size measured in pixels +@param ratio Chooses the enforcement of superpixel compactness factor of superpixel + +The function initializes a SuperpixelLSC object for the input image. It sets the parameters of +superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future +computing iterations over the given image. An example of LSC is ilustrated in the following picture. +For enanched results it is recommended for color images to preprocess image with little gaussian blur +with a small 3 x 3 kernel and additional conversion into CieLAB color space. + + + + */ + + CV_EXPORTS_W Ptr<SuperpixelLSC> createSuperpixelLSC( InputArray image, int region_size = 10, float ratio = 0.075f ); + +//! @} + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/paillou_filter.hpp b/thirdparty/linux/include/opencv2/ximgproc/paillou_filter.hpp new file mode 100644 index 0000000..03754a1 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/paillou_filter.hpp @@ -0,0 +1,67 @@ +/* + * 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_PAILLOUFILTER_HPP__ +#define __OPENCV_PAILLOUFILTER_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv { +namespace ximgproc { + +//! @addtogroup ximgproc_filters +//! @{ + +/** +* @brief Applies Paillou filter to an image. +* +* For more details about this implementation, please see @cite paillou1997detecting +* +* @param op Source CV_8U(S) or CV_16U(S), 1-channel or 3-channels image. +* @param _dst result CV_32F image with same number of channel than op. +* @param omega double see paper +* @param alpha double see paper +* +* @sa GradientPaillouX, GradientPaillouY +*/ +CV_EXPORTS void GradientPaillouY(InputArray op, OutputArray _dst, double alpha, double omega); +CV_EXPORTS void GradientPaillouX(InputArray op, OutputArray _dst, double alpha, double omega); + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/seeds.hpp b/thirdparty/linux/include/opencv2/ximgproc/seeds.hpp new file mode 100644 index 0000000..4db8b8f --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/seeds.hpp @@ -0,0 +1,183 @@ +/*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) 2014, Beat Kueng (beat-kueng@gmx.net), Lukas Vogel, Morten Lysgaard +// 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_SEEDS_HPP__ +#define __OPENCV_SEEDS_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +//! @addtogroup ximgproc_superpixel +//! @{ + +/** @brief Class implementing the SEEDS (Superpixels Extracted via Energy-Driven Sampling) superpixels +algorithm described in @cite VBRV14 . + +The algorithm uses an efficient hill-climbing algorithm to optimize the superpixels' energy +function that is based on color histograms and a boundary term, which is optional. The energy +function encourages superpixels to be of the same color, and if the boundary term is activated, the +superpixels have smooth boundaries and are of similar shape. In practice it starts from a regular +grid of superpixels and moves the pixels or blocks of pixels at the boundaries to refine the +solution. The algorithm runs in real-time using a single CPU. + */ +class CV_EXPORTS_W SuperpixelSEEDS : public Algorithm +{ +public: + + /** @brief Calculates the superpixel segmentation on a given image stored in SuperpixelSEEDS object. + + The function computes the superpixels segmentation of an image with the parameters initialized + with the function createSuperpixelSEEDS(). + */ + CV_WRAP virtual int getNumberOfSuperpixels() = 0; + + /** @brief Calculates the superpixel segmentation on a given image with the initialized + parameters in the SuperpixelSEEDS object. + + This function can be called again for other images without the need of initializing the + algorithm with createSuperpixelSEEDS(). This save the computational cost of allocating memory + for all the structures of the algorithm. + + @param img Input image. Supported formats: CV_8U, CV_16U, CV_32F. Image size & number of + channels must match with the initialized image size & channels with the function + createSuperpixelSEEDS(). It should be in HSV or Lab color space. Lab is a bit better, but also + slower. + + @param num_iterations Number of pixel level iterations. Higher number improves the result. + + The function computes the superpixels segmentation of an image with the parameters initialized + with the function createSuperpixelSEEDS(). The algorithms starts from a grid of superpixels and + then refines the boundaries by proposing updates of blocks of pixels that lie at the boundaries + from large to smaller size, finalizing with proposing pixel updates. An illustrative example + can be seen below. + +  + */ + CV_WRAP virtual void iterate(InputArray img, int num_iterations=4) = 0; + + /** @brief Returns the segmentation labeling of the image. + + Each label represents a superpixel, and each pixel is assigned to one superpixel label. + + @param labels_out Return: A CV_32UC1 integer array containing the labels of the superpixel + segmentation. The labels are in the range [0, getNumberOfSuperpixels()]. + + The function returns an image with ssthe labels of the superpixel segmentation. The labels are in + the range [0, getNumberOfSuperpixels()]. + */ + CV_WRAP virtual void getLabels(OutputArray labels_out) = 0; + + /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelSEEDS object. + + @param image Return: CV_8UC1 image mask where -1 indicates that the pixel is a superpixel border, + and 0 otherwise. + + @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border + are masked. + + The function return the boundaries of the superpixel segmentation. + + @note + - (Python) A demo on how to generate superpixels in images from the webcam can be found at + opencv_source_code/samples/python2/seeds.py + - (cpp) A demo on how to generate superpixels in images from the webcam can be found at + opencv_source_code/modules/ximgproc/samples/seeds.cpp. By adding a file image as a command + line argument, the static image will be used instead of the webcam. + - It will show a window with the video from the webcam with the superpixel boundaries marked + in red (see below). Use Space to switch between different output modes. At the top of the + window there are 4 sliders, from which the user can change on-the-fly the number of + superpixels, the number of block levels, the strength of the boundary prior term to modify + the shape, and the number of iterations at pixel level. This is useful to play with the + parameters and set them to the user convenience. In the console the frame-rate of the + algorithm is indicated. + +  + */ + CV_WRAP virtual void getLabelContourMask(OutputArray image, bool thick_line = false) = 0; + + virtual ~SuperpixelSEEDS() {} +}; + +/** @brief Initializes a SuperpixelSEEDS object. + +@param image_width Image width. +@param image_height Image height. +@param image_channels Number of channels of the image. +@param num_superpixels Desired number of superpixels. Note that the actual number may be smaller +due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to +get the actual number. +@param num_levels Number of block levels. The more levels, the more accurate is the segmentation, +but needs more memory and CPU time. +@param prior enable 3x3 shape smoothing term if \>0. A larger value leads to smoother shapes. prior +must be in the range [0, 5]. +@param histogram_bins Number of histogram bins. +@param double_step If true, iterate each block level twice for higher accuracy. + +The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of +the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS +superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and +double_step. + +The number of levels in num_levels defines the amount of block levels that the algorithm use in the +optimization. The initialization is a grid, in which the superpixels are equally distributed through +the width and the height of the image. The larger blocks correspond to the superpixel size, and the +levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels, +recursively until the smaller block level. An example of initialization of 4 block levels is +illustrated in the following figure. + + + */ +CV_EXPORTS_W Ptr<SuperpixelSEEDS> createSuperpixelSEEDS( + int image_width, int image_height, int image_channels, + int num_superpixels, int num_levels, int prior = 2, + int histogram_bins=5, bool double_step = false); + +//! @} + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/segmentation.hpp b/thirdparty/linux/include/opencv2/ximgproc/segmentation.hpp new file mode 100644 index 0000000..02d28bf --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/segmentation.hpp @@ -0,0 +1,252 @@ +/* +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) +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: + * 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_XIMGPROC_SEGMENTATION_HPP__ +#define __OPENCV_XIMGPROC_SEGMENTATION_HPP__ + +#include <opencv2/core.hpp> + +namespace cv { + namespace ximgproc { + namespace segmentation { + //! @addtogroup ximgproc_segmentation + //! @{ + + /** @brief Graph Based Segmentation Algorithm. + The class implements the algorithm described in @cite PFF2004 . + */ + class CV_EXPORTS_W GraphSegmentation : public Algorithm { + public: + /** @brief Segment an image and store output in dst + @param src The input image. Any number of channel (1 (Eg: Gray), 3 (Eg: RGB), 4 (Eg: RGB-D)) can be provided + @param dst The output segmentation. It's a CV_32SC1 Mat with the same number of cols and rows as input image, with an unique, sequential, id for each pixel. + */ + CV_WRAP virtual void processImage(InputArray src, OutputArray dst) = 0; + + CV_WRAP virtual void setSigma(double sigma) = 0; + CV_WRAP virtual double getSigma() = 0; + + CV_WRAP virtual void setK(float k) = 0; + CV_WRAP virtual float getK() = 0; + + CV_WRAP virtual void setMinSize(int min_size) = 0; + CV_WRAP virtual int getMinSize() = 0; + }; + + /** @brief Creates a graph based segmentor + @param sigma The sigma parameter, used to smooth image + @param k The k parameter of the algorythm + @param min_size The minimum size of segments + */ + CV_EXPORTS_W Ptr<GraphSegmentation> createGraphSegmentation(double sigma=0.5, float k=300, int min_size=100); + + /** @brief Strategie for the selective search segmentation algorithm + The class implements a generic stragery for the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategy : public Algorithm { + public: + /** @brief Set a initial image, with a segementation. + @param img The input image. Any number of channel can be provided + @param regions A segementation of the image. The parameter must be the same size of img. + @param sizes The sizes of different regions + @param image_id If not set to -1, try to cache pre-computations. If the same set og (img, regions, size) is used, the image_id need to be the same. + */ + CV_WRAP virtual void setImage(InputArray img, InputArray regions, InputArray sizes, int image_id = -1) = 0; + + /** @brief Return the score between two regions (between 0 and 1) + @param r1 The first region + @param r2 The second region + */ + CV_WRAP virtual float get(int r1, int r2) = 0; + + /** @brief Inform the strategy that two regions will be merged + @param r1 The first region + @param r2 The second region + */ + CV_WRAP virtual void merge(int r1, int r2) = 0; + }; + + /** @brief Color-based strategy for the selective search segmentation algorithm + The class is implemented from the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategyColor : public SelectiveSearchSegmentationStrategy { + }; + + /** @brief Create a new color-based strategy */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyColor> createSelectiveSearchSegmentationStrategyColor(); + + /** @brief Size-based strategy for the selective search segmentation algorithm + The class is implemented from the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategySize : public SelectiveSearchSegmentationStrategy { + }; + + /** @brief Create a new size-based strategy */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategySize> createSelectiveSearchSegmentationStrategySize(); + + /** @brief Texture-based strategy for the selective search segmentation algorithm + The class is implemented from the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategyTexture : public SelectiveSearchSegmentationStrategy { + }; + + /** @brief Create a new size-based strategy */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyTexture> createSelectiveSearchSegmentationStrategyTexture(); + + /** @brief Fill-based strategy for the selective search segmentation algorithm + The class is implemented from the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategyFill : public SelectiveSearchSegmentationStrategy { + }; + + /** @brief Create a new fill-based strategy */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyFill> createSelectiveSearchSegmentationStrategyFill(); + + /** @brief Regroup multiple strategies for the selective search segmentation algorithm + */ + class CV_EXPORTS_W SelectiveSearchSegmentationStrategyMultiple : public SelectiveSearchSegmentationStrategy { + public: + + /** @brief Add a new sub-strategy + @param g The strategy + @param weight The weight of the strategy + */ + CV_WRAP virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> g, float weight) = 0; + /** @brief Remove all sub-strategies + */ + CV_WRAP virtual void clearStrategies() = 0; + }; + + /** @brief Create a new multiple strategy */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(); + + /** @brief Create a new multiple strategy and set one subtrategy + @param s1 The first strategy + */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1); + + /** @brief Create a new multiple strategy and set two subtrategies, with equal weights + @param s1 The first strategy + @param s2 The second strategy + */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2); + + + /** @brief Create a new multiple strategy and set three subtrategies, with equal weights + @param s1 The first strategy + @param s2 The second strategy + @param s3 The third strategy + */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3); + + /** @brief Create a new multiple strategy and set four subtrategies, with equal weights + @param s1 The first strategy + @param s2 The second strategy + @param s3 The third strategy + @param s4 The forth strategy + */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentationStrategyMultiple> createSelectiveSearchSegmentationStrategyMultiple(Ptr<SelectiveSearchSegmentationStrategy> s1, Ptr<SelectiveSearchSegmentationStrategy> s2, Ptr<SelectiveSearchSegmentationStrategy> s3, Ptr<SelectiveSearchSegmentationStrategy> s4); + + /** @brief Selective search segmentation algorithm + The class implements the algorithm described in @cite uijlings2013selective. + */ + class CV_EXPORTS_W SelectiveSearchSegmentation : public Algorithm { + public: + + /** @brief Set a image used by switch* functions to initialize the class + @param img The image + */ + CV_WRAP virtual void setBaseImage(InputArray img) = 0; + + /** @brief Initialize the class with the 'Single stragegy' parameters describled in @cite uijlings2013selective. + @param k The k parameter for the graph segmentation + @param sigma The sigma parameter for the graph segmentation + */ + CV_WRAP virtual void switchToSingleStrategy(int k = 200, float sigma = 0.8f) = 0; + + /** @brief Initialize the class with the 'Selective search fast' parameters describled in @cite uijlings2013selective. + @param base_k The k parameter for the first graph segmentation + @param inc_k The increment of the k parameter for all graph segmentations + @param sigma The sigma parameter for the graph segmentation + */ + CV_WRAP virtual void switchToSelectiveSearchFast(int base_k = 150, int inc_k = 150, float sigma = 0.8f) = 0; + + /** @brief Initialize the class with the 'Selective search fast' parameters describled in @cite uijlings2013selective. + @param base_k The k parameter for the first graph segmentation + @param inc_k The increment of the k parameter for all graph segmentations + @param sigma The sigma parameter for the graph segmentation + */ + CV_WRAP virtual void switchToSelectiveSearchQuality(int base_k = 150, int inc_k = 150, float sigma = 0.8f) = 0; + + /** @brief Add a new image in the list of images to process. + @param img The image + */ + CV_WRAP virtual void addImage(InputArray img) = 0; + + /** @brief Clear the list of images to process + */ + CV_WRAP virtual void clearImages() = 0; + + /** @brief Add a new graph segmentation in the list of graph segementations to process. + @param g The graph segmentation + */ + CV_WRAP virtual void addGraphSegmentation(Ptr<GraphSegmentation> g) = 0; + + /** @brief Clear the list of graph segmentations to process; + */ + CV_WRAP virtual void clearGraphSegmentations() = 0; + + /** @brief Add a new strategy in the list of strategy to process. + @param s The strategy + */ + CV_WRAP virtual void addStrategy(Ptr<SelectiveSearchSegmentationStrategy> s) = 0; + + /** @brief Clear the list of strategy to process; + */ + CV_WRAP virtual void clearStrategies() = 0; + + /** @brief Based on all images, graph segmentations and stragies, computes all possible rects and return them + @param rects The list of rects. The first ones are more relevents than the lasts ones. + */ + CV_WRAP virtual void process(std::vector<Rect>& rects) = 0; + }; + + /** @brief Create a new SelectiveSearchSegmentation class. + */ + CV_EXPORTS_W Ptr<SelectiveSearchSegmentation> createSelectiveSearchSegmentation(); + + //! @} + + } + } +} + +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/slic.hpp b/thirdparty/linux/include/opencv2/ximgproc/slic.hpp new file mode 100644 index 0000000..8b99a65 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/slic.hpp @@ -0,0 +1,168 @@ +/********************************************************************* + * Software License Agreement (BSD License) + * + * Copyright (c) 2013 + * Radhakrishna Achanta + * email : Radhakrishna [dot] Achanta [at] epfl [dot] ch + * web : http://ivrl.epfl.ch/people/achanta + * + * 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 name of the copyright holders nor the names of its + * 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 THE + * COPYRIGHT OWNER 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. + *********************************************************************/ + +/* + "SLIC Superpixels Compared to State-of-the-art Superpixel Methods" + Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, + and Sabine Susstrunk, IEEE TPAMI, Volume 34, Issue 11, Pages 2274-2282, + November 2012. + + "SLIC Superpixels" Radhakrishna Achanta, Appu Shaji, Kevin Smith, + Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk, EPFL Technical + Report no. 149300, June 2010. + + OpenCV port by: Cristian Balint <cristian dot balint at gmail dot com> + */ + +#ifndef __OPENCV_SLIC_HPP__ +#define __OPENCV_SLIC_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +//! @addtogroup ximgproc_superpixel +//! @{ + + enum SLIC { SLIC = 100, SLICO = 101, MSLIC = 102 }; + +/** @brief Class implementing the SLIC (Simple Linear Iterative Clustering) superpixels +algorithm described in @cite Achanta2012. + +SLIC (Simple Linear Iterative Clustering) clusters pixels using pixel channels and image plane space +to efficiently generate compact, nearly uniform superpixels. The simplicity of approach makes it +extremely easy to use a lone parameter specifies the number of superpixels and the efficiency of +the algorithm makes it very practical. +Several optimizations are available for SLIC class: +SLICO stands for "Zero parameter SLIC" and it is an optimization of baseline SLIC descibed in @cite Achanta2012. +MSLIC stands for "Manifold SLIC" and it is an optimization of baseline SLIC described in @cite Liu_2016_CVPR. + */ + +class CV_EXPORTS_W SuperpixelSLIC : public Algorithm +{ +public: + + /** @brief Calculates the actual amount of superpixels on a given segmentation computed + and stored in SuperpixelSLIC object. + */ + CV_WRAP virtual int getNumberOfSuperpixels() const = 0; + + /** @brief Calculates the superpixel segmentation on a given image with the initialized + parameters in the SuperpixelSLIC object. + + This function can be called again without the need of initializing the algorithm with + createSuperpixelSLIC(). This save the computational cost of allocating memory for all the + structures of the algorithm. + + @param num_iterations Number of iterations. Higher number improves the result. + + The function computes the superpixels segmentation of an image with the parameters initialized + with the function createSuperpixelSLIC(). The algorithms starts from a grid of superpixels and + then refines the boundaries by proposing updates of edges boundaries. + + */ + CV_WRAP virtual void iterate( int num_iterations = 10 ) = 0; + + /** @brief Returns the segmentation labeling of the image. + + Each label represents a superpixel, and each pixel is assigned to one superpixel label. + + @param labels_out Return: A CV_32SC1 integer array containing the labels of the superpixel + segmentation. The labels are in the range [0, getNumberOfSuperpixels()]. + + The function returns an image with the labels of the superpixel segmentation. The labels are in + the range [0, getNumberOfSuperpixels()]. + */ + CV_WRAP virtual void getLabels( OutputArray labels_out ) const = 0; + + /** @brief Returns the mask of the superpixel segmentation stored in SuperpixelSLIC object. + + @param image Return: CV_8U1 image mask where -1 indicates that the pixel is a superpixel border, + and 0 otherwise. + + @param thick_line If false, the border is only one pixel wide, otherwise all pixels at the border + are masked. + + The function return the boundaries of the superpixel segmentation. + */ + CV_WRAP virtual void getLabelContourMask( OutputArray image, bool thick_line = true ) const = 0; + + /** @brief Enforce label connectivity. + + @param min_element_size The minimum element size in percents that should be absorbed into a bigger + superpixel. Given resulted average superpixel size valid value should be in 0-100 range, 25 means + that less then a quarter sized superpixel should be absorbed, this is default. + + The function merge component that is too small, assigning the previously found adjacent label + to this component. Calling this function may change the final number of superpixels. + */ + CV_WRAP virtual void enforceLabelConnectivity( int min_element_size = 25 ) = 0; + + +}; + +/** @brief Initialize a SuperpixelSLIC object + +@param image Image to segment +@param algorithm Chooses the algorithm variant to use: +SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor, +while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels. +@param region_size Chooses an average superpixel size measured in pixels +@param ruler Chooses the enforcement of superpixel smoothness factor of superpixel + +The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed +superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future +computing iterations over the given image. For enanched results it is recommended for color images to +preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into +CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture. + + + + */ + + CV_EXPORTS_W Ptr<SuperpixelSLIC> createSuperpixelSLIC( InputArray image, int algorithm = SLICO, + int region_size = 10, float ruler = 10.0f ); + +//! @} + +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/sparse_match_interpolator.hpp b/thirdparty/linux/include/opencv2/ximgproc/sparse_match_interpolator.hpp new file mode 100644 index 0000000..fffcfd6 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/sparse_match_interpolator.hpp @@ -0,0 +1,132 @@ +/* + * 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_SPARSEMATCHINTERPOLATOR_HPP__ +#define __OPENCV_SPARSEMATCHINTERPOLATOR_HPP__ +#ifdef __cplusplus + +#include <opencv2/core.hpp> + +namespace cv { +namespace ximgproc { + +//! @addtogroup ximgproc_filters +//! @{ + +/** @brief Main interface for all filters, that take sparse matches as an +input and produce a dense per-pixel matching (optical flow) as an output. + */ +class CV_EXPORTS_W SparseMatchInterpolator : public Algorithm +{ +public: + /** @brief Interpolate input sparse matches. + + @param from_image first of the two matched images, 8-bit single-channel or three-channel. + + @param from_points points of the from_image for which there are correspondences in the + to_image (Point2f vector, size shouldn't exceed 32767) + + @param to_image second of the two matched images, 8-bit single-channel or three-channel. + + @param to_points points in the to_image corresponding to from_points + (Point2f vector, size shouldn't exceed 32767) + + @param dense_flow output dense matching (two-channel CV_32F image) + */ + CV_WRAP virtual void interpolate(InputArray from_image, InputArray from_points, + InputArray to_image , InputArray to_points, + OutputArray dense_flow) = 0; +}; + +/** @brief Sparse match interpolation algorithm based on modified locally-weighted affine +estimator from @cite Revaud2015 and Fast Global Smoother as post-processing filter. + */ +class CV_EXPORTS_W EdgeAwareInterpolator : public SparseMatchInterpolator +{ +public: + /** @brief K is a number of nearest-neighbor matches considered, when fitting a locally affine + model. Usually it should be around 128. However, lower values would make the interpolation + noticeably faster. + */ + CV_WRAP virtual void setK(int _k) = 0; + /** @see setK */ + CV_WRAP virtual int getK() = 0; + + /** @brief Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine + fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the + output flow. + */ + CV_WRAP virtual void setSigma(float _sigma) = 0; + /** @see setSigma */ + CV_WRAP virtual float getSigma() = 0; + + /** @brief Lambda is a parameter defining the weight of the edge-aware term in geodesic distance, + should be in the range of 0 to 1000. + */ + CV_WRAP virtual void setLambda(float _lambda) = 0; + /** @see setLambda */ + CV_WRAP virtual float getLambda() = 0; + + /** @brief Sets whether the fastGlobalSmootherFilter() post-processing is employed. It is turned on by + default. + */ + CV_WRAP virtual void setUsePostProcessing(bool _use_post_proc) = 0; + /** @see setUsePostProcessing */ + CV_WRAP virtual bool getUsePostProcessing() = 0; + + /** @brief Sets the respective fastGlobalSmootherFilter() parameter. + */ + CV_WRAP virtual void setFGSLambda(float _lambda) = 0; + /** @see setFGSLambda */ + CV_WRAP virtual float getFGSLambda() = 0; + + /** @see setFGSLambda */ + CV_WRAP virtual void setFGSSigma(float _sigma) = 0; + /** @see setFGSLambda */ + CV_WRAP virtual float getFGSSigma() = 0; +}; + +/** @brief Factory method that creates an instance of the +EdgeAwareInterpolator. +*/ +CV_EXPORTS_W +Ptr<EdgeAwareInterpolator> createEdgeAwareInterpolator(); + +//! @} +} +} +#endif +#endif diff --git a/thirdparty/linux/include/opencv2/ximgproc/structured_edge_detection.hpp b/thirdparty/linux/include/opencv2/ximgproc/structured_edge_detection.hpp new file mode 100644 index 0000000..db6e906 --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/structured_edge_detection.hpp @@ -0,0 +1,128 @@ +/*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-2011, 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*/ + +#ifndef __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__ +#define __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__ +#ifdef __cplusplus + +/** @file +@date Jun 17, 2014 +@author Yury Gitman + */ + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace ximgproc +{ + +//! @addtogroup ximgproc_edge +//! @{ + +/*! + Helper class for training part of [P. Dollar and C. L. Zitnick. Structured Forests for Fast Edge Detection, 2013]. + */ +class CV_EXPORTS_W RFFeatureGetter : public Algorithm +{ +public: + + /*! + * This functions extracts feature channels from src. + * Than StructureEdgeDetection uses this feature space + * to detect edges. + * + * \param src : source image to extract features + * \param features : output n-channel floating point feature matrix. + * + * \param gnrmRad : __rf.options.gradientNormalizationRadius + * \param gsmthRad : __rf.options.gradientSmoothingRadius + * \param shrink : __rf.options.shrinkNumber + * \param outNum : __rf.options.numberOfOutputChannels + * \param gradNum : __rf.options.numberOfGradientOrientations + */ + CV_WRAP virtual void getFeatures(const Mat &src, Mat &features, + const int gnrmRad, + const int gsmthRad, + const int shrink, + const int outNum, + const int gradNum) const = 0; +}; + +CV_EXPORTS_W Ptr<RFFeatureGetter> createRFFeatureGetter(); + + + +/** @brief Class implementing edge detection algorithm from @cite Dollar2013 : + */ +class CV_EXPORTS_W StructuredEdgeDetection : public Algorithm +{ +public: + + /** @brief The function detects edges in src and draw them to dst. + + The algorithm underlies this function is much more robust to texture presence, than common + approaches, e.g. Sobel + @param src source image (RGB, float, in [0;1]) to detect edges + @param dst destination image (grayscale, float, in [0;1]) where edges are drawn + @sa Sobel, Canny + */ + CV_WRAP virtual void detectEdges(const Mat &src, CV_OUT Mat &dst) const = 0; +}; + +/*! +* The only constructor +* +* \param model : name of the file where the model is stored +* \param howToGetFeatures : optional object inheriting from RFFeatureGetter. +* You need it only if you would like to train your +* own forest, pass NULL otherwise +*/ +CV_EXPORTS_W Ptr<StructuredEdgeDetection> createStructuredEdgeDetection(const String &model, + Ptr<const RFFeatureGetter> howToGetFeatures = Ptr<RFFeatureGetter>()); + +//! @} + +} +} +#endif +#endif /* __OPENCV_STRUCTURED_EDGE_DETECTION_HPP__ */ diff --git a/thirdparty/linux/include/opencv2/ximgproc/weighted_median_filter.hpp b/thirdparty/linux/include/opencv2/ximgproc/weighted_median_filter.hpp new file mode 100644 index 0000000..30a169c --- /dev/null +++ b/thirdparty/linux/include/opencv2/ximgproc/weighted_median_filter.hpp @@ -0,0 +1,95 @@ +/*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) 2015, The Chinese University of Hong Kong, 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_WEIGHTED_MEDIAN_FILTER_HPP__ +#define __OPENCV_WEIGHTED_MEDIAN_FILTER_HPP__ +#ifdef __cplusplus + +/** +* @file +* @date Sept 9, 2015 +* @author Zhou Chao +*/ + +#include <opencv2/core.hpp> +#include <string> + +namespace cv +{ +namespace ximgproc +{ + +/** +* @brief Specifies weight types of weighted median filter. +*/ +enum WMFWeightType +{ + WMF_EXP, //!< \f$exp(-|I1-I2|^2/(2*sigma^2))\f$ + WMF_IV1, //!< \f$(|I1-I2|+sigma)^-1\f$ + WMF_IV2, //!< \f$(|I1-I2|^2+sigma^2)^-1\f$ + WMF_COS, //!< \f$dot(I1,I2)/(|I1|*|I2|)\f$ + WMF_JAC, //!< \f$(min(r1,r2)+min(g1,g2)+min(b1,b2))/(max(r1,r2)+max(g1,g2)+max(b1,b2))\f$ + WMF_OFF //!< unweighted +}; + +/** +* @brief Applies weighted median filter to an image. +* +* For more details about this implementation, please see @cite zhang2014100+ +* +* @param joint Joint 8-bit, 1-channel or 3-channel image. +* @param src Source 8-bit or floating-point, 1-channel or 3-channel image. +* @param dst Destination image. +* @param r Radius of filtering kernel, should be a positive integer. +* @param sigma Filter range standard deviation for the joint image. +* @param weightType weightType The type of weight definition, see WMFWeightType +* @param mask A 0-1 mask that has the same size with I. This mask is used to ignore the effect of some pixels. If the pixel value on mask is 0, +* the pixel will be ignored when maintaining the joint-histogram. This is useful for applications like optical flow occlusion handling. +* +* @sa medianBlur, jointBilateralFilter +*/ +CV_EXPORTS void weightedMedianFilter(InputArray joint, InputArray src, OutputArray dst, int r, double sigma=25.5, WMFWeightType weightType=WMF_EXP, Mat mask=Mat()); +} +} + +#endif +#endif |