diff options
Diffstat (limited to 'thirdparty1/linux/include/opencv2/xphoto/white_balance.hpp')
| -rw-r--r-- | thirdparty1/linux/include/opencv2/xphoto/white_balance.hpp | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/thirdparty1/linux/include/opencv2/xphoto/white_balance.hpp b/thirdparty1/linux/include/opencv2/xphoto/white_balance.hpp new file mode 100644 index 0000000..1767f1f --- /dev/null +++ b/thirdparty1/linux/include/opencv2/xphoto/white_balance.hpp @@ -0,0 +1,230 @@ +/*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_SIMPLE_COLOR_BALANCE_HPP__ +#define __OPENCV_SIMPLE_COLOR_BALANCE_HPP__ + +/** @file +@date Jun 26, 2014 +@author Yury Gitman +*/ + +#include <opencv2/core.hpp> + +namespace cv +{ +namespace xphoto +{ + +//! @addtogroup xphoto +//! @{ + +/** @brief The base class for auto white balance algorithms. + */ +class CV_EXPORTS_W WhiteBalancer : public Algorithm +{ + public: + /** @brief Applies white balancing to the input image + + @param src Input image + @param dst White balancing result + @sa cvtColor, equalizeHist + */ + CV_WRAP virtual void balanceWhite(InputArray src, OutputArray dst) = 0; +}; + +/** @brief A simple white balance algorithm that works by independently stretching + each of the input image channels to the specified range. For increased robustness + it ignores the top and bottom \f$p\%\f$ of pixel values. + */ +class CV_EXPORTS_W SimpleWB : public WhiteBalancer +{ + public: + /** @brief Input image range minimum value + @see setInputMin */ + CV_WRAP virtual float getInputMin() const = 0; + /** @copybrief getInputMin @see getInputMin */ + CV_WRAP virtual void setInputMin(float val) = 0; + + /** @brief Input image range maximum value + @see setInputMax */ + CV_WRAP virtual float getInputMax() const = 0; + /** @copybrief getInputMax @see getInputMax */ + CV_WRAP virtual void setInputMax(float val) = 0; + + /** @brief Output image range minimum value + @see setOutputMin */ + CV_WRAP virtual float getOutputMin() const = 0; + /** @copybrief getOutputMin @see getOutputMin */ + CV_WRAP virtual void setOutputMin(float val) = 0; + + /** @brief Output image range maximum value + @see setOutputMax */ + CV_WRAP virtual float getOutputMax() const = 0; + /** @copybrief getOutputMax @see getOutputMax */ + CV_WRAP virtual void setOutputMax(float val) = 0; + + /** @brief Percent of top/bottom values to ignore + @see setP */ + CV_WRAP virtual float getP() const = 0; + /** @copybrief getP @see getP */ + CV_WRAP virtual void setP(float val) = 0; +}; + +/** @brief Creates an instance of SimpleWB + */ +CV_EXPORTS_W Ptr<SimpleWB> createSimpleWB(); + +/** @brief Gray-world white balance algorithm + +This algorithm scales the values of pixels based on a +gray-world assumption which states that the average of all channels +should result in a gray image. + +It adds a modification which thresholds pixels based on their +saturation value and only uses pixels below the provided threshold in +finding average pixel values. + +Saturation is calculated using the following for a 3-channel RGB image per +pixel I and is in the range [0, 1]: + +\f[ \texttt{Saturation} [I] = \frac{\textrm{max}(R,G,B) - \textrm{min}(R,G,B) +}{\textrm{max}(R,G,B)} \f] + +A threshold of 1 means that all pixels are used to white-balance, while a +threshold of 0 means no pixels are used. Lower thresholds are useful in +white-balancing saturated images. + +Currently supports images of type @ref CV_8UC3 and @ref CV_16UC3. + */ +class CV_EXPORTS_W GrayworldWB : public WhiteBalancer +{ + public: + /** @brief Maximum saturation for a pixel to be included in the + gray-world assumption + @see setSaturationThreshold */ + CV_WRAP virtual float getSaturationThreshold() const = 0; + /** @copybrief getSaturationThreshold @see getSaturationThreshold */ + CV_WRAP virtual void setSaturationThreshold(float val) = 0; +}; + +/** @brief Creates an instance of GrayworldWB + */ +CV_EXPORTS_W Ptr<GrayworldWB> createGrayworldWB(); + +/** @brief More sophisticated learning-based automatic white balance algorithm. + +As @ref GrayworldWB, this algorithm works by applying different gains to the input +image channels, but their computation is a bit more involved compared to the +simple gray-world assumption. More details about the algorithm can be found in +@cite Cheng2015 . + +To mask out saturated pixels this function uses only pixels that satisfy the +following condition: + +\f[ \frac{\textrm{max}(R,G,B)}{\texttt{range_max_val}} < \texttt{saturation_thresh} \f] + +Currently supports images of type @ref CV_8UC3 and @ref CV_16UC3. + */ +class CV_EXPORTS_W LearningBasedWB : public WhiteBalancer +{ + public: + /** @brief Implements the feature extraction part of the algorithm. + + In accordance with @cite Cheng2015 , computes the following features for the input image: + 1. Chromaticity of an average (R,G,B) tuple + 2. Chromaticity of the brightest (R,G,B) tuple (while ignoring saturated pixels) + 3. Chromaticity of the dominant (R,G,B) tuple (the one that has the highest value in the RGB histogram) + 4. Mode of the chromaticity palette, that is constructed by taking 300 most common colors according to + the RGB histogram and projecting them on the chromaticity plane. Mode is the most high-density point + of the palette, which is computed by a straightforward fixed-bandwidth kernel density estimator with + a Epanechnikov kernel function. + + @param src Input three-channel image (BGR color space is assumed). + @param dst An array of four (r,g) chromaticity tuples corresponding to the features listed above. + */ + CV_WRAP virtual void extractSimpleFeatures(InputArray src, OutputArray dst) = 0; + + /** @brief Maximum possible value of the input image (e.g. 255 for 8 bit images, + 4095 for 12 bit images) + @see setRangeMaxVal */ + CV_WRAP virtual int getRangeMaxVal() const = 0; + /** @copybrief getRangeMaxVal @see getRangeMaxVal */ + CV_WRAP virtual void setRangeMaxVal(int val) = 0; + + /** @brief Threshold that is used to determine saturated pixels, i.e. pixels where at least one of the + channels exceeds \f$\texttt{saturation_threshold}\times\texttt{range_max_val}\f$ are ignored. + @see setSaturationThreshold */ + CV_WRAP virtual float getSaturationThreshold() const = 0; + /** @copybrief getSaturationThreshold @see getSaturationThreshold */ + CV_WRAP virtual void setSaturationThreshold(float val) = 0; + + /** @brief Defines the size of one dimension of a three-dimensional RGB histogram that is used internally + by the algorithm. It often makes sense to increase the number of bins for images with higher bit depth + (e.g. 256 bins for a 12 bit image). + @see setHistBinNum */ + CV_WRAP virtual int getHistBinNum() const = 0; + /** @copybrief getHistBinNum @see getHistBinNum */ + CV_WRAP virtual void setHistBinNum(int val) = 0; +}; + +/** @brief Creates an instance of LearningBasedWB + +@param path_to_model Path to a .yml file with the model. If not specified, the default model is used + */ +CV_EXPORTS_W Ptr<LearningBasedWB> createLearningBasedWB(const String& path_to_model = String()); + +/** @brief Implements an efficient fixed-point approximation for applying channel gains, which is + the last step of multiple white balance algorithms. + +@param src Input three-channel image in the BGR color space (either CV_8UC3 or CV_16UC3) +@param dst Output image of the same size and type as src. +@param gainB gain for the B channel +@param gainG gain for the G channel +@param gainR gain for the R channel +*/ +CV_EXPORTS_W void applyChannelGains(InputArray src, OutputArray dst, float gainB, float gainG, float gainR); +//! @} +} +} + +#endif // __OPENCV_SIMPLE_COLOR_BALANCE_HPP__ |