/*M///////////////////////////////////////////////////////////////////////////////////////

//

//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.

//

//  By downloading, copying, installing or using the software you agree to this license.

//  If you do not agree to this license, do not download, install,

//  copy or use the software.

//

//

//                           License Agreement

//                For Open Source Computer Vision Library

//

// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.

// Copyright (C) 2009, Willow Garage Inc., all rights reserved.

// Third party copyrights are property of their respective owners.

//

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

// are permitted provided that the following conditions are met:

//

//   * Redistribution's of source code must retain the above copyright notice,

//     this list of conditions and the following disclaimer.

//

//   * Redistribution's in binary form must reproduce the above copyright notice,

//     this list of conditions and the following disclaimer in the documentation

//     and/or other materials provided with the distribution.

//

//   * The name of the copyright holders may not be used to endorse or promote products

//     derived from this software without specific prior written permission.

//

// This software is provided by the copyright holders and contributors "as is" and

// any express or implied warranties, including, but not limited to, the implied

// warranties of merchantability and fitness for a particular purpose are disclaimed.

// In no event shall the Intel Corporation or contributors be liable for any direct,

// indirect, incidental, special, exemplary, or consequential damages

// (including, but not limited to, procurement of substitute goods or services;

// loss of use, data, or profits; or business interruption) however caused

// and on any theory of liability, whether in contract, strict liability,

// or tort (including negligence or otherwise) arising in any way out of

// the use of this software, even if advised of the possibility of such damage.

//

//M*/

#ifndef OPENCV_IMGPROC_HPP

#define OPENCV_IMGPROC_HPP

#include "opencv2/core.hpp"

/**

@defgroup imgproc Image Processing

This module offers a comprehensive suite of image processing functions, enabling tasks such as those listed above.

@{

    @defgroup imgproc_filter Image Filtering

    Functions and classes described in this section are used to perform various linear or non-linear

    filtering operations on 2D images (represented as Mat's). It means that for each pixel location

    \f$(x,y)\f$ in the source image (normally, rectangular), its neighborhood is considered and used to

    compute the response. In case of a linear filter, it is a weighted sum of pixel values. In case of

    morphological operations, it is the minimum or maximum values, and so on. The computed response is

    stored in the destination image at the same location \f$(x,y)\f$. It means that the output image

    will be of the same size as the input image. Normally, the functions support multi-channel arrays,

    in which case every channel is processed independently. Therefore, the output image will also have

    the same number of channels as the input one.

    Another common feature of the functions and classes described in this section is that, unlike

    simple arithmetic functions, they need to extrapolate values of some non-existing pixels. For

    example, if you want to smooth an image using a Gaussian \f$3 \times 3\f$ filter, then, when

    processing the left-most pixels in each row, you need pixels to the left of them, that is, outside

    of the image. You can let these pixels be the same as the left-most image pixels ("replicated

    border" extrapolation method), or assume that all the non-existing pixels are zeros ("constant

    border" extrapolation method), and so on. OpenCV enables you to specify the extrapolation method.

    For details, see #BorderTypes

    @anchor filter_depths

    ### Depth combinations

    Input depth (src.depth()) | Output depth (ddepth)

    --------------------------|----------------------

    CV_8U                     | -1/CV_16S/CV_32F/CV_64F

    CV_16U/CV_16S             | -1/CV_32F/CV_64F

    CV_32F                    | -1/CV_32F

    CV_64F                    | -1/CV_64F

    @note when ddepth=-1, the output image will have the same depth as the source.

    @note if you need double floating-point accuracy and using single floating-point input data

    (CV_32F input and CV_64F output depth combination), you can use @ref Mat.convertTo to convert

    the input data to the desired precision.

    @defgroup imgproc_transform Geometric Image Transformations

    The functions in this section perform various geometrical transformations of 2D images. They do not

    change the image content but deform the pixel grid and map this deformed grid to the destination

    image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from

    destination to the source. That is, for each pixel \f$(x, y)\f$ of the destination image, the

    functions compute coordinates of the corresponding "donor" pixel in the source image and copy the

    pixel value:

    \f[\texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))\f]

    In case when you specify the forward mapping \f$\left<g_x, g_y\right>: \texttt{src} \rightarrow

    \texttt{dst}\f$, the OpenCV functions first compute the corresponding inverse mapping

    \f$\left<f_x, f_y\right>: \texttt{dst} \rightarrow \texttt{src}\f$ and then use the above formula.

    The actual implementations of the geometrical transformations, from the most generic remap and to

    the simplest and the fastest resize, need to solve two main problems with the above formula:

    - Extrapolation of non-existing pixels. Similarly to the filtering functions described in the

    previous section, for some \f$(x,y)\f$, either one of \f$f_x(x,y)\f$, or \f$f_y(x,y)\f$, or both

    of them may fall outside of the image. In this case, an extrapolation method needs to be used.

    OpenCV provides the same selection of extrapolation methods as in the filtering functions. In

    addition, it provides the method #BORDER_TRANSPARENT. This means that the corresponding pixels in

    the destination image will not be modified at all.

    - Interpolation of pixel values. Usually \f$f_x(x,y)\f$ and \f$f_y(x,y)\f$ are floating-point

    numbers. This means that \f$\left<f_x, f_y\right>\f$ can be either an affine or perspective

    transformation, or radial lens distortion correction, and so on. So, a pixel value at fractional

    coordinates needs to be retrieved. In the simplest case, the coordinates can be just rounded to the

    nearest integer coordinates and the corresponding pixel can be used. This is called a

    nearest-neighbor interpolation. However, a better result can be achieved by using more

    sophisticated [interpolation methods](https://en.wikipedia.org/wiki/Multivariate_interpolation) ,

    where a polynomial function is fit into some neighborhood of the computed pixel \f$(f_x(x,y),

    f_y(x,y))\f$, and then the value of the polynomial at \f$(f_x(x,y), f_y(x,y))\f$ is taken as the

    interpolated pixel value. In OpenCV, you can choose between several interpolation methods. See

    #resize for details.

    @note The geometrical transformations do not work with `CV_8S` or `CV_32S` images.

    @defgroup imgproc_misc Miscellaneous Image Transformations

    @defgroup imgproc_draw Drawing Functions

    Drawing functions work with matrices/images of arbitrary depth. The boundaries of the shapes can be

    rendered with antialiasing (implemented only for 8-bit images for now). All the functions include

    the parameter color that uses an RGB value (that may be constructed with the Scalar constructor )

    for color images and brightness for grayscale images. For color images, the channel ordering is

    normally *Blue, Green, Red*. This is what imshow, imread, and imwrite expect. So, if you form a

    color using the Scalar constructor, it should look like:

    \f[\texttt{Scalar} (blue \_ component, green \_ component, red \_ component[, alpha \_ component])\f]

    If you are using your own image rendering and I/O functions, you can use any channel ordering. The

    drawing functions process each channel independently and do not depend on the channel order or even

    on the used color space. The whole image can be converted from BGR to RGB or to a different color

    space using cvtColor .

    If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also,

    many drawing functions can handle pixel coordinates specified with sub-pixel accuracy. This means

    that the coordinates can be passed as fixed-point numbers encoded as integers. The number of

    fractional bits is specified by the shift parameter and the real point coordinates are calculated as

    \f$\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})\f$ . This feature is

    especially effective when rendering antialiased shapes.

    @note The functions do not support alpha-transparency when the target image is 4-channel. In this

    case, the color[3] is simply copied to the repainted pixels. Thus, if you want to paint

    semi-transparent shapes, you can paint them in a separate buffer and then blend it with the main

    image.

    @defgroup imgproc_color_conversions Color Space Conversions

    @defgroup imgproc_colormap ColorMaps in OpenCV

    The human perception isn't built for observing fine changes in grayscale images. Human eyes are more

    sensitive to observing changes between colors, so you often need to recolor your grayscale images to

    get a clue about them. OpenCV now comes with various colormaps to enhance the visualization in your

    computer vision application.

    In OpenCV you only need applyColorMap to apply a colormap on a given image. The following sample

    code reads the path to an image from command line, applies a Jet colormap on it and shows the

    result:

    @include snippets/imgproc_applyColorMap.cpp

    @see #ColormapTypes

    @defgroup imgproc_subdiv2d Planar Subdivision

    The Subdiv2D class described in this section is used to perform various planar subdivision on

    a set of 2D points (represented as vector of Point2f). OpenCV subdivides a plane into triangles

    using the Delaunay's algorithm, which corresponds to the dual graph of the Voronoi diagram.

    In the figure below, the Delaunay's triangulation is marked with black lines and the Voronoi

    diagram with red lines.

    ![Delaunay triangulation (black) and Voronoi (red)](pics/delaunay_voronoi.png)

    The subdivisions can be used for the 3D piece-wise transformation of a plane, morphing, fast

    location of points on the plane, building special graphs (such as NNG,RNG), and so forth.

    @defgroup imgproc_hist Histograms

    @defgroup imgproc_shape Structural Analysis and Shape Descriptors

    @defgroup imgproc_motion Motion Analysis and Object Tracking

    @defgroup imgproc_feature Feature Detection

    @defgroup imgproc_object Object Detection

    @defgroup imgproc_segmentation Image Segmentation

    @defgroup imgproc_hal Hardware Acceleration Layer

    @{

        @defgroup imgproc_hal_functions Functions

        @defgroup imgproc_hal_interface Interface

    @}

  @}

*/

namespace cv

{

/** @addtogroup imgproc

@{

*/

//! @addtogroup imgproc_filter

//! @{

enum SpecialFilter {

    FILTER_SCHARR = -1

};

//! type of morphological operation

enum MorphTypes{

    MORPH_ERODE    = 0, //!< see #erode

    MORPH_DILATE   = 1, //!< see #dilate

    MORPH_OPEN     = 2, //!< an opening operation

                        //!< \f[\texttt{dst} = \mathrm{open} ( \texttt{src} , \texttt{kernel} )= \mathrm{dilate} ( \mathrm{erode} ( \texttt{src} , \texttt{kernel} ))\f]

    MORPH_CLOSE    = 3, //!< a closing operation

                        //!< \f[\texttt{dst} = \mathrm{close} ( \texttt{src} , \texttt{kernel} )= \mathrm{erode} ( \mathrm{dilate} ( \texttt{src} , \texttt{kernel} ))\f]

    MORPH_GRADIENT = 4, //!< a morphological gradient

                        //!< \f[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src} , \texttt{kernel} )= \mathrm{dilate} ( \texttt{src} , \texttt{kernel} )- \mathrm{erode} ( \texttt{src} , \texttt{kernel} )\f]

    MORPH_TOPHAT   = 5, //!< "top hat"

                        //!< \f[\texttt{dst} = \mathrm{tophat} ( \texttt{src} , \texttt{kernel} )= \texttt{src} - \mathrm{open} ( \texttt{src} , \texttt{kernel} )\f]

    MORPH_BLACKHAT = 6, //!< "black hat"

                        //!< \f[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} , \texttt{kernel} )= \mathrm{close} ( \texttt{src} , \texttt{kernel} )- \texttt{src}\f]

    MORPH_HITMISS  = 7  //!< "hit or miss"

                        //!<   .- Only supported for CV_8UC1 binary images. A tutorial can be found in the documentation

};

//! shape of the structuring element

enum MorphShapes {

    MORPH_RECT    = 0, //!< a rectangular structuring element:  \f[E_{ij}=1\f]

    MORPH_CROSS   = 1, //!< a cross-shaped structuring element:

                       //!< \f[E_{ij} = \begin{cases} 1 & \texttt{if } {i=\texttt{anchor.y } {or } {j=\texttt{anchor.x}}} \\0 & \texttt{otherwise} \end{cases}\f]

    MORPH_ELLIPSE = 2, //!< an elliptic structuring element, that is, a filled ellipse inscribed

                      //!< into the rectangle Rect(0, 0, esize.width, esize.height)

    MORPH_DIAMOND = 3  //!< a diamond structuring element defined by Manhattan distance

};

//! @} imgproc_filter

//! @addtogroup imgproc_transform

//! @{

//! interpolation algorithm

enum InterpolationFlags{

    /** nearest neighbor interpolation */

    INTER_NEAREST        = 0,

    /** bilinear interpolation */

    INTER_LINEAR         = 1,

    /** bicubic interpolation */

    INTER_CUBIC          = 2,

    /** resampling using pixel area relation. It may be a preferred method for image decimation, as

    it gives moire'-free results. But when the image is zoomed, it is similar to the INTER_NEAREST

    method. */

    INTER_AREA           = 3,

    /** Lanczos interpolation over 8x8 neighborhood */

    INTER_LANCZOS4       = 4,

    /** Bit exact bilinear interpolation */

    INTER_LINEAR_EXACT = 5,

    /** Bit exact nearest neighbor interpolation. This will produce same results as

    the nearest neighbor method in PIL, scikit-image or Matlab. */

    INTER_NEAREST_EXACT  = 6,

    /** mask for interpolation codes */

    INTER_MAX            = 7,

    /** flag, fills all of the destination image pixels. If some of them correspond to outliers in the

    source image, they are set to zero */

    WARP_FILL_OUTLIERS   = 8,

    /** flag, inverse transformation

    For example, #linearPolar or #logPolar transforms:

    - flag is __not__ set: \f$dst( \rho , \phi ) = src(x,y)\f$

    - flag is set: \f$dst(x,y) = src( \rho , \phi )\f$

    */

    WARP_INVERSE_MAP     = 16,

    WARP_RELATIVE_MAP    = 32

};

/** \brief Specify the polar mapping mode

@sa warpPolar

*/

enum WarpPolarMode

{

    WARP_POLAR_LINEAR = 0, ///< Remaps an image to/from polar space.

    WARP_POLAR_LOG = 256   ///< Remaps an image to/from semilog-polar space.

};

enum InterpolationMasks {

       INTER_BITS      = 5,

       INTER_BITS2     = INTER_BITS * 2,

       INTER_TAB_SIZE  = 1 << INTER_BITS,

       INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE

     };

//! @} imgproc_transform

//! @addtogroup imgproc_misc

//! @{

//! Distance types for Distance Transform and M-estimators

//! @see distanceTransform, fitLine

enum DistanceTypes {

    DIST_USER    = -1,  //!< User defined distance

    DIST_L1      = 1,   //!< distance = |x1-x2| + |y1-y2|

    DIST_L2      = 2,   //!< the simple euclidean distance

    DIST_C       = 3,   //!< distance = max(|x1-x2|,|y1-y2|)

    DIST_L12     = 4,   //!< L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))

    DIST_FAIR    = 5,   //!< distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998

    DIST_WELSCH  = 6,   //!< distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846

    DIST_HUBER   = 7    //!< distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345

};

//! Mask size for distance transform

enum DistanceTransformMasks {

    DIST_MASK_3       = 3, //!< mask=3

    DIST_MASK_5       = 5, //!< mask=5

    DIST_MASK_PRECISE = 0  //!<

};

//! type of the threshold operation

//! ![threshold types](pics/threshold.png)

enum ThresholdTypes {

    THRESH_BINARY     = 0, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{maxval}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]

    THRESH_BINARY_INV = 1, //!< \f[\texttt{dst} (x,y) =  \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{maxval}}{otherwise}\f]

    THRESH_TRUNC      = 2, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{threshold}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]

    THRESH_TOZERO     = 3, //!< \f[\texttt{dst} (x,y) =  \fork{\texttt{src}(x,y)}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]

    THRESH_TOZERO_INV = 4, //!< \f[\texttt{dst} (x,y) =  \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]

    THRESH_MASK       = 7,

    THRESH_OTSU       = 8, //!< flag, use Otsu algorithm to choose the optimal threshold value

    THRESH_TRIANGLE   = 16, //!< flag, use Triangle algorithm to choose the optimal threshold value

    THRESH_DRYRUN     = 128 //!< flag, compute threshold only (useful for OTSU/TRIANGLE) but does not actually run thresholding

};

//! adaptive threshold algorithm

//! @see adaptiveThreshold

enum AdaptiveThresholdTypes {

    /** the threshold value \f$T(x,y)\f$ is a mean of the \f$\texttt{blockSize} \times

    \texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$ minus C */

    ADAPTIVE_THRESH_MEAN_C     = 0,

    /** the threshold value \f$T(x, y)\f$ is a weighted sum (cross-correlation with a Gaussian

    window) of the \f$\texttt{blockSize} \times \texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$

    minus C . The default sigma (standard deviation) is used for the specified blockSize . See

    #getGaussianKernel*/

    ADAPTIVE_THRESH_GAUSSIAN_C = 1

};

//! class of the pixel in GrabCut algorithm

enum GrabCutClasses {

    GC_BGD    = 0,  //!< an obvious background pixels

    GC_FGD    = 1,  //!< an obvious foreground (object) pixel

    GC_PR_BGD = 2,  //!< a possible background pixel

    GC_PR_FGD = 3   //!< a possible foreground pixel

};

//! GrabCut algorithm flags

enum GrabCutModes {

    /** The function initializes the state and the mask using the provided rectangle. After that it

    runs iterCount iterations of the algorithm. */

    GC_INIT_WITH_RECT  = 0,

    /** The function initializes the state using the provided mask. Note that GC_INIT_WITH_RECT

    and GC_INIT_WITH_MASK can be combined. Then, all the pixels outside of the ROI are

    automatically initialized with GC_BGD .*/

    GC_INIT_WITH_MASK  = 1,

    /** The value means that the algorithm should just resume. */

    GC_EVAL            = 2,

    /** The value means that the algorithm should just run the grabCut algorithm (a single iteration) with the fixed model */

    GC_EVAL_FREEZE_MODEL = 3

};

//! distanceTransform algorithm flags

enum DistanceTransformLabelTypes {

    /** each connected component of zeros in src (as well as all the non-zero pixels closest to the

    connected component) will be assigned the same label */

    DIST_LABEL_CCOMP = 0,

    /** each zero pixel (and all the non-zero pixels closest to it) gets its own label. */

    DIST_LABEL_PIXEL = 1

};

//! floodfill algorithm flags

enum FloodFillFlags {

    /** If set, the difference between the current pixel and seed pixel is considered. Otherwise,

    the difference between neighbor pixels is considered (that is, the range is floating). */

    FLOODFILL_FIXED_RANGE = 1 << 16,

    /** If set, the function does not change the image ( newVal is ignored), and only fills the

    mask with the value specified in bits 8-16 of flags as described above. This option only make

    sense in function variants that have the mask parameter. */

    FLOODFILL_MASK_ONLY   = 1 << 17

};

//! @} imgproc_misc

//! @addtogroup imgproc_shape

//! @{

//! connected components statistics

enum ConnectedComponentsTypes {

    CC_STAT_LEFT   = 0, //!< The leftmost (x) coordinate which is the inclusive start of the bounding

                        //!< box in the horizontal direction.

    CC_STAT_TOP    = 1, //!< The topmost (y) coordinate which is the inclusive start of the bounding

                        //!< box in the vertical direction.

    CC_STAT_WIDTH  = 2, //!< The horizontal size of the bounding box

    CC_STAT_HEIGHT = 3, //!< The vertical size of the bounding box

    CC_STAT_AREA   = 4, //!< The total area (in pixels) of the connected component

#ifndef CV_DOXYGEN

    CC_STAT_MAX    = 5 //!< Max enumeration value. Used internally only for memory allocation

#endif

};

//! connected components algorithm

enum ConnectedComponentsAlgorithmsTypes {

    CCL_DEFAULT   = -1, //!< Spaghetti @cite Bolelli2019 algorithm for 8-way connectivity, Spaghetti4C @cite Bolelli2021 algorithm for 4-way connectivity.

    CCL_WU        = 0,  //!< SAUF @cite Wu2009 algorithm for 8-way connectivity, SAUF algorithm for 4-way connectivity. The parallel implementation described in @cite Bolelli2017 is available for SAUF.

    CCL_GRANA     = 1,  //!< BBDT @cite Grana2010 algorithm for 8-way connectivity, SAUF algorithm for 4-way connectivity. The parallel implementation described in @cite Bolelli2017 is available for both BBDT and SAUF.

    CCL_BOLELLI   = 2,  //!< Spaghetti @cite Bolelli2019 algorithm for 8-way connectivity, Spaghetti4C @cite Bolelli2021 algorithm for 4-way connectivity. The parallel implementation described in @cite Bolelli2017 is available for both Spaghetti and Spaghetti4C.

    CCL_SAUF      = 3,  //!< Same as CCL_WU. It is preferable to use the flag with the name of the algorithm (CCL_SAUF) rather than the one with the name of the first author (CCL_WU).

    CCL_BBDT      = 4,  //!< Same as CCL_GRANA. It is preferable to use the flag with the name of the algorithm (CCL_BBDT) rather than the one with the name of the first author (CCL_GRANA).

    CCL_SPAGHETTI = 5,  //!< Same as CCL_BOLELLI. It is preferable to use the flag with the name of the algorithm (CCL_SPAGHETTI) rather than the one with the name of the first author (CCL_BOLELLI).

};

//! mode of the contour retrieval algorithm

enum RetrievalModes {

    /** retrieves only the extreme outer contours. It sets `hierarchy[i][2]=hierarchy[i][3]=-1` for

    all the contours. */

    RETR_EXTERNAL  = 0,

    /** retrieves all of the contours without establishing any hierarchical relationships. */

    RETR_LIST      = 1,

    /** retrieves all of the contours and organizes them into a two-level hierarchy. At the top

    level, there are external boundaries of the components. At the second level, there are

    boundaries of the holes. If there is another contour inside a hole of a connected component, it

    is still put at the top level. */

    RETR_CCOMP     = 2,

    /** retrieves all of the contours and reconstructs a full hierarchy of nested contours.*/

    RETR_TREE      = 3,

    RETR_FLOODFILL = 4 //!<

};

//! the contour approximation algorithm

enum ContourApproximationModes {

    /** stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and

    (x2,y2) of the contour will be either horizontal, vertical or diagonal neighbors, that is,

    max(abs(x1-x2),abs(y2-y1))==1. */

    CHAIN_APPROX_NONE      = 1,

    /** compresses horizontal, vertical, and diagonal segments and leaves only their end points.

    For example, an up-right rectangular contour is encoded with 4 points. */

    CHAIN_APPROX_SIMPLE    = 2,

    /** applies one of the flavors of the Teh-Chin chain approximation algorithm @cite TehChin89 */

    CHAIN_APPROX_TC89_L1   = 3,

    /** applies one of the flavors of the Teh-Chin chain approximation algorithm @cite TehChin89 */

    CHAIN_APPROX_TC89_KCOS = 4

};

/** @brief Shape matching methods

\f$A\f$ denotes object1,\f$B\f$ denotes object2

\f$\begin{array}{l} m^A_i =  \mathrm{sign} (h^A_i)  \cdot \log{h^A_i} \\ m^B_i =  \mathrm{sign} (h^B_i)  \cdot \log{h^B_i} \end{array}\f$

and \f$h^A_i, h^B_i\f$ are the Hu moments of \f$A\f$ and \f$B\f$ , respectively.

*/

enum ShapeMatchModes {

    CONTOURS_MATCH_I1  =1, //!< \f[I_1(A,B) =  \sum _{i=1...7}  \left |  \frac{1}{m^A_i} -  \frac{1}{m^B_i} \right |\f]

    CONTOURS_MATCH_I2  =2, //!< \f[I_2(A,B) =  \sum _{i=1...7}  \left | m^A_i - m^B_i  \right |\f]

    CONTOURS_MATCH_I3  =3  //!< \f[I_3(A,B) =  \max _{i=1...7}  \frac{ \left| m^A_i - m^B_i \right| }{ \left| m^A_i \right| }\f]

};

//! @} imgproc_shape

//! @addtogroup imgproc_feature

//! @{

//! Variants of a Hough transform

enum HoughModes {

    /** classical or standard Hough transform. Every line is represented by two floating-point

    numbers \f$(\rho, \theta)\f$ , where \f$\rho\f$ is a distance between (0,0) point and the line,

    and \f$\theta\f$ is the angle between x-axis and the normal to the line. Thus, the matrix must

    be (the created sequence will be) of CV_32FC2 type */

    HOUGH_STANDARD      = 0,

    /** probabilistic Hough transform (more efficient in case if the picture contains a few long

    linear segments). It returns line segments rather than the whole line. Each segment is

    represented by starting and ending points, and the matrix must be (the created sequence will

    be) of the CV_32SC4 type. */

    HOUGH_PROBABILISTIC = 1,

    /** multi-scale variant of the classical Hough transform. The lines are encoded the same way as

    HOUGH_STANDARD. */

    HOUGH_MULTI_SCALE   = 2,

    HOUGH_GRADIENT      = 3, //!< basically *21HT*, described in @cite Yuen90

    HOUGH_GRADIENT_ALT  = 4, //!< variation of HOUGH_GRADIENT to get better accuracy

};

//! Variants of Line Segment %Detector

enum LineSegmentDetectorModes {

    LSD_REFINE_NONE = 0, //!< No refinement applied

    LSD_REFINE_STD  = 1, //!< Standard refinement is applied. E.g. breaking arches into smaller straighter line approximations.

    LSD_REFINE_ADV  = 2  //!< Advanced refinement. Number of false alarms is calculated, lines are

                         //!< refined through increase of precision, decrement in size, etc.

};

//! @} imgproc_feature

/** Histogram comparison methods

  @ingroup imgproc_hist

*/

enum HistCompMethods {

    /** Correlation

    \f[d(H_1,H_2) =  \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) - \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) - \bar{H_2})^2}}\f]

    where

    \f[\bar{H_k} =  \frac{1}{N} \sum _J H_k(J)\f]

    and \f$N\f$ is a total number of histogram bins. */

    HISTCMP_CORREL        = 0,

    /** Chi-Square

    \f[d(H_1,H_2) =  \sum _I  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\f] */

    HISTCMP_CHISQR        = 1,

    /** Intersection

    \f[d(H_1,H_2) =  \sum _I  \min (H_1(I), H_2(I))\f] */

    HISTCMP_INTERSECT     = 2,

    /** Bhattacharyya distance

    (In fact, OpenCV computes Hellinger distance, which is related to Bhattacharyya coefficient.)

    \f[d(H_1,H_2) =  \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}}\f] */

    HISTCMP_BHATTACHARYYA = 3,

    HISTCMP_HELLINGER     = HISTCMP_BHATTACHARYYA, //!< Synonym for HISTCMP_BHATTACHARYYA

    /** Alternative Chi-Square

    \f[d(H_1,H_2) =  2 * \sum _I  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)+H_2(I)}\f]

    This alternative formula is regularly used for texture comparison. See e.g. @cite Puzicha1997 */

    HISTCMP_CHISQR_ALT    = 4,

    /** Kullback-Leibler divergence

    \f[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\f] */

    HISTCMP_KL_DIV        = 5

};

/** the color conversion codes

@see @ref imgproc_color_conversions

@note The source image (src) must be of an appropriate type for the desired color conversion.

- `[8U]` means to support `CV_8U` src type.

- `[16U]` means to support `CV_16U` src type.

- `[32F]` means to support `CV_32F` src type.

@ingroup imgproc_color_conversions

 */

enum ColorConversionCodes {

    COLOR_BGR2BGRA     = 0, //!< [8U/16U/32F] add alpha channel to RGB or BGR image

    COLOR_RGB2RGBA     = COLOR_BGR2BGRA, //!< [8U/16U/32F]

    COLOR_BGRA2BGR     = 1, //!< [8U/16U/32F] remove alpha channel from RGB or BGR image

    COLOR_RGBA2RGB     = COLOR_BGRA2BGR, //!< [8U/16U/32F]

    COLOR_BGR2RGBA     = 2, //!< [8U/16U/32F] convert between RGB and BGR color spaces (with or without alpha channel)

    COLOR_RGB2BGRA     = COLOR_BGR2RGBA, //!< [8U/16U/32F]

    COLOR_RGBA2BGR     = 3, //!< [8U/16U/32F]

    COLOR_BGRA2RGB     = COLOR_RGBA2BGR, //!< [8U/16U/32F]

    COLOR_BGR2RGB      = 4, //!< [8U/16U/32F]

    COLOR_RGB2BGR      = COLOR_BGR2RGB, //!< [8U/16U/32F]

    COLOR_BGRA2RGBA    = 5, //!< [8U/16U/32F]

    COLOR_RGBA2BGRA    = COLOR_BGRA2RGBA, //!< [8U/16U/32F]

    COLOR_BGR2GRAY     = 6, //!< [8U/16U/32F] convert between RGB/BGR and grayscale, @ref color_convert_rgb_gray "color conversions"

    COLOR_RGB2GRAY     = 7, //!< [8U/16U/32F]

    COLOR_GRAY2BGR     = 8, //!< [8U/16U/32F]

    COLOR_GRAY2RGB     = COLOR_GRAY2BGR, //!< [8U/16U/32F]

    COLOR_GRAY2BGRA    = 9, //!< [8U/16U/32F]

    COLOR_GRAY2RGBA    = COLOR_GRAY2BGRA, //!< [8U/16U/32F]

    COLOR_BGRA2GRAY    = 10, //!< [8U/16U/32F]

    COLOR_RGBA2GRAY    = 11, //!< [8U/16U/32F]

    COLOR_BGR2BGR565   = 12, //!< [8U] convert between RGB/BGR and BGR565 (16-bit images)

    COLOR_RGB2BGR565   = 13, //!< [8U]

    COLOR_BGR5652BGR   = 14, //!< [8U]

    COLOR_BGR5652RGB   = 15, //!< [8U]

    COLOR_BGRA2BGR565  = 16, //!< [8U]

    COLOR_RGBA2BGR565  = 17, //!< [8U]

    COLOR_BGR5652BGRA  = 18, //!< [8U]

    COLOR_BGR5652RGBA  = 19, //!< [8U]

    COLOR_GRAY2BGR565  = 20, //!< [8U] convert between grayscale to BGR565 (16-bit images)

    COLOR_BGR5652GRAY  = 21, //!< [8U]

    COLOR_BGR2BGR555   = 22,  //!< [8U] convert between RGB/BGR and BGR555 (16-bit images)

    COLOR_RGB2BGR555   = 23,  //!< [8U]

    COLOR_BGR5552BGR   = 24,  //!< [8U]

    COLOR_BGR5552RGB   = 25,  //!< [8U]

    COLOR_BGRA2BGR555  = 26,  //!< [8U]

    COLOR_RGBA2BGR555  = 27,  //!< [8U]

    COLOR_BGR5552BGRA  = 28,  //!< [8U]

    COLOR_BGR5552RGBA  = 29,  //!< [8U]

    COLOR_GRAY2BGR555  = 30, //!< [8U] convert between grayscale and BGR555 (16-bit images)

    COLOR_BGR5552GRAY  = 31, //!< [8U]

    COLOR_BGR2XYZ      = 32, //!< [8U/16U/32F] convert RGB/BGR to CIE XYZ, @ref color_convert_rgb_xyz "color conversions"

    COLOR_RGB2XYZ      = 33, //!< [8U/16U/32F]

    COLOR_XYZ2BGR      = 34, //!< [8U/16U/32F]

    COLOR_XYZ2RGB      = 35, //!< [8U/16U/32F]

    COLOR_BGR2YCrCb    = 36, //!< [8U/16U/32F] convert RGB/BGR to luma-chroma (aka YCC), @ref color_convert_rgb_ycrcb "color conversions"

    COLOR_RGB2YCrCb    = 37, //!< [8U/16U/32F]

    COLOR_YCrCb2BGR    = 38, //!< [8U/16U/32F]

    COLOR_YCrCb2RGB    = 39, //!< [8U/16U/32F]

    COLOR_BGR2HSV      = 40, //!< [8U/32F] convert RGB/BGR to HSV (hue saturation value) with H range 0..180 if 8 bit image, @ref color_convert_rgb_hsv "color conversions"

    COLOR_RGB2HSV      = 41, //!< [8U/32F]

    COLOR_BGR2Lab      = 44, //!< [8U/32F] convert RGB/BGR to CIE Lab, @ref color_convert_rgb_lab "color conversions"

    COLOR_RGB2Lab      = 45, //!< [8U/32F]

    COLOR_BGR2Luv      = 50, //!< [8U/32F] convert RGB/BGR to CIE Luv, @ref color_convert_rgb_luv "color conversions"

    COLOR_RGB2Luv      = 51, //!< [8U/32F]

    COLOR_BGR2HLS      = 52, //!< [8U/32F] convert RGB/BGR to HLS (hue lightness saturation) with H range 0..180 if 8 bit image, @ref color_convert_rgb_hls "color conversions"

    COLOR_RGB2HLS      = 53, //!< [8U/32F]

    COLOR_HSV2BGR      = 54, //!< [8U/32F] backward conversions HSV to RGB/BGR with H range 0..180 if 8 bit image

    COLOR_HSV2RGB      = 55, //!< [8U/32F]

    COLOR_Lab2BGR      = 56, //!< [8U/32F]

    COLOR_Lab2RGB      = 57, //!< [8U/32F]

    COLOR_Luv2BGR      = 58, //!< [8U/32F]

    COLOR_Luv2RGB      = 59, //!< [8U/32F]

    COLOR_HLS2BGR      = 60, //!< [8U/32F] backward conversions HLS to RGB/BGR with H range 0..180 if 8 bit image

    COLOR_HLS2RGB      = 61, //!< [8U/32F]

    COLOR_BGR2HSV_FULL = 66, //!< [8U/32F] convert RGB/BGR to HSV (hue saturation value) with H range 0..255 if 8 bit image, @ref color_convert_rgb_hsv "color conversions"

    COLOR_RGB2HSV_FULL = 67, //!< [8U/32F]

    COLOR_BGR2HLS_FULL = 68, //!< [8U/32F] convert RGB/BGR to HLS (hue lightness saturation) with H range 0..255 if 8 bit image, @ref color_convert_rgb_hls "color conversions"

    COLOR_RGB2HLS_FULL = 69, //!< [8U/32F]

    COLOR_HSV2BGR_FULL = 70, //!< [8U/32F] backward conversions HSV to RGB/BGR with H range 0..255 if 8 bit image

    COLOR_HSV2RGB_FULL = 71, //!< [8U/32F]

    COLOR_HLS2BGR_FULL = 72, //!< [8U/32F] backward conversions HLS to RGB/BGR with H range 0..255 if 8 bit image

    COLOR_HLS2RGB_FULL = 73, //!< [8U/32F]

    COLOR_LBGR2Lab     = 74, //!< [8U/32F]

    COLOR_LRGB2Lab     = 75, //!< [8U/32F]

    COLOR_LBGR2Luv     = 76, //!< [8U/32F]

    COLOR_LRGB2Luv     = 77, //!< [8U/32F]

    COLOR_Lab2LBGR     = 78, //!< [8U/32F]

    COLOR_Lab2LRGB     = 79, //!< [8U/32F]

    COLOR_Luv2LBGR     = 80, //!< [8U/32F]

    COLOR_Luv2LRGB     = 81, //!< [8U/32F]

    COLOR_BGR2YUV      = 82, //!< [8U/16U/32F] convert between RGB/BGR and YUV

    COLOR_RGB2YUV      = 83, //!< [8U/16U/32F]

    COLOR_YUV2BGR      = 84, //!< [8U/16U/32F]

    COLOR_YUV2RGB      = 85, //!< [8U/16U/32F]

    COLOR_YUV2RGB_NV12  = 90, //!< [8U] convert between 4:2:0-subsampled YUV NV12 and RGB, two planes (in one or separate arrays): Y and U/V interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_NV12  = 91, //!< [8U] convert between 4:2:0-subsampled YUV NV12 and BGR, two planes (in one or separate arrays): Y and U/V interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_NV21  = 92, //!< [8U] convert between 4:2:0-subsampled YUV NV21 and RGB, two planes (in one or separate arrays): Y and V/U interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_NV21  = 93, //!< [8U] convert between 4:2:0-subsampled YUV NV21 and BGR, two planes (in one or separate arrays): Y and V/U interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV420sp2RGB  = COLOR_YUV2RGB_NV21, //!< synonym to NV21

    COLOR_YUV420sp2BGR  = COLOR_YUV2BGR_NV21, //!< synonym to NV21

    COLOR_YUV2RGBA_NV12 = 94, //!< [8U] convert between 4:2:0-subsampled YUV NV12 and RGBA, two planes (in one or separate arrays): Y and U/V interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_NV12 = 95, //!< [8U] convert between 4:2:0-subsampled YUV NV12 and BGRA, two planes (in one or separate arrays): Y and U/V interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_NV21 = 96, //!< [8U] convert between 4:2:0-subsampled YUV NV21 and RGBA, two planes (in one or separate arrays): Y and V/U interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_NV21 = 97, //!< [8U] convert between 4:2:0-subsampled YUV NV21 and BGRA, two planes (in one or separate arrays): Y and V/U interleaved, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, //!< synonym to NV21

    COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, //!< synonym to NV21

    COLOR_YUV2RGB_YV12  =  98, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and RGB, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_YV12  =  99, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and BGR, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_IYUV  = 100, //!< [8U] convert between 4:2:0-subsampled YUV IYUV and RGB, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_IYUV  = 101, //!< [8U] convert between 4:2:0-subsampled YUV IYUV and BGR, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_I420  = COLOR_YUV2RGB_IYUV, //!< synonym to IYUV

    COLOR_YUV2BGR_I420  = COLOR_YUV2BGR_IYUV, //!< synonym to IYUV

    COLOR_YUV420p2RGB   = COLOR_YUV2RGB_YV12, //!< synonym to YV12

    COLOR_YUV420p2BGR   = COLOR_YUV2BGR_YV12, //!< synonym to YV12

    COLOR_YUV2RGBA_YV12 = 102, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and RGBA, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_YV12 = 103, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and BGRA, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_IYUV = 104, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and RGBA, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_IYUV = 105, //!< [8U] convert between 4:2:0-subsampled YUV YV12 and BGRA, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, //!< synonym to IYUV

    COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, //!< synonym to IYUV

    COLOR_YUV420p2RGBA  = COLOR_YUV2RGBA_YV12, //!< synonym to YV12

    COLOR_YUV420p2BGRA  = COLOR_YUV2BGRA_YV12, //!< synonym to YV12

    COLOR_YUV2GRAY_420  = 106, //!< [8U] extract Y channel from YUV 4:2:0 image

    COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV420p2GRAY  = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420

    COLOR_YUV2RGB_UYVY = 107, //!< [8U] convert between YUV UYVY and RGB, YUV is 4:2:2-subsampled and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_UYVY = 108, //!< [8U] convert between YUV UYVY and BGR, YUV is 4:2:2-subsampled and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    //COLOR_YUV2RGB_VYUY = 109, //!< convert between YUV VYUY and RGB, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref color_convert_rgb_yuv_42x

    //COLOR_YUV2BGR_VYUY = 110, //!< convert between YUV VYUY and BGR, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY

    COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY

    COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY

    COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY

    COLOR_YUV2RGBA_UYVY = 111, //!< [8U] convert between YUV UYVY and RGBA, YUV is 4:2:2-subsampled and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_UYVY = 112, //!< [8U] convert between YUV UYVY and BGRA, YUV is 4:2:2-subsampled and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    //COLOR_YUV2RGBA_VYUY = 113, //!< [8U] convert between YUV VYUY and RGBA, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref color_convert_rgb_yuv_42x

    //COLOR_YUV2BGRA_VYUY = 114, //!< [8U] convert between YUV VYUY and BGRA, YUV is 4:2:2-subsampled and interleaved as V/Y1/U/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY

    COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY

    COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY

    COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY

    COLOR_YUV2RGB_YUY2 = 115, //!< [8U] convert between YUV YUY2 and RGB, YUV is 4:2:2-subsampled and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_YUY2 = 116, //!< [8U] convert between YUV YUY2 and BGR, YUV is 4:2:2-subsampled and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_YVYU = 117, //!< [8U] convert between YUV YVYU and RGB, YUV is 4:2:2-subsampled and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGR_YVYU = 118, //!< [8U] convert between YUV YVYU and BGR, YUV is 4:2:2-subsampled and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2

    COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2

    COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2

    COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2

    COLOR_YUV2RGBA_YUY2 = 119, //!< [8U] convert between YUV YUY2 and RGBA, YUV is 4:2:2-subsampled and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_YUY2 = 120, //!< [8U] convert between YUV YUY2 and BGRA, YUV is 4:2:2-subsampled and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_YVYU = 121, //!< [8U] convert between YUV YVYU and RGBA, YUV is 4:2:2-subsampled and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2BGRA_YVYU = 122, //!< [8U] convert between YUV YVYU and BGRA, YUV is 4:2:2-subsampled and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2

    COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2

    COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2

    COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2

    COLOR_YUV2GRAY_UYVY = 123, //!< [8U] extract Y channel from YUV 4:2:2 image

    COLOR_YUV2GRAY_YUY2 = 124, //!< [8U] extract Y channel from YUV 4:2:2 image

    //CV_YUV2GRAY_VYUY  = CV_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY

    COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY

    COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY

    COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2

    COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2

    COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2

    //! alpha premultiplication

    COLOR_RGBA2mRGBA    = 125, //!< [8U]

    COLOR_mRGBA2RGBA    = 126, //!< [8U]

    COLOR_RGB2YUV_I420  = 127, //!< [8U] convert between RGB and 4:2:0-subsampled YUV I420, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_BGR2YUV_I420  = 128, //!< [8U] convert between BGR and 4:2:0-subsampled YUV I420, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_RGB2YUV_IYUV  = COLOR_RGB2YUV_I420, //!< synonym to I420

    COLOR_BGR2YUV_IYUV  = COLOR_BGR2YUV_I420, //!< synonym to I420

    COLOR_RGBA2YUV_I420 = 129, //!< [8U] convert between RGBA and 4:2:0-subsampled YUV I420, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_BGRA2YUV_I420 = 130, //!< [8U] convert between BGRA and 4:2:0-subsampled YUV I420, three planes in one array: Y, U and V, see @ref color_convert_rgb_yuv_42x

    COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, //!< synonym to I420

    COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, //!< synonym to I420

    COLOR_RGB2YUV_YV12  = 131, //!< [8U] convert between RGB and 4:2:0-subsampled YUV YV12, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_BGR2YUV_YV12  = 132, //!< [8U] convert between BGR and 4:2:0-subsampled YUV YV12, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_RGBA2YUV_YV12 = 133, //!< [8U] convert between RGBA and 4:2:0-subsampled YUV YV12, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    COLOR_BGRA2YUV_YV12 = 134, //!< [8U] convert between BGRA and 4:2:0-subsampled YUV YV12, three planes in one array: Y, V and U, see @ref color_convert_rgb_yuv_42x

    //! Demosaicing, see @ref color_convert_bayer "color conversions" for additional information

    COLOR_BayerBG2BGR = 46, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2BGR = 47, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2BGR = 48, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2BGR = 49, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR, //!< [8U/16U]

    COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR, //!< [8U/16U]

    COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR, //!< [8U/16U]

    COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR, //!< [8U/16U]

    COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR, //!< [8U/16U]

    COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR, //!< [8U/16U]

    COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR, //!< [8U/16U]

    COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR, //!< [8U/16U]

    COLOR_BayerBG2RGB = COLOR_BayerRG2BGR, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2RGB = COLOR_BayerGR2BGR, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2RGB = COLOR_BayerBG2BGR, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2RGB = COLOR_BayerGB2BGR, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_BayerBG2GRAY = 86, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2GRAY = 87, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2GRAY = 88, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2GRAY = 89, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY, //!< [8U/16U]

    COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY, //!< [8U/16U]

    COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY, //!< [8U/16U]

    COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY, //!< [8U/16U]

    //! Demosaicing using Variable Number of Gradients

    COLOR_BayerBG2BGR_VNG = 62, //!< [8U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2BGR_VNG = 63, //!< [8U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2BGR_VNG = 64, //!< [8U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2BGR_VNG = 65, //!< [8U] equivalent to GBRG Bayer pattern

    COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG, //!< [8U]

    COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG, //!< [8U]

    COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG, //!< [8U]

    COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG, //!< [8U]

    COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG, //!< [8U]

    COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG, //!< [8U]

    COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG, //!< [8U]

    COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG, //!< [8U]

    COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG, //!< [8U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG, //!< [8U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG, //!< [8U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG, //!< [8U] equivalent to GBRG Bayer pattern

    //! Edge-Aware Demosaicing

    COLOR_BayerBG2BGR_EA  = 135, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2BGR_EA  = 136, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2BGR_EA  = 137, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2BGR_EA  = 138, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_BayerRGGB2BGR_EA  = COLOR_BayerBG2BGR_EA, //!< [8U/16U]

    COLOR_BayerGRBG2BGR_EA  = COLOR_BayerGB2BGR_EA, //!< [8U/16U]

    COLOR_BayerBGGR2BGR_EA  = COLOR_BayerRG2BGR_EA, //!< [8U/16U]

    COLOR_BayerGBRG2BGR_EA  = COLOR_BayerGR2BGR_EA, //!< [8U/16U]

    COLOR_BayerRGGB2RGB_EA  = COLOR_BayerBGGR2BGR_EA, //!< [8U/16U]

    COLOR_BayerGRBG2RGB_EA  = COLOR_BayerGBRG2BGR_EA, //!< [8U/16U]

    COLOR_BayerBGGR2RGB_EA  = COLOR_BayerRGGB2BGR_EA, //!< [8U/16U]

    COLOR_BayerGBRG2RGB_EA  = COLOR_BayerGRBG2BGR_EA, //!< [8U/16U]

    COLOR_BayerBG2RGB_EA  = COLOR_BayerRG2BGR_EA, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2RGB_EA  = COLOR_BayerGR2BGR_EA, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2RGB_EA  = COLOR_BayerBG2BGR_EA, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2RGB_EA  = COLOR_BayerGB2BGR_EA, //!< [8U/16U] equivalent to GBRG Bayer pattern

    //! Demosaicing with alpha channel

    COLOR_BayerBG2BGRA = 139, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2BGRA = 140, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2BGRA = 141, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2BGRA = 142, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA, //!< [8U/16U]

    COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA, //!< [8U/16U]

    COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA, //!< [8U/16U]

    COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA, //!< [8U/16U]

    COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA, //!< [8U/16U]

    COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA, //!< [8U/16U]

    COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA, //!< [8U/16U]

    COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA, //!< [8U/16U]

    COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA, //!< [8U/16U] equivalent to RGGB Bayer pattern

    COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA, //!< [8U/16U] equivalent to GRBG Bayer pattern

    COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA, //!< [8U/16U] equivalent to BGGR Bayer pattern

    COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA, //!< [8U/16U] equivalent to GBRG Bayer pattern

    COLOR_RGB2YUV_UYVY = 143, //!< [8U] convert between RGB and YUV UYVU, YUV is 4:2:2 and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_BGR2YUV_UYVY = 144, //!< [8U] convert between BGR and YUV UYVU, YUV is 4:2:2 and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_RGB2YUV_Y422 = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY

    COLOR_BGR2YUV_Y422 = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY

    COLOR_RGB2YUV_UYNV = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY

    COLOR_BGR2YUV_UYNV = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY

    COLOR_RGBA2YUV_UYVY = 145, //!< [8U] convert between RGBA and YUV UYVU, YUV is 4:2:2 and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_BGRA2YUV_UYVY = 146, //!< [8U] convert between BGRA and YUV UYVU, YUV is 4:2:2 and interleaved as U/Y1/V/Y2, see @ref color_convert_rgb_yuv_42x

    COLOR_RGBA2YUV_Y422 = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY

    COLOR_BGRA2YUV_Y422 = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY

    COLOR_RGBA2YUV_UYNV = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY

    COLOR_BGRA2YUV_UYNV = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY

    COLOR_RGB2YUV_YUY2 = 147, //!< [8U] convert between RGB and YUV YUY2, YUV is 4:2:2 and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_BGR2YUV_YUY2 = 148, //!< [8U] convert between BGR and YUV YUY2, YUV is 4:2:2 and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_RGB2YUV_YVYU = 149, //!< [8U] convert between RGB and YUV YVYU, YUV is 4:2:2 and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_BGR2YUV_YVYU = 150, //!< [8U] convert between BGR and YUV YVYU, YUV is 4:2:2 and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_RGB2YUV_YUYV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2

    COLOR_BGR2YUV_YUYV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2

    COLOR_RGB2YUV_YUNV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2

    COLOR_BGR2YUV_YUNV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2

    COLOR_RGBA2YUV_YUY2 = 151, //!< [8U] convert between RGBA and YUV YUY2, YUV is 4:2:2 and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_BGRA2YUV_YUY2 = 152, //!< [8U] convert between BGRA and YUV YUY2, YUV is 4:2:2 and interleaved as Y1/U/Y2/V, see @ref color_convert_rgb_yuv_42x

    COLOR_RGBA2YUV_YVYU = 153, //!< [8U] convert between RGBA and YUV YVYU, YUV is 4:2:2 and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_BGRA2YUV_YVYU = 154, //!< [8U] convert between BGRA and YUV YVYU, YUV is 4:2:2 and interleaved as Y1/V/Y2/U, see @ref color_convert_rgb_yuv_42x

    COLOR_RGBA2YUV_YUYV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2

    COLOR_BGRA2YUV_YUYV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2

    COLOR_RGBA2YUV_YUNV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2

    COLOR_BGRA2YUV_YUNV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2

    COLOR_COLORCVT_MAX  = 155

};

//! @addtogroup imgproc_shape

//! @{

//! types of intersection between rectangles

enum RectanglesIntersectTypes {

    INTERSECT_NONE = 0, //!< No intersection

    INTERSECT_PARTIAL  = 1, //!< There is a partial intersection

    INTERSECT_FULL  = 2 //!< One of the rectangle is fully enclosed in the other

};

/** types of line

@ingroup imgproc_draw

*/

enum LineTypes {

    FILLED  = -1,

    LINE_4  = 4, //!< 4-connected line

    LINE_8  = 8, //!< 8-connected line

    LINE_AA = 16 //!< antialiased line

};

/** Only a subset of Hershey fonts <https://en.wikipedia.org/wiki/Hershey_fonts> are supported

@ingroup imgproc_draw

*/

enum HersheyFonts {

    FONT_HERSHEY_SIMPLEX        = 0, //!< normal size sans-serif font

    FONT_HERSHEY_PLAIN          = 1, //!< small size sans-serif font

    FONT_HERSHEY_DUPLEX         = 2, //!< normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)

    FONT_HERSHEY_COMPLEX        = 3, //!< normal size serif font

    FONT_HERSHEY_TRIPLEX        = 4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX)

    FONT_HERSHEY_COMPLEX_SMALL  = 5, //!< smaller version of FONT_HERSHEY_COMPLEX

    FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font

    FONT_HERSHEY_SCRIPT_COMPLEX = 7, //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX

    FONT_ITALIC                 = 16 //!< flag for italic font

};

/** Possible set of marker types used for the cv::drawMarker function

@ingroup imgproc_draw

*/

enum MarkerTypes

{

    MARKER_CROSS = 0,           //!< A crosshair marker shape

    MARKER_TILTED_CROSS = 1,    //!< A 45 degree tilted crosshair marker shape

    MARKER_STAR = 2,            //!< A star marker shape, combination of cross and tilted cross

    MARKER_DIAMOND = 3,         //!< A diamond marker shape

    MARKER_SQUARE = 4,          //!< A square marker shape

    MARKER_TRIANGLE_UP = 5,     //!< An upwards pointing triangle marker shape

    MARKER_TRIANGLE_DOWN = 6    //!< A downwards pointing triangle marker shape

};

/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform

*/

class CV_EXPORTS_W GeneralizedHough : public Algorithm

{

public:

    //! set template to search

    CV_WRAP virtual void setTemplate(InputArray templ, Point templCenter = Point(-1, -1)) = 0;

    CV_WRAP virtual void setTemplate(InputArray edges, InputArray dx, InputArray dy, Point templCenter = Point(-1, -1)) = 0;

    //! find template on image

    CV_WRAP virtual void detect(InputArray image, OutputArray positions, OutputArray votes = noArray()) = 0;

    CV_WRAP virtual void detect(InputArray edges, InputArray dx, InputArray dy, OutputArray positions, OutputArray votes = noArray()) = 0;

    //! Canny low threshold.

    CV_WRAP virtual void setCannyLowThresh(int cannyLowThresh) = 0;

    CV_WRAP virtual int getCannyLowThresh() const = 0;

    //! Canny high threshold.

    CV_WRAP virtual void setCannyHighThresh(int cannyHighThresh) = 0;

    CV_WRAP virtual int getCannyHighThresh() const = 0;

    //! Minimum distance between the centers of the detected objects.

    CV_WRAP virtual void setMinDist(double minDist) = 0;

    CV_WRAP virtual double getMinDist() const = 0;

    //! Inverse ratio of the accumulator resolution to the image resolution.

    CV_WRAP virtual void setDp(double dp) = 0;

    CV_WRAP virtual double getDp() const = 0;

    //! Maximal size of inner buffers.

    CV_WRAP virtual void setMaxBufferSize(int maxBufferSize) = 0;

    CV_WRAP virtual int getMaxBufferSize() const = 0;

};

/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform

Detects position only without translation and rotation @cite Ballard1981 .

*/

class CV_EXPORTS_W GeneralizedHoughBallard : public GeneralizedHough

{

public:

    //! R-Table levels.

    CV_WRAP virtual void setLevels(int levels) = 0;

    CV_WRAP virtual int getLevels() const = 0;

    //! The accumulator threshold for the template centers at the detection stage. The smaller it is, the more false positions may be detected.

    CV_WRAP virtual void setVotesThreshold(int votesThreshold) = 0;

    CV_WRAP virtual int getVotesThreshold() const = 0;

};

/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform

Detects position, translation and rotation @cite Guil1999 .

*/

class CV_EXPORTS_W GeneralizedHoughGuil : public GeneralizedHough

{

public:

    //! Angle difference in degrees between two points in feature.

    CV_WRAP virtual void setXi(double xi) = 0;

    CV_WRAP virtual double getXi() const = 0;

    //! Feature table levels.

    CV_WRAP virtual void setLevels(int levels) = 0;

    CV_WRAP virtual int getLevels() const = 0;

    //! Maximal difference between angles that treated as equal.

    CV_WRAP virtual void setAngleEpsilon(double angleEpsilon) = 0;

    CV_WRAP virtual double getAngleEpsilon() const = 0;

    //! Minimal rotation angle to detect in degrees.

    CV_WRAP virtual void setMinAngle(double minAngle) = 0;

    CV_WRAP virtual double getMinAngle() const = 0;

    //! Maximal rotation angle to detect in degrees.

    CV_WRAP virtual void setMaxAngle(double maxAngle) = 0;

    CV_WRAP virtual double getMaxAngle() const = 0;

    //! Angle step in degrees.

    CV_WRAP virtual void setAngleStep(double angleStep) = 0;

    CV_WRAP virtual double getAngleStep() const = 0;

    //! Angle votes threshold.

    CV_WRAP virtual void setAngleThresh(int angleThresh) = 0;

    CV_WRAP virtual int getAngleThresh() const = 0;

    //! Minimal scale to detect.

    CV_WRAP virtual void setMinScale(double minScale) = 0;

    CV_WRAP virtual double getMinScale() const = 0;

    //! Maximal scale to detect.

    CV_WRAP virtual void setMaxScale(double maxScale) = 0;

    CV_WRAP virtual double getMaxScale() const = 0;

    //! Scale step.

    CV_WRAP virtual void setScaleStep(double scaleStep) = 0;

    CV_WRAP virtual double getScaleStep() const = 0;

    //! Scale votes threshold.

    CV_WRAP virtual void setScaleThresh(int scaleThresh) = 0;

    CV_WRAP virtual int getScaleThresh() const = 0;

    //! Position votes threshold.

    CV_WRAP virtual void setPosThresh(int posThresh) = 0;

    CV_WRAP virtual int getPosThresh() const = 0;

};

//! @} imgproc_shape

//! @addtogroup imgproc_hist

//! @{

/** @brief Base class for Contrast Limited Adaptive Histogram Equalization.

*/

class CV_EXPORTS_W CLAHE : public Algorithm

{

public:

    /** @brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.

    @param src Source image of type CV_8UC1 or CV_16UC1.

    @param dst Destination image.

     */

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

    /** @brief Sets threshold for contrast limiting.

    @param clipLimit threshold value.

    */

    CV_WRAP virtual void setClipLimit(double clipLimit) = 0;

    //! Returns threshold value for contrast limiting.

    CV_WRAP virtual double getClipLimit() const = 0;

    /** @brief Sets size of grid for histogram equalization. Input image will be divided into

    equally sized rectangular tiles.

    @param tileGridSize defines the number of tiles in row and column.

    */

    CV_WRAP virtual void setTilesGridSize(Size tileGridSize) = 0;

    //!@brief Returns Size defines the number of tiles in row and column.

    CV_WRAP virtual Size getTilesGridSize() const = 0;

    /** @brief Sets bit shift parameter for histogram bins.

    @param bitShift bit shift value (default is 0).

    */

    CV_WRAP virtual void setBitShift(int bitShift) = 0;

    /** @brief Returns the bit shift parameter for histogram bins.

    @return current bit shift value.

    */

    CV_WRAP virtual int getBitShift() const = 0;

    CV_WRAP virtual void collectGarbage() = 0;

};

//! @} imgproc_hist

//! @addtogroup imgproc_subdiv2d

//! @{

class CV_EXPORTS_W Subdiv2D

{

public:

    /** Subdiv2D point location cases */

    enum { PTLOC_ERROR        = -2, //!< Point location error

           PTLOC_OUTSIDE_RECT = -1, //!< Point outside the subdivision bounding rect

           PTLOC_INSIDE       = 0, //!< Point inside some facet

           PTLOC_VERTEX       = 1, //!< Point coincides with one of the subdivision vertices

           PTLOC_ON_EDGE      = 2  //!< Point on some edge

         };

    /** Subdiv2D edge type navigation (see: getEdge()) */

    enum { NEXT_AROUND_ORG   = 0x00,

           NEXT_AROUND_DST   = 0x22,

           PREV_AROUND_ORG   = 0x11,

           PREV_AROUND_DST   = 0x33,

           NEXT_AROUND_LEFT  = 0x13,

           NEXT_AROUND_RIGHT = 0x31,

           PREV_AROUND_LEFT  = 0x20,

           PREV_AROUND_RIGHT = 0x02

         };

    /** creates an empty Subdiv2D object.

    To create a new empty Delaunay subdivision you need to use the #initDelaunay function.

     */

    CV_WRAP Subdiv2D();

    /** @overload

    @param rect Rectangle that includes all of the 2D points that are to be added to the subdivision.

    The function creates an empty Delaunay subdivision where 2D points can be added using the function

    insert() . All of the points to be added must be within the specified rectangle, otherwise a runtime

    error is raised.

     */

    CV_WRAP Subdiv2D(Rect rect);

    /** @overload */

    CV_WRAP Subdiv2D(Rect2f rect2f);

    /** @overload

    @brief Creates a new empty Delaunay subdivision

    @param rect Rectangle that includes all of the 2D points that are to be added to the subdivision.

     */